@csszyx/unplugin 0.9.0 → 0.9.1

package/dist/shared/unplugin.BceVw1eW.mjs

@@ -0,0 +1,184 @@
+import { createHash } from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+const CACHE_SCHEMA_VERSION = 6;
+function resolveTransformCacheDir(rootDir, cacheDir) {
+  return path.resolve(rootDir, cacheDir ?? ".csszyx/cache", "transform");
+}
+function createTransformCacheKey(input) {
+  const inputSha256 = 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: 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.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.dirname(file);
+  const tmp = path.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.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(tmp, JSON.stringify(entry), "utf8");
+    fs.renameSync(tmp, file);
+  } catch {
+    try {
+      fs.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.readFileSync(file, "utf8"));
+      const timestamp = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : 0;
+      if (!Number.isFinite(timestamp) || now - timestamp > options.maxAgeMs) {
+        fs.rmSync(file, { force: true });
+        deleted++;
+      } else {
+        survivors.push({ file, timestamp });
+      }
+    } catch {
+      fs.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.rmSync(survivor.file, { force: true });
+      deleted++;
+    }
+  }
+  return deleted;
+}
+function cacheEntryPath(cacheRoot, key) {
+  return path.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.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listJsonFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".json")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+export { readTransformCache as a, createTransformCacheKey as c, evictOldTransformCacheEntries as e, resolveTransformCacheDir as r, writeTransformCache as w };