@csszyx/unplugin 0.8.0 → 0.9.1

package/dist/next-watcher.mjs

@@ -0,0 +1,219 @@
+import * as path from 'node:path';
+import { r as runNextWatcherCycle } from './shared/unplugin.BtQzlC2C.mjs';
+import 'node:fs';
+import 'node:crypto';
+import 'node:os';
+import 'proper-lockfile';
+
+class NextWatcherLoop {
+  context;
+  cycleOptions;
+  debounceMs;
+  runCycle;
+  setTimeoutFn;
+  clearTimeoutFn;
+  onError;
+  timer;
+  disposed = false;
+  pendingReasons = /* @__PURE__ */ new Set();
+  lastResult;
+  lastError;
+  /**
+   *
+   * @param options
+   */
+  constructor(options) {
+    this.context = options.context;
+    this.cycleOptions = options.cycleOptions ?? {};
+    this.debounceMs = options.debounceMs ?? 50;
+    this.runCycle = options.runCycle ?? runNextWatcherCycle;
+    this.setTimeoutFn = options.setTimeout ?? setTimeout;
+    this.clearTimeoutFn = options.clearTimeout ?? clearTimeout;
+    this.onError = options.onError;
+  }
+  /**
+   *
+   */
+  get pending() {
+    return this.timer !== void 0;
+  }
+  /**
+   *
+   */
+  get reasons() {
+    return [...this.pendingReasons];
+  }
+  /**
+   *
+   * @param reason
+   */
+  notify(reason = "change") {
+    if (this.disposed) {
+      return;
+    }
+    this.pendingReasons.add(reason);
+    if (this.timer !== void 0) {
+      return;
+    }
+    this.timer = this.setTimeoutFn(() => {
+      try {
+        this.runPendingCycle();
+      } catch (error) {
+        this.lastError = error;
+        this.onError?.(error);
+      }
+    }, this.debounceMs);
+  }
+  /**
+   *
+   */
+  flush() {
+    if (this.disposed || this.timer === void 0) {
+      return void 0;
+    }
+    return this.runPendingCycle();
+  }
+  /**
+   *
+   */
+  dispose() {
+    if (this.timer !== void 0) {
+      this.clearTimeoutFn(this.timer);
+    }
+    this.timer = void 0;
+    this.pendingReasons.clear();
+    this.disposed = true;
+  }
+  /**
+   *
+   */
+  runPendingCycle() {
+    const timer = this.timer;
+    if (timer !== void 0) {
+      this.clearTimeoutFn(timer);
+    }
+    this.timer = void 0;
+    const reasons = [...this.pendingReasons];
+    this.pendingReasons.clear();
+    const result = this.runCycle(this.context, this.cycleOptions, reasons);
+    this.lastResult = result;
+    this.lastError = void 0;
+    return result;
+  }
+}
+
+function isNextSafelistShardPath(shardsDir, filePath) {
+  if (!path.isAbsolute(filePath)) {
+    return false;
+  }
+  const relative = path.relative(path.resolve(shardsDir), path.resolve(filePath));
+  return relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative) && !relative.includes(path.sep) && !relative.startsWith(".") && relative.endsWith(".json");
+}
+function isNextAppSourcePath(root, filePath) {
+  if (!path.isAbsolute(filePath)) {
+    return false;
+  }
+  const relative = path.relative(path.resolve(root), path.resolve(filePath));
+  return relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+class NextSafelistWatcher {
+  root;
+  shardsDir;
+  loop;
+  started = false;
+  closed = false;
+  /**
+   *
+   * @param options
+   */
+  constructor(options) {
+    this.root = path.resolve(options.context.root);
+    this.shardsDir = path.resolve(options.context.safelist.shardsDir);
+    this.loop = new NextWatcherLoop(options);
+  }
+  /**
+   *
+   */
+  get pending() {
+    return this.loop.pending;
+  }
+  /**
+   *
+   */
+  get lastResult() {
+    return this.loop.lastResult;
+  }
+  /**
+   *
+   */
+  get lastError() {
+    return this.loop.lastError;
+  }
+  /**
+   * Materialize existing shards before accepting live filesystem events.
+   */
+  start() {
+    if (this.closed) {
+      throw new Error("[csszyx] Cannot start a closed Next safelist watcher.");
+    }
+    if (this.started && this.loop.lastResult) {
+      return this.loop.lastResult;
+    }
+    this.started = true;
+    this.loop.notify("initial");
+    const result = this.loop.flush();
+    if (!result) {
+      throw new Error("[csszyx] Next safelist watcher failed to run its initial cycle.");
+    }
+    return result;
+  }
+  /**
+   * Queue a materialization cycle for one relevant shard filesystem event.
+   *
+   * @param event Normalized add/change/unlink event.
+   * @param filePath Absolute event path.
+   * @returns Whether the event was accepted.
+   */
+  notify(event, filePath) {
+    if (this.closed || !this.started || !isNextSafelistShardPath(this.shardsDir, filePath)) {
+      return false;
+    }
+    this.loop.notify(`shard:${event}`);
+    return true;
+  }
+  /**
+   * Queue tombstone cleanup after a source file is removed.
+   *
+   * @param filePath Absolute deleted source path.
+   * @returns Whether the event was accepted.
+   */
+  notifySourceRemoval(filePath) {
+    if (this.closed || !this.started || !isNextAppSourcePath(this.root, filePath)) {
+      return false;
+    }
+    this.loop.notify("source:unlink");
+    return true;
+  }
+  /**
+   * Flush any pending event batch immediately.
+   */
+  flush() {
+    return this.loop.flush();
+  }
+  /**
+   * Flush pending work before permanently closing the controller.
+   */
+  close() {
+    if (this.closed) {
+      return void 0;
+    }
+    this.closed = true;
+    try {
+      return this.loop.flush();
+    } finally {
+      this.loop.dispose();
+    }
+  }
+}
+
+export { NextSafelistWatcher, isNextAppSourcePath, isNextSafelistShardPath };

package/dist/shared/unplugin.8er8o6rn.mjs

@@ -0,0 +1,276 @@
+import { readFileSync } from 'node:fs';
+import { ensureRustTransformAvailable, transformSourceCode, transformRust, transformOxc, transform } from '@csszyx/compiler';
+import { c as createTransformCacheKey, a as readTransformCache, w as writeTransformCache } from './unplugin.BceVw1eW.mjs';
+import { createHash } from 'node:crypto';
+
+function readPackageVersion(relativePackageJson, fromUrl) {
+  try {
+    const packageJson = JSON.parse(
+      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") {
+    ensureRustTransformAvailable();
+  }
+  const cacheKey = input.cacheRoot ? createTransformCacheKey(cacheInput) : null;
+  if (input.cacheRoot && cacheKey) {
+    const cached = 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) {
+    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: transformSourceCode(input.source, filename, compilerOptions),
+      producer: "babel"
+    };
+  }
+  if (input.parserMode === "rust") {
+    return {
+      result: transformRust(input.source, filename, compilerOptions),
+      producer: "rust"
+    };
+  }
+  try {
+    return {
+      result: transformOxc(input.source, filename, compilerOptions),
+      producer: "oxc"
+    };
+  } catch (error) {
+    if (input.allowBabelFallback === false) {
+      throw error;
+    }
+    const result = 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: 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(
+        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(
+        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(
+        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);
+  }
+}
+
+export { createNextSafelistShardFromMetadata as a, collectNextTransformMetadata as c, readPackageVersion as r, transformNextSource as t };