@danielx/civet 0.11.6 → 0.11.8

package/dist/cache.js

@@ -0,0 +1,128 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// source/cache.civet
+var cache_exports = {};
+__export(cache_exports, {
+  createDiskCache: () => createDiskCache,
+  createMemoryCache: () => createMemoryCache,
+  hashParts: () => hashParts,
+  makeCacheKey: () => makeCacheKey,
+  stableStringify: () => stableStringify
+});
+module.exports = __toCommonJS(cache_exports);
+var crypto = __toESM(require("node:crypto"));
+var fs = __toESM(require("node:fs"));
+var path = __toESM(require("node:path"));
+function hashParts(parts) {
+  const hash = crypto.createHash("sha1");
+  for (const part of parts) {
+    hash.update(part).update("\0");
+  }
+  return hash.digest("hex");
+}
+function stableStringify(value) {
+  return JSON.stringify(value, (_key, val) => {
+    if (typeof val === "function") {
+      return void 0;
+    }
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      const sorted = {};
+      for (const key of Object.keys(val).sort()) {
+        sorted[key] = val[key];
+      }
+      return sorted;
+    }
+    return val;
+  });
+}
+function makeCacheKey(input) {
+  const resolved = path.resolve(input.sourcePath).replace(/\\/g, "/");
+  return hashParts([
+    input.source,
+    input.compilerName,
+    input.compilerVersion,
+    input.civetVersion ?? "",
+    input.civetMtime ?? "",
+    resolved,
+    stableStringify(input.options ?? {})
+  ]);
+}
+function createMemoryCache() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      return store.get(key);
+    },
+    set(key, value) {
+      store.set(key, value);
+      return;
+    }
+  };
+}
+function createDiskCache(dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch {
+  }
+  return {
+    get(key) {
+      const target = path.join(dir, key);
+      try {
+        const content = fs.readFileSync(target, "utf8");
+        try {
+          const now = /* @__PURE__ */ new Date();
+          fs.utimesSync(target, now, now);
+        } catch {
+        }
+        return content;
+      } catch {
+        return void 0;
+      }
+    },
+    set(key, value) {
+      const target = path.join(dir, key);
+      try {
+        const tmp = `${target}.tmp.${process.pid}`;
+        fs.writeFileSync(tmp, value);
+        return fs.renameSync(tmp, target);
+      } catch {
+        return;
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDiskCache,
+  createMemoryCache,
+  hashParts,
+  makeCacheKey,
+  stableStringify
+});

package/dist/cache.mjs

@@ -0,0 +1,89 @@
+// source/cache.civet
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+function hashParts(parts) {
+  const hash = crypto.createHash("sha1");
+  for (const part of parts) {
+    hash.update(part).update("\0");
+  }
+  return hash.digest("hex");
+}
+function stableStringify(value) {
+  return JSON.stringify(value, (_key, val) => {
+    if (typeof val === "function") {
+      return void 0;
+    }
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      const sorted = {};
+      for (const key of Object.keys(val).sort()) {
+        sorted[key] = val[key];
+      }
+      return sorted;
+    }
+    return val;
+  });
+}
+function makeCacheKey(input) {
+  const resolved = path.resolve(input.sourcePath).replace(/\\/g, "/");
+  return hashParts([
+    input.source,
+    input.compilerName,
+    input.compilerVersion,
+    input.civetVersion ?? "",
+    input.civetMtime ?? "",
+    resolved,
+    stableStringify(input.options ?? {})
+  ]);
+}
+function createMemoryCache() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      return store.get(key);
+    },
+    set(key, value) {
+      store.set(key, value);
+      return;
+    }
+  };
+}
+function createDiskCache(dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch {
+  }
+  return {
+    get(key) {
+      const target = path.join(dir, key);
+      try {
+        const content = fs.readFileSync(target, "utf8");
+        try {
+          const now = /* @__PURE__ */ new Date();
+          fs.utimesSync(target, now, now);
+        } catch {
+        }
+        return content;
+      } catch {
+        return void 0;
+      }
+    },
+    set(key, value) {
+      const target = path.join(dir, key);
+      try {
+        const tmp = `${target}.tmp.${process.pid}`;
+        fs.writeFileSync(tmp, value);
+        return fs.renameSync(tmp, target);
+      } catch {
+        return;
+      }
+    }
+  };
+}
+export {
+  createDiskCache,
+  createMemoryCache,
+  hashParts,
+  makeCacheKey,
+  stableStringify
+};

package/dist/civet

