@knighted/css 1.0.0-rc.6 → 1.0.0-rc.8

package/dist/loaderInternals.js

@@ -1,4 +1,5 @@
 export const COMBINED_QUERY_FLAG = 'combined';
+export const TYPES_QUERY_FLAG = 'types';
 export const NAMED_ONLY_QUERY_FLAGS = ['named-only', 'no-default'];
 export function splitQuery(query) {
     const trimmed = query.startsWith('?') ? query.slice(1) : query;
@@ -25,6 +26,9 @@ export function buildSanitizedQuery(query) {
         if (isQueryFlag(part, 'knighted-css')) {
             return false;
         }
+        if (isQueryFlag(part, TYPES_QUERY_FLAG)) {
+            return false;
+        }
         if (NAMED_ONLY_QUERY_FLAGS.some(flag => isQueryFlag(part, flag))) {
             return false;
         }
@@ -32,6 +36,22 @@ export function buildSanitizedQuery(query) {
     });
     return entries.length > 0 ? `?${entries.join('&')}` : '';
 }
+export 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;
+    }
+}
 export function shouldForwardDefaultExport(request) {
     const [pathPart] = request.split('?');
     if (!pathPart)
@@ -42,6 +62,18 @@ export function shouldForwardDefaultExport(request) {
     }
     return true;
 }
