fix: normalize generate-types specifiers via tsconfig context.

packages/css/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knighted/css",
-  "version": "1.0.0-rc.9",
+  "version": "1.0.0-rc.10",
   "description": "A build-time utility that traverses JavaScript/TypeScript module dependency graphs to extract, compile, and optimize all imported CSS into a single, in-memory string.",
   "type": "module",
   "main": "./dist/css.js",

packages/css/src/generateTypes.ts

@@ -7,6 +7,9 @@ import { fileURLToPath, pathToFileURL } from 'node:url'
 import { init, parse } from 'es-module-lexer'
 import { moduleType } from 'node-module-type'
 
+import { getTsconfig, type TsConfigResult } from 'get-tsconfig'
+import { createMatchPath, type MatchPath } from 'tsconfig-paths'
+
 import { cssWithMeta } from './css.js'
 import {
   determineSelectorVariant,
@@ -34,12 +37,22 @@ interface DeclarationRecord {
   filePath: string
 }
 
+interface TsconfigResolutionContext {
+  absoluteBaseUrl?: string
+  matchPath?: MatchPath
+}
+
+type CssWithMetaFn = typeof cssWithMeta
+
+let activeCssWithMeta: CssWithMetaFn = cssWithMeta
+
 interface GenerateTypesInternalOptions {
   rootDir: string
   include: string[]
   outDir: string
   typesRoot: string
   stableNamespace?: string
+  tsconfig?: TsconfigResolutionContext
 }
 
 export interface GenerateTypesResult {
@@ -84,12 +97,17 @@ const SUPPORTED_EXTENSIONS = new Set([
   '.cjs',
 ])
 
+type ModuleTypeDetector = () => ReturnType<typeof moduleType>
+
+let moduleTypeDetector: ModuleTypeDetector = moduleType
+let importMetaUrlProvider: () => string | undefined = getImportMetaUrl
+
 function resolvePackageRoot(): string {
-  const detectedType = moduleType()
+  const detectedType = moduleTypeDetector()
   if (detectedType === 'commonjs' && typeof __dirname === 'string') {
     return path.resolve(__dirname, '..')
   }
-  const moduleUrl = getImportMetaUrl()
+  const moduleUrl = importMetaUrlProvider()
   if (moduleUrl) {
     return path.resolve(path.dirname(fileURLToPath(moduleUrl)), '..')
   }
@@ -115,6 +133,7 @@ export async function generateTypes(
   const include = normalizeIncludeOptions(options.include, rootDir)
   const outDir = path.resolve(options.outDir ?? DEFAULT_OUT_DIR)
   const typesRoot = path.resolve(options.typesRoot ?? DEFAULT_TYPES_ROOT)
+  const tsconfig = loadTsconfigResolutionContext(rootDir)
   await init
   await fs.mkdir(outDir, { recursive: true })
   await fs.mkdir(typesRoot, { recursive: true })
@@ -125,6 +144,7 @@ export async function generateTypes(
     outDir,
     typesRoot,
     stableNamespace: options.stableNamespace,
+    tsconfig,
   }
 
   return generateDeclarations(internalOptions)
@@ -162,6 +182,7 @@ async function generateDeclarations(
         resource,
         match.importer,
         options.rootDir,
+        options.tsconfig,
       )
       if (!resolvedPath) {
         warnings.push(
@@ -174,7 +195,7 @@ async function generateDeclarations(
       let selectorMap = selectorCache.get(cacheKey)
       if (!selectorMap) {
         try {
-          const { css } = await cssWithMeta(resolvedPath, {
+          const { css } = await activeCssWithMeta(resolvedPath, {
             cwd: options.rootDir,
             peerResolver,
           })
@@ -342,6 +363,7 @@ async function resolveImportPath(
   resourceSpecifier: string,
   importerPath: string,
   rootDir: string,
+  tsconfig?: TsconfigResolutionContext,
 ): Promise<string | undefined> {
   if (!resourceSpecifier) return undefined
   if (resourceSpecifier.startsWith('.')) {
@@ -350,6 +372,10 @@ async function resolveImportPath(
   if (resourceSpecifier.startsWith('/')) {
     return path.resolve(rootDir, resourceSpecifier.slice(1))
   }
+  const tsconfigResolved = await resolveWithTsconfigPaths(resourceSpecifier, tsconfig)
+  if (tsconfigResolved) {
+    return tsconfigResolved
+  }
   const requireFromRoot = getProjectRequire(rootDir)
   try {
     return requireFromRoot.resolve(resourceSpecifier)
@@ -491,6 +517,93 @@ async function fileExists(target: string): Promise<boolean> {
   }
 }
 
+async function resolveWithTsconfigPaths(
+  specifier: string,
+  tsconfig?: TsconfigResolutionContext,
+): Promise<string | undefined> {
+  if (!tsconfig) {
+    return undefined
+  }
+  if (tsconfig.matchPath) {
+    const matched = tsconfig.matchPath(specifier)
+    if (matched && (await fileExists(matched))) {
+      return matched
+    }
+  }
+  if (tsconfig.absoluteBaseUrl && isNonRelativeSpecifier(specifier)) {
+    const candidate = path.join(
+      tsconfig.absoluteBaseUrl,
+      specifier.split('/').join(path.sep),
+    )
+    if (await fileExists(candidate)) {
+      return candidate
+    }
+  }
+  return undefined
+}
+
+function loadTsconfigResolutionContext(
+  rootDir: string,
+  loader: typeof getTsconfig = getTsconfig,
+): TsconfigResolutionContext | undefined {
+  let result: TsConfigResult | null
+  try {
+    result = loader(rootDir) as TsConfigResult | null
+  } catch {
+    return undefined
+  }
+  if (!result) {
+    return undefined
+  }
+  const compilerOptions = result.config.compilerOptions ?? {}
+  const configDir = path.dirname(result.path)
+  const absoluteBaseUrl = compilerOptions.baseUrl
+    ? path.resolve(configDir, compilerOptions.baseUrl)
+    : undefined
+  const normalizedPaths = normalizeTsconfigPaths(compilerOptions.paths)
+  const matchPath =
+    absoluteBaseUrl && normalizedPaths
+      ? createMatchPath(absoluteBaseUrl, normalizedPaths)
+      : undefined
+  if (!absoluteBaseUrl && !matchPath) {
+    return undefined
+  }
+  return { absoluteBaseUrl, matchPath }
+}
+
+function normalizeTsconfigPaths(
+  paths: Record<string, string[] | string> | undefined,
+): Record<string, string[]> | undefined {
+  if (!paths) {
+    return undefined
+  }
+  const normalized: Record<string, string[]> = {}
+  for (const [pattern, replacements] of Object.entries(paths)) {
+    if (!replacements) {
+      continue
+    }
+    const values = Array.isArray(replacements) ? replacements : [replacements]
+    if (values.length === 0) {
+      continue
+    }
+    normalized[pattern] = values
+  }
+  return Object.keys(normalized).length > 0 ? normalized : undefined
+}
+
+function isNonRelativeSpecifier(specifier: string): boolean {
+  if (!specifier) {
+    return false
+  }
+  if (specifier.startsWith('.') || specifier.startsWith('/')) {
+    return false
+  }
+  if (/^[a-z][\w+.-]*:/i.test(specifier)) {
+    return false
+  }
+  return true
+}
+
 function createProjectPeerResolver(rootDir: string) {
   const resolver = getProjectRequire(rootDir)
   return async (name: string) => {
@@ -643,13 +756,40 @@ function reportCliResult(result: GenerateTypesResult): void {
   }
 }
 
+function setCssWithMetaImplementation(impl?: CssWithMetaFn): void {
+  activeCssWithMeta = impl ?? cssWithMeta
+}
+
+function setModuleTypeDetector(detector?: ModuleTypeDetector): void {
+  moduleTypeDetector = detector ?? moduleType
+}
+
+function setImportMetaUrlProvider(provider?: () => string | undefined): void {
+  importMetaUrlProvider = provider ?? getImportMetaUrl
+}
+
 export const __generateTypesInternals = {
+  writeTypesIndex,
   stripInlineLoader,
   splitResourceAndQuery,
+  findSpecifierImports,
+  resolveImportPath,
+  resolvePackageRoot,
   buildDeclarationFileName,
   formatModuleDeclaration,
   formatSelectorType,
+  relativeToRoot,
+  collectCandidateFiles,
   normalizeIncludeOptions,
+  normalizeTsconfigPaths,
+  setCssWithMetaImplementation,
+  setModuleTypeDetector,
+  setImportMetaUrlProvider,
+  isNonRelativeSpecifier,
+  createProjectPeerResolver,
+  getProjectRequire,
+  loadTsconfigResolutionContext,
+  resolveWithTsconfigPaths,
   parseCliArgs,
   printHelp,
   reportCliResult,