@danielx/civet 0.7.13 → 0.7.15

package/dist/civet

@@ -40,8 +40,8 @@ module.exports = __toCommonJS(cli_exports);
 var import_main = require("./main.js");
 var import_config = require("./config.js");
 var import_unplugin = require("./unplugin");
-var import_promises = __toESM(require("fs/promises"));
-var import_path = __toESM(require("path"));
+var import_promises = __toESM(require("node:fs/promises"));
+var import_node_path = __toESM(require("node:path"));
 var unplugin;
 function version() {
   return require("../package.json").version;
@@ -98,11 +98,7 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
 var encoding = "utf8";
 function parseArgs(args) {
   const options = {};
-  Object.defineProperty(options, "run", {
-    get: function() {
-      return !(this.ast || this.compile || this.typecheck || this.emitDeclaration);
-    }
-  });
+  const isRun = () => !(options.ast || options.compile || options.typecheck || options.emitDeclaration);
   const filenames = [];
   let scriptArgs = [];
   let i = 0;
@@ -208,7 +204,7 @@ function parseArgs(args) {
         if (arg.startsWith("-") && arg !== "-") {
           console.error(`Invalid command-line argument: ${arg}`);
           errors++;
-        } else if (options.run) {
+        } else if (options.run = isRun()) {
           endOfArgs(i);
         } else {
           filenames.push(arg);
@@ -220,6 +216,7 @@ function parseArgs(args) {
   if (errors) {
     process.exit(Math.min(255, errors));
   }
+  options.run = isRun();
   return { filenames, scriptArgs, options };
 }
 async function* readFiles(filenames) {
@@ -276,7 +273,7 @@ async function repl(options) {
       const { pathToFileURL } = await import("node:url");
       importModuleDynamically = (specifier) => {
         if (/^\.\.?[/\\]/.test(specifier)) {
-          return import(pathToFileURL(import_path.default.join(process.cwd(), specifier)));
+          return import(pathToFileURL(import_node_path.default.join(process.cwd(), specifier)));
         } else {
           return import(specifier);
         }
@@ -457,7 +454,8 @@ async function cli() {
       ...options
     };
   }
-  if (!filenames.length) {
+  const typescript = options.typecheck || options.emitDeclaration;
+  if (!(filenames.length || typescript)) {
     if (process.stdin.isTTY) {
       options.repl = true;
     } else {
@@ -465,13 +463,13 @@ async function cli() {
       filenames = ["-"];
     }
   }
-  if (options.typecheck || options.emitDeclaration) {
+  if (typescript) {
     const unpluginOptions = {
       ...options,
       ts: options.js ? "civet" : "preserve",
       outputExtension: ".tsx"
     };
-    (unpluginOptions.parseOptions ??= {}).rewriteCivetImports = ".civet.tsx";
+    (unpluginOptions.parseOptions ??= {}).rewriteCivetImports = ".civet.jsx";
     unplugin = (0, import_unplugin.rawPlugin)(unpluginOptions, { framework: "civet-cli" });
     await unplugin.buildStart();
   }
@@ -484,14 +482,14 @@ async function cli() {
   }
   let outputDir, outputExt, outputPath;
   if (options.output) {
-    const optionsPath = import_path.default.parse(options.output);
+    const optionsPath = import_node_path.default.parse(options.output);
     let stat;
     try {
       stat = await import_promises.default.stat(options.output);
     } catch {
       stat = null;
     }
-    if (stat?.isDirectory() || options.output.endsWith(import_path.default.sep) || options.output.endsWith("/")) {
+    if (stat?.isDirectory() || options.output.endsWith(import_node_path.default.sep) || options.output.endsWith("/")) {
       outputDir = options.output;
     } else if (/^(\.[^.]+)+$/.test(optionsPath.base)) {
       outputExt = optionsPath.base;
@@ -543,7 +541,7 @@ async function cli() {
       if (stdin && !options.output || options.output === "-") {
         process.stdout.write(output);
       } else {
-        let targetPath = import_path.default.parse(filename);
+        let targetPath = import_node_path.default.parse(filename);
         delete targetPath.base;
         if (options.js) {
           targetPath.ext += ".jsx";
@@ -562,7 +560,7 @@ async function cli() {
         if (targetPath.dir) {
           await import_promises.default.mkdir(targetPath.dir, { recursive: true });
         }
-        const targetFilename = import_path.default.format(targetPath);
+        const targetFilename = import_node_path.default.format(targetPath);
         try {
           await import_promises.default.writeFile(targetFilename, output);
         } catch (error2) {
@@ -627,7 +625,7 @@ async function cli() {
           module.filename = filename;
         }
         process.argv = ["civet", module.filename, ...scriptArgs];
-        module.paths = require("module")._nodeModulePaths(import_path.default.dirname(module.filename));
+        module.paths = require("module")._nodeModulePaths(import_node_path.default.dirname(module.filename));
         try {
           module._compile(output, module.filename);
         } catch (error2) {
@@ -645,7 +643,7 @@ async function cli() {
         emitFile({ source, fileName }) {
           return import_promises.default.writeFile(fileName, source);
         }
-      });
+      }, !filenames.length);
     } catch (error) {
       let ref1;
       if (ref1 = error.message.match(/Aborting build because of (\d+) TypeScript diagnostic/)) {

package/dist/config.js

@@ -38,38 +38,51 @@ module.exports = __toCommonJS(config_exports);
 var import_path = __toESM(require("path"));
 var import_promises = __toESM(require("fs/promises"));
 var import_main = require("./main.js");
-var configFileNames = /* @__PURE__ */ new Set([
-  "\u{1F408}.json",
-  "\u{1F408}.civet",
-  "civetconfig.json",
-  "civetconfig.civet",
-  "civet.config.json",
-  "civet.config.civet"
-]);
+var configNames = [
+  "\u{1F408}",
+  "civetconfig",
+  "civet.config",
+  "package"
+];
+var configExtensions = [
+  ".civet",
+  ".js",
+  ".yaml",
+  ".yml",
+  ".json"
+];
+var configDir = ".config";
 async function findInDir(dirPath) {
-  for (const entryName of await import_promises.default.readdir(dirPath)) {
-    const entryPath = import_path.default.join(dirPath, entryName);
-    if (entryName === ".config" && await (async () => {
-      try {
-        return (await import_promises.default.stat(entryPath)).isDirectory();
-      } catch (e) {
-        return;
-      }
-    })()) {
-      const found = await findInDir(entryPath);
-      if (found) {
-        return found;
-      }
+  const entries = new Set(await import_promises.default.readdir(dirPath));
+  const pathFor = (name) => import_path.default.join(dirPath, name);
+  if (entries.has(configDir) && await (async () => {
+    try {
+      return (await import_promises.default.stat(pathFor(configDir))).isDirectory();
+    } catch (e) {
+      return;
     }
-    const name = entryName.replace(/^\./, "");
-    if (configFileNames.has(name) && await (async () => {
-      try {
-        return (await import_promises.default.stat(entryPath)).isFile();
-      } catch (e) {
-        return;
+  })()) {
+    const found = await findInDir(pathFor(configDir));
+    if (found) {
+      return found;
+    }
+  }
+  for (let i = 0, len = configNames.length; i < len; i++) {
+    const configName = configNames[i];
+    for (let i1 = 0, len1 = configExtensions.length; i1 < len1; i1++) {
+      const extension = configExtensions[i1];
+      for (let ref = ["." + configName + extension, configName + extension], i2 = 0, len2 = ref.length; i2 < len2; i2++) {
+        const entry = ref[i2];
+        if (entries.has(entry) && await (async () => {
+          try {
+            return (await import_promises.default.stat(pathFor(entry))).isFile();
+          } catch (e) {
+            return;
+          }
+        })()) {
+          return pathFor(entry);
+        }
       }
-    })()) {
-      return entryPath;
     }
   }
   return;
@@ -87,30 +100,49 @@ async function findConfig(startDir) {
   }
   return;
 }
-async function loadConfig(path2) {
-  const config = await import_promises.default.readFile(path2, "utf8");
+async function loadConfig(pathname) {
+  const config = await import_promises.default.readFile(pathname, "utf8");
   let data = {};
-  if (path2.endsWith(".json")) {
+  if (pathname.endsWith(".json")) {
+    let json;
     try {
-      data = JSON.parse(config);
+      json = JSON.parse(config);
     } catch (e) {
-      throw new Error(`Error parsing JSON config file ${path2}: ${e}`);
+      throw new Error(`Error parsing JSON config file ${pathname}: ${e}`);
     }
-  } else {
-    let js;
+    if ("civetConfig" in json) {
+      data = json.civetConfig;
+    } else if (import_path.default.basename(pathname).startsWith("package")) {
+      return {};
+    } else {
+      data = json;
+    }
+  } else if (/\.ya?ml$/.test(pathname)) {
     try {
-      js = (0, import_main.compile)(config, {
-        js: true,
-        sync: true
-      });
+      const { default: YAML } = await import("yaml");
+      const yaml = YAML.parse(config);
+      data = yaml.civetConfig ?? yaml;
     } catch (e) {
-      throw new Error(`Error compiling Civet config file ${path2}: ${e}`);
+      throw new Error(`Error parsing YAML config file ${pathname}: ${e}`);
+    }
+  } else {
+    let js;
+    if (pathname.endsWith(".civet")) {
+      try {
+        js = await (0, import_main.compile)(config, {
+          js: true
+        });
+      } catch (e) {
+        throw new Error(`Error compiling Civet config file ${pathname}: ${e}`);
+      }
+    } else {
+      js = config;
     }
     try {
       const exports2 = await import(`data:text/javascript,${encodeURIComponent(js)}`);
       data = exports2?.default;
     } catch (e) {
-      throw new Error(`Error running Civet config file ${path2}: ${e}`);
+      throw new Error(`Error running Civet config file ${pathname}: ${e}`);
     }
   }
   if (!(data != null && typeof data === "object" && !Array.isArray(data))) {

package/dist/esbuild.js

@@ -100,6 +100,8 @@ var rawPlugin = (options = {}, meta) => {
   let compilerOptions, compilerOptionsWithSourceMap;
   let rootDir = process.cwd();
   let esbuildOptions;
+  let configErrors;
+  let configFileNames;
   const tsPromise = transformTS || options.ts === "tsc" ? import("typescript").then((m) => m.default) : null;
   const getFormatHost = (sys) => {
     return {
@@ -114,6 +116,16 @@ var rawPlugin = (options = {}, meta) => {
     enforce: "pre",
     async buildStart() {
       if (transformTS || options.ts === "tsc") {
+        let mogrify2 = function(key) {
+          if (key in config && Array.isArray(config[key])) {
+            config[key] = config[key].map((item) => {
+              if (typeof item !== "string")
+                return item;
+              return item.replace(/\.civet\b(?!\.)/g, ".civet.tsx");
+            });
+          }
+        };
+        var mogrify = mogrify2;
         const ts = await tsPromise;
         const civetConfigPath = "config" in options ? options.config : await (0, import_config.findInDir)(process.cwd());
         if (civetConfigPath) {
@@ -135,17 +147,26 @@ var rawPlugin = (options = {}, meta) => {
           console.error(ts.formatDiagnostic(error, getFormatHost(ts.sys)));
           throw error;
         }
+        mogrify2("files");
+        const system = { ...ts.sys };
+        const { readDirectory: systemReadDirectory } = system;
+        system.readDirectory = (path2, extensions, excludes, includes, depth) => {
+          extensions = [...extensions ?? [], ".civet"];
+          return systemReadDirectory(path2, extensions, excludes, includes, depth).map((name) => name.endsWith(".civet") ? name + ".tsx" : name);
+        };
         const configContents = ts.parseJsonConfigFileContent(
           config,
-          ts.sys,
+          system,
           process.cwd()
         );
+        configErrors = configContents.errors;
+        configFileNames = configContents.fileNames;
         compilerOptions = {
           ...configContents.options,
           target: ts.ScriptTarget.ESNext,
           composite: false
         };
-        compilerOptions.jsx ?? (compilerOptions.jsx = "preserve");
+        compilerOptions.jsx ?? (compilerOptions.jsx = ts.JsxEmit.Preserve);
         compilerOptionsWithSourceMap = {
           ...compilerOptions,
           sourceMap: true
@@ -153,11 +174,15 @@ var rawPlugin = (options = {}, meta) => {
         fsMap = /* @__PURE__ */ new Map();
       }
     },
-    async buildEnd() {
+    async buildEnd(useConfigFileNames = false) {
       if (transformTS) {
         const ts = await tsPromise;
         const system = tsvfs.createFSBackedSystem(fsMap, process.cwd(), ts);
-        const { fileExists: systemFileExists, readFile: systemReadFile } = system;
+        const {
+          fileExists: systemFileExists,
+          readFile: systemReadFile,
+          readDirectory: systemReadDirectory
+        } = system;
         system.fileExists = (filename) => {
           if (!filename.endsWith(".civet.tsx"))
             return systemFileExists(filename);
@@ -165,9 +190,35 @@ var rawPlugin = (options = {}, meta) => {
             return true;
           return systemFileExists(filename.slice(0, -4));
         };
+        system.readDirectory = (path2) => systemReadDirectory(path2).map((name) => name.endsWith(".civet") ? name + ".tsx" : name);
         system.readFile = (filename, encoding = "utf-8") => {
+          if (import_path.default.basename(filename) === "package.json") {
+            let recurse2 = function(node) {
+              if (node && typeof node === "object") {
+                for (const key in node) {
+                  const value = node[key];
+                  if (typeof value === "string") {
+                    if (value.endsWith(".civet")) {
+                      node[key] = value + ".tsx";
+                      modified = true;
+                    }
+                  } else if (value) {
+                    recurse2(value);
+                  }
+                }
+              }
+            };
+            var recurse = recurse2;
+            const json = systemReadFile(filename, encoding);
+            if (!json)
+              return json;
+            const parsed = JSON.parse(json);
+            let modified = false;
+            recurse2(parsed.imports);
+            return modified ? JSON.stringify(parsed) : json;
+          }
           if (!filename.endsWith(".civet.tsx"))
-            return systemReadFile(filename);
+            return systemReadFile(filename, encoding);
           if (fsMap.has(filename))
             return fsMap.get(filename);
           const civetFilename = filename.slice(0, -4);
@@ -189,8 +240,9 @@ var rawPlugin = (options = {}, meta) => {
           compilerOptions,
           ts
         );
+        host.compilerHost.getDirectories = system.getDirectories;
         const program = ts.createProgram({
-          rootNames: [...fsMap.keys()],
+          rootNames: useConfigFileNames ? configFileNames : [...fsMap.keys()],
           options: compilerOptions,
           host: host.compilerHost
         });
@@ -216,6 +268,9 @@ var rawPlugin = (options = {}, meta) => {
             start: range.start
           };
         });
+        if (configErrors?.length) {
+          diagnostics.unshift(...configErrors);
+        }
         if (diagnostics.length > 0) {
           console.error(
             ts.formatDiagnosticsWithColorAndContext(