+export function hasCombinedQuery(query) {
+    return hasQueryFlag(query, COMBINED_QUERY_FLAG);
+}
+export function hasNamedOnlyQueryFlag(query) {
+    return NAMED_ONLY_QUERY_FLAGS.some(flag => hasQueryFlag(query, flag));
+}
+export function determineSelectorVariant(query) {
+    if (hasCombinedQuery(query)) {
+        return hasNamedOnlyQueryFlag(query) ? 'combinedWithoutDefault' : 'combined';
+    }
+    return 'types';
+}
 export function shouldEmitCombinedDefault(options) {
     if (options.skipSyntheticDefault) {
         return false;
@@ -60,4 +92,5 @@ export function shouldEmitCombinedDefault(options) {
 export const __loaderInternals = {
     buildSanitizedQuery,
     shouldEmitCombinedDefault,
+    determineSelectorVariant,
 };

package/dist/stableNamespace.d.ts

@@ -0,0 +1,3 @@
+declare const DEFAULT_STABLE_NAMESPACE = "knighted";
+export declare function resolveStableNamespace(optionNamespace?: string): string;
+export { DEFAULT_STABLE_NAMESPACE };

package/dist/stableNamespace.js

@@ -0,0 +1,8 @@
+const DEFAULT_STABLE_NAMESPACE = 'knighted';
+export function resolveStableNamespace(optionNamespace) {
+    if (typeof optionNamespace === 'string') {
+        return optionNamespace;
+    }
+    return DEFAULT_STABLE_NAMESPACE;
+}
+export { DEFAULT_STABLE_NAMESPACE };

package/dist/stableSelectorsLiteral.d.ts

@@ -0,0 +1,19 @@
+export interface StableSelectorsLiteralResult {
+    literal: string;
+    selectorMap: Map<string, string>;
+}
+export declare function buildStableSelectorsLiteral(options: {
+    css: string;
+    namespace: string;
+    resourcePath: string;
+    emitWarning: (message: string) => void;
+}): StableSelectorsLiteralResult;
+export declare function collectStableSelectors(css: string, namespace: string, filename?: string): Map<string, string>;
+declare function collectStableSelectorsByRegex(css: string, namespace: string): Map<string, string>;
+export declare function formatStableSelectorMap(map: Map<string, string>): string;
+export declare const __stableSelectorsLiteralInternals: {
+    collectStableSelectors: typeof collectStableSelectors;
+    collectStableSelectorsByRegex: typeof collectStableSelectorsByRegex;
+    formatStableSelectorMap: typeof formatStableSelectorMap;
+};
+export {};

package/dist/stableSelectorsLiteral.js

@@ -0,0 +1,98 @@
+import { transform as lightningTransform } from 'lightningcss';
+import { escapeRegex, serializeSelector } from './helpers.js';
+export function buildStableSelectorsLiteral(options) {
+    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(),
+        };
+    }
+    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 {
+        literal: `export const stableSelectors = ${formatStableSelectorMap(selectorMap)} as const;\n`,
+        selectorMap,
+    };
+}
+export function collectStableSelectors(css, namespace, filename) {
+    if (!namespace)
+        return new Map();
+    const astResult = collectStableSelectorsFromAst(css, namespace, filename);
+    if (astResult) {
+        return astResult;
+    }
+    return collectStableSelectorsByRegex(css, namespace);
+}
+function collectStableSelectorsFromAst(css, namespace, filename) {
+    try {
+        const tokens = new Map();
+        const escaped = escapeRegex(namespace);
+        const pattern = new RegExp(`\\.${escaped}-([A-Za-z0-9_-]+)`, 'g');
+        lightningTransform({
+            filename: filename ?? 'knighted-types-probe.css',
+            code: Buffer.from(css),
+            minify: false,
+            visitor: {
+                Rule: {
+                    style(rule) {
+                        const target = Array.isArray(rule?.selectors)
+                            ? rule
+                            : rule?.value && Array.isArray(rule.value.selectors)
+                                ? rule.value
+                                : undefined;
+                        if (!target)
+                            return rule;
+                        for (const selector of target.selectors) {
+                            const selectorStr = serializeSelector(selector);
+                            pattern.lastIndex = 0;
+                            let match;
+                            while ((match = pattern.exec(selectorStr)) !== null) {
+                                const token = match[1];
+                                if (!token)
+                                    continue;
+                                tokens.set(token, `${namespace}-${token}`);
+                            }
+                        }
+                        return rule;
+                    },
+                },
+            },
+        });
+        return tokens;
+    }
+    catch {
+        return undefined;
+    }
+}
+function collectStableSelectorsByRegex(css, namespace) {
+    const escaped = escapeRegex(namespace);
+    const pattern = new RegExp(`\\.${escaped}-([A-Za-z0-9_-]+)`, 'g');
+    const tokens = new Map();
+    let match;
+    while ((match = pattern.exec(css)) !== null) {
+        const token = match[1];
+        if (!token)
+            continue;
+        tokens.set(token, `${namespace}-${token}`);
+    }
+    return tokens;
+}
+export function formatStableSelectorMap(map) {
+    if (map.size === 0) {
+        return 'Object.freeze({})';
+    }
+    const entries = Array.from(map.entries()).sort(([a], [b]) => a.localeCompare(b));
+    const lines = entries.map(([token, selector]) => {
+        return `  ${JSON.stringify(token)}: ${JSON.stringify(selector)}`;
+    });
+    return `Object.freeze({\n${lines.join(',\n')}\n})`;
+}
+export const __stableSelectorsLiteralInternals = {
+    collectStableSelectors,
+    collectStableSelectorsByRegex,
+    formatStableSelectorMap,
+};

package/loader-queries.d.ts

@@ -6,6 +6,13 @@ declare module '*?knighted-css' {
   export const knightedCss: string
 }
 
+type KnightedCssStableSelectorMap = Readonly<Record<string, string>>
+
+declare module '*?knighted-css&types' {
+  export const knightedCss: string
+  export const stableSelectors: KnightedCssStableSelectorMap
+}
+
 /**
  * Ambient declaration for combined loader imports (e.g. "./file.tsx?knighted-css&combined").
  * These modules behave like the original module with an additional `knightedCss` export.
@@ -20,10 +27,35 @@ declare module '*?knighted-css&combined' {
   export const knightedCss: string
 }
 
-declare module '*?knighted-css&combined&named-only*' {
+declare module '*?knighted-css&combined&named-only' {
+  const combined: KnightedCssCombinedModule<Record<string, unknown>>
+  export default combined
+  export const knightedCss: string
+}
+
+declare module '*?knighted-css&combined&no-default' {
+  const combined: KnightedCssCombinedModule<Record<string, unknown>>
+  export default combined
   export const knightedCss: string
 }
 
-declare module '*?knighted-css&combined&no-default*' {
+declare module '*?knighted-css&combined&types' {
+  const combined: KnightedCssCombinedModule<Record<string, unknown>>
+  export default combined
+  export const knightedCss: string
+  export const stableSelectors: KnightedCssStableSelectorMap
+}
+
+declare module '*?knighted-css&combined&named-only&types' {
+  const combined: KnightedCssCombinedModule<Record<string, unknown>>
+  export default combined
+  export const knightedCss: string
+  export const stableSelectors: KnightedCssStableSelectorMap
+}
+
+declare module '*?knighted-css&combined&no-default&types' {
+  const combined: KnightedCssCombinedModule<Record<string, unknown>>
+  export default combined
   export const knightedCss: string
+  export const stableSelectors: KnightedCssStableSelectorMap
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knighted/css",
-  "version": "1.0.0-rc.6",
+  "version": "1.0.0-rc.8",
   "description": "A build-time utility that traverses JavaScript/TypeScript module dependency graphs to extract, compile, and optimize all imported CSS into a single, in-memory string.",
   "type": "module",
   "main": "./dist/css.js",
@@ -13,6 +13,9 @@
       "loader-queries": [
         "./loader-queries.d.ts"
       ],
+      "generate-types": [
+        "./dist/generateTypes.d.ts"
+      ],
       "*": [
         "./types.d.ts"
       ]
@@ -33,6 +36,11 @@
       "types": "./loader-queries.d.ts",
       "default": "./loader-queries.d.ts"
     },
+    "./generate-types": {
+      "types": "./dist/generateTypes.d.ts",
+      "import": "./dist/generateTypes.js",
+      "default": "./dist/generateTypes.js"
+    },
     "./stableSelectors": {
       "types": "./dist/stableSelectors.d.ts",
       "import": "./dist/stableSelectors.js",
@@ -58,16 +66,20 @@
     "vanilla-extract",
     "lightningcss"
   ],
+  "bin": {
+    "knighted-css-generate-types": "./bin/generate-types.js"
+  },
   "scripts": {
-    "build": "duel",
-    "check-types": "tsc --noEmit",
+    "build": "duel && node ./scripts/copy-types-stub.js",
+    "check-types": "tsc --noEmit --project tsconfig.json && tsc --noEmit --project tsconfig.tests.json",
     "test": "c8 --reporter=text --reporter=text-summary --reporter=lcov --include \"src/**/*.ts\" tsx --test test/**/*.test.ts",
     "prepack": "npm run build"
   },
   "dependencies": {
     "dependency-tree": "^11.2.0",
     "es-module-lexer": "^2.0.0",
-    "lightningcss": "^1.30.2"
+    "lightningcss": "^1.30.2",
+    "node-module-type": "^1.0.1"
   },
   "overrides": {
     "module-lookup-amd": {
@@ -94,7 +106,9 @@
     "dist",
     "loader-queries.d.ts",
     "types.d.ts",
-    "stable"
+    "stable",
+    "bin",
+    "types-stub"
   ],
   "author": "KCM <knightedcodemonkey@gmail.com>",
   "license": "MIT",

package/types-stub/index.d.ts

@@ -0,0 +1,5 @@
+// Placeholder stub for @knighted/css stable selector declarations.
+// Running `knighted-css-generate-types` replaces this file with project-specific
+// references into the generated `.knighted-css` manifest.
+
+export {}

package/types.d.ts

@@ -1,3 +1,4 @@
 /// <reference path="./loader-queries.d.ts" />
+/// <reference path="./types-stub/index.d.ts" />
 
 export * from './dist/css.js'