@@ -42,11 +42,9 @@ __export(cli_exports, {
 module.exports = __toCommonJS(cli_exports);
 var import_main = require("./main.js");
 var import_config = require("./config.js");
-var import_unplugin = require("./unplugin/unplugin.js");
 var import_promises = __toESM(require("node:fs/promises"));
 var import_node_path = __toESM(require("node:path"));
 var import_meta = {};
-var unplugin;
 async function version() {
   if (import_meta.url) {
     const { createRequire } = await import("node:module");
@@ -56,6 +54,7 @@ async function version() {
   }
 }
 var encoding = "utf8";
+var epipeStdoutHandlerInstalled = false;
 async function parseArgs(args, isTTY = process.stdin.isTTY) {
   const options = {};
   const isRun = () => !(options.ast || options.compile || options.typecheck || options.emitDeclaration);
@@ -176,6 +175,28 @@ async function parseArgs(args, isTTY = process.stdin.isTTY) {
         options.typecheck = true;
         break;
       }
+      case "--max-errors": {
+        const n = parseInt(args[++i] ?? "", 10);
+        if (isNaN(n) || n < 0) {
+          console.error(`Invalid value for --max-errors: ${args[i]}`);
+          errors++;
+        } else {
+          options.maxErrors = n;
+        }
+        ;
+        break;
+      }
+      case "--tsbuildinfo": {
+        const v = args[++i];
+        if (!v || v.startsWith("-")) {
+          console.error(`Missing PATH after --tsbuildinfo`);
+          errors++;
+        } else {
+          options.tsBuildInfoFile = v;
+        }
+        ;
+        break;
+      }
       case "--emit-declaration":
       case "--emitDeclaration": {
         options.emitDeclaration = true;
@@ -202,6 +223,12 @@ async function parseArgs(args, isTTY = process.stdin.isTTY) {
   if (options.typecheck || options.emitDeclaration) {
     options.typescript = true;
   }
+  if (options.maxErrors == null && process.env.CIVET_TYPECHECK_MAX_ERRORS) {
+    const parsed = parseInt(process.env.CIVET_TYPECHECK_MAX_ERRORS, 10);
+    if (!isNaN(parsed)) {
+      options.maxErrors = parsed;
+    }
+  }
   if (!(filenames.length || options.typescript || options.eval)) {
     if (isTTY) {
       options.repl = true;
@@ -231,6 +258,9 @@ async function parseArgs(args, isTTY = process.stdin.isTTY) {
       options.outputExt = optionsPath.ext;
     }
   }
+  if (options.outputExt && /\.[cm]?jsx?$/i.test(options.outputExt)) {
+    options.js ??= true;
+  }
   ;
   (options.parseOptions ??= {}).rewriteCivetImports ??= options.outputExt ?? ".civet.jsx";
   if (errors) {
@@ -388,7 +418,7 @@ async function repl(args, options) {
       input = input.replace(/\r/g, "\n");
       if (input === "\n") {
         return callback(null, void 0);
-      } else if (input in ["quit\n", "exit\n", "quit()\n", "exit()\n"]) {
+      } else if (["quit\n", "exit\n", "quit()\n", "exit()\n"].includes(input)) {
         return process.exit(0);
       } else if (input.endsWith("\n\n")) {
         let showError2 = function(error) {
@@ -495,6 +525,7 @@ ${" ".repeat(error.column - 1)}^ ${error.header}`);
   return;
 }
 async function cli(args = process.argv.slice(2)) {
+  let unplugin;
   let { filenames, scriptArgs, options } = await parseArgs(args);
   if (options.version) {
     console.log(await version());
@@ -536,6 +567,10 @@ Options:
   --inline-map     Generate a sourcemap
   --no-cache       Disable compiler caching (slow, for debugging)
   --typecheck      Run TypeScript and output diagnostics
+  --max-errors N   Allow up to N TS diagnostics before exiting non-zero
+                   (also: CIVET_TYPECHECK_MAX_ERRORS env)
+  --tsbuildinfo PATH  Persist incremental TS analysis state to PATH for
+                      faster repeat typechecks
   --emit-declaration  Run TypeScript and emit .d.ts files (if no errors)
   --trace XX       Log detailed parsing notes to a file, for parser debugging
 
@@ -564,6 +599,7 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
     }
   }
   if (options.typescript) {
+    const { rawPlugin } = await import("./unplugin/unplugin.js");
     if (!import_meta.url) {
       try {
         require("typescript");
@@ -590,10 +626,13 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
       ...options,
       ts: options.js ? "civet" : "preserve",
       outputExtension: ".tsx",
-      declarationExtension: options.outputExt?.replace(/\.[jt]sx?$/i, ".d.ts")
+      declarationExtension: options.outputExt?.replace(/\.[jt]sx?$/i, ".d.ts"),
+      // No filenames + --typecheck: lint the project.  Filenames given:
+      // scope to those (matches the bundler-driven default).
+      discoverProjectFiles: filenames.length === 0
     };
-    (unpluginOptions.parseOptions ??= {}).rewriteCivetImports = ".civet.jsx";
-    unplugin = (0, import_unplugin.rawPlugin)(unpluginOptions, { framework: "civet-cli" });
+    (unpluginOptions.parseOptions ??= {}).rewriteCivetImports = false;
+    unplugin = rawPlugin(unpluginOptions, { framework: "civet-cli" });
     await unplugin.buildStart();
   }
   if (options.run) {
@@ -603,14 +642,17 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
   if (options.repl) {
     return repl(args, options);
   }
-  process.stdout.on("error", (e) => {
-    if (["EPIPE", "EOF"].includes(e.code)) {
-      return process.exit(0);
-    } else {
-      console.error(e);
-      return process.exit(1);
-    }
-  });
+  if (!epipeStdoutHandlerInstalled) {
+    epipeStdoutHandlerInstalled = true;
+    process.stdout.on("error", (e) => {
+      if (["EPIPE", "EOF"].includes(e.code)) {
+        return process.exit(0);
+      } else {
+        console.error(e);
+        return process.exit(1);
+      }
+    });
+  }
   let errors = 0;
   for await (let { filename, error, content, stdin } of readFiles(filenames, options.eval)) {
     if (error) {
@@ -739,11 +781,21 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
   process.exitCode = Math.min(255, errors);
   if (unplugin != null) {
     try {
-      return await unplugin.buildEnd.call({
+      const pending = [];
+      await unplugin.buildEnd.call({
         emitFile({ source, fileName }) {
-          return import_promises.default.writeFile(fileName, source);
+          pending.push((async () => {
+            {
+              const outputDir = import_node_path.default.dirname(fileName);
+              if (!(outputDir === ".")) {
+                await import_promises.default.mkdir(outputDir, { recursive: true });
+              }
+              return await import_promises.default.writeFile(fileName, source);
+            }
+          })());
         }
       }, !filenames.length);
+      return await Promise.all(pending);
     } catch (error) {
       let ref5;
       if (ref5 = error.message.match(/Aborting build because of (\d+) TypeScript diagnostic/)) {