@jk2908/cxx 0.3.1 → 0.3.4

package/dist/vite/index.js

@@ -14,6 +14,86 @@ var PKG_NAME = `@jk2908/${NAME}`;
 var GENERATED_DIR = `.${NAME}`;
 var AUTOGEN_MSG = `// auto-generated by ${NAME}`;
 
+// src/logger.ts
+var LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  fatal: 4
+};
+var defaultLevel = process.env["NODE_ENV"] === "production" ? "error" : "info";
+
+class Logger {
+  name;
+  #level = defaultLevel;
+  constructor(name) {
+    this.name = name;
+  }
+  static toError(err) {
+    return err instanceof Error ? err : new Error(String(err), { cause: err });
+  }
+  static print(err) {
+    if (err instanceof Error) {
+      return err.message + (err.stack ? `
+${err.stack}` : "");
+    }
+    if (typeof err === "object" && err !== null) {
+      try {
+        return JSON.stringify(err, null, 2);
+      } catch {
+        return String(err);
+      }
+    }
+    return String(err);
+  }
+  set level(level) {
+    this.#level = level;
+  }
+  get level() {
+    return this.#level;
+  }
+  log(level, message, error) {
+    if (LEVELS[level] < LEVELS[this.level])
+      return;
+    const entry = {
+      ts: Date.now(),
+      level,
+      message
+    };
+    if (level === "error" || level === "fatal") {
+      entry.error = error ? Logger.toError(error) : new Error(message);
+    }
+    const line = `${this.name ? `[${this.name}]` : ""} [${entry.ts}] [${level.toUpperCase()}] ${message}`;
+    const extra = entry.error ? `
+${Logger.print(entry.error)}` : "";
+    if (level === "warn") {
+      console.warn(line, extra);
+      return;
+    }
+    if (level === "error" || level === "fatal") {
+      console.error(line, extra);
+      return;
+    }
+    console.log(line, extra);
+  }
+  debug(...messages) {
+    this.log("debug", messages.join(" "));
+  }
+  info(...messages) {
+    this.log("info", messages.join(" "));
+  }
+  warn(...messages) {
+    this.log("warn", messages.join(" "));
+  }
+  error(message, error) {
+    this.log("error", message, error === undefined ? undefined : Logger.toError(error));
+  }
+  fatal(message, error) {
+    this.log("fatal", message, error === undefined ? undefined : Logger.toError(error));
+  }
+}
+
 // src/lru.ts
 var CACHE_MAX_SIZE = 100;
 
