@knighted/css 1.0.0-rc.0 → 1.0.0-rc.10

package/dist/cjs/generateTypes.d.cts

@@ -0,0 +1,104 @@
+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 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;
+    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,32 +2,106 @@
 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 = resolveCssOptions(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 input = toSourceString(source);
+    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');
-    return isStyleModule ? `${injection}export default {};\n` : `${input}${injection}`;
+    if (isStyleModule) {
+        const { source: compiledSource } = await (0, css_js_1.compileVanillaModule)(this.resourcePath, cssOptions.cwd ?? this.rootContext ?? process.cwd(), cssOptions.peerResolver);
+        const vanillaSource = maybeTransformVanillaModule(compiledSource, vanillaOptions);
+        return `${vanillaSource}${injection}`;
+    }
+    const input = toSourceString(source);
+    return `${input}${injection}`;
 };
+function transformVanillaModuleToEsm(source) {
+    const exportBlock = /__export\([^,]+,\s*{([\s\S]*?)}\);/m.exec(source);
+    if (!exportBlock) {
+        return source;
+    }
+    const names = exportBlock[1]
+        .split(',')
+        .map(part => part.trim())
+        .filter(Boolean)
+        .map(entry => entry.split(':')[0]?.trim())
+        .filter(Boolean);
+    let transformed = source.replace(/module\.exports\s*=\s*__toCommonJS\([^;]+;\n?/m, '');
+    transformed = transformed.replace(/0 && \(module\.exports = {[^}]+}\);?\n?/m, '');
+    if (names.length > 0) {
+        transformed = `${transformed}\nexport { ${names.join(', ')} };\n`;
+    }
+    return transformed;
+}
+function maybeTransformVanillaModule(source, options) {
+    if (!options?.transformToEsm) {
+        return source;
+    }
+    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 = resolveCssOptions(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 resolveCssOptions(ctx) {
+function resolveLoaderOptions(ctx) {
     const rawOptions = (typeof ctx.getOptions === 'function' ? ctx.getOptions() : {});
+    const { vanilla, stableNamespace, ...rest } = rawOptions;
+    const cssOptions = {
+        ...rest,
+        cwd: rest.cwd ?? ctx.rootContext ?? process.cwd(),
+    };
     return {
-        ...rawOptions,
-        cwd: rawOptions.cwd ?? ctx.rootContext ?? process.cwd(),
+        cssOptions,
+        vanillaOptions: vanilla,
+        stableNamespace,
     };
 }
 async function extractCss(ctx, options) {
@@ -41,22 +115,20 @@ 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);
+        return `${stripped}${sanitizedQuery}`;
+    }
     const request = `${ctx.resourcePath}${sanitizedQuery}`;
     const context = ctx.context ?? ctx.rootContext ?? process.cwd();
     if (ctx.utils && typeof ctx.utils.contextify === 'function') {
@@ -64,40 +136,40 @@ function buildProxyRequest(ctx) {
     }
     return 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 getRawRequest(ctx) {
+    const mod = ctx._module;
+    const request = mod?.rawRequest;
+    if (typeof request === 'string' && request.length > 0) {
+        return request;
     }
+    return undefined;
+}
+function stripResourceQuery(request) {
+    const idx = request.indexOf('?');
+    return idx >= 0 ? request.slice(0, idx) : request;
 }
-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 defaultExport = `const __knightedDefault =
-typeof __knightedModule.default !== 'undefined'
-  ? __knightedModule.default
-  : __knightedModule;`;
-    return [
+    const lines = [
         `import * as __knightedModule from ${requestLiteral};`,
         `export * from ${requestLiteral};`,
-        defaultExport,
-        'export default __knightedDefault;',
-        buildInjection(css),
-    ].join('\n');
+    ];
+    if (shouldEmitDefault) {
+        lines.push(`const __knightedDefault =
+typeof __knightedModule.default !== 'undefined'
+  ? __knightedModule.default
+  : __knightedModule;`, 'export default __knightedDefault;');
+    }
+    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/cjs/loader.d.cts

@@ -3,7 +3,12 @@ import { type CssOptions } from './css.cjs';
 export type KnightedCssCombinedModule<TModule> = TModule & {
     knightedCss: string;
 };
+export interface KnightedCssVanillaOptions {
+    transformToEsm?: boolean;
+}
 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;
+};