@knighted/css 1.0.0-rc.9 → 1.0.0

package/dist/generateTypes.js

@@ -5,10 +5,12 @@ import { createRequire } from 'node:module';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { init, parse } from 'es-module-lexer';
 import { moduleType } from 'node-module-type';
+import { getTsconfig } from 'get-tsconfig';
+import { createMatchPath } from 'tsconfig-paths';
 import { cssWithMeta } from './css.js';
-import { determineSelectorVariant, hasQueryFlag, TYPES_QUERY_FLAG, } from './loaderInternals.js';
 import { buildStableSelectorsLiteral } from './stableSelectorsLiteral.js';
 import { resolveStableNamespace } from './stableNamespace.js';
+let activeCssWithMeta = cssWithMeta;
 const DEFAULT_SKIP_DIRS = new Set([
     'node_modules',
     '.git',
@@ -32,12 +34,14 @@ const SUPPORTED_EXTENSIONS = new Set([
     '.mjs',
     '.cjs',
 ]);
+let moduleTypeDetector = moduleType;
+let importMetaUrlProvider = getImportMetaUrl;
 function resolvePackageRoot() {
-    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)), '..');
     }
@@ -52,61 +56,55 @@ function getImportMetaUrl() {
     }
 }
 const PACKAGE_ROOT = resolvePackageRoot();
