@knighted/css 1.0.0-rc.9 → 1.0.0

package/dist/cjs/generateTypes.cjs

@@ -13,10 +13,12 @@ const node_module_1 = require("node:module");
 const node_url_1 = require("node:url");
 const es_module_lexer_1 = require("es-module-lexer");
 const node_module_type_1 = require("node-module-type");
+const get_tsconfig_1 = require("get-tsconfig");
+const tsconfig_paths_1 = require("tsconfig-paths");
 const css_js_1 = require("./css.cjs");
-const loaderInternals_js_1 = require("./loaderInternals.cjs");
 const stableSelectorsLiteral_js_1 = require("./stableSelectorsLiteral.cjs");
 const stableNamespace_js_1 = require("./stableNamespace.cjs");
+let activeCssWithMeta = css_js_1.cssWithMeta;
 const DEFAULT_SKIP_DIRS = new Set([
     'node_modules',
     '.git',
@@ -40,12 +42,14 @@ const SUPPORTED_EXTENSIONS = new Set([
     '.mjs',
     '.cjs',
 ]);
+let moduleTypeDetector = node_module_type_1.moduleType;
+let importMetaUrlProvider = getImportMetaUrl;
 function resolvePackageRoot() {
-    const detectedType = (0, node_module_type_1.moduleType)();
+    const detectedType = moduleTypeDetector();
     if (detectedType === 'commonjs' && typeof __dirname === 'string') {
         return node_path_1.default.resolve(__dirname, '..');
     }
-    const moduleUrl = getImportMetaUrl();
+    const moduleUrl = importMetaUrlProvider();
     if (moduleUrl) {
         return node_path_1.default.resolve(node_path_1.default.dirname((0, node_url_1.fileURLToPath)(moduleUrl)), '..');
     }
@@ -60,61 +64,55 @@ function getImportMetaUrl() {
     }
 }
 const PACKAGE_ROOT = resolvePackageRoot();
-const DEFAULT_TYPES_ROOT = node_path_1.default.join(PACKAGE_ROOT, 'types-stub');
-const DEFAULT_OUT_DIR = node_path_1.default.join(PACKAGE_ROOT, 'node_modules', '.knighted-css');
+const SELECTOR_REFERENCE = '.knighted-css';
+const SELECTOR_MODULE_SUFFIX = '.knighted-css.ts';
 async function generateTypes(options = {}) {
     const rootDir = node_path_1.default.resolve(options.rootDir ?? process.cwd());
     const include = normalizeIncludeOptions(options.include, rootDir);
-    const outDir = node_path_1.default.resolve(options.outDir ?? DEFAULT_OUT_DIR);
-    const typesRoot = node_path_1.default.resolve(options.typesRoot ?? DEFAULT_TYPES_ROOT);
+    const cacheDir = node_path_1.default.resolve(options.outDir ?? node_path_1.default.join(rootDir, '.knighted-css'));
+    const tsconfig = loadTsconfigResolutionContext(rootDir);
     await es_module_lexer_1.init;
-    await promises_1.default.mkdir(outDir, { recursive: true });
-    await promises_1.default.mkdir(typesRoot, { recursive: true });
+    await promises_1.default.mkdir(cacheDir, { recursive: true });
     const internalOptions = {
         rootDir,
         include,
-        outDir,
-        typesRoot,
+        cacheDir,
         stableNamespace: options.stableNamespace,
+        tsconfig,
     };
     return generateDeclarations(internalOptions);
 }
 async function generateDeclarations(options) {
     const peerResolver = createProjectPeerResolver(options.rootDir);
     const files = await collectCandidateFiles(options.include);
-    const manifestPath = node_path_1.default.join(options.outDir, 'manifest.json');
-    const previousManifest = await readManifest(manifestPath);
-    const nextManifest = {};
+    const selectorModulesManifestPath = node_path_1.default.join(options.cacheDir, 'selector-modules.json');
+    const previousSelectorManifest = await readManifest(selectorModulesManifestPath);
+    const nextSelectorManifest = {};
     const selectorCache = new Map();
-    const processedSpecifiers = new Set();
-    const declarations = [];
+    const processedSelectors = new Set();
     const warnings = [];
-    let writes = 0;
+    let selectorModuleWrites = 0;
     for (const filePath of files) {
         const matches = await findSpecifierImports(filePath);
         for (const match of matches) {
             const cleaned = match.specifier.trim();
             const inlineFree = stripInlineLoader(cleaned);
-            if (!inlineFree.includes('?knighted-css'))
-                continue;
-            const { resource, query } = splitResourceAndQuery(inlineFree);
-            if (!query || !(0, loaderInternals_js_1.hasQueryFlag)(query, loaderInternals_js_1.TYPES_QUERY_FLAG)) {
-                continue;
-            }
-            if (processedSpecifiers.has(cleaned)) {
+            const { resource } = splitResourceAndQuery(inlineFree);
+            const selectorSource = extractSelectorSourceSpecifier(resource);
+            if (!selectorSource) {
                 continue;
             }
             const resolvedNamespace = (0, stableNamespace_js_1.resolveStableNamespace)(options.stableNamespace);
-            const resolvedPath = await resolveImportPath(resource, match.importer, options.rootDir);
+            const resolvedPath = await resolveImportPath(selectorSource, match.importer, options.rootDir, options.tsconfig);
             if (!resolvedPath) {
-                warnings.push(`Unable to resolve ${resource} referenced by ${relativeToRoot(match.importer, options.rootDir)}.`);
+                warnings.push(`Unable to resolve ${selectorSource} referenced by ${relativeToRoot(match.importer, options.rootDir)}.`);
                 continue;
             }
             const cacheKey = `${resolvedPath}::${resolvedNamespace}`;
             let selectorMap = selectorCache.get(cacheKey);
             if (!selectorMap) {
                 try {
-                    const { css } = await (0, css_js_1.cssWithMeta)(resolvedPath, {
+                    const { css } = await activeCssWithMeta(resolvedPath, {
                         cwd: options.rootDir,
                         peerResolver,
                     });
@@ -131,38 +129,28 @@ async function generateDeclarations(options) {
                 }
                 selectorCache.set(cacheKey, selectorMap);
             }
-            const variant = (0, loaderInternals_js_1.determineSelectorVariant)(query);
-            const declaration = formatModuleDeclaration(cleaned, variant, selectorMap);
-            const declarationHash = hashContent(declaration);
-            const fileName = buildDeclarationFileName(cleaned);
-            const targetPath = node_path_1.default.join(options.outDir, fileName);
-            const previousEntry = previousManifest[cleaned];
-            const needsWrite = previousEntry?.hash !== declarationHash || !(await fileExists(targetPath));
-            if (needsWrite) {
-                await promises_1.default.writeFile(targetPath, declaration, 'utf8');
-                writes += 1;
+            if (!isWithinRoot(resolvedPath, options.rootDir)) {
+                warnings.push(`Skipping selector module for ${relativeToRoot(resolvedPath, options.rootDir)} because it is outside the project root.`);
+                continue;
+            }
+            const manifestKey = buildSelectorModuleManifestKey(resolvedPath);
+            if (processedSelectors.has(manifestKey)) {
+                continue;
             }
-            nextManifest[cleaned] = { file: fileName, hash: declarationHash };
-            if (needsWrite) {
-                declarations.push({ specifier: cleaned, filePath: targetPath });
+            const moduleWrite = await ensureSelectorModule(resolvedPath, selectorMap, previousSelectorManifest, nextSelectorManifest);
+            if (moduleWrite) {
+                selectorModuleWrites += 1;
             }
-            processedSpecifiers.add(cleaned);
+            processedSelectors.add(manifestKey);
         }
     }
-    const removed = await removeStaleDeclarations(previousManifest, nextManifest, options.outDir);
-    await writeManifest(manifestPath, nextManifest);
-    const typesIndexPath = node_path_1.default.join(options.typesRoot, 'index.d.ts');
-    await writeTypesIndex(typesIndexPath, nextManifest, options.outDir);
-    if (Object.keys(nextManifest).length === 0) {
-        declarations.length = 0;
-    }
+    const selectorModulesRemoved = await removeStaleSelectorModules(previousSelectorManifest, nextSelectorManifest);
+    await writeManifest(selectorModulesManifestPath, nextSelectorManifest);
     return {
-        written: writes,
-        removed,
-        declarations,
+        selectorModulesWritten: selectorModuleWrites,
+        selectorModulesRemoved,
         warnings,
-        outDir: options.outDir,
-        typesIndexPath,
+        manifestPath: selectorModulesManifestPath,
     };
 }
 function normalizeIncludeOptions(include, rootDir) {
@@ -220,18 +208,18 @@ async function findSpecifierImports(filePath) {
     catch {
         return [];
     }
-    if (!source.includes('?knighted-css')) {
+    if (!source.includes(SELECTOR_REFERENCE)) {
         return [];
     }
     const matches = [];
     const [imports] = (0, es_module_lexer_1.parse)(source, filePath);
     for (const record of imports) {
         const specifier = record.n ?? source.slice(record.s, record.e);
-        if (specifier && specifier.includes('?knighted-css')) {
+        if (specifier && specifier.includes(SELECTOR_REFERENCE)) {
             matches.push({ specifier, importer: filePath });
         }
     }
-    const requireRegex = /require\((['"])([^'"`]+?\?knighted-css[^'"`]*)\1\)/g;
+    const requireRegex = /require\((['"])([^'"`]+?\.knighted-css[^'"`]*)\1\)/g;
     let reqMatch;
     while ((reqMatch = requireRegex.exec(source)) !== null) {
         const spec = reqMatch[2];
@@ -254,8 +242,23 @@ function splitResourceAndQuery(specifier) {
     }
     return { resource: trimmed.slice(0, queryIndex), query: trimmed.slice(queryIndex) };
 }
+function extractSelectorSourceSpecifier(specifier) {
+    const markerIndex = specifier.indexOf(SELECTOR_REFERENCE);
+    if (markerIndex < 0) {
+        return undefined;
+    }
+    const suffix = specifier.slice(markerIndex + SELECTOR_REFERENCE.length);
+    if (suffix.length > 0 && !/\.(?:[cm]?[tj]s|[tj]sx)$/.test(suffix)) {
+        return undefined;
+    }
+    const base = specifier.slice(0, markerIndex);
+    if (!base) {
+        return undefined;
+    }
+    return base;
+}
 const projectRequireCache = new Map();
-async function resolveImportPath(resourceSpecifier, importerPath, rootDir) {
+async function resolveImportPath(resourceSpecifier, importerPath, rootDir, tsconfig) {
     if (!resourceSpecifier)
         return undefined;
     if (resourceSpecifier.startsWith('.')) {
@@ -264,6 +267,10 @@ async function resolveImportPath(resourceSpecifier, importerPath, rootDir) {
     if (resourceSpecifier.startsWith('/')) {
         return node_path_1.default.resolve(rootDir, resourceSpecifier.slice(1));
     }
+    const tsconfigResolved = await resolveWithTsconfigPaths(resourceSpecifier, tsconfig);
+    if (tsconfigResolved) {
+        return tsconfigResolved;
+    }
     const requireFromRoot = getProjectRequire(rootDir);
     try {
         return requireFromRoot.resolve(resourceSpecifier);
@@ -272,47 +279,29 @@ async function resolveImportPath(resourceSpecifier, importerPath, rootDir) {
         return undefined;
     }
 }
-function buildDeclarationFileName(specifier) {
-    const digest = node_crypto_1.default.createHash('sha1').update(specifier).digest('hex').slice(0, 12);
-    return `knt-${digest}.d.ts`;
-}
-function formatModuleDeclaration(specifier, variant, selectors) {
-    const literalSpecifier = JSON.stringify(specifier);
-    const selectorType = formatSelectorType(selectors);
-    const header = `declare module ${literalSpecifier} {`;
-    const footer = '}';
-    if (variant === 'types') {
-        return `${header}
-  export const knightedCss: string
-  export const stableSelectors: ${selectorType}
-${footer}
-`;
-    }
-    const stableLine = `  export const stableSelectors: ${selectorType}`;
-    const shared = `  const combined: KnightedCssCombinedModule<Record<string, unknown>>
-  export const knightedCss: string
-${stableLine}`;
-    if (variant === 'combined') {
-        return `${header}
-${shared}
-  export default combined
-${footer}
-`;
-    }
-    return `${header}
-${shared}
-${footer}
-`;
+function buildSelectorModuleManifestKey(resolvedPath) {
+    return resolvedPath.split(node_path_1.default.sep).join('/');
 }
-function formatSelectorType(selectors) {
-    if (selectors.size === 0) {
-        return 'Readonly<Record<string, string>>';
-    }
+function buildSelectorModulePath(resolvedPath) {
+    return `${resolvedPath}${SELECTOR_MODULE_SUFFIX}`;
+}
+function formatSelectorModuleSource(selectors) {
+    const header = '// Generated by @knighted/css/generate-types\n// Do not edit.\n';
     const entries = Array.from(selectors.entries()).sort(([a], [b]) => a.localeCompare(b));
-    const lines = entries.map(([token, selector]) => `    readonly ${JSON.stringify(token)}: ${JSON.stringify(selector)}`);
-    return `Readonly<{
+    const lines = entries.map(([token, selector]) => `  ${JSON.stringify(token)}: ${JSON.stringify(selector)},`);
+    const literal = lines.length > 0
+        ? `{
 ${lines.join('\n')}
-  }>`;
+} as const`
+        : '{} as const';
+    return `${header}
+export const stableSelectors = ${literal}
+
+export type KnightedCssStableSelectors = typeof stableSelectors
+export type KnightedCssStableSelectorToken = keyof typeof stableSelectors
+
+export default stableSelectors
+`;
 }
 function hashContent(content) {
     return node_crypto_1.default.createHash('sha1').update(content).digest('hex');
@@ -329,13 +318,12 @@ async function readManifest(manifestPath) {
 async function writeManifest(manifestPath, manifest) {
     await promises_1.default.writeFile(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
 }
-async function removeStaleDeclarations(previous, next, outDir) {
-    const stale = Object.entries(previous).filter(([specifier]) => !next[specifier]);
+async function removeStaleSelectorModules(previous, next) {
+    const stale = Object.entries(previous).filter(([key]) => !next[key]);
     let removed = 0;
     for (const [, entry] of stale) {
-        const targetPath = node_path_1.default.join(outDir, entry.file);
         try {
-            await promises_1.default.unlink(targetPath);
+            await promises_1.default.unlink(entry.file);
             removed += 1;
         }
         catch {
@@ -344,25 +332,6 @@ async function removeStaleDeclarations(previous, next, outDir) {
     }
     return removed;
 }
-async function writeTypesIndex(indexPath, manifest, outDir) {
-    const header = '// Generated by @knighted/css/generate-types\n// Do not edit.\n';
-    const references = Object.values(manifest)
-        .sort((a, b) => a.file.localeCompare(b.file))
-        .map(entry => {
-        const rel = node_path_1.default
-            .relative(node_path_1.default.dirname(indexPath), node_path_1.default.join(outDir, entry.file))
-            .split(node_path_1.default.sep)
-            .join('/');
-        return `/// <reference path="${rel}" />`;
-    });
-    const content = references.length > 0
-        ? `${header}
-${references.join('\n')}
-`
-        : `${header}
-`;
-    await promises_1.default.writeFile(indexPath, content, 'utf8');
-}
 function formatErrorMessage(error) {
     if (error instanceof Error && typeof error.message === 'string') {
         return error.message;
@@ -372,6 +341,23 @@ function formatErrorMessage(error) {
 function relativeToRoot(filePath, rootDir) {
     return node_path_1.default.relative(rootDir, filePath) || filePath;
 }
+function isWithinRoot(filePath, rootDir) {
+    const relative = node_path_1.default.relative(rootDir, filePath);
+    return relative === '' || (!relative.startsWith('..') && !node_path_1.default.isAbsolute(relative));
+}
+async function ensureSelectorModule(resolvedPath, selectors, previousManifest, nextManifest) {
+    const manifestKey = buildSelectorModuleManifestKey(resolvedPath);
+    const targetPath = buildSelectorModulePath(resolvedPath);
+    const source = formatSelectorModuleSource(selectors);
+    const hash = hashContent(source);
+    const previousEntry = previousManifest[manifestKey];
+    const needsWrite = previousEntry?.hash !== hash || !(await fileExists(targetPath));
+    if (needsWrite) {
+        await promises_1.default.writeFile(targetPath, source, 'utf8');
+    }
+    nextManifest[manifestKey] = { file: targetPath, hash };
+    return needsWrite;
+}
 async function fileExists(target) {
     try {
         await promises_1.default.access(target);
@@ -381,6 +367,78 @@ async function fileExists(target) {
         return false;
     }
 }
+async function resolveWithTsconfigPaths(specifier, tsconfig) {
+    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 = node_path_1.default.join(tsconfig.absoluteBaseUrl, specifier.split('/').join(node_path_1.default.sep));
+        if (await fileExists(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function loadTsconfigResolutionContext(rootDir, loader = get_tsconfig_1.getTsconfig) {
+    let result;
+    try {
+        result = loader(rootDir);
+    }
+    catch {
+        return undefined;
+    }
+    if (!result) {
+        return undefined;
+    }
+    const compilerOptions = result.config.compilerOptions ?? {};
+    const configDir = node_path_1.default.dirname(result.path);
+    const absoluteBaseUrl = compilerOptions.baseUrl
+        ? node_path_1.default.resolve(configDir, compilerOptions.baseUrl)
+        : undefined;
+    const normalizedPaths = normalizeTsconfigPaths(compilerOptions.paths);
+    const matchPath = absoluteBaseUrl && normalizedPaths
+        ? (0, tsconfig_paths_1.createMatchPath)(absoluteBaseUrl, normalizedPaths)
+        : undefined;
+    if (!absoluteBaseUrl && !matchPath) {
+        return undefined;
+    }
+    return { absoluteBaseUrl, matchPath };
+}
+function normalizeTsconfigPaths(paths) {
+    if (!paths) {
+        return undefined;
+    }
+    const normalized = {};
+    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) {
+    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) {
     const resolver = getProjectRequire(rootDir);
     return async (name) => {
@@ -423,7 +481,6 @@ async function runGenerateTypesCli(argv = process.argv.slice(2)) {
             rootDir: parsed.rootDir,
             include: parsed.include,
             outDir: parsed.outDir,
-            typesRoot: parsed.typesRoot,
             stableNamespace: parsed.stableNamespace,
         });
         reportCliResult(result);
@@ -438,12 +495,11 @@ function parseCliArgs(argv) {
     let rootDir = process.cwd();
     const include = [];
     let outDir;
-    let typesRoot;
     let stableNamespace;
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         if (arg === '--help' || arg === '-h') {
-            return { rootDir, include, outDir, typesRoot, stableNamespace, help: true };
+            return { rootDir, include, outDir, stableNamespace, help: true };
         }
         if (arg === '--root' || arg === '-r') {
             const value = argv[++i];
@@ -469,14 +525,6 @@ function parseCliArgs(argv) {
             outDir = value;
             continue;
         }
-        if (arg === '--types-root') {
-            const value = argv[++i];
-            if (!value) {
-                throw new Error('Missing value for --types-root');
-            }
-            typesRoot = value;
-            continue;
-        }
         if (arg === '--stable-namespace') {
             const value = argv[++i];
             if (!value) {
@@ -490,7 +538,7 @@ function parseCliArgs(argv) {
         }
         include.push(arg);
     }
-    return { rootDir, include, outDir, typesRoot, stableNamespace };
+    return { rootDir, include, outDir, stableNamespace };
 }
 function printHelp() {
     console.log(`Usage: knighted-css-generate-types [options]
@@ -498,32 +546,59 @@ function printHelp() {
 Options:
   -r, --root <path>              Project root directory (default: cwd)
   -i, --include <path>           Additional directories/files to scan (repeatable)
-      --out-dir <path>           Output directory for generated declarations
-      --types-root <path>        Directory for generated @types entrypoint
+      --out-dir <path>           Directory to store selector module manifest cache
       --stable-namespace <name>  Stable namespace prefix for generated selector maps
   -h, --help                     Show this help message
 `);
 }
 function reportCliResult(result) {
-    if (result.written === 0 && result.removed === 0) {
-        console.log('[knighted-css] No changes to ?knighted-css&types declarations (cache is up to date).');
+    if (result.selectorModulesWritten === 0 && result.selectorModulesRemoved === 0) {
+        console.log('[knighted-css] Selector modules are up to date.');
     }
     else {
-        console.log(`[knighted-css] Updated ${result.written} declaration(s), removed ${result.removed}, output in ${result.outDir}.`);
+        console.log(`[knighted-css] Selector modules updated: wrote ${result.selectorModulesWritten}, removed ${result.selectorModulesRemoved}.`);
     }
-    console.log(`[knighted-css] Type references: ${result.typesIndexPath}`);
+    console.log(`[knighted-css] Manifest: ${result.manifestPath}`);
     for (const warning of result.warnings) {
         console.warn(`[knighted-css] ${warning}`);
     }
 }
+function setCssWithMetaImplementation(impl) {
+    activeCssWithMeta = impl ?? css_js_1.cssWithMeta;
+}
+function setModuleTypeDetector(detector) {
+    moduleTypeDetector = detector ?? node_module_type_1.moduleType;
+}
+function setImportMetaUrlProvider(provider) {
+    importMetaUrlProvider = provider ?? getImportMetaUrl;
+}
 exports.__generateTypesInternals = {
     stripInlineLoader,
     splitResourceAndQuery,
-    buildDeclarationFileName,
-    formatModuleDeclaration,
-    formatSelectorType,
+    extractSelectorSourceSpecifier,
+    findSpecifierImports,
+    resolveImportPath,
+    resolvePackageRoot,
+    relativeToRoot,
+    collectCandidateFiles,
     normalizeIncludeOptions,
+    normalizeTsconfigPaths,
+    setCssWithMetaImplementation,
+    setModuleTypeDetector,
+    setImportMetaUrlProvider,
+    isNonRelativeSpecifier,
+    createProjectPeerResolver,
+    getProjectRequire,
+    loadTsconfigResolutionContext,
+    resolveWithTsconfigPaths,
     parseCliArgs,
     printHelp,
     reportCliResult,
+    buildSelectorModuleManifestKey,
+    buildSelectorModulePath,
+    formatSelectorModuleSource,
+    ensureSelectorModule,
+    removeStaleSelectorModules,
+    readManifest,
+    writeManifest,
 };

package/dist/cjs/generateTypes.d.cts

@@ -1,54 +1,103 @@
-import { type SelectorTypeVariant } from './loaderInternals.cjs';
-interface DeclarationRecord {
+import { createRequire } from 'node:module';
+import { moduleType } from 'node-module-type';
+import { getTsconfig } from 'get-tsconfig';
+import { type MatchPath } from 'tsconfig-paths';
+import { cssWithMeta } from './css.cjs';
+interface ImportMatch {
     specifier: string;
-    filePath: string;
+    importer: string;
 }
+interface ManifestEntry {
+    file: string;
+    hash: string;
+}
+type SelectorModuleManifest = Record<string, ManifestEntry>;
+interface TsconfigResolutionContext {
+    absoluteBaseUrl?: string;
+    matchPath?: MatchPath;
+}
+type CssWithMetaFn = typeof cssWithMeta;
 export interface GenerateTypesResult {
-    written: number;
-    removed: number;
-    declarations: DeclarationRecord[];
+    selectorModulesWritten: number;
+    selectorModulesRemoved: number;
     warnings: string[];
-    outDir: string;
-    typesIndexPath: string;
+    manifestPath: string;
 }
 export interface GenerateTypesOptions {
     rootDir?: string;
     include?: string[];
     outDir?: string;
-    typesRoot?: string;
     stableNamespace?: string;
 }
+type ModuleTypeDetector = () => ReturnType<typeof moduleType>;
+declare function resolvePackageRoot(): string;
 export declare function generateTypes(options?: GenerateTypesOptions): Promise<GenerateTypesResult>;
 declare function normalizeIncludeOptions(include: string[] | undefined, rootDir: string): string[];
+declare function collectCandidateFiles(entries: string[]): Promise<string[]>;
+declare function findSpecifierImports(filePath: string): Promise<ImportMatch[]>;
 declare function stripInlineLoader(specifier: string): string;
 declare function splitResourceAndQuery(specifier: string): {
     resource: string;
     query: string;
 };
-declare function buildDeclarationFileName(specifier: string): string;
-declare function formatModuleDeclaration(specifier: string, variant: SelectorTypeVariant, selectors: Map<string, string>): string;
-declare function formatSelectorType(selectors: Map<string, string>): string;
+declare function extractSelectorSourceSpecifier(specifier: string): string | undefined;
+declare function resolveImportPath(resourceSpecifier: string, importerPath: string, rootDir: string, tsconfig?: TsconfigResolutionContext): Promise<string | undefined>;
+declare function buildSelectorModuleManifestKey(resolvedPath: string): string;
+declare function buildSelectorModulePath(resolvedPath: string): string;
+declare function formatSelectorModuleSource(selectors: Map<string, string>): string;
+declare function readManifest(manifestPath: string): Promise<SelectorModuleManifest>;
+declare function writeManifest(manifestPath: string, manifest: SelectorModuleManifest): Promise<void>;
+declare function removeStaleSelectorModules(previous: SelectorModuleManifest, next: SelectorModuleManifest): Promise<number>;
+declare function relativeToRoot(filePath: string, rootDir: string): string;
+declare function ensureSelectorModule(resolvedPath: string, selectors: Map<string, string>, previousManifest: SelectorModuleManifest, nextManifest: SelectorModuleManifest): Promise<boolean>;
+declare function resolveWithTsconfigPaths(specifier: string, tsconfig?: TsconfigResolutionContext): Promise<string | undefined>;
+declare function loadTsconfigResolutionContext(rootDir: string, loader?: typeof getTsconfig): TsconfigResolutionContext | undefined;
+declare function normalizeTsconfigPaths(paths: Record<string, string[] | string> | undefined): Record<string, string[]> | undefined;
+declare function isNonRelativeSpecifier(specifier: string): boolean;
+declare function createProjectPeerResolver(rootDir: string): (name: string) => Promise<any>;
+declare function getProjectRequire(rootDir: string): ReturnType<typeof createRequire>;
 export declare function runGenerateTypesCli(argv?: string[]): Promise<void>;
 export interface ParsedCliArgs {
     rootDir: string;
     include?: string[];
     outDir?: string;
-    typesRoot?: string;
     stableNamespace?: string;
     help?: boolean;
 }
 declare function parseCliArgs(argv: string[]): ParsedCliArgs;
 declare function printHelp(): void;
 declare function reportCliResult(result: GenerateTypesResult): void;
+declare function setCssWithMetaImplementation(impl?: CssWithMetaFn): void;
+declare function setModuleTypeDetector(detector?: ModuleTypeDetector): void;
+declare function setImportMetaUrlProvider(provider?: () => string | undefined): void;
 export declare const __generateTypesInternals: {
     stripInlineLoader: typeof stripInlineLoader;
     splitResourceAndQuery: typeof splitResourceAndQuery;
-    buildDeclarationFileName: typeof buildDeclarationFileName;
-    formatModuleDeclaration: typeof formatModuleDeclaration;
-    formatSelectorType: typeof formatSelectorType;
+    extractSelectorSourceSpecifier: typeof extractSelectorSourceSpecifier;
+    findSpecifierImports: typeof findSpecifierImports;
+    resolveImportPath: typeof resolveImportPath;
+    resolvePackageRoot: typeof resolvePackageRoot;
+    relativeToRoot: typeof relativeToRoot;
+    collectCandidateFiles: typeof collectCandidateFiles;
     normalizeIncludeOptions: typeof normalizeIncludeOptions;
+    normalizeTsconfigPaths: typeof normalizeTsconfigPaths;
+    setCssWithMetaImplementation: typeof setCssWithMetaImplementation;
+    setModuleTypeDetector: typeof setModuleTypeDetector;
+    setImportMetaUrlProvider: typeof setImportMetaUrlProvider;
+    isNonRelativeSpecifier: typeof isNonRelativeSpecifier;
+    createProjectPeerResolver: typeof createProjectPeerResolver;
+    getProjectRequire: typeof getProjectRequire;
+    loadTsconfigResolutionContext: typeof loadTsconfigResolutionContext;
+    resolveWithTsconfigPaths: typeof resolveWithTsconfigPaths;
     parseCliArgs: typeof parseCliArgs;
     printHelp: typeof printHelp;
     reportCliResult: typeof reportCliResult;
+    buildSelectorModuleManifestKey: typeof buildSelectorModuleManifestKey;
+    buildSelectorModulePath: typeof buildSelectorModulePath;
+    formatSelectorModuleSource: typeof formatSelectorModuleSource;
+    ensureSelectorModule: typeof ensureSelectorModule;
+    removeStaleSelectorModules: typeof removeStaleSelectorModules;
+    readManifest: typeof readManifest;
+    writeManifest: typeof writeManifest;
 };
 export {};

package/dist/cjs/loader-helpers.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asKnightedCssCombinedModule = asKnightedCssCombinedModule;
+function asKnightedCssCombinedModule(module) {
+    return module;
+}