@knighted/css 1.0.0-rc.7 → 1.0.0-rc.9

package/dist/generateTypes.js

@@ -0,0 +1,521 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+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 { cssWithMeta } from './css.js';
+import { determineSelectorVariant, hasQueryFlag, TYPES_QUERY_FLAG, } from './loaderInternals.js';
+import { buildStableSelectorsLiteral } from './stableSelectorsLiteral.js';
+import { resolveStableNamespace } from './stableNamespace.js';
+const DEFAULT_SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'coverage',
+    '.knighted-css',
+    '.next',
+    '.nuxt',
+    '.svelte-kit',
+    '.output',
+    'tmp',
+]);
+const SUPPORTED_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mts',
+    '.cts',
+    '.mjs',
+    '.cjs',
+]);
+function resolvePackageRoot() {
+    const detectedType = moduleType();
+    if (detectedType === 'commonjs' && typeof __dirname === 'string') {
+        return path.resolve(__dirname, '..');
+    }
+    const moduleUrl = getImportMetaUrl();
+    if (moduleUrl) {
+        return path.resolve(path.dirname(fileURLToPath(moduleUrl)), '..');
+    }
+    return path.resolve(process.cwd(), 'node_modules', '@knighted', 'css');
+}
+function getImportMetaUrl() {
+    try {
+        return (0, eval)('import.meta.url');
+    }
+    catch {
+        return undefined;
+    }
+}
+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');
+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);
+    await init;
+    await fs.mkdir(outDir, { recursive: true });
+    await fs.mkdir(typesRoot, { recursive: true });
+    const internalOptions = {
+        rootDir,
+        include,
+        outDir,
+        typesRoot,
+        stableNamespace: options.stableNamespace,
+    };
+    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 selectorCache = new Map();
+    const processedSpecifiers = new Set();
+    const declarations = [];
+    const warnings = [];
+    let writes = 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)) {
+                continue;
+            }
+            const resolvedNamespace = resolveStableNamespace(options.stableNamespace);
+            const resolvedPath = await resolveImportPath(resource, match.importer, options.rootDir);
+            if (!resolvedPath) {
+                warnings.push(`Unable to resolve ${resource} 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, {
+                        cwd: options.rootDir,
+                        peerResolver,
+                    });
+                    selectorMap = buildStableSelectorsLiteral({
+                        css,
+                        namespace: resolvedNamespace,
+                        resourcePath: resolvedPath,
+                        emitWarning: message => warnings.push(message),
+                    }).selectorMap;
+                }
+                catch (error) {
+                    warnings.push(`Failed to extract CSS for ${relativeToRoot(resolvedPath, options.rootDir)}: ${formatErrorMessage(error)}`);
+                    continue;
+                }
+                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;
+            }
+            nextManifest[cleaned] = { file: fileName, hash: declarationHash };
+            if (needsWrite) {
+                declarations.push({ specifier: cleaned, filePath: targetPath });
+            }
+            processedSpecifiers.add(cleaned);
+        }
+    }
+    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;
+    }
+    return {
+        written: writes,
+        removed,
+        declarations,
+        warnings,
+        outDir: options.outDir,
+        typesIndexPath,
+    };
+}
+function normalizeIncludeOptions(include, rootDir) {
+    if (!include || include.length === 0) {
+        return [rootDir];
+    }
+    return include.map(entry => path.isAbsolute(entry) ? entry : path.resolve(rootDir, entry));
+}
+async function collectCandidateFiles(entries) {
+    const files = [];
+    const visited = new Set();
+    async function walk(entryPath) {
+        const resolved = path.resolve(entryPath);
+        if (visited.has(resolved)) {
+            return;
+        }
+        visited.add(resolved);
+        let stat;
+        try {
+            stat = await fs.stat(resolved);
+        }
+        catch {
+            return;
+        }
+        if (stat.isDirectory()) {
+            const base = path.basename(resolved);
+            if (DEFAULT_SKIP_DIRS.has(base)) {
+                return;
+            }
+            const children = await fs.readdir(resolved, { withFileTypes: true });
+            for (const child of children) {
+                await walk(path.join(resolved, child.name));
+            }
+            return;
+        }
+        if (!stat.isFile()) {
+            return;
+        }
+        const ext = path.extname(resolved).toLowerCase();
+        if (!SUPPORTED_EXTENSIONS.has(ext)) {
+            return;
+        }
+        files.push(resolved);
+    }
+    for (const entry of entries) {
+        await walk(entry);
+    }
+    return files;
+}
+async function findSpecifierImports(filePath) {
+    let source;
+    try {
+        source = await fs.readFile(filePath, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    if (!source.includes('?knighted-css')) {
+        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')) {
+            matches.push({ specifier, importer: filePath });
+        }
+    }
+    const requireRegex = /require\((['"])([^'"`]+?\?knighted-css[^'"`]*)\1\)/g;
+    let reqMatch;
+    while ((reqMatch = requireRegex.exec(source)) !== null) {
+        const spec = reqMatch[2];
+        if (spec) {
+            matches.push({ specifier: spec, importer: filePath });
+        }
+    }
+    return matches;
+}
+function stripInlineLoader(specifier) {
+    const idx = specifier.lastIndexOf('!');
+    return idx >= 0 ? specifier.slice(idx + 1) : specifier;
+}
+function splitResourceAndQuery(specifier) {
+    const hashIndex = specifier.indexOf('#');
+    const trimmed = hashIndex >= 0 ? specifier.slice(0, hashIndex) : specifier;
+    const queryIndex = trimmed.indexOf('?');
+    if (queryIndex < 0) {
+        return { resource: trimmed, query: '' };
+    }
+    return { resource: trimmed.slice(0, queryIndex), query: trimmed.slice(queryIndex) };
+}
+const projectRequireCache = new Map();
+async function resolveImportPath(resourceSpecifier, importerPath, rootDir) {
+    if (!resourceSpecifier)
+        return undefined;
+    if (resourceSpecifier.startsWith('.')) {
+        return path.resolve(path.dirname(importerPath), resourceSpecifier);
+    }
+    if (resourceSpecifier.startsWith('/')) {
+        return path.resolve(rootDir, resourceSpecifier.slice(1));
+    }
+    const requireFromRoot = getProjectRequire(rootDir);
+    try {
+        return requireFromRoot.resolve(resourceSpecifier);
+    }
+    catch {
+        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 formatSelectorType(selectors) {
+    if (selectors.size === 0) {
+        return 'Readonly<Record<string, string>>';
+    }
+    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<{
+${lines.join('\n')}
+  }>`;
+}
+function hashContent(content) {
+    return crypto.createHash('sha1').update(content).digest('hex');
+}
+async function readManifest(manifestPath) {
+    try {
+        const raw = await fs.readFile(manifestPath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+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]);
+    let removed = 0;
+    for (const [, entry] of stale) {
+        const targetPath = path.join(outDir, entry.file);
+        try {
+            await fs.unlink(targetPath);
+            removed += 1;
+        }
+        catch {
+            // ignore
+        }
+    }
+    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;
+    }
+    return String(error);
+}
+function relativeToRoot(filePath, rootDir) {
+    return path.relative(rootDir, filePath) || filePath;
+}
+async function fileExists(target) {
+    try {
+        await fs.access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function createProjectPeerResolver(rootDir) {
+    const resolver = getProjectRequire(rootDir);
+    return async (name) => {
+        const resolved = resolver.resolve(name);
+        return import(pathToFileURL(resolved).href);
+    };
+}
+function getProjectRequire(rootDir) {
+    const cached = projectRequireCache.get(rootDir);
+    if (cached) {
+        return cached;
+    }
+    const anchor = path.join(rootDir, 'package.json');
+    let loader;
+    try {
+        loader = createRequire(anchor);
+    }
+    catch {
+        loader = createRequire(path.join(process.cwd(), 'package.json'));
+    }
+    projectRequireCache.set(rootDir, loader);
+    return loader;
+}
+export async function runGenerateTypesCli(argv = process.argv.slice(2)) {
+    let parsed;
+    try {
+        parsed = parseCliArgs(argv);
+    }
+    catch (error) {
+        console.error(`[knighted-css] ${formatErrorMessage(error)}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (parsed.help) {
+        printHelp();
+        return;
+    }
+    try {
+        const result = await generateTypes({
+            rootDir: parsed.rootDir,
+            include: parsed.include,
+            outDir: parsed.outDir,
+            typesRoot: parsed.typesRoot,
+            stableNamespace: parsed.stableNamespace,
+        });
+        reportCliResult(result);
+    }
+    catch (error) {
+        console.error('[knighted-css] generate-types failed.');
+        console.error(error);
+        process.exitCode = 1;
+    }
+}
+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 };
+        }
+        if (arg === '--root' || arg === '-r') {
+            const value = argv[++i];
+            if (!value) {
+                throw new Error('Missing value for --root');
+            }
+            rootDir = path.resolve(value);
+            continue;
+        }
+        if (arg === '--include' || arg === '-i') {
+            const value = argv[++i];
+            if (!value) {
+                throw new Error('Missing value for --include');
+            }
+            include.push(value);
+            continue;
+        }
+        if (arg === '--out-dir') {
+            const value = argv[++i];
+            if (!value) {
+                throw new Error('Missing value for --out-dir');
+            }
+            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) {
+                throw new Error('Missing value for --stable-namespace');
+            }
+            stableNamespace = value;
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            throw new Error(`Unknown flag: ${arg}`);
+        }
+        include.push(arg);
+    }
+    return { rootDir, include, outDir, typesRoot, stableNamespace };
+}
+function printHelp() {
+    console.log(`Usage: knighted-css-generate-types [options]
+
+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
+      --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).');
+    }
+    else {
+        console.log(`[knighted-css] Updated ${result.written} declaration(s), removed ${result.removed}, output in ${result.outDir}.`);
+    }
+    console.log(`[knighted-css] Type references: ${result.typesIndexPath}`);
+    for (const warning of result.warnings) {
+        console.warn(`[knighted-css] ${warning}`);
+    }
+}
+export const __generateTypesInternals = {
+    stripInlineLoader,
+    splitResourceAndQuery,
+    buildDeclarationFileName,
+    formatModuleDeclaration,
+    formatSelectorType,
+    normalizeIncludeOptions,
+    parseCliArgs,
+    printHelp,
+    reportCliResult,
+};

package/dist/loader.d.ts

@@ -8,6 +8,7 @@ export interface KnightedCssVanillaOptions {
 }
 export interface KnightedCssLoaderOptions extends CssOptions {
     vanilla?: KnightedCssVanillaOptions;
+    stableNamespace?: string;
 }
 declare const loader: LoaderDefinitionFunction<KnightedCssLoaderOptions>;
 export declare const pitch: PitchLoaderDefinitionFunction<KnightedCssLoaderOptions>;

package/dist/loader.js

@@ -1,11 +1,25 @@
 import { cssWithMeta, compileVanillaModule } from './css.js';
 import { detectModuleDefaultExport } from './moduleInfo.js';
-import { buildSanitizedQuery, COMBINED_QUERY_FLAG, isQueryFlag, NAMED_ONLY_QUERY_FLAGS, shouldEmitCombinedDefault, shouldForwardDefaultExport, splitQuery, } from './loaderInternals.js';
+import { buildSanitizedQuery, hasCombinedQuery, hasNamedOnlyQueryFlag, hasQueryFlag, shouldEmitCombinedDefault, shouldForwardDefaultExport, TYPES_QUERY_FLAG, } from './loaderInternals.js';
+import { buildStableSelectorsLiteral } from './stableSelectorsLiteral.js';
+import { resolveStableNamespace } from './stableNamespace.js';
 const DEFAULT_EXPORT_NAME = 'knightedCss';
 const loader = async function loader(source) {
-    const { cssOptions, vanillaOptions } = resolveLoaderOptions(this);
+    const { cssOptions, vanillaOptions, stableNamespace: optionNamespace, } = resolveLoaderOptions(this);
+    const resolvedNamespace = resolveStableNamespace(optionNamespace);
+    const typesRequested = hasQueryFlag(this.resourceQuery, TYPES_QUERY_FLAG);
     const css = await extractCss(this, cssOptions);
-    const injection = buildInjection(css);
+    const stableSelectorsLiteral = typesRequested
+        ? buildStableSelectorsLiteral({
+            css,
+            namespace: resolvedNamespace,
+            resourcePath: this.resourcePath,
+            emitWarning: message => emitKnightedWarning(this, message),
+        })
+        : undefined;
+    const injection = buildInjection(css, {
+        stableSelectorsLiteral: stableSelectorsLiteral?.literal,
+    });
     const isStyleModule = this.resourcePath.endsWith('.css.ts');
     if (isStyleModule) {
         const { source: compiledSource } = await compileVanillaModule(this.resourcePath, cssOptions.cwd ?? this.rootContext ?? process.cwd(), cssOptions.peerResolver);
@@ -44,7 +58,9 @@ export const pitch = function pitch() {
         return;
     }
     const request = buildProxyRequest(this);
-    const { cssOptions } = resolveLoaderOptions(this);
+    const { cssOptions, stableNamespace: optionNamespace } = resolveLoaderOptions(this);
+    const typesRequested = hasQueryFlag(this.resourceQuery, TYPES_QUERY_FLAG);
+    const resolvedNamespace = resolveStableNamespace(optionNamespace);
     const skipSyntheticDefault = hasNamedOnlyQueryFlag(this.resourceQuery);
     const defaultSignalPromise = skipSyntheticDefault
         ? Promise.resolve('unknown')
@@ -55,14 +71,25 @@ export const pitch = function pitch() {
             skipSyntheticDefault,
             detection: defaultSignal,
         });
-        return createCombinedModule(request, css, { emitDefault });
+        const stableSelectorsLiteral = typesRequested
+            ? buildStableSelectorsLiteral({
+                css,
+                namespace: resolvedNamespace,
+                resourcePath: this.resourcePath,
+                emitWarning: message => emitKnightedWarning(this, message),
+            })
+            : undefined;
+        return createCombinedModule(request, css, {
+            emitDefault,
+            stableSelectorsLiteral: stableSelectorsLiteral?.literal,
+        });
     });
 };
 loader.pitch = pitch;
 export default loader;
 function resolveLoaderOptions(ctx) {
     const rawOptions = (typeof ctx.getOptions === 'function' ? ctx.getOptions() : {});
-    const { vanilla, ...rest } = rawOptions;
+    const { vanilla, stableNamespace, ...rest } = rawOptions;
     const cssOptions = {
         ...rest,
         cwd: rest.cwd ?? ctx.rootContext ?? process.cwd(),
@@ -70,6 +97,7 @@ function resolveLoaderOptions(ctx) {
     return {
         cssOptions,
         vanillaOptions: vanilla,
+        stableNamespace,
     };
 }
 async function extractCss(ctx, options) {
@@ -83,25 +111,12 @@ async function extractCss(ctx, options) {
 function toSourceString(source) {
     return typeof source === 'string' ? source : source.toString('utf8');
 }
-function buildInjection(css) {
-    return `\n\nexport const ${DEFAULT_EXPORT_NAME} = ${JSON.stringify(css)};\n`;
-}
-function hasCombinedQuery(query) {
-    if (!query)
-        return false;
-    const trimmed = query.startsWith('?') ? query.slice(1) : query;
-    if (!trimmed)
-        return false;
-    return trimmed
-        .split('&')
-        .filter(Boolean)
-        .some(part => isQueryFlag(part, COMBINED_QUERY_FLAG));
-}
-function hasNamedOnlyQueryFlag(query) {
-    if (!query)
-        return false;
-    const entries = splitQuery(query);
-    return entries.some(part => NAMED_ONLY_QUERY_FLAGS.some(flag => isQueryFlag(part, flag)));
+function buildInjection(css, extras) {
+    const lines = [`\n\nexport const ${DEFAULT_EXPORT_NAME} = ${JSON.stringify(css)};\n`];
+    if (extras?.stableSelectorsLiteral) {
+        lines.push(extras.stableSelectorsLiteral);
+    }
+    return lines.join('');
 }
 function buildProxyRequest(ctx) {
     const sanitizedQuery = buildSanitizedQuery(ctx.resourceQuery);
@@ -142,6 +157,15 @@ typeof __knightedModule.default !== 'undefined'
   ? __knightedModule.default
   : __knightedModule;`, 'export default __knightedDefault;');
     }
