@jk2908/cxx 0.2.6 → 0.3.3

package/dist/vite/index.js

@@ -1,8 +1,12 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
 // src/build.ts
 import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { transform } from "lightningcss";
+import MagicString from "magic-string";
 
 // src/config.ts
 var NAME = "cxx";
@@ -52,45 +56,93 @@ function capitalise(str) {
 function pascalise(str) {
   return str.split(/[ _-]+/).map(capitalise).join("");
 }
-function debounce(fn, wait) {
-  let timeoutId = null;
-  return (...args) => {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-    timeoutId = setTimeout(() => {
-      fn.apply(null, args);
+function createBatcher(wait, flush) {
+  const pending = new Map;
+  let timer = null;
+  let current = null;
+  function drain() {
+    if (current)
+      return current;
+    const run = (async () => {
+      while (pending.size > 0) {
+        const batch = new Map(pending);
+        pending.clear();
+        await flush(batch);
+      }
+    })();
+    current = run;
+    run.then(() => {
+      if (current === run)
+        current = null;
+    }, () => {
+      if (current === run)
+        current = null;
+    });
+    return run;
+  }
+  function schedule() {
+    if (timer)
+      clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      drain().catch(() => {});
     }, wait);
+  }
+  return {
+    add(key, value) {
+      pending.set(key, value);
+      schedule();
+    },
+    flush() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      return drain();
+    }
   };
 }
 
 // src/build.ts
+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";
 }
-async function maybeWrite(filePath, content) {
-  const cached = fileCache.get(filePath);
-  if (cached !== content) {
-    await fs.writeFile(filePath, content);
-    fileCache.set(filePath, content);
-    return true;
+async function writeFileAtomic(filePath, content) {
+  const tmp = `${filePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await fs.writeFile(tmp, content);
+  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);
+  writeChain = run.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  return run;
+}
+async function maybeWrite(filePath, content) {
   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 fs.writeFile(filePath, content);
-  fileCache.set(filePath, content);
+  await writeFileAtomic(filePath, content);
   return true;
 }
-var regex = /(?:const|var|let)\s*\[(\w+|)\s*,?\s*(\w+|)\s*,?\s*(\w+|)\s*\]\s*=\s*cxx(?:\s*`([\s\S]*?)`|\s*\.\s*tag(?:\s*<[^>]+>)?\s*\(\s*(['"])(.*?)\5\s*\)\s*`([\s\S]*?)`)/gm;
+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;
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 function hashCss(code) {
   return `cxx-${createHash("sha256").update(code).digest("base64url").slice(0, 12)}`;
 }
@@ -101,73 +153,137 @@ class DuplicateTagError extends Error {
     super(`Tag ${tag} has already been seen. Tags must be unique across your application`);
   }
 }
+
+class InvalidTagError extends Error {
+  name = "InvalidTagError";
+  constructor(tag) {
+    super(`Tag "${tag}" does not map to a valid TypeScript identifier. ` + `Use letters, numbers, spaces, "_" or "-"`);
+  }
+}
 function collect(source, id, config) {
-  const tags = new Map;
+  const configKey = JSON.stringify(config);
   const cached = collectCache.get(id);
-  if (cached?.source === source)
+  if (cached?.source === source && cached.config === configKey)
     return cached;
-  const template = source.replace(regex, (_match, varOne, varTwo, varThree, plainCss, _quote, tag, taggedCss) => {
+  const tags = new Map;
+  const magic = new MagicString(source);
+  let matched = false;
+  regex.lastIndex = 0;
+  let match;
+  while (match = regex.exec(source)) {
+    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}`);
+      if (!IDENTIFIER.test(tagWithSuffix))
+        throw new InvalidTagError(tag);
       if (tags.has(tagWithSuffix))
         throw new DuplicateTagError(tagWithSuffix);
       tags.set(tagWithSuffix, Object.keys(styles));
     }
-    return [
-      varOne && `const ${varOne} = \`${code}\``,
-      varTwo && `const ${varTwo} = ${JSON.stringify(styles)}`,
-      varThree && `const ${varThree} = \`${href}\``
-    ].filter(Boolean).join(`
+    const statements = [];
+    if (varOne) {
+      statements.push(`${exp}const ${varOne} = ${JSON.stringify(decoder.decode(code))}`);
+    }
+    if (varTwo) {
+      statements.push(`${exp}const ${varTwo} = ${JSON.stringify(styles)}`);
+    }
+    if (varThree) {
+      statements.push(`${exp}const ${varThree} = ${JSON.stringify(href)}`);
+    }
+    magic.overwrite(matchIndex, matchIndex + match[0].length, statements.join(`
+`));
+  }
+  const template = magic.toString();
+  const map = matched ? magic.generateMap({ source: id, includeContent: true, hires: true }) : null;
+  const result = { source, config: configKey, template, tags, map };
+  collectCache.set(id, result);
+  return result;
+}
+function renderTypes(tags) {
+  return [
+    AUTOGEN_MSG,
+    "",
+    `import '${PKG_NAME}'`,
+    "",
+    `declare module '${PKG_NAME}' {`,
+    tagsToType(tags),
+    "}",
+    ""
+  ].join(`
 `);
-  });
-  collectCache.set(id, { source, template, tags });
-  return {
-    template,
-    tags
-  };
 }
-async function writeTypes(tags) {
+async function writeRenderedTypes(tags) {
   const filePath = path.join(GENERATED_DIR, "index.d.ts");
   if (!tags.size) {
-    try {
-      await fs.rm(filePath, { force: true });
-      fileCache.delete(filePath);
-    } catch (err) {
-      if (!isENOENT(err))
-        throw err;
-    }
+    await fs.rm(filePath, { force: true });
     return;
   }
   await fs.mkdir(GENERATED_DIR, { recursive: true });
-  await maybeWrite(filePath, `${AUTOGEN_MSG}
-
-			import '${PKG_NAME}'
-
-			declare module '${PKG_NAME}' {
-				${tagsToType(tags)}
-			}
-		`);
+  await maybeWrite(filePath, renderTypes(tags));
 }
-function tagsToType(tags) {
-  return [...tags].map(([tag, classes]) => `
-		export type ${tag} = ${classes.length > 0 ? classes.toSorted((a, b) => a.length - b.length).map((c) => `'${c}'`).join(" | ") : "never"}
-	`).join(`
-`);
+var PARTIAL_DIR = path.join(GENERATED_DIR, "tags");
+var REBUILD_WAIT = 100;
+var rebuildTimer = null;
+var rebuildError = null;
+function partialPath(filePath) {
+  return path.join(PARTIAL_DIR, `${createHash("sha1").update(filePath).digest("hex")}.json`);
+}
+async function partialDirMtime() {
+  try {
+    return (await fs.stat(PARTIAL_DIR)).mtimeMs;
+  } catch (err) {
+    if (isENOENT(err))
+      return 0;
+    throw err;
+  }
 }
-function flattenTags(tagsByFile) {
+async function readPartials() {
+  let entries;
+  try {
+    entries = await fs.readdir(PARTIAL_DIR);
+  } catch (err) {
+    if (isENOENT(err))
+      return new Map;
+    throw err;
+  }
   const tags = new Map;
-  for (const fileTags of tagsByFile.values()) {
-    for (const [name, classes] of fileTags) {
+  for (const entry of entries) {
+    if (!entry.endsWith(".json"))
+      continue;
+    const partial = path.join(PARTIAL_DIR, entry);
+    let parsed;
+    try {
+      parsed = JSON.parse(await fs.readFile(partial, "utf-8"));
+    } catch {
+      continue;
+    }
+    try {
+      await fs.access(parsed.file);
+    } catch {
+      await fs.rm(partial, { force: true });
+      continue;
+    }
+    for (const [name, classes] of Object.entries(parsed.tags)) {
       if (tags.has(name))
         throw new DuplicateTagError(name);
       tags.set(name, classes);
@@ -175,6 +291,57 @@ function flattenTags(tagsByFile) {
   }
   return tags;
 }
+function writeTypesForFile(filePath, tags) {
+  return enqueueWrite(async () => {
+    await fs.mkdir(PARTIAL_DIR, { recursive: true });
+    const partial = partialPath(filePath);
+    if (!tags.size) {
+      await fs.rm(partial, { force: true });
+    } else {
+      await writeFileAtomic(partial, JSON.stringify({ file: filePath, tags: Object.fromEntries(tags) }));
+    }
+  }).then(() => {
+    scheduleRebuild();
+  });
+}
+function scheduleRebuild() {
+  if (rebuildTimer)
+    clearTimeout(rebuildTimer);
+  rebuildTimer = setTimeout(() => {
+    rebuildTimer = null;
+    flushTypes().catch((err) => {
+      rebuildError = err;
+    });
+  }, REBUILD_WAIT);
+}
+function flushTypes() {
+  if (rebuildTimer) {
+    clearTimeout(rebuildTimer);
+    rebuildTimer = null;
+  }
+  return enqueueWrite(async () => {
+    let before = await partialDirMtime();
+    for (let attempt = 0;attempt < 3; attempt++) {
+      await writeRenderedTypes(await readPartials());
+      const after = await partialDirMtime();
+      if (after === before)
+        return;
+      before = after;
+    }
+  });
+}
+function takeRebuildError() {
+  const err = rebuildError;
+  rebuildError = null;
+  return err;
+}
+function tagsToType(tags) {
+  return [...tags].toSorted(([a], [b]) => a.localeCompare(b)).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
 import { realpathSync } from "node:fs";
@@ -189,20 +356,14 @@ var LEVELS = {
   error: 3,
   fatal: 4
 };
+var defaultLevel = process.env["NODE_ENV"] === "production" ? "error" : "info";
 
 class Logger {
   name;
-  static #defaultLevel = "info";
   #level;
   constructor(level, name) {
     this.name = name;
-    this.#level = level;
-  }
-  static set defaultLevel(level) {
-    Logger.#defaultLevel = level;
-  }
-  static get defaultLevel() {
-    return Logger.#defaultLevel;
+    this.#level = level ?? defaultLevel;
   }
   static toError(err) {
     return err instanceof Error ? err : new Error(String(err), { cause: err });
@@ -225,7 +386,7 @@ ${err.stack}` : "");
     this.#level = level;
   }
   get level() {
-    return this.#level ?? Logger.#defaultLevel;
+    return this.#level;
   }
   log(level, message, error) {
     if (LEVELS[level] < LEVELS[this.level])
@@ -273,15 +434,14 @@ var ACCEPTED_EXTENSIONS = new Set([".js", ".jsx", ".ts", ".tsx"]);
 function normaliseWatchPath(p) {
   return p.replace(/\\/g, "/");
 }
+function globToRegExp(glob) {
+  const pattern = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*(\/|$)/g, ".*$1").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+  return new RegExp(`^${pattern}$`);
+}
 function cxx(pluginConfig = {}) {
-  const buildContext = {
-    tagsByFile: new Map
-  };
-  const logger = new Logger(pluginConfig?.logger?.level ?? false ? "error" : "debug");
-  const watchRoot = normaliseWatchPath(realpathSync.native(process.cwd()));
-  const watchedRoots = [`${watchRoot}/`];
-  let rebuildRunning = false;
-  let rebuildQueued = false;
+  const logger = new Logger;
+  let watchRoot = normaliseWatchPath(process.cwd());
+  const ignored = (pluginConfig.watch?.ignore ?? []).map(globToRegExp);
   function resolveWatchFile(filePath) {
     const absolutePath = path2.resolve(watchRoot, filePath);
     const parentPath = path2.dirname(absolutePath);
@@ -294,75 +454,112 @@ function cxx(pluginConfig = {}) {
   }
   function watchedFile(filePath) {
     const resolvedPath = resolveWatchFile(filePath);
-    return watchedRoots.some((root) => resolvedPath.startsWith(root)) && !resolvedPath.includes(`/${GENERATED_DIR}/`) && ACCEPTED_EXTENSIONS.has(path2.extname(resolvedPath));
-  }
-  const rebuild = debounce((event, filePath) => {
-    function queue() {
-      (async () => {
-        if (rebuildRunning) {
-          rebuildQueued = true;
-          return;
-        }
-        rebuildRunning = true;
-        do {
-          rebuildQueued = false;
-          try {
-            const hadTags = buildContext.tagsByFile.has(file);
-            let hasTags = false;
-            if (event === "unlink") {
-              buildContext.tagsByFile.delete(file);
-            } else {
-              const source = await fs2.readFile(file, "utf-8");
-              const { tags } = collect(source, file, pluginConfig);
-              hasTags = tags.size > 0;
-              if (hasTags) {
-                buildContext.tagsByFile.set(file, tags);
-              } else {
-                buildContext.tagsByFile.delete(file);
-              }
-            }
-            if (!hadTags && !hasTags)
-              continue;
-            await writeTypes(flattenTags(buildContext.tagsByFile));
-            logger.info(`updated types from ${file}`);
-          } catch (err) {
-            if (isENOENT(err)) {
-              if (!buildContext.tagsByFile.has(file))
-                continue;
-              buildContext.tagsByFile.delete(file);
-              await writeTypes(flattenTags(buildContext.tagsByFile));
-              logger.info(`updated types from ${file}`);
-              continue;
-            }
-            logger.error(`failed to update types from ${file}`, err);
-          }
-        } while (rebuildQueued);
-        rebuildRunning = false;
-      })();
+    if (resolvedPath.startsWith(`${watchRoot}/`) && !resolvedPath.includes(`/${GENERATED_DIR}/`) && ACCEPTED_EXTENSIONS.has(path2.extname(resolvedPath)) && !ignored.some((regexp) => regexp.test(resolvedPath))) {
+      return resolvedPath;
     }
-    if (!watchedFile(filePath))
+    return null;
+  }
+  async function recordFile(file) {
+    let source;
+    try {
+      source = await fs2.readFile(file, "utf-8");
+    } catch (err) {
+      if (!isENOENT(err))
+        throw err;
+      await writeTypesForFile(file, new Map);
+      return;
+    }
+    const tags = source.includes("cxx") ? collect(source, file, pluginConfig).tags : new Map;
+    await writeTypesForFile(file, tags);
+  }
+  async function scan(dir) {
+    let entries;
+    try {
+      entries = await fs2.readdir(dir, { withFileTypes: true });
+    } catch {
       return;
-    const file = resolveWatchFile(filePath);
-    queue();
-  }, 75);
+    }
+    await Promise.all(entries.map(async (entry) => {
+      if (entry.name.startsWith(".") || entry.name === "node_modules")
+        return;
+      const full = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await scan(full);
+        return;
+      }
+      if (!ACCEPTED_EXTENSIONS.has(path2.extname(entry.name)))
+        return;
+      const resolved = resolveWatchFile(full);
+      if (ignored.some((regexp) => regexp.test(resolved)))
+        return;
+      await recordFile(resolved);
+    }));
+  }
+  const queue = createBatcher(75, async (batch) => {
+    for (const [file, event] of batch) {
+      try {
+        if (event === "unlink") {
+          await writeTypesForFile(file, new Map);
+        } else {
+          await recordFile(file);
+        }
+        logger.info(`updated types from ${file}`);
+      } catch (err) {
+        logger.error(`failed to update types from ${file}`, err);
+      }
+    }
+  });
   return {
     name: "cxx",
     enforce: "pre",
+    configResolved(config) {
+      const root = pluginConfig.watch?.root ?? config.root;
+      try {
+        watchRoot = normaliseWatchPath(realpathSync.native(root));
+      } catch {
+        watchRoot = normaliseWatchPath(root);
+      }
+    },
     transform(code, id) {
-      const { template, tags } = collect(code, id, pluginConfig);
-      if (tags.size)
-        buildContext.tagsByFile.set(id, tags);
+      if (id.startsWith("\x00") || id.includes("/node_modules/"))
+        return null;
+      if (!code.includes("cxx"))
+        return null;
+      const cleanId = id.split("?")[0];
+      if (!ACCEPTED_EXTENSIONS.has(path2.extname(cleanId)))
+        return null;
+      const { template, tags, map } = collect(code, cleanId, pluginConfig);
+      if (template === code)
+        return null;
+      writeTypesForFile(resolveWatchFile(cleanId), tags);
       return {
         code: template,
-        map: null
+        map
       };
     },
     configureServer(server) {
       logger.info("Watching for changes...");
-      server.watcher.on("add", (p) => rebuild("add", p)).on("change", (p) => rebuild("change", p)).on("unlink", (p) => rebuild("unlink", p));
+      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");
+      });
+      scan(watchRoot).then(() => flushTypes()).then(() => {
+        const err = takeRebuildError();
+        if (err)
+          logger.error("failed to generate types", err);
+      }).catch((err) => logger.error("failed to scan for cxx templates", err));
     },
     async writeBundle() {
-      await writeTypes(flattenTags(buildContext.tagsByFile));
+      await flushTypes();
     }
   };
 }
@@ -370,4 +567,4 @@ export {
   cxx as default
 };
 
-//# debugId=99F5EDE4479120ED64756E2164756E21
+//# debugId=7C0503EFBFB9E21F64756E2164756E21