@csszyx/unplugin 0.8.0 → 0.9.1

package/dist/shared/unplugin.DLrBgECN.d.mts

@@ -0,0 +1,282 @@
+import { GlobalVarUsageDiagnostic, CssVariableMangleValue, TransformSourceCodeOptions } from '@csszyx/compiler';
+import { PartialCsszyxConfig } from '@csszyx/types';
+import { Plugin } from 'esbuild';
+import { InputPluginOption } from 'rollup';
+import { UnpluginInstance, WebpackPluginInstance } from 'unplugin';
+import { PluginOption } from 'vite';
+
+/** Source location for one CSS custom-property occurrence. */
+interface CssVarLocation {
+    /** Source file path, when known. */
+    filePath: string;
+    /** 1-based source line. */
+    line: number;
+    /** 1-based source column. */
+    column: number;
+}
+/** One CSS custom-property definition. */
+interface CssVarDefinition extends CssVarLocation {
+    /** Custom-property name including the leading `--`. */
+    name: string;
+    /** Stable declaration scope key built from ancestor at-rules and selectors. */
+    scopeId: string;
+    /** Whether the definition lives inside a Tailwind v4 @theme block. */
+    tailwindOwned: boolean;
+    /** Whether this name is registered by an @property at-rule. */
+    registered: boolean;
+}
+/** One var(--token) reference. */
+interface CssVarReference extends CssVarLocation {
+    /** Custom-property name including the leading `--`. */
+    name: string;
+    /** Stable reference scope key built from ancestor at-rules and selectors. */
+    scopeId: string;
+    /** Declaration property or at-rule params where the reference appears. */
+    owner: string;
+    /** Whether the reference lives inside a Tailwind v4 @theme block. */
+    tailwindOwned: boolean;
+}
+/** CSS custom-property scan output for one CSS source. */
+interface CssVarScanResult {
+    /** Source file path, when known. */
+    filePath: string;
+    /** Custom-property declarations. */
+    definitions: CssVarDefinition[];
+    /** var(--token) references. */
+    references: CssVarReference[];
+    /** @property registered custom-property names. */
+    registered: string[];
+    /** Whether the file path appears to be third-party CSS. */
+    thirdParty: boolean;
+}
+/** Cache entry for one CSS variable scan result. */
+interface GlobalVarScanCacheEntry {
+    /** Cache key derived from file path, mtime, and content hash. */
+    key: string;
+    /** Cached scan result. */
+    result: CssVarScanResult;
+}
+/** Inputs used to derive a scan cache key. */
+interface GlobalVarScanCacheKeyInput {
+    /** Source file path. */
+    filePath: string;
+    /** CSS source text. */
+    css: string;
+    /** Source file mtime in milliseconds. */
+    mtimeMs: number;
+}
+/** CSS source supplied to the Phase H validation orchestrator. */
+interface GlobalVarCssSource {
+    /** Source file path. */
+    filePath: string;
+    /** CSS source text. */
+    css: string;
+    /** Source file mtime in milliseconds, used when cacheDir is set. */
+    mtimeMs?: number;
+}
+/** JS/TS/JSX/TSX source supplied to the Phase H validation orchestrator. */
+interface GlobalVarCodeSource {
+    /** Source file path. */
+    filePath: string;
+    /** JS/TS/JSX/TSX source text. */
+    code: string;
+}
+/** CSS asset supplied by a bundler output hook. */
+interface GlobalVarCssAssetSource {
+    /** CSS asset file name, relative to the build output or absolute. */
+    fileName: string;
+    /** CSS asset source contents. */
+    source: string | Uint8Array;
+    /** Source file mtime in milliseconds, used when cacheDir is set. */
+    mtimeMs?: number;
+}
+/** Options for scanning one CSS source. */
+interface ScanGlobalVarCssOptions {
+    /** File path used for diagnostics. */
+    filePath?: string;
+}
+/** Planner diagnostic severity. */
+type GlobalVarAliasDiagnosticSeverity = 'error';
+/** Planner diagnostic. */
+interface GlobalVarAliasDiagnostic {
+    /** Machine-readable diagnostic code. */
+    code: 'missing-definition' | 'tailwind-reserved' | 'tailwind-owned' | 'registered-property' | 'alias-collision';
+    /** Diagnostic severity. Phase H M2 is fail-closed. */
+    severity: GlobalVarAliasDiagnosticSeverity;
+    /** Related custom-property name. */
+    name: string;
+    /** Human-readable message. */
+    message: string;
+    /** Source location when available. */
+    location?: CssVarLocation;
+}
+/** One planned alias mapping. */
+interface GlobalVarAliasEntry {
+    /** Original app-owned custom-property name. */
+    original: string;
+    /** Deterministic short alias name. */
+    alias: string;
+    /** Declaration scopes where aliases must be emitted. */
+    scopes: string[];
+}
+/** Input to the pure global variable alias planner. */
+interface PlanGlobalVarAliasesInput {
+    /** CSS scan results. */
+    scans: CssVarScanResult[];
+    /** Explicit app-owned custom-property names. */
+    tokens?: string[];
+    /** Optional app-owned prefix discovery. Empty string disables discovery. */
+    autoPrefix?: string;
+    /** Prefix for generated aliases. Defaults to `---g`. */
+    aliasPrefix?: string;
+    /** Additional reserved names or prefixes. Prefixes may end with `*`. */
+    reserved?: string[];
+}
+/** Output from the pure global variable alias planner. */
+interface GlobalVarAliasPlan {
+    /** Deterministic alias entries. Empty when diagnostics contain errors. */
+    entries: GlobalVarAliasEntry[];
+    /** Original-to-alias lookup. Empty when diagnostics contain errors. */
+    aliases: Map<string, string>;
+    /** Planner diagnostics. */
+    diagnostics: GlobalVarAliasDiagnostic[];
+}
+/** Input for Phase H scanner/planner/diagnostics integration. */
+interface ValidateGlobalVarAliasInputsOptions {
+    /** CSS sources that define or reference custom properties. */
+    cssFiles: GlobalVarCssSource[];
+    /** JS/TS/JSX/TSX sources to scan for out-of-band usage. */
+    sourceFiles?: GlobalVarCodeSource[];
+    /** Explicit app-owned custom-property names. */
+    tokens?: string[];
+    /** Optional app-owned prefix discovery. Empty string disables discovery. */
+    autoPrefix?: string;
+    /** Prefix for generated aliases. Defaults to `---g`. */
+    aliasPrefix?: string;
+    /** Additional reserved names or prefixes. Prefixes may end with `*`. */
+    reserved?: string[];
+    /** Optional global-var scan cache directory. */
+    cacheDir?: string;
+}
+/** Input for building validation options from bundler output state. */
+interface CreateGlobalVarAliasValidationOptionsInput {
+    /** Project root used to normalize relative asset names. */
+    rootDir: string;
+    /** CSS assets emitted by the bundler. Non-CSS assets are ignored. */
+    cssAssets: GlobalVarCssAssetSource[];
+    /** Source files transformed or observed before bundling. */
+    sourceFiles?: GlobalVarCodeSource[];
+    /** Explicit app-owned custom-property names. */
+    tokens?: string[];
+    /** Optional app-owned prefix discovery. Empty string disables discovery. */
+    autoPrefix?: string;
+    /** Prefix for generated aliases. Defaults to `---g`. */
+    aliasPrefix?: string;
+    /** Additional reserved names or prefixes. Prefixes may end with `*`. */
+    reserved?: string[];
+    /** Optional global-var scan cache directory. */
+    cacheDir?: string;
+}
+/** Output from Phase H scanner/planner/diagnostics integration. */
+interface GlobalVarAliasValidationResult {
+    /** CSS scan results. */
+    scans: CssVarScanResult[];
+    /** Deterministic alias plan. */
+    plan: GlobalVarAliasPlan;
+    /** JS/JSX out-of-band usage diagnostics for planned candidates. */
+    usageDiagnostics: GlobalVarUsageDiagnostic[];
+}
+/** Options for rewriting CSS with a validated global variable alias plan. */
+interface RewriteGlobalVarCssAliasesOptions {
+    /** CSS source text. */
+    css: string;
+    /** Validated alias plan. Diagnostics keep the rewrite as a no-op. */
+    plan: GlobalVarAliasPlan;
+    /** Source file path used by PostCSS diagnostics/source maps. */
+    filePath?: string;
+}
+/** Result of a pure global variable CSS alias rewrite. */
+interface GlobalVarCssAliasRewriteResult {
+    /** Rewritten CSS source. */
+    css: string;
+    /** Number of alias declarations inserted. */
+    aliasDeclarations: number;
+    /** Number of `var(--token)` references rewritten. */
+    rewrittenReferences: number;
+    /** Planner diagnostics that prevented rewriting, when any. */
+    diagnostics: GlobalVarAliasDiagnostic[];
+}
+
+/**
+ * Extracts Phase H global custom-property aliases for manifest/debug tooling.
+ *
+ * The legacy `varMangleMap` also carries dynamic s/c-tier CSS variables. This
+ * helper keeps manifest consumers from guessing tiers by exposing only aliases
+ * that use the active generated prefix.
+ *
+ * @param varMangleMap CSS variable mangle metadata.
+ * @param aliasPrefix Active generated alias prefix.
+ * @param validationResult Validated CSS alias plan to include CSS-only aliases.
+ * @returns Original global variable names mapped to their generated aliases.
+ */
+declare function extractGlobalVarAliasesForManifest(varMangleMap: Record<string, CssVariableMangleValue>, aliasPrefix?: string, validationResult?: GlobalVarAliasValidationResult | null): Record<string, string>;
+/**
+ * Serializes the standalone global-var map asset when g-tier aliases exist.
+ *
+ * @param varMangleMap CSS variable mangle metadata.
+ * @param aliasPrefix Active generated alias prefix.
+ * @param validationResult Validated CSS alias plan to include CSS-only aliases.
+ * @returns JSON asset contents, or null when there are no global aliases.
+ */
+declare function createGlobalVarMapAssetSource(varMangleMap: Record<string, CssVariableMangleValue>, aliasPrefix?: string, validationResult?: GlobalVarAliasValidationResult | null): string | null;
+/**
+ * Normalizes compiler global-var aliases for transform-cache identity.
+ *
+ * @param aliases Compiler option value.
+ * @returns Stable original-to-alias entries.
+ */
+declare function normalizeGlobalVarAliasesForCache(aliases: TransformSourceCodeOptions['globalVarAliases']): Array<[string, string]>;
+/**
+ * Mangles class strings in bundled code (JS/HTML assets) using the given mangle map.
+ *
+ * Exported for unit testing; the plugin calls this via the thin private wrapper that
+ * supplies state.mangleMap.
+ *
+ * Pass 1:   Direct `className="..."` / `class="..."` static strings
+ * Pass 1.5: Template literal quasi (static) segments in `className:\`...\``
+ * Pass 2:   `className:EXPR` patterns with ternary operators containing quoted strings
+ * Pass 3:   Quoted string arguments to csszyx runtime helpers (_szMerge, _szIf, etc.)
+ *
+ * @param code     bundled source code
+ * @param mangleMap class-name → mangled-token mapping
+ * @returns code with mangled class names
+ */
+declare function mangleCodeClassesSync(code: string, mangleMap: Record<string, string>): string;
+declare const unplugin: UnpluginInstance<PartialCsszyxConfig, boolean>;
+/**
+ * Creates a Vite plugin array with both pre-transform and post-mangle plugins.
+ * @param options - csszyx configuration options
+ * @returns array of Vite plugins for pre-transform and post-mangle phases
+ */
+declare const vitePlugin: (options?: PartialCsszyxConfig) => PluginOption[];
+/**
+ * Creates a combined Webpack plugin that applies both pre-transform and post-mangle phases.
+ * @param options - csszyx configuration options
+ * @returns a Webpack plugin instance combining both phases
+ */
+declare const webpackPlugin: (options?: PartialCsszyxConfig) => WebpackPluginInstance;
+/**
+ * Creates a Rollup plugin array with both pre-transform and post-mangle plugins.
+ * @param options - csszyx configuration options
+ * @returns array of Rollup plugins for pre-transform and post-mangle phases
+ */
+declare const rollupPlugin: (options?: PartialCsszyxConfig) => InputPluginOption[];
+/**
+ * Creates an esbuild plugin that delegates setup to both pre-transform and post-mangle plugins.
+ * @param options - csszyx configuration options
+ * @returns an esbuild plugin combining both pre-transform and post-mangle phases
+ */
+declare const esbuildPlugin: (options?: PartialCsszyxConfig) => Plugin;
+
+export { createGlobalVarMapAssetSource as o, esbuildPlugin as p, extractGlobalVarAliasesForManifest as q, mangleCodeClassesSync as r, normalizeGlobalVarAliasesForCache as s, rollupPlugin as t, unplugin as u, vitePlugin as v, webpackPlugin as w };
+export type { CssVarScanResult as C, GlobalVarScanCacheKeyInput as G, PlanGlobalVarAliasesInput as P, RewriteGlobalVarCssAliasesOptions as R, ScanGlobalVarCssOptions as S, ValidateGlobalVarAliasInputsOptions as V, GlobalVarAliasPlan as a, GlobalVarCssAliasRewriteResult as b, CreateGlobalVarAliasValidationOptionsInput as c, GlobalVarAliasValidationResult as d, CssVarDefinition as e, CssVarLocation as f, CssVarReference as g, GlobalVarAliasDiagnostic as h, GlobalVarAliasDiagnosticSeverity as i, GlobalVarAliasEntry as j, GlobalVarCodeSource as k, GlobalVarCssAssetSource as l, GlobalVarCssSource as m, GlobalVarScanCacheEntry as n };