@@ -56,51 +136,12 @@ function capitalise(str) {
 function pascalise(str) {
   return str.split(/[ _-]+/).map(capitalise).join("");
 }
-function createBatcher(wait, flush) {
-  const pending = new Map;
-  let timer = null;
-  let running = false;
-  async function drain() {
-    if (running)
-      return;
-    running = true;
-    try {
-      while (pending.size > 0) {
-        const batch = new Map(pending);
-        pending.clear();
-        await flush(batch);
-      }
-    } finally {
-      running = false;
-    }
-  }
-  function schedule() {
-    if (timer)
-      clearTimeout(timer);
-    timer = setTimeout(() => {
-      timer = null;
-      drain();
-    }, wait);
-  }
-  return {
-    add(key, value) {
-      pending.set(key, value);
-      schedule();
-    },
-    flush() {
-      if (timer) {
-        clearTimeout(timer);
-        timer = null;
-      }
-      return drain();
-    }
-  };
-}
 
 // src/build.ts
+var logger = new Logger(NAME);
 var decoder = new TextDecoder;
+var encoder = new TextEncoder;
 var collectCache = new LruCache;
-var fileCache = new LruCache;
 var writeChain = Promise.resolve();
 function isENOENT(err) {
   return err instanceof Error && "code" in err && err.code === "ENOENT";
@@ -108,7 +149,12 @@ function isENOENT(err) {
 async function writeFileAtomic(filePath, content) {
   const tmp = `${filePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   await fs.writeFile(tmp, content);
-  await fs.rename(tmp, filePath);
+  try {
+    await fs.rename(tmp, filePath);
+  } catch (err) {
+    await fs.rm(tmp, { force: true });
+    throw err;
+  }
 }
 function enqueueWrite(task) {
   const run = writeChain.then(task, task);
@@ -120,20 +166,14 @@ function enqueueWrite(task) {
   return run;
 }
 async function maybeWrite(filePath, content) {
-  const cached = fileCache.get(filePath);
-  if (cached === content)
-    return false;
   try {
-    if (await fs.readFile(filePath, "utf-8") === content) {
-      fileCache.set(filePath, content);
+    if (await fs.readFile(filePath, "utf-8") === content)
       return false;
-    }
   } catch (err) {
     if (!isENOENT(err))
       throw err;
   }
   await writeFileAtomic(filePath, content);
-  fileCache.set(filePath, content);
   return true;
 }
 var regex = /((?:export\s+)?)(?:const|var|let)\s*\[(\w*)\s*,?\s*(\w*)\s*,?\s*(\w*)\s*\]\s*=\s*cxx(?:\s*`([\s\S]*?)`|\s*\.\s*tag(?:\s*<[^>]+>)?\s*\(\s*(['"])(.*?)\6\s*\)\s*`([\s\S]*?)`)/gm;
@@ -169,14 +209,23 @@ function collect(source, id, config) {
     matched = true;
     const [, exp, varOne, varTwo, varThree, plainCss, , tag, taggedCss] = match;
     const css = plainCss ?? taggedCss;
-    const { code, exports = {} } = transform({
-      minify: true,
-      cssModules: true,
-      filename: id,
-      code: new TextEncoder().encode(css)
-    });
+    const matchIndex = match.index;
+    const { code, exports: classExports = {} } = (() => {
+      try {
+        return transform({
+          minify: true,
+          cssModules: true,
+          filename: id,
+          code: encoder.encode(css)
+        });
+      } catch (err) {
+        const line = source.slice(0, matchIndex).split(`
+`).length;
+        throw new Error(`Failed to compile cxx CSS at ${id}:${line}`, { cause: err });
+      }
+    })();
     const href = hashCss(code);
-    const styles = Object.fromEntries(Object.entries(exports).map(([k, v]) => [k, v.name]));
+    const styles = Object.fromEntries(Object.entries(classExports).map(([k, v]) => [k, v.name]));
     if (tag) {
       const suffix = typeof config.typeSuffix === "string" ? config.typeSuffix : config.typeSuffix === false ? "" : "Classes";
       const tagWithSuffix = pascalise(`${tag}${suffix}`);
@@ -196,7 +245,7 @@ function collect(source, id, config) {
     if (varThree) {
       statements.push(`${exp}const ${varThree} = ${JSON.stringify(href)}`);
     }
-    magic.overwrite(match.index, match.index + match[0].length, statements.join(`
+    magic.overwrite(matchIndex, matchIndex + match[0].length, statements.join(`
 `));
   }
   const template = magic.toString();
@@ -222,16 +271,14 @@ async function writeRenderedTypes(tags) {
   const filePath = path.join(GENERATED_DIR, "index.d.ts");
   if (!tags.size) {
     await fs.rm(filePath, { force: true });
-    fileCache.delete(filePath);
     return;
   }
   await fs.mkdir(GENERATED_DIR, { recursive: true });
   await maybeWrite(filePath, renderTypes(tags));
 }
-function writeTypes(tags) {
-  return enqueueWrite(() => writeRenderedTypes(tags));
-}
 var PARTIAL_DIR = path.join(GENERATED_DIR, "tags");
+var REBUILD_WAIT = 100;
+var rebuildTimer = null;
 function partialPath(filePath) {
   return path.join(PARTIAL_DIR, `${createHash("sha1").update(filePath).digest("hex")}.json`);
 }
@@ -241,10 +288,12 @@ async function readPartials() {
     entries = await fs.readdir(PARTIAL_DIR);
   } catch (err) {
     if (isENOENT(err))
-      return new Map;
+      return { tags: new Map, duplicates: [] };
     throw err;
   }
   const tags = new Map;
+  const fileByTag = new Map;
+  const duplicates = [];
   for (const entry of entries) {
     if (!entry.endsWith(".json"))
       continue;
@@ -255,19 +304,28 @@ async function readPartials() {
     } catch {
       continue;
     }
+    let source;
     try {
-      await fs.access(parsed.file);
+      source = await fs.readFile(parsed.file, "utf-8");
     } catch {
       await fs.rm(partial, { force: true });
       continue;
     }
+    if (!source.includes("cxx")) {
+      await fs.rm(partial, { force: true });
+      continue;
+    }
     for (const [name, classes] of Object.entries(parsed.tags)) {
-      if (tags.has(name))
-        throw new DuplicateTagError(name);
+      const existing = fileByTag.get(name);
+      if (existing) {
+        duplicates.push({ tag: name, files: [existing, parsed.file] });
+        continue;
+      }
+      fileByTag.set(name, parsed.file);
       tags.set(name, classes);
     }
   }
-  return tags;
+  return { tags, duplicates };
 }
 function writeTypesForFile(filePath, tags) {
   return enqueueWrite(async () => {
@@ -278,201 +336,149 @@ function writeTypesForFile(filePath, tags) {
     } else {
       await writeFileAtomic(partial, JSON.stringify({ file: filePath, tags: Object.fromEntries(tags) }));
     }
-    await writeRenderedTypes(await readPartials());
+  }).then(() => scheduleRebuild()).catch((err) => {
+    logger.error(`failed to write types for ${filePath}`, err);
   });
 }
-function tagsToType(tags) {
-  return [...tags].map(([tag, classes]) => {
-    const union = classes.length > 0 ? classes.toSorted((a, b) => a.length - b.length).map((c) => `'${c}'`).join(" | ") : "never";
-    return `	export type ${tag} = ${union}`;
-  }).join(`
-`);
+function scheduleRebuild() {
+  if (rebuildTimer)
+    clearTimeout(rebuildTimer);
+  rebuildTimer = setTimeout(() => {
+    rebuildTimer = null;
+    flushTypes().catch((err) => {
+      logger.error("failed to generate types", err);
+    });
+  }, REBUILD_WAIT);
 }
-function flattenTags(tagsByFile) {
-  const tags = new Map;
-  for (const fileTags of tagsByFile.values()) {
-    for (const [name, classes] of fileTags) {
-      if (tags.has(name))
-        throw new DuplicateTagError(name);
-      tags.set(name, classes);
-    }
+function flushTypes() {
+  if (rebuildTimer) {
+    clearTimeout(rebuildTimer);
+    rebuildTimer = null;
   }
-  return tags;
-}
-
-// src/vite/index.ts
-import { realpathSync } from "node:fs";
-import fs2 from "node:fs/promises";
-import path2 from "node:path";
-
-// src/logger.ts
-var LEVELS = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-  fatal: 4
-};
-var defaultLevel = process.env["NODE_ENV"] === "production" ? "error" : "info";
-
-class Logger {
-  name;
-  #level;
-  constructor(level, name) {
-    this.name = name;
-    this.#level = level ?? defaultLevel;
-  }
-  static toError(err) {
-    return err instanceof Error ? err : new Error(String(err), { cause: err });
-  }
-  static print(err) {
-    if (err instanceof Error) {
-      return err.message + (err.stack ? `
-${err.stack}` : "");
+  return enqueueWrite(async () => {
+    const { tags, duplicates } = await readPartials();
+    await writeRenderedTypes(tags);
+    for (const duplicate of duplicates) {
+      logger.error(`Tag "${duplicate.tag}" is defined in multiple files: ${duplicate.files.join(", ")}`);
     }
-    if (typeof err === "object" && err !== null) {
-      try {
-        return JSON.stringify(err, null, 2);
-      } catch {
-        return String(err);
-      }
+  });
+}
+var SOURCE_EXTENSIONS = new Set([".js", ".jsx", ".ts", ".tsx"]);
+var SKIP_DIRS = new Set(["node_modules", "dist", "build", "coverage", "out"]);
+async function runWithConcurrency(items, concurrency, fn) {
+  let cursor = 0;
+  const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+    while (cursor < items.length) {
+      const index = cursor++;
+      await fn(items[index]);
     }
-    return String(err);
-  }
-  set level(level) {
-    this.#level = level;
-  }
-  get level() {
-    return this.#level;
+  });
+  await Promise.all(workers);
+}
+async function refreshFile(file, config) {
+  let source;
+  try {
+    source = await fs.readFile(file, "utf-8");
+  } catch (err) {
+    if (!isENOENT(err))
+      throw err;
+    await writeTypesForFile(file, new Map);
+    return;
   }
-  log(level, message, error) {
-    if (LEVELS[level] < LEVELS[this.level])
-      return;
-    const entry = {
-      ts: Date.now(),
-      level,
-      message
-    };
-    if (level === "error" || level === "fatal") {
-      entry.error = error ? Logger.toError(error) : new Error(message);
-    }
-    const line = `${this.name ? `[${this.name}]` : ""} [${entry.ts}] [${level.toUpperCase()}] ${message}`;
-    const extra = entry.error ? `
-${Logger.print(entry.error)}` : "";
-    if (level === "warn") {
-      console.warn(line, extra);
-      return;
-    }
-    if (level === "error" || level === "fatal") {
-      console.error(line, extra);
+  const tags = source.includes("cxx") ? collect(source, file, config).tags : new Map;
+  await writeTypesForFile(file, tags);
+}
+async function seedTypes(root, config) {
+  async function scan(dir) {
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
       return;
     }
-    console.log(line, extra);
-  }
-  debug(...messages) {
-    this.log("debug", messages.join(" "));
-  }
-  info(...messages) {
-    this.log("info", messages.join(" "));
-  }
-  warn(...messages) {
-    this.log("warn", messages.join(" "));
-  }
-  error(message, error) {
-    this.log("error", message, error === undefined ? undefined : Logger.toError(error));
-  }
-  fatal(message, error) {
-    this.log("fatal", message, error === undefined ? undefined : Logger.toError(error));
+    await runWithConcurrency(entries, 8, async (entry) => {
+      if (entry.name.startsWith(".") || SKIP_DIRS.has(entry.name))
+        return;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await scan(full);
+        return;
+      }
+      if (!SOURCE_EXTENSIONS.has(path.extname(entry.name)))
+        return;
+      await refreshFile(full, config);
+    });
   }
+  await scan(root);
+  await flushTypes();
+}
+function tagsToType(tags) {
+  return [...tags].toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([tag, classes]) => {
+    const union = classes.length > 0 ? classes.toSorted((a, b) => a.length - b.length).map((c) => `'${c}'`).join(" | ") : "never";
+    return `	export type ${tag} = ${union}`;
+  }).join(`
+`);
 }
 
 // src/vite/index.ts
-var ACCEPTED_EXTENSIONS = new Set([".js", ".jsx", ".ts", ".tsx"]);
+import { realpathSync } from "node:fs";
+import path2 from "node:path";
 function normaliseWatchPath(p) {
   return p.replace(/\\/g, "/");
 }
 function cxx(pluginConfig = {}) {
-  const buildContext = {
-    tagsByFile: new Map
-  };
-  const logger = new Logger;
+  const logger2 = new Logger;
   let watchRoot = normaliseWatchPath(process.cwd());
+  let seeded = false;
+  const realpaths = new Map;
   function resolveWatchFile(filePath) {
     const absolutePath = path2.resolve(watchRoot, filePath);
     const parentPath = path2.dirname(absolutePath);
-    try {
-      const resolvedParentPath = normaliseWatchPath(realpathSync.native(parentPath));
-      return normaliseWatchPath(path2.join(resolvedParentPath, path2.basename(absolutePath)));
-    } catch {
-      return normaliseWatchPath(absolutePath);
+    let resolvedParentPath = realpaths.get(parentPath);
+    if (resolvedParentPath === undefined) {
+      try {
+        resolvedParentPath = normaliseWatchPath(realpathSync.native(parentPath));
+      } catch {
+        resolvedParentPath = normaliseWatchPath(parentPath);
+      }
+      realpaths.set(parentPath, resolvedParentPath);
     }
+    return normaliseWatchPath(path2.join(resolvedParentPath, path2.basename(absolutePath)));
   }
   function watchedFile(filePath) {
     const resolvedPath = resolveWatchFile(filePath);
-    if (resolvedPath.startsWith(`${watchRoot}/`) && !resolvedPath.includes(`/${GENERATED_DIR}/`) && ACCEPTED_EXTENSIONS.has(path2.extname(resolvedPath))) {
+    if (resolvedPath.startsWith(`${watchRoot}/`) && !resolvedPath.includes(`/${GENERATED_DIR}/`) && SOURCE_EXTENSIONS.has(path2.extname(resolvedPath))) {
       return resolvedPath;
     }
     return null;
   }
-  async function onEvent(event, file) {
-    const hadTags = buildContext.tagsByFile.has(file);
+  async function handleEvent(event, file) {
     if (event === "unlink") {
-      if (!hadTags)
-        return;
-      buildContext.tagsByFile.delete(file);
-      await writeTypes(flattenTags(buildContext.tagsByFile));
-      logger.info(`updated types from ${file}`);
-      return;
-    }
-    let source;
-    try {
-      source = await fs2.readFile(file, "utf-8");
-    } catch (err) {
-      if (!isENOENT(err))
-        throw err;
-      if (!hadTags)
-        return;
-      buildContext.tagsByFile.delete(file);
-      await writeTypes(flattenTags(buildContext.tagsByFile));
-      logger.info(`updated types from ${file}`);
-      return;
-    }
-    const { tags } = collect(source, file, pluginConfig);
-    const hasTags = tags.size > 0;
-    if (hasTags) {
-      buildContext.tagsByFile.set(file, tags);
+      await writeTypesForFile(file, new Map);
     } else {
-      buildContext.tagsByFile.delete(file);
+      await refreshFile(file, pluginConfig);
     }
-    if (!hadTags && !hasTags)
+    logger2.info(`updated types from ${file}`);
+  }
+  function onWatch(event) {
+    return (p) => {
+      const file = watchedFile(p);
+      if (!file)
+        return;
+      handleEvent(event, file).catch((err) => {
+        logger2.error(`failed to update types from ${file}`, err);
+      });
+    };
+  }
+  async function seed() {
+    if (seeded)
       return;
-    await writeTypes(flattenTags(buildContext.tagsByFile));
-    logger.info(`updated types from ${file}`);
+    seeded = true;
+    await seedTypes(watchRoot, pluginConfig);
   }
-  const queue = createBatcher(75, async (batch) => {
-    for (const [file, event] of batch) {
-      try {
-        await onEvent(event, file);
-      } catch (err) {
-        logger.error(`failed to update types from ${file}`, err);
-      }
-    }
-  });
   return {
     name: "cxx",
     enforce: "pre",
-    config() {
-      const ignore = pluginConfig.watch?.ignore;
-      if (!ignore?.length)
-        return null;
-      return {
-        server: {
-          watch: {
-            ignored: ignore
-          }
-        }
-      };
-    },
     configResolved(config) {
       const root = pluginConfig.watch?.root ?? config.root;
       try {
@@ -480,6 +486,10 @@ function cxx(pluginConfig = {}) {
       } catch {
         watchRoot = normaliseWatchPath(root);
       }
+      realpaths.clear();
+    },
+    async buildStart() {
+      await seed();
     },
     transform(code, id) {
       if (id.startsWith("\x00") || id.includes("/node_modules/"))
@@ -487,40 +497,23 @@ function cxx(pluginConfig = {}) {
       if (!code.includes("cxx"))
         return null;
       const cleanId = id.split("?")[0];
-      if (!ACCEPTED_EXTENSIONS.has(path2.extname(cleanId)))
+      if (!SOURCE_EXTENSIONS.has(path2.extname(cleanId)))
         return null;
       const { template, tags, map } = collect(code, cleanId, pluginConfig);
       if (template === code)
         return null;
-      const resolved = resolveWatchFile(cleanId);
-      if (tags.size) {
-        buildContext.tagsByFile.set(resolved, tags);
-      } else {
-        buildContext.tagsByFile.delete(resolved);
-      }
+      writeTypesForFile(resolveWatchFile(cleanId), tags);
       return {
         code: template,
         map
       };
     },
     configureServer(server) {
-      logger.info("Watching for changes...");
-      server.watcher.on("add", (p) => {
-        const file = watchedFile(p);
-        if (file)
-          queue.add(file, "add");
-      }).on("change", (p) => {
-        const file = watchedFile(p);
-        if (file)
-          queue.add(file, "change");
-      }).on("unlink", (p) => {
-        const file = watchedFile(p);
-        if (file)
-          queue.add(file, "unlink");
-      });
+      logger2.info("Watching for changes...");
+      server.watcher.on("add", onWatch("add")).on("change", onWatch("change")).on("unlink", onWatch("unlink"));
     },
     async writeBundle() {
-      await writeTypes(flattenTags(buildContext.tagsByFile));
+      await flushTypes();
     }
   };
 }
@@ -528,4 +521,4 @@ export {
   cxx as default
 };
 
-//# debugId=8BACD1ACA42BF59D64756E2164756E21
+//# debugId=294541A31A244C8364756E2164756E21