@knighted/css 1.0.0-rc.1 → 1.0.0-rc.11

package/dist/cjs/generateTypes.d.cts

@@ -0,0 +1,108 @@
+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';
+import { type SelectorTypeVariant } from './loaderInternals.cjs';
+interface ManifestEntry {
+    file: string;
+    hash: string;
+}
+type Manifest = Record<string, ManifestEntry>;
+interface ImportMatch {
+    specifier: string;
+    importer: string;
+}
+interface DeclarationRecord {
+    specifier: string;
+    filePath: string;
+}
+interface TsconfigResolutionContext {
+    absoluteBaseUrl?: string;
+    matchPath?: MatchPath;
+}
+type CssWithMetaFn = typeof cssWithMeta;
+export interface GenerateTypesResult {
+    written: number;
+    removed: number;
+    declarations: DeclarationRecord[];
+    warnings: string[];
+    outDir: string;
+    typesIndexPath: 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 resolveImportPath(resourceSpecifier: string, importerPath: string, rootDir: string, tsconfig?: TsconfigResolutionContext): Promise<string | undefined>;
+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 buildDeclarationModuleSpecifier(resolvedPath: string, declarationDir: string, query: string): string;
+declare function buildCanonicalQuery(query: string): string;
+declare function writeTypesIndex(indexPath: string, manifest: Manifest, outDir: string): Promise<void>;
+declare function relativeToRoot(filePath: string, rootDir: string): string;
+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: {
+    writeTypesIndex: typeof writeTypesIndex;
+    stripInlineLoader: typeof stripInlineLoader;
+    splitResourceAndQuery: typeof splitResourceAndQuery;
+    findSpecifierImports: typeof findSpecifierImports;
+    resolveImportPath: typeof resolveImportPath;
+    resolvePackageRoot: typeof resolvePackageRoot;
+    buildDeclarationFileName: typeof buildDeclarationFileName;
+    formatModuleDeclaration: typeof formatModuleDeclaration;
+    formatSelectorType: typeof formatSelectorType;
+    buildDeclarationModuleSpecifier: typeof buildDeclarationModuleSpecifier;
+    buildCanonicalQuery: typeof buildCanonicalQuery;
+    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;
+};
+export {};

package/dist/cjs/loader.cjs

@@ -2,12 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pitch = void 0;
 const css_js_1 = require("./css.cjs");
+const moduleInfo_js_1 = require("./moduleInfo.cjs");
+const loaderInternals_js_1 = require("./loaderInternals.cjs");
+const stableSelectorsLiteral_js_1 = require("./stableSelectorsLiteral.cjs");
+const stableNamespace_js_1 = require("./stableNamespace.cjs");
 const DEFAULT_EXPORT_NAME = 'knightedCss';
-const COMBINED_QUERY_FLAG = 'combined';
 const loader = async function loader(source) {
-    const { cssOptions, vanillaOptions } = resolveLoaderOptions(this);
+    const { cssOptions, vanillaOptions, stableNamespace: optionNamespace, } = resolveLoaderOptions(this);
+    const resolvedNamespace = (0, stableNamespace_js_1.resolveStableNamespace)(optionNamespace);
+    const typesRequested = (0, loaderInternals_js_1.hasQueryFlag)(this.resourceQuery, loaderInternals_js_1.TYPES_QUERY_FLAG);
     const css = await extractCss(this, cssOptions);
-    const injection = buildInjection(css);
+    const stableSelectorsLiteral = typesRequested
+        ? (0, stableSelectorsLiteral_js_1.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 (0, css_js_1.compileVanillaModule)(this.resourcePath, cssOptions.cwd ?? this.rootContext ?? process.cwd(), cssOptions.peerResolver);
@@ -42,19 +57,43 @@ function maybeTransformVanillaModule(source, options) {
     return transformVanillaModuleToEsm(source);
 }
 const pitch = function pitch() {
-    if (!hasCombinedQuery(this.resourceQuery)) {
+    if (!(0, loaderInternals_js_1.hasCombinedQuery)(this.resourceQuery)) {
         return;
     }
     const request = buildProxyRequest(this);
-    const { cssOptions } = resolveLoaderOptions(this);
-    return extractCss(this, cssOptions).then(css => createCombinedModule(request, css));
+    const { cssOptions, stableNamespace: optionNamespace } = resolveLoaderOptions(this);
+    const typesRequested = (0, loaderInternals_js_1.hasQueryFlag)(this.resourceQuery, loaderInternals_js_1.TYPES_QUERY_FLAG);
+    const resolvedNamespace = (0, stableNamespace_js_1.resolveStableNamespace)(optionNamespace);
+    const skipSyntheticDefault = (0, loaderInternals_js_1.hasNamedOnlyQueryFlag)(this.resourceQuery);
+    const defaultSignalPromise = skipSyntheticDefault
+        ? Promise.resolve('unknown')
+        : (0, moduleInfo_js_1.detectModuleDefaultExport)(this.resourcePath);
+    return Promise.all([extractCss(this, cssOptions), defaultSignalPromise]).then(([css, defaultSignal]) => {
+        const emitDefault = (0, loaderInternals_js_1.shouldEmitCombinedDefault)({
+            request,
+            skipSyntheticDefault,
+            detection: defaultSignal,
+        });
+        const stableSelectorsLiteral = typesRequested
+            ? (0, stableSelectorsLiteral_js_1.buildStableSelectorsLiteral)({
+                css,
+                namespace: resolvedNamespace,
+                resourcePath: this.resourcePath,
+                emitWarning: message => emitKnightedWarning(this, message),
+            })
+            : undefined;
+        return createCombinedModule(request, css, {
+            emitDefault,
+            stableSelectorsLiteral: stableSelectorsLiteral?.literal,
+        });
+    });
 };
 exports.pitch = pitch;
 loader.pitch = exports.pitch;
 exports.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(),
@@ -62,6 +101,7 @@ function resolveLoaderOptions(ctx) {
     return {
         cssOptions,
         vanillaOptions: vanilla,
+        stableNamespace,
     };
 }
 async function extractCss(ctx, options) {
@@ -75,22 +115,15 @@ 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 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);
+    const sanitizedQuery = (0, loaderInternals_js_1.buildSanitizedQuery)(ctx.resourceQuery);
     const rawRequest = getRawRequest(ctx);
     if (rawRequest) {
         const stripped = stripResourceQuery(rawRequest);
@@ -115,51 +148,28 @@ function stripResourceQuery(request) {
     const idx = request.indexOf('?');
     return idx >= 0 ? request.slice(0, idx) : request;
 }
-function buildSanitizedQuery(query) {
-    if (!query)
-        return '';
-    const entries = splitQuery(query).filter(part => {
-        return !isQueryFlag(part, COMBINED_QUERY_FLAG) && !isQueryFlag(part, 'knighted-css');
-    });
-    return entries.length > 0 ? `?${entries.join('&')}` : '';
-}
-function splitQuery(query) {
-    const trimmed = query.startsWith('?') ? query.slice(1) : query;
-    if (!trimmed)
-        return [];
-    return trimmed.split('&').filter(Boolean);
-}
-function isQueryFlag(entry, flag) {
-    const [rawKey] = entry.split('=');
-    try {
-        return decodeURIComponent(rawKey) === flag;
-    }
-    catch {
-        return rawKey === flag;
-    }
-}
-function createCombinedModule(request, css) {
+function createCombinedModule(request, css, options) {
+    const shouldEmitDefault = options?.emitDefault ?? (0, loaderInternals_js_1.shouldForwardDefaultExport)(request);
     const requestLiteral = JSON.stringify(request);
     const lines = [
         `import * as __knightedModule from ${requestLiteral};`,
         `export * from ${requestLiteral};`,
     ];
-    if (shouldForwardDefaultExport(request)) {
+    if (shouldEmitDefault) {
         lines.push(`const __knightedDefault =
 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 shouldForwardDefaultExport(request) {
-    const [pathPart] = request.split('?');
-    if (!pathPart)
-        return true;
-    const lower = pathPart.toLowerCase();
-    if (lower.endsWith('.css.ts') || lower.endsWith('.css.js')) {
-        return false;
+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;
     }
-    return true;
+    // eslint-disable-next-line no-console
+    console.warn(formatted);
 }

package/dist/cjs/loader.d.cts

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__loaderInternals = exports.NAMED_ONLY_QUERY_FLAGS = exports.TYPES_QUERY_FLAG = exports.COMBINED_QUERY_FLAG = void 0;
+exports.splitQuery = splitQuery;
+exports.isQueryFlag = isQueryFlag;
+exports.buildSanitizedQuery = buildSanitizedQuery;
+exports.hasQueryFlag = hasQueryFlag;
+exports.shouldForwardDefaultExport = shouldForwardDefaultExport;
+exports.hasCombinedQuery = hasCombinedQuery;
+exports.hasNamedOnlyQueryFlag = hasNamedOnlyQueryFlag;
+exports.determineSelectorVariant = determineSelectorVariant;
+exports.shouldEmitCombinedDefault = shouldEmitCombinedDefault;
+exports.COMBINED_QUERY_FLAG = 'combined';
+exports.TYPES_QUERY_FLAG = 'types';
+exports.NAMED_ONLY_QUERY_FLAGS = ['named-only', 'no-default'];
+function splitQuery(query) {
+    const trimmed = query.startsWith('?') ? query.slice(1) : query;
+    if (!trimmed)
+        return [];
+    return trimmed.split('&').filter(Boolean);
+}
+function isQueryFlag(entry, flag) {
+    const [rawKey] = entry.split('=');
+    try {
+        return decodeURIComponent(rawKey) === flag;
+    }
+    catch {
+        return rawKey === flag;
+    }
+}
+function buildSanitizedQuery(query) {
+    if (!query)
+        return '';
+    const entries = splitQuery(query).filter(part => {
+        if (isQueryFlag(part, exports.COMBINED_QUERY_FLAG)) {
+            return false;
+        }
+        if (isQueryFlag(part, 'knighted-css')) {
+            return false;
+        }
+        if (isQueryFlag(part, exports.TYPES_QUERY_FLAG)) {
+            return false;
+        }
+        if (exports.NAMED_ONLY_QUERY_FLAGS.some(flag => isQueryFlag(part, flag))) {
+            return false;
+        }
+        return true;
+    });
+    return entries.length > 0 ? `?${entries.join('&')}` : '';
+}
+function hasQueryFlag(query, flag) {
+    if (!query)
+        return false;
+    const entries = splitQuery(query);
+    if (entries.length === 0)
+        return false;
+    return entries.some(part => isQueryFlag(part, flag));
+}
+function safeDecode(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function shouldForwardDefaultExport(request) {
+    const [pathPart] = request.split('?');
+    if (!pathPart)
+        return true;
+    const lower = pathPart.toLowerCase();
+    if (lower.endsWith('.css.ts') || lower.endsWith('.css.js')) {
+        return false;
+    }
+    return true;
+}
+function hasCombinedQuery(query) {
+    return hasQueryFlag(query, exports.COMBINED_QUERY_FLAG);
+}
+function hasNamedOnlyQueryFlag(query) {
+    return exports.NAMED_ONLY_QUERY_FLAGS.some(flag => hasQueryFlag(query, flag));
+}
+function determineSelectorVariant(query) {
+    if (hasCombinedQuery(query)) {
+        return hasNamedOnlyQueryFlag(query) ? 'combinedWithoutDefault' : 'combined';
+    }
+    return 'types';
+}
+function shouldEmitCombinedDefault(options) {
+    if (options.skipSyntheticDefault) {
+        return false;
+    }
+    if (!shouldForwardDefaultExport(options.request)) {
+        return false;
+    }
+    if (options.detection === 'has-default') {
+        return true;
+    }
+    if (options.detection === 'no-default') {
+        return false;
+    }
+    return true;
+}
+exports.__loaderInternals = {
+    buildSanitizedQuery,
+    shouldEmitCombinedDefault,
+    determineSelectorVariant,
+};

package/dist/cjs/loaderInternals.d.cts

@@ -0,0 +1,23 @@
+import type { ModuleDefaultSignal } from './moduleInfo.cjs';
+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;
+    skipSyntheticDefault: boolean;
+}): boolean;
+export declare const __loaderInternals: {
+    buildSanitizedQuery: typeof buildSanitizedQuery;
+    shouldEmitCombinedDefault: typeof shouldEmitCombinedDefault;
+    determineSelectorVariant: typeof determineSelectorVariant;
+};