@csszyx/unplugin 0.8.0 → 0.9.1

package/dist/shared/unplugin.B_U4rZvG.cjs

@@ -0,0 +1,281 @@
+'use strict';
+
+const fs = require('node:fs');
+const compiler = require('@csszyx/compiler');
+const transformCache = require('./unplugin.DUxdYaSG.cjs');
+const node_crypto = require('node:crypto');
+
+function readPackageVersion(relativePackageJson, fromUrl) {
+  try {
+    const packageJson = JSON.parse(
+      fs.readFileSync(new URL(relativePackageJson, fromUrl), "utf8")
+    );
+    return typeof packageJson.version === "string" ? packageJson.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+function transformNextSource(input) {
+  const filename = normalizeSourceFilename(input.filename);
+  const producer = input.parserMode;
+  const cacheInput = createNextSourceTransformCacheInput(input, filename, producer);
+  if (input.parserMode === "rust") {
+    compiler.ensureRustTransformAvailable();
+  }
+  const cacheKey = input.cacheRoot ? transformCache.createTransformCacheKey(cacheInput) : null;
+  if (input.cacheRoot && cacheKey) {
+    const cached = transformCache.readTransformCache(input.cacheRoot, cacheInput, cacheKey);
+    if (cached) {
+      return { result: cached, cacheStatus: "hit", producer };
+    }
+  }
+  const result = runNextSourceTransform(input, filename);
+  assertNoUnsafePassThrough(input.source, result.result, filename);
+  if (input.cacheRoot && cacheKey && result.producer === producer) {
+    transformCache.writeTransformCache(input.cacheRoot, cacheInput, result.result, cacheKey);
+    return { ...result, cacheStatus: "write" };
+  }
+  return { ...result, cacheStatus: input.cacheRoot ? "miss" : "disabled" };
+}
+function assertNoUnsafePassThrough(source, result, filename) {
+  if (!hasSzSyntax(source)) {
+    return;
+  }
+  if (!result.transformed && result.code === source) {
+    throw new Error(
+      `[csszyx] Next source transform failed closed for ${filename}: source still contains csszyx sz syntax.`
+    );
+  }
+}
+function hasSzSyntax(source) {
+  const cleaned = stripJsCommentsAndStrings(source);
+  return /\bsz\s*=/.test(cleaned) || /\bsz\s*:\s*[{"']/.test(cleaned);
+}
+function stripJsCommentsAndStrings(source) {
+  let out = "";
+  let index = 0;
+  const length = source.length;
+  while (index < length) {
+    const char = source[index];
+    const peek = index + 1 < length ? source[index + 1] : "";
+    if (char === "/" && peek === "/") {
+      index += 2;
+      while (index < length && source[index] !== "\n") {
+        index++;
+      }
+      continue;
+    }
+    if (char === "/" && peek === "*") {
+      index += 2;
+      while (index + 1 < length && !(source[index] === "*" && source[index + 1] === "/")) {
+        index++;
+      }
+      index = Math.min(length, index + 2);
+      continue;
+    }
+    if (char === "/" && isRegexLiteralStart(out)) {
+      index++;
+      let inCharClass = false;
+      while (index < length) {
+        const current = source[index];
+        if (current === "\\" && index + 1 < length) {
+          index += 2;
+          continue;
+        }
+        if (current === "[") {
+          inCharClass = true;
+          index++;
+          continue;
+        }
+        if (current === "]") {
+          inCharClass = false;
+          index++;
+          continue;
+        }
+        if (current === "/" && !inCharClass) {
+          index++;
+          while (/[a-z]/i.test(source[index] ?? "")) {
+            index++;
+          }
+          break;
+        }
+        index++;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      const quote = char;
+      index++;
+      while (index < length && source[index] !== quote) {
+        if (source[index] === "\\" && index + 1 < length) {
+          index += 2;
+        } else {
+          index++;
+        }
+      }
+      index++;
+      continue;
+    }
+    out += char;
+    index++;
+  }
+  return out;
+}
+function isRegexLiteralStart(emitted) {
+  const trimmed = emitted.trimEnd();
+  const previous = trimmed.length > 0 ? trimmed.charAt(trimmed.length - 1) : void 0;
+  return previous === void 0 || /[({[=:;,!&|?+\-*%^~<>]/.test(previous);
+}
+function runNextSourceTransform(input, filename) {
+  const compilerOptions = input.compilerOptions;
+  if (input.parserMode === "babel") {
+    return {
+      result: compiler.transformSourceCode(input.source, filename, compilerOptions),
+      producer: "babel"
+    };
+  }
+  if (input.parserMode === "rust") {
+    return {
+      result: compiler.transformRust(input.source, filename, compilerOptions),
+      producer: "rust"
+    };
+  }
+  try {
+    return {
+      result: compiler.transformOxc(input.source, filename, compilerOptions),
+      producer: "oxc"
+    };
+  } catch (error) {
+    if (input.allowBabelFallback === false) {
+      throw error;
+    }
+    const result = compiler.transformSourceCode(input.source, filename, compilerOptions);
+    const reason = error instanceof Error ? error.message : String(error);
+    result.diagnostics.push(
+      `[csszyx] oxc parser fell back to Babel for ${filename}: ${reason}`
+    );
+    return { result, producer: "babel-fallback" };
+  }
+}
+function createNextSourceTransformCacheInput(input, filename, producer) {
+  return {
+    pluginVersion: input.pluginVersion,
+    compilerVersion: input.compilerVersion,
+    parserMode: input.parserMode,
+    producer,
+    astBudget: input.astBudget ?? input.compilerOptions?.astBudget,
+    mangleVars: input.compilerOptions?.mangleVars,
+    mangleVarHoistMaxDepth: input.compilerOptions?.mangleVarHoistMaxDepth,
+    globalVarAliases: normalizeGlobalVarAliasesForCache(
+      input.compilerOptions?.globalVarAliases
+    ),
+    filename,
+    source: input.source
+  };
+}
+function normalizeSourceFilename(filename) {
+  return filename.replace(/\\/g, "/");
+}
+function normalizeGlobalVarAliasesForCache(aliases) {
+  if (!aliases) {
+    return [];
+  }
+  const entries = aliases instanceof Map ? aliases.entries() : Array.isArray(aliases) ? aliases : Object.entries(aliases);
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [original, alias] of entries) {
+    if (original.startsWith("--") && alias.startsWith("--")) {
+      normalized.set(original, alias);
+    }
+  }
+  return [...normalized].sort(([left], [right]) => left.localeCompare(right));
+}
+
+function collectNextTransformMetadata(result, source, sourcePath) {
+  const classes = new Set(result.classes);
+  collectRuntimeStaticClasses(result, classes);
+  return {
+    sourcePath,
+    sourceHash: node_crypto.createHash("sha256").update(source).digest("hex"),
+    classes: [...classes].sort(),
+    rawClassNames: [...result.rawClassNames].sort(),
+    recoveryTokenCount: result.recoveryTokens.size,
+    cssVariableCount: result.cssVariableMap.size
+  };
+}
+function createNextSafelistShardFromMetadata(metadata, cacheKey) {
+  return {
+    cacheKey,
+    sourcePath: metadata.sourcePath,
+    sourceHash: metadata.sourceHash,
+    classes: metadata.classes
+  };
+}
+function collectRuntimeStaticClasses(result, discoveredClasses) {
+  if (!result.usesRuntime) {
+    return;
+  }
+  const szCallRe = /_sz\(\s*\{/g;
+  for (const szMatch of result.code.matchAll(szCallRe)) {
+    let depth = 1;
+    let index = (szMatch.index ?? 0) + szMatch[0].length;
+    while (index < result.code.length && depth > 0) {
+      if (result.code[index] === "{") {
+        depth++;
+      } else if (result.code[index] === "}") {
+        depth--;
+      }
+      index++;
+    }
+    const objectSource = result.code.slice((szMatch.index ?? 0) + szMatch[0].length, index - 1);
+    collectRuntimeStringClasses(objectSource, discoveredClasses);
+    collectRuntimeNumberClasses(objectSource, discoveredClasses);
+    collectRuntimeBooleanClasses(objectSource, discoveredClasses);
+  }
+}
+function collectRuntimeStringClasses(objectSource, discoveredClasses) {
+  const stringKeyValue = /(\w+)\s*:\s*(?:"([^"]*)"|'([^']*)')/g;
+  for (const match of objectSource.matchAll(stringKeyValue)) {
+    try {
+      collectTransformClasses(
+        compiler.transform({ [match[1]]: match[2] ?? match[3] }),
+        discoveredClasses
+      );
+    } catch {
+    }
+  }
+}
+function collectRuntimeNumberClasses(objectSource, discoveredClasses) {
+  const numberKeyValue = /(\w+)\s*:\s*(-?\d+(?:\.\d+)?)\s*(?=[,}\n])/g;
+  for (const match of objectSource.matchAll(numberKeyValue)) {
+    try {
+      collectTransformClasses(
+        compiler.transform({ [match[1]]: Number.parseFloat(match[2]) }),
+        discoveredClasses
+      );
+    } catch {
+    }
+  }
+}
+function collectRuntimeBooleanClasses(objectSource, discoveredClasses) {
+  const booleanKeyValue = /(\w+)\s*:\s*(true|false)\s*(?=[,}\n])/g;
+  for (const match of objectSource.matchAll(booleanKeyValue)) {
+    try {
+      collectTransformClasses(
+        compiler.transform({ [match[1]]: match[2] === "true" }),
+        discoveredClasses
+      );
+    } catch {
+    }
+  }
+}
+function collectTransformClasses(result, discoveredClasses) {
+  for (const className of result.className.split(/\s+/).filter(Boolean)) {
+    discoveredClasses.add(className);
+  }
+}
+
+exports.collectNextTransformMetadata = collectNextTransformMetadata;
+exports.createNextSafelistShardFromMetadata = createNextSafelistShardFromMetadata;
+exports.readPackageVersion = readPackageVersion;
+exports.transformNextSource = transformNextSource;