@knighted/css 1.0.0-rc.9 → 1.0.0

package/dist/cjs/loader-helpers.d.cts

@@ -0,0 +1,4 @@
+import type { KnightedCssCombinedModule } from './loader.cjs';
+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/cjs/loader.cjs

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

package/dist/cjs/loader.d.cts

@@ -1,6 +1,7 @@
 import type { LoaderDefinitionFunction, PitchLoaderDefinitionFunction } from 'webpack';
 import { type CssOptions } from './css.cjs';
-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/cjs/moduleGraph.cjs

@@ -197,7 +197,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 '';
@@ -303,9 +306,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 oxc_resolver_1.ResolverFactory(options);
 }
 function buildExtensionAlias(scriptExtensions) {

package/dist/cjs/stableSelectors.cjs

@@ -6,8 +6,10 @@ exports.stableClass = stableClass;
 exports.stableSelector = stableSelector;
 exports.createStableClassFactory = createStableClassFactory;
 exports.stableClassName = stableClassName;
+exports.mergeStableClass = mergeStableClass;
 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()
@@ -42,3 +44,30 @@ function stableClassName(styles, key, options) {
     return join([hashed, stable]);
 }
 exports.stableClassFromModule = stableClassName;
+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;
+}

package/dist/cjs/stableSelectors.d.cts

@@ -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/cjs/stableSelectorsLiteral.cjs

@@ -7,20 +7,23 @@ exports.formatStableSelectorMap = formatStableSelectorMap;
 const lightningcss_1 = require("lightningcss");
 const helpers_js_1 = require("./helpers.cjs");
 function buildStableSelectorsLiteral(options) {
+    const target = options.target ?? 'ts';
     const trimmedNamespace = options.namespace.trim();
     if (!trimmedNamespace) {
         options.emitWarning(`stableSelectors requested for ${options.resourcePath} but "stableNamespace" resolved to an empty value.`);
-        return {
-            literal: 'export const stableSelectors = {} as const;\n',
-            selectorMap: new Map(),
-        };
+        return finalizeLiteral(new Map(), target);
     }
     const selectorMap = collectStableSelectors(options.css, trimmedNamespace, options.resourcePath);
     if (selectorMap.size === 0) {
         options.emitWarning(`stableSelectors requested for ${options.resourcePath} but no selectors matched namespace "${trimmedNamespace}".`);
     }
+    return finalizeLiteral(selectorMap, target);
+}
+function finalizeLiteral(selectorMap, target) {
+    const formatted = formatStableSelectorMap(selectorMap);
+    const suffix = target === 'ts' ? ' as const' : '';
     return {
-        literal: `export const stableSelectors = ${formatStableSelectorMap(selectorMap)} as const;\n`,
+        literal: `export const stableSelectors = ${formatted}${suffix};\n`,
         selectorMap,
     };
 }

package/dist/cjs/stableSelectorsLiteral.d.cts

@@ -2,11 +2,13 @@ export interface StableSelectorsLiteralResult {
     literal: string;
     selectorMap: Map<string, string>;
 }
+type StableSelectorsLiteralTarget = 'ts' | 'js';
 export declare function buildStableSelectorsLiteral(options: {
     css: string;
     namespace: string;
     resourcePath: string;
     emitWarning: (message: string) => void;
+    target?: StableSelectorsLiteralTarget;
 }): StableSelectorsLiteralResult;
 export declare function collectStableSelectors(css: string, namespace: string, filename?: string): Map<string, string>;
 declare function collectStableSelectorsByRegex(css: string, namespace: string): Map<string, string>;

package/dist/generateTypes.d.ts

@@ -1,54 +1,103 @@
-import { type SelectorTypeVariant } from './loaderInternals.js';
-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.js';
+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 {};