-    lines.push(buildInjection(css));
+    lines.push(buildInjection(css, { stableSelectorsLiteral: options?.stableSelectorsLiteral }));
     return lines.join('\n');
 }
+function emitKnightedWarning(ctx, message) {
+    const formatted = `\x1b[33m@knighted/css warning\x1b[0m ${message}`;
+    if (typeof ctx.emitWarning === 'function') {
+        ctx.emitWarning(new Error(formatted));
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.warn(formatted);
+}

package/dist/loaderInternals.d.ts

@@ -1,10 +1,16 @@
 import type { ModuleDefaultSignal } from './moduleInfo.js';
 export declare const COMBINED_QUERY_FLAG = "combined";
+export declare const TYPES_QUERY_FLAG = "types";
 export declare const NAMED_ONLY_QUERY_FLAGS: readonly ["named-only", "no-default"];
+export type SelectorTypeVariant = 'types' | 'combined' | 'combinedWithoutDefault';
 export declare function splitQuery(query: string): string[];
 export declare function isQueryFlag(entry: string, flag: string): boolean;
 export declare function buildSanitizedQuery(query?: string | null): string;
+export declare function hasQueryFlag(query: string | null | undefined, flag: string): boolean;
 export declare function shouldForwardDefaultExport(request: string): boolean;
+export declare function hasCombinedQuery(query?: string | null): boolean;
+export declare function hasNamedOnlyQueryFlag(query?: string | null): boolean;
+export declare function determineSelectorVariant(query?: string | null): SelectorTypeVariant;
 export declare function shouldEmitCombinedDefault(options: {
     detection: ModuleDefaultSignal;
     request: string;
@@ -13,4 +19,5 @@ export declare function shouldEmitCombinedDefault(options: {
 export declare const __loaderInternals: {
     buildSanitizedQuery: typeof buildSanitizedQuery;
     shouldEmitCombinedDefault: typeof shouldEmitCombinedDefault;
+    determineSelectorVariant: typeof determineSelectorVariant;
 };