package/dist/shared/unplugin.DUxdYaSG.cjs

@@ -0,0 +1,205 @@
+'use strict';
+
+const node_crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+function _interopNamespaceCompat(e) {
+    if (e && typeof e === 'object' && 'default' in e) return e;
+    const n = Object.create(null);
+    if (e) {
+        for (const k in e) {
+            n[k] = e[k];
+        }
+    }
+    n.default = e;
+    return n;
+}
+
+const fs__namespace = /*#__PURE__*/_interopNamespaceCompat(fs);
+const path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
+
+const CACHE_SCHEMA_VERSION = 6;
+function resolveTransformCacheDir(rootDir, cacheDir) {
+  return path__namespace.resolve(rootDir, cacheDir ?? ".csszyx/cache", "transform");
+}
+function createTransformCacheKey(input) {
+  const inputSha256 = node_crypto.createHash("sha256").update(input.source).digest("hex");
+  const globalVarAliases = normalizeGlobalVarAliasEntries(input.globalVarAliases);
+  const keyMaterial = [
+    `schema=${CACHE_SCHEMA_VERSION}`,
+    `plugin=${input.pluginVersion}`,
+    `compiler=${input.compilerVersion}`,
+    `parser=${input.parserMode}`,
+    `producer=${input.producer}`,
+    `astBudget=${input.astBudget ?? "default"}`,
+    `mangleVars=${input.mangleVars === true}`,
+    `mangleVarHoistMaxDepth=${input.mangleVarHoistMaxDepth ?? "default"}`,
+    `globalVarAliases=${JSON.stringify(globalVarAliases)}`,
+    `filename=${input.filename}`,
+    `source=${inputSha256}`
+  ].join("\n");
+  return {
+    key: node_crypto.createHash("sha256").update(keyMaterial).digest("hex").slice(0, 16),
+    inputSha256
+  };
+}
+function readTransformCache(cacheRoot, input, precomputedKey) {
+  const { key, inputSha256 } = precomputedKey ?? createTransformCacheKey(input);
+  const globalVarAliases = normalizeGlobalVarAliasEntries(input.globalVarAliases);
+  const file = cacheEntryPath(cacheRoot, key);
+  let entry;
+  try {
+    entry = JSON.parse(fs__namespace.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (entry.version !== CACHE_SCHEMA_VERSION || entry.pluginVersion !== input.pluginVersion || entry.compilerVersion !== input.compilerVersion || entry.parserMode !== input.parserMode || entry.producer !== input.producer || entry.astBudget !== (input.astBudget ?? null) || entry.mangleVars !== (input.mangleVars === true) || entry.mangleVarHoistMaxDepth !== (input.mangleVarHoistMaxDepth ?? null) || !sameGlobalVarAliases(entry.globalVarAliases, globalVarAliases) || entry.filename !== input.filename || entry.inputSha256 !== inputSha256) {
+    return null;
+  }
+  return deserializeResult(entry.result);
+}
+function writeTransformCache(cacheRoot, input, result, precomputedKey) {
+  const { key, inputSha256 } = precomputedKey ?? createTransformCacheKey(input);
+  const globalVarAliases = normalizeGlobalVarAliasEntries(input.globalVarAliases);
+  const file = cacheEntryPath(cacheRoot, key);
+  const dir = path__namespace.dirname(file);
+  const tmp = path__namespace.join(
+    dir,
+    `.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.json`
+  );
+  const entry = {
+    version: CACHE_SCHEMA_VERSION,
+    pluginVersion: input.pluginVersion,
+    compilerVersion: input.compilerVersion,
+    parserMode: input.parserMode,
+    producer: input.producer,
+    astBudget: input.astBudget ?? null,
+    mangleVars: input.mangleVars === true,
+    mangleVarHoistMaxDepth: input.mangleVarHoistMaxDepth ?? null,
+    globalVarAliases,
+    filename: input.filename,
+    inputSha256,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    result: serializeResult(result)
+  };
+  try {
+    fs__namespace.mkdirSync(dir, { recursive: true });
+    fs__namespace.writeFileSync(tmp, JSON.stringify(entry), "utf8");
+    fs__namespace.renameSync(tmp, file);
+  } catch {
+    try {
+      fs__namespace.rmSync(tmp, { force: true });
+    } catch {
+    }
+  }
+}
+function evictOldTransformCacheEntries(cacheRoot, options) {
+  let deleted = 0;
+  const now = options.now ?? Date.now();
+  const survivors = [];
+  for (const file of listJsonFiles(cacheRoot)) {
+    try {
+      const entry = JSON.parse(fs__namespace.readFileSync(file, "utf8"));
+      const timestamp = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : 0;
+      if (!Number.isFinite(timestamp) || now - timestamp > options.maxAgeMs) {
+        fs__namespace.rmSync(file, { force: true });
+        deleted++;
+      } else {
+        survivors.push({ file, timestamp });
+      }
+    } catch {
+      fs__namespace.rmSync(file, { force: true });
+      deleted++;
+    }
+  }
+  const overflow = survivors.length - options.maxEntries ;
+  if (overflow > 0) {
+    survivors.sort((a, b) => a.timestamp - b.timestamp);
+    for (const survivor of survivors.slice(0, overflow)) {
+      fs__namespace.rmSync(survivor.file, { force: true });
+      deleted++;
+    }
+  }
+  return deleted;
+}
+function cacheEntryPath(cacheRoot, key) {
+  return path__namespace.join(cacheRoot, key.slice(0, 2), `${key.slice(2)}.json`);
+}
+function serializeResult(result) {
+  return {
+    code: result.code,
+    transformed: result.transformed,
+    usesRuntime: result.usesRuntime,
+    usesMerge: result.usesMerge,
+    usesColorVar: result.usesColorVar,
+    classes: [...result.classes],
+    rawClassNames: [...result.rawClassNames],
+    diagnostics: [...result.diagnostics],
+    recoveryTokens: [...result.recoveryTokens],
+    cssVariableMap: [...result.cssVariableMap ?? /* @__PURE__ */ new Map()]
+  };
+}
+function deserializeResult(result) {
+  return {
+    code: result.code,
+    transformed: result.transformed,
+    usesRuntime: result.usesRuntime,
+    usesMerge: result.usesMerge,
+    usesColorVar: result.usesColorVar,
+    classes: new Set(result.classes),
+    rawClassNames: new Set(result.rawClassNames),
+    diagnostics: [...result.diagnostics],
+    recoveryTokens: new Map(result.recoveryTokens),
+    cssVariableMap: new Map(result.cssVariableMap ?? [])
+  };
+}
+function normalizeGlobalVarAliasEntries(aliases) {
+  if (!aliases || aliases.length === 0) {
+    return [];
+  }
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [original, alias] of aliases) {
+    if (typeof original === "string" && typeof alias === "string") {
+      normalized.set(original, alias);
+    }
+  }
+  return [...normalized].sort(([left], [right]) => left.localeCompare(right));
+}
+function sameGlobalVarAliases(left, right) {
+  if (!Array.isArray(left) || left.length !== right.length) {
+    return false;
+  }
+  for (let index = 0; index < left.length; index++) {
+    const leftEntry = left[index];
+    const rightEntry = right[index];
+    if (leftEntry?.[0] !== rightEntry?.[0] || leftEntry?.[1] !== rightEntry?.[1]) {
+      return false;
+    }
+  }
+  return true;
+}
+function listJsonFiles(dir) {
+  let entries;
+  try {
+    entries = fs__namespace.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path__namespace.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listJsonFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".json")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+exports.createTransformCacheKey = createTransformCacheKey;
+exports.evictOldTransformCacheEntries = evictOldTransformCacheEntries;
+exports.readTransformCache = readTransformCache;
+exports.resolveTransformCacheDir = resolveTransformCacheDir;
+exports.writeTransformCache = writeTransformCache;