-const DEFAULT_TYPES_ROOT = path.join(PACKAGE_ROOT, 'types-stub');
-const DEFAULT_OUT_DIR = path.join(PACKAGE_ROOT, 'node_modules', '.knighted-css');
+const SELECTOR_REFERENCE = '.knighted-css';
+const SELECTOR_MODULE_SUFFIX = '.knighted-css.ts';
 export async function generateTypes(options = {}) {
     const rootDir = path.resolve(options.rootDir ?? process.cwd());
     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 cacheDir = path.resolve(options.outDir ?? path.join(rootDir, '.knighted-css'));
+    const tsconfig = loadTsconfigResolutionContext(rootDir);
     await init;
-    await fs.mkdir(outDir, { recursive: true });
-    await fs.mkdir(typesRoot, { recursive: true });
+    await fs.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 = path.join(options.outDir, 'manifest.json');
-    const previousManifest = await readManifest(manifestPath);
-    const nextManifest = {};
+    const selectorModulesManifestPath = path.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 || !hasQueryFlag(query, TYPES_QUERY_FLAG)) {
-                continue;
-            }
-            if (processedSpecifiers.has(cleaned)) {
+            const { resource } = splitResourceAndQuery(inlineFree);
+            const selectorSource = extractSelectorSourceSpecifier(resource);
+            if (!selectorSource) {
                 continue;
             }
             const resolvedNamespace = 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 cssWithMeta(resolvedPath, {
+                    const { css } = await activeCssWithMeta(resolvedPath, {
                         cwd: options.rootDir,
                         peerResolver,
                     });
@@ -123,38 +121,28 @@ async function generateDeclarations(options) {
                 }
                 selectorCache.set(cacheKey, selectorMap);
             }
-            const variant = determineSelectorVariant(query);
-            const declaration = formatModuleDeclaration(cleaned, variant, selectorMap);
-            const declarationHash = hashContent(declaration);
-            const fileName = buildDeclarationFileName(cleaned);
-            const targetPath = path.join(options.outDir, fileName);
-            const previousEntry = previousManifest[cleaned];
-            const needsWrite = previousEntry?.hash !== declarationHash || !(await fileExists(targetPath));
-            if (needsWrite) {
-                await fs.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 = path.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) {
@@ -212,18 +200,18 @@ async function findSpecifierImports(filePath) {
     catch {
         return [];
     }
-    if (!source.includes('?knighted-css')) {
+    if (!source.includes(SELECTOR_REFERENCE)) {
         return [];
     }
     const matches = [];
     const [imports] = 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];
@@ -246,8 +234,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('.')) {
@@ -256,6 +259,10 @@ async function resolveImportPath(resourceSpecifier, importerPath, rootDir) {
     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);
@@ -264,47 +271,29 @@ async function resolveImportPath(resourceSpecifier, importerPath, rootDir) {
         return undefined;
     }
 }
-function buildDeclarationFileName(specifier) {
-    const digest = crypto.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(path.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 crypto.createHash('sha1').update(content).digest('hex');
@@ -321,13 +310,12 @@ async function readManifest(manifestPath) {
 async function writeManifest(manifestPath, manifest) {
     await fs.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 = path.join(outDir, entry.file);
         try {
-            await fs.unlink(targetPath);
+            await fs.unlink(entry.file);
             removed += 1;
         }
         catch {
@@ -336,25 +324,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 = path
-            .relative(path.dirname(indexPath), path.join(outDir, entry.file))
-            .split(path.sep)
-            .join('/');
-        return `/// <reference path="${rel}" />`;
-    });
-    const content = references.length > 0
-        ? `${header}
-${references.join('\n')}
-`
-        : `${header}
-`;
-    await fs.writeFile(indexPath, content, 'utf8');
-}
 function formatErrorMessage(error) {
     if (error instanceof Error && typeof error.message === 'string') {
         return error.message;
@@ -364,6 +333,23 @@ function formatErrorMessage(error) {
 function relativeToRoot(filePath, rootDir) {
     return path.relative(rootDir, filePath) || filePath;
 }
+function isWithinRoot(filePath, rootDir) {
+    const relative = path.relative(rootDir, filePath);
+    return relative === '' || (!relative.startsWith('..') && !path.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 fs.writeFile(targetPath, source, 'utf8');
+    }
+    nextManifest[manifestKey] = { file: targetPath, hash };
+    return needsWrite;
+}
 async function fileExists(target) {
     try {
         await fs.access(target);
@@ -373,6 +359,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 = path.join(tsconfig.absoluteBaseUrl, specifier.split('/').join(path.sep));
+        if (await fileExists(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function loadTsconfigResolutionContext(rootDir, loader = getTsconfig) {
+    let result;
+    try {
+        result = loader(rootDir);
+    }
+    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) {
+    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) => {
@@ -415,7 +473,6 @@ export 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);
@@ -430,12 +487,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];
@@ -461,14 +517,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) {
@@ -482,7 +530,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]
@@ -490,32 +538,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 ?? cssWithMeta;
+}
+function setModuleTypeDetector(detector) {
+    moduleTypeDetector = detector ?? moduleType;
+}
+function setImportMetaUrlProvider(provider) {
+    importMetaUrlProvider = provider ?? getImportMetaUrl;
+}
 export const __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/loader-helpers.d.ts

@@ -0,0 +1,4 @@
+import type { KnightedCssCombinedModule } from './loader.js';
+type KnightedCssCombinedExtras = Readonly<Record<string, unknown>>;
+export declare function asKnightedCssCombinedModule<TModule, TExtras extends KnightedCssCombinedExtras = Record<never, never>>(module: unknown): KnightedCssCombinedModule<TModule, TExtras>;
+export {};

package/dist/loader-helpers.js

@@ -0,0 +1,3 @@
+export function asKnightedCssCombinedModule(module) {
+    return module;
+}

package/dist/loader.d.ts

@@ -1,6 +1,7 @@
 import type { LoaderDefinitionFunction, PitchLoaderDefinitionFunction } from 'webpack';
 import { type CssOptions } from './css.js';
-export type KnightedCssCombinedModule<TModule> = TModule & {
+type KnightedCssCombinedExtras = Readonly<Record<string, unknown>>;
+export type KnightedCssCombinedModule<TModule, TExtras extends KnightedCssCombinedExtras = Record<never, never>> = TModule & TExtras & {
     knightedCss: string;
 };
 export interface KnightedCssVanillaOptions {

package/dist/loader.js

@@ -15,6 +15,7 @@ const loader = async function loader(source) {
             namespace: resolvedNamespace,
             resourcePath: this.resourcePath,
             emitWarning: message => emitKnightedWarning(this, message),
+            target: 'js',
         })
         : undefined;
     const injection = buildInjection(css, {
@@ -77,6 +78,7 @@ export const pitch = function pitch() {
                 namespace: resolvedNamespace,
                 resourcePath: this.resourcePath,
                 emitWarning: message => emitKnightedWarning(this, message),
+                target: 'js',
             })
             : undefined;
         return createCombinedModule(request, css, {

package/dist/moduleGraph.js

@@ -191,7 +191,10 @@ function normalizeSpecifier(raw) {
     if (!trimmed || trimmed.startsWith('\0')) {
         return '';
     }
-    const queryIndex = trimmed.search(/[?#]/);
+    const querySearchOffset = trimmed.startsWith('#') ? 1 : 0;
+    const remainder = trimmed.slice(querySearchOffset);
+    const queryMatchIndex = remainder.search(/[?#]/);
+    const queryIndex = queryMatchIndex === -1 ? -1 : querySearchOffset + queryMatchIndex;
     const withoutQuery = queryIndex === -1 ? trimmed : trimmed.slice(0, queryIndex);
     if (!withoutQuery) {
         return '';
@@ -297,9 +300,7 @@ function createResolverFactory(cwd, extensions, scriptExtensions, graphOptions)
         options.extensionAlias = extensionAlias;
     }
     const tsconfigOption = resolveResolverTsconfig(graphOptions?.tsConfig, cwd);
-    if (tsconfigOption) {
-        options.tsconfig = tsconfigOption;
-    }
+    options.tsconfig = tsconfigOption ?? 'auto';
     return new ResolverFactory(options);
 }
 function buildExtensionAlias(scriptExtensions) {

package/dist/stableSelectors.d.ts

@@ -5,9 +5,24 @@ export interface StableClassNameOptions extends StableSelectorOptions {
     token?: string;
     join?: (values: string[]) => string;
 }
+export interface MergeStableClassSingleInput extends StableSelectorOptions {
+    hashed: string | string[];
+    selector?: string;
+    token: string;
+    join?: (values: string[]) => string;
+}
+export interface MergeStableClassBatchInput<Hashed extends Record<string, string | string[]>, Selectors extends Record<string, string> | undefined = Record<string, string>> extends StableSelectorOptions {
+    hashed: Hashed;
+    selectors?: Selectors;
+    join?: (values: string[]) => string;
+}
 export declare function stableToken(token: string, options?: StableSelectorOptions): string;
 export declare function stableClass(token: string, options?: StableSelectorOptions): string;
 export declare function stableSelector(token: string, options?: StableSelectorOptions): string;
 export declare function createStableClassFactory(options?: StableSelectorOptions): (token: string) => string;
 export declare function stableClassName<T extends Record<string, string>>(styles: T, key: keyof T | string, options?: StableClassNameOptions): string;
 export declare const stableClassFromModule: typeof stableClassName;
+export declare function mergeStableClass(input: MergeStableClassSingleInput): string;
+export declare function mergeStableClass<Hashed extends Record<string, string | string[]>>(input: MergeStableClassBatchInput<Hashed>): {
+    [Key in keyof Hashed]: string;
+};

package/dist/stableSelectors.js

@@ -1,5 +1,6 @@
 const DEFAULT_NAMESPACE = 'knighted';
 const defaultJoin = (values) => values.filter(Boolean).join(' ');
+const toArray = (value) => Array.isArray(value) ? value : [value];
 const normalizeToken = (token) => {
     const sanitized = token
         .trim()
@@ -34,3 +35,30 @@ export function stableClassName(styles, key, options) {
     return join([hashed, stable]);
 }
 export const stableClassFromModule = stableClassName;
+export function mergeStableClass(input) {
+    if ('token' in input) {
+        return mergeSingle(input);
+    }
+    return mergeBatch(input);
+}
+function mergeSingle(input) {
+    const join = input.join ?? defaultJoin;
+    const hashed = toArray(input.hashed);
+    const stable = input.selector?.trim().length
+        ? input.selector
+        : stableClass(input.token, { namespace: input.namespace });
+    return join([...hashed, stable]);
+}
+function mergeBatch(input) {
+    const join = input.join ?? defaultJoin;
+    const output = {};
+    for (const key of Object.keys(input.hashed)) {
+        const hashedValue = input.hashed[key];
+        const selector = input.selectors?.[String(key)];
+        const stable = selector?.trim().length
+            ? selector
+            : stableClass(String(key), { namespace: input.namespace });
+        output[key] = join([...toArray(hashedValue), stable]);
+    }
+    return output;
+}