@csszyx/unplugin 0.12.0 → 0.14.0

package/dist/shared/unplugin.BKGCkMgM.cjs

@@ -0,0 +1,523 @@
+'use strict';
+
+const path = require('node:path');
+const compiler = require('@csszyx/compiler');
+const fs = require('node:fs');
+const node_crypto = require('node:crypto');
+
+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 path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
+const fs__namespace = /*#__PURE__*/_interopNamespaceCompat(fs);
+
+const WINDOWS_PATH_SEPARATOR = String.fromCodePoint(92);
+function normalizePathSeparators(value) {
+  return value.split(WINDOWS_PATH_SEPARATOR).join("/");
+}
+
+const TSCONFIG_CANDIDATES = ["tsconfig.json", "jsconfig.json", "tsconfig.app.json"];
+const MAX_EXTENDS_DEPTH = 8;
+function collectSpecifierAliases(rootDir, resolveAlias) {
+  return [...aliasesFromResolveConfig(rootDir, resolveAlias), ...aliasesFromTsconfig(rootDir)];
+}
+function aliasesFromResolveConfig(rootDir, raw) {
+  const aliases = [];
+  if (Array.isArray(raw)) {
+    for (const entry of raw) {
+      const find = entry.find;
+      const replacement = entry.replacement;
+      if (typeof find !== "string" || typeof replacement !== "string") continue;
+      aliases.push(makeAlias(rootDir, find, replacement));
+    }
+    return aliases;
+  }
+  if (raw === null || typeof raw !== "object") return aliases;
+  for (const [find, target] of Object.entries(raw)) {
+    for (const value of Array.isArray(target) ? target : [target]) {
+      if (typeof value !== "string") continue;
+      aliases.push(makeAlias(rootDir, find, value));
+    }
+  }
+  return aliases;
+}
+function makeAlias(rootDir, find, replacement) {
+  const exact = find.endsWith("$");
+  return {
+    find: exact ? find.slice(0, -1) : find,
+    replacement: absolute(rootDir, replacement),
+    exact
+  };
+}
+function aliasesFromTsconfig(rootDir) {
+  for (const candidate of TSCONFIG_CANDIDATES) {
+    const loaded = loadPathsConfig(path__namespace.join(rootDir, candidate), 0);
+    if (loaded === void 0) continue;
+    const aliases = pathsToAliases(loaded.base, loaded.paths);
+    if (aliases.length > 0) return aliases;
+  }
+  return [];
+}
+function loadPathsConfig(configPath, depth) {
+  if (depth > MAX_EXTENDS_DEPTH) return void 0;
+  let parsed;
+  try {
+    parsed = parseJsonc(fs__namespace.readFileSync(configPath, "utf-8"));
+  } catch {
+    return void 0;
+  }
+  const directory = path__namespace.dirname(configPath);
+  const compilerOptions = asRecord(parsed.compilerOptions);
+  const paths = asRecord(compilerOptions?.paths);
+  if (paths !== void 0) {
+    const baseUrl = compilerOptions?.baseUrl;
+    return {
+      base: typeof baseUrl === "string" ? absolute(directory, baseUrl) : absolute(directory, "."),
+      paths
+    };
+  }
+  const extended = parsed.extends;
+  if (typeof extended !== "string" || !extended.startsWith(".")) return void 0;
+  const resolved = path__namespace.resolve(directory, extended);
+  return loadPathsConfig(resolved, depth + 1) ?? loadPathsConfig(`${resolved}.json`, depth + 1);
+}
+function pathsToAliases(base, paths) {
+  return Object.entries(paths).flatMap(
+    ([pattern, targets]) => patternToAliases(base, pattern, targets)
+  );
+}
+function patternToAliases(base, pattern, targets) {
+  const wildcard = pattern.indexOf("*");
+  if (wildcard !== -1 && wildcard !== pattern.length - 1) return [];
+  const exact = wildcard === -1;
+  const find = exact ? pattern : pattern.slice(0, -1);
+  const declared = Array.isArray(targets) ? targets : [targets];
+  return declared.filter((target) => typeof target === "string").map((target) => ({
+    find,
+    replacement: absolute(base, target.endsWith("*") ? target.slice(0, -1) : target),
+    exact
+  }));
+}
+function aliasedSpecifierBases(specifier, aliases) {
+  const bases = [];
+  for (const alias of aliases) {
+    if (alias.exact) {
+      if (specifier === alias.find) bases.push(alias.replacement);
+      continue;
+    }
+    if (!specifier.startsWith(alias.find)) continue;
+    bases.push(normalizePathSeparators(alias.replacement + specifier.slice(alias.find.length)));
+  }
+  return bases;
+}
+function absolute(directory, target) {
+  const resolved = normalizePathSeparators(path__namespace.resolve(directory, target));
+  const declaredTrailingSlash = target.endsWith("/") || target.endsWith("\\");
+  return declaredTrailingSlash && !resolved.endsWith("/") ? `${resolved}/` : resolved;
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function parseJsonc(text) {
+  const parsed = JSON.parse(stripComments(text).replace(/,(\s*[}\]])/g, "$1"));
+  return asRecord(parsed) ?? {};
+}
+function stripComments(text) {
+  const out = [];
+  let index = 0;
+  while (index < text.length) {
+    const run = consumeString(text, index) ?? consumeComment(text, index);
+    if (run === void 0) {
+      out.push(text[index]);
+      index += 1;
+      continue;
+    }
+    out.push(run.keep);
+    index = run.next;
+  }
+  return out.join("");
+}
+function consumeString(text, start) {
+  if (text[start] !== '"') return void 0;
+  let index = start + 1;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    index += 1;
+    if (char === '"') break;
+  }
+  return { keep: text.slice(start, index), next: index };
+}
+function consumeComment(text, start) {
+  if (text[start] !== "/") return void 0;
+  if (text[start + 1] === "/") {
+    const end = text.indexOf("\n", start);
+    return { keep: "", next: end === -1 ? text.length : end };
+  }
+  if (text[start + 1] === "*") {
+    const end = text.indexOf("*/", start + 2);
+    return { keep: "", next: end === -1 ? text.length : end + 2 };
+  }
+  return void 0;
+}
+
+function mayExportSzvFactories(content) {
+  return content.includes("szv(") && content.includes("export");
+}
+function recordSzvRegistryFile(registry, filePath, content) {
+  const entries = mayExportSzvFactories(content) ? compiler.extractCrossModuleRegistryEntries(content, filePath) : [];
+  replaceEntriesOfKind(registry, filePath, "szv-config", entries);
+}
+function recordSzObjectRegistryFile(registry, filePath, content) {
+  replaceEntriesOfKind(
+    registry,
+    filePath,
+    "sz-object",
+    compiler.extractCrossModuleRegistryEntries(content, filePath)
+  );
+}
+function replaceEntriesOfKind(registry, filePath, kind, entries) {
+  const key = normalizePathSeparators(filePath);
+  const byName = emptyNameIndex();
+  for (const [name, recorded] of Object.entries(registry.get(key) ?? {})) {
+    if (recorded.kind !== kind) byName[name] = recorded;
+  }
+  for (const entry of entries) {
+    if (entry.kind === kind) byName[entry.exportName] = { kind, value: entry.value };
+  }
+  if (Object.keys(byName).length === 0) registry.delete(key);
+  else registry.set(key, byName);
+}
+function emptyNameIndex() {
+  return /* @__PURE__ */ Object.create(null);
+}
+const SPECIFIER_PROBES = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx"];
+const EMITTED_EXTENSION_SOURCES = [
+  [".js", [".ts", ".tsx"]],
+  [".jsx", [".tsx"]],
+  [".mjs", [".mts"]],
+  [".cjs", [".cts"]]
+];
+function resolveCrossModuleStaticsFor(registry, filename, source, aliases = []) {
+  if (registry.size === 0 || !source.includes("from")) return {};
+  const directory = path__namespace.dirname(filename);
+  const resolved = {};
+  const seen = /* @__PURE__ */ new Set();
+  for (const specifier of importedSpecifiersIn(source)) {
+    if (seen.has(specifier)) continue;
+    seen.add(specifier);
+    const entries = firstRegistryHit(registry, specifier, directory, aliases);
+    if (entries !== void 0) fileUnderSpecifier(resolved, specifier, entries);
+  }
+  return resolved;
+}
+function firstRegistryHit(registry, specifier, directory, aliases) {
+  for (const base of specifierBases(specifier, directory, aliases)) {
+    const entries = lookupRegistryKey(registry, base);
+    if (entries !== void 0) return entries;
+  }
+  return void 0;
+}
+function recordResolvedEntry(resolved, kind, specifier, name, value) {
+  if (specifier === "__proto__" || name === "__proto__") return;
+  const channel = kind === "szv-config" ? "szvConfigs" : "szObjects";
+  let bySpecifier = resolved[channel];
+  if (bySpecifier === void 0) {
+    bySpecifier = emptyNameIndex();
+    resolved[channel] = bySpecifier;
+  }
+  let byName = bySpecifier[specifier];
+  if (byName === void 0) {
+    byName = emptyNameIndex();
+    bySpecifier[specifier] = byName;
+  }
+  byName[name] = value;
+}
+function fileUnderSpecifier(resolved, specifier, entries) {
+  for (const [name, recorded] of Object.entries(entries)) {
+    recordResolvedEntry(resolved, recorded.kind, specifier, name, recorded.value);
+  }
+}
+function importedSpecifiersIn(source) {
+  if (!source.includes("from")) return [];
+  return [...source.matchAll(/from\s*['"]([^'"]*)['"]/g)].map((match) => match[1]);
+}
+function specifierBases(specifier, directory, aliases) {
+  if (specifier.startsWith(".")) {
+    return [normalizePathSeparators(path__namespace.resolve(directory, specifier))];
+  }
+  return aliasedSpecifierBases(specifier, aliases);
+}
+function resolveProviderPath(seenPaths, base) {
+  return resolveProviderPathWith(base, (candidate) => seenPaths.has(candidate));
+}
+function resolveProviderPathWith(base, exists) {
+  return probeSpecifier(base, (candidate) => exists(candidate) ? candidate : void 0);
+}
+function probeSpecifier(base, lookup) {
+  for (const probe of SPECIFIER_PROBES) {
+    const found = lookup(`${base}${probe}`);
+    if (found !== void 0) return found;
+  }
+  for (const [emitted, sources] of EMITTED_EXTENSION_SOURCES) {
+    if (!base.endsWith(emitted)) continue;
+    const stem = base.slice(0, -emitted.length);
+    for (const extension of sources) {
+      const found = lookup(`${stem}${extension}`);
+      if (found !== void 0) return found;
+    }
+    break;
+  }
+  return void 0;
+}
+function lookupRegistryKey(registry, base) {
+  return probeSpecifier(base, (candidate) => registry.get(candidate));
+}
+
+function isReadableProviderFile(candidate) {
+  try {
+    return fs.existsSync(candidate) && fs.statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}
+
+const CACHE_SCHEMA_VERSION = 17;
+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}`,
+    `native=${input.nativeIdentity ?? "none"}`,
+    `parser=${input.parserMode}`,
+    `producer=${input.producer}`,
+    `astBudget=${input.astBudget ?? "default"}`,
+    `mangleVars=${input.mangleVars === true}`,
+    `mangleVarHoistMaxDepth=${input.mangleVarHoistMaxDepth ?? "default"}`,
+    `globalVarAliases=${JSON.stringify(globalVarAliases)}`,
+    `crossModuleStatics=${input.crossModuleStatics ?? "none"}`,
+    `crossModuleSzObjects=${input.crossModuleSzObjects ?? "none"}`,
+    `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.nativeIdentity !== (input.nativeIdentity ?? null) || 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()}-${node_crypto.randomUUID()}.json`);
+  const entry = {
+    version: CACHE_SCHEMA_VERSION,
+    pluginVersion: input.pluginVersion,
+    compilerVersion: input.compilerVersion,
+    nativeIdentity: input.nativeIdentity ?? null,
+    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,
+    usesSzcn: result.usesSzcn,
+    usesSzPart: result.usesSzPart,
+    usesSzvPick: result.usesSzvPick,
+    usesSzvPick1: result.usesSzvPick1,
+    szPartArgsProvable: result.szPartArgsProvable,
+    usesColorVar: result.usesColorVar,
+    usesSpacingVar: result.usesSpacingVar,
+    usesUnitVar: result.usesUnitVar,
+    usesBoolClass: result.usesBoolClass,
+    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,
+    usesSzcn: result.usesSzcn,
+    usesSzPart: result.usesSzPart,
+    usesSzvPick: result.usesSzvPick,
+    usesSzvPick1: result.usesSzvPick1,
+    szPartArgsProvable: result.szPartArgsProvable,
+    usesColorVar: result.usesColorVar,
+    usesSpacingVar: result.usesSpacingVar,
+    usesUnitVar: result.usesUnitVar,
+    usesBoolClass: result.usesBoolClass,
+    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;
+}
+function evictMemoryCacheToBudget(cache, totalCodeChars, maxEntries, maxCodeChars) {
+  let total = totalCodeChars;
+  while (cache.size > maxEntries || total > maxCodeChars && cache.size > 1) {
+    const oldest = cache.keys().next().value;
+    if (oldest === void 0) {
+      break;
+    }
+    const evicted = cache.get(oldest);
+    cache.delete(oldest);
+    total -= evicted?.code.length ?? 0;
+  }
+  return total;
+}
+
+exports.collectSpecifierAliases = collectSpecifierAliases;
+exports.createTransformCacheKey = createTransformCacheKey;
+exports.evictMemoryCacheToBudget = evictMemoryCacheToBudget;
+exports.evictOldTransformCacheEntries = evictOldTransformCacheEntries;
+exports.importedSpecifiersIn = importedSpecifiersIn;
+exports.isReadableProviderFile = isReadableProviderFile;
+exports.mayExportSzvFactories = mayExportSzvFactories;
+exports.normalizePathSeparators = normalizePathSeparators;
+exports.readTransformCache = readTransformCache;
+exports.recordResolvedEntry = recordResolvedEntry;
+exports.recordSzObjectRegistryFile = recordSzObjectRegistryFile;
+exports.recordSzvRegistryFile = recordSzvRegistryFile;
+exports.resolveCrossModuleStaticsFor = resolveCrossModuleStaticsFor;
+exports.resolveProviderPath = resolveProviderPath;
+exports.resolveProviderPathWith = resolveProviderPathWith;
+exports.resolveTransformCacheDir = resolveTransformCacheDir;
+exports.specifierBases = specifierBases;
+exports.writeTransformCache = writeTransformCache;

package/dist/shared/{unplugin.DMcbmP01.mjs → unplugin.BU0O4IkX.mjs}

@@ -165,11 +165,14 @@ function atomicRenameWithRetry(from, to, options = {}) {
 function isExistingShardEquivalent(filePath, shard) {
   try {
     const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
-    return parsed.version === 1 && parsed.sourcePath === shard.sourcePath && parsed.sourceHash === shard.sourceHash;
+    return parsed.version === 1 && parsed.sourcePath === shard.sourcePath && parsed.sourceHash === shard.sourceHash && sameClasses(parsed.classes, shard.classes);
   } catch {
     return false;
   }
 }
+function sameClasses(left, right) {
+  return Array.isArray(left) && left.length === right.length && left.every((value, index) => value === right[index]);
+}
 function normalizeShardInput(input) {
   const sourcePath = path.resolve(input.sourcePath);
   const classes = sortStrings(