@danielx/civet 0.5.17 → 0.5.18

package/dist/browser.js

@@ -11113,8 +11113,10 @@ ${input.slice(result.pos)}
           return true;
         });
         if (classes.length) {
-          let braced = function(c) {
+          let isBraced = function(c) {
             return c[0] === "{" || c[0]?.token === "{";
+          }, unbrace = function(c) {
+            return c.slice(1, -1);
           }, parseClass = function(c) {
             c = c.token || c;
             if (c.startsWith("'")) {
@@ -11132,21 +11134,25 @@ ${input.slice(result.pos)}
             }
             return true;
           });
+          const strings = [], exprs = [];
+          classes.forEach((c) => {
+            if (isBraced(c)) {
+              exprs.push(unbrace(c));
+              exprs.push(", ");
+            } else {
+              strings.push(parseClass(c));
+            }
+          });
+          const stringPart = strings.filter(Boolean).join(" ");
           let classValue;
-          if (classes.some(braced)) {
-            classValue = ["{`"];
-            classes.forEach((c, i) => {
-              if (i > 0)
-                classValue.push(" ");
-              if (braced(c)) {
-                classValue.push("$", c);
-              } else {
-                classValue.push(parseClass(c));
-              }
-            });
-            classValue.push("`}");
+          if (exprs.length) {
+            exprs.pop();
+            if (stringPart) {
+              exprs.unshift(JSON.stringify(stringPart), ", ");
+            }
+            classValue = ["{[", ...exprs, '].filter(Boolean).join(" ")}'];
           } else {
-            classValue = JSON.stringify(classes.map(parseClass).join(" "));
+            classValue = JSON.stringify(stringPart);
           }
           attrs.splice(0, 0, [" ", [className, ["=", classValue]]]);
         }
@@ -12690,11 +12696,11 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var CivetPrologue$0 = $T($S($EXPECT($R50, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
+      var CivetPrologue$0 = $T($S($EXPECT($R50, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), $E(EOS)), function(value) {
         var content = value[2];
         return content;
       });
-      var CivetPrologue$1 = $T($S($EXPECT($R50, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
+      var CivetPrologue$1 = $T($S($EXPECT($R50, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), $E(EOS)), function(value) {
         var content = value[2];
         return content;
       });
@@ -15246,6 +15252,9 @@ ${input.slice(result.pos)}
         compile: function(src, options = defaultOptions) {
           var ast, code, events, filename, sm, srcMapJSON;
           filename = options.filename || "unknown";
+          if (filename.endsWith(".coffee") && !/^(#![^\r\n]*(\r\n|\n|\r))?\s*['"]civet/.test(src)) {
+            src = `"civet coffeeCompat"; ${src}`;
+          }
           if (!options.noCache) {
             events = makeCache();
           }

package/dist/civet

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
 "use strict";
-var compile, encoding, fs, generate, parse, prune, readLines, readline;
+var cli, compile, encoding, fs, generate, parse, parseArgs, path, prune, readFiles, repl, version, splice = [].splice;
+version = function() {
+  return require("../package.json").version;
+};
 if (process.argv.includes("--version")) {
-  process.stdout.write(require("../package.json").version + "\n");
+  console.log(version());
   process.exit(0);
 }
 if (process.argv.includes("--help")) {
@@ -15,14 +18,24 @@ if (process.argv.includes("--help")) {
 
 Usage:
 
-    civet [options] < input.civet > output.ts
+    civet [options]                              # REPL
+    civet [options] -c input.civet               # -> input.civet.tsx
+    civet [options] -c input.civet -o .ts        # -> input.ts
+    civet [options] -c input.civet -o dir        # -> dir/input.civet.tsx
+    civet [options] -c input.civet -o dir/.ts    # -> dir/input.ts
+    civet [options] -c input.civet -o output.ts  # -> output.ts
+    civet [options] < input.civet > output.ts    # pipe form
 
 Options:
-  --help          Show this help message
-  --version       Show the version number
-  --ast           Output the AST instead of the compiled code
-  --inline-map    Generate a sourcemap
-  --js            Strip out all type annotations
+  --help           Show this help message
+  --version        Show the version number
+  -o / --output XX Specify output directory and/or extension, or filename
+  -c / --compile   Compile input files to TypeScript (or JavaScript)
+  --js             Strip out all type annotations; default to .jsx extension
+  --ast            Print the AST instead of the compiled code
+  --inline-map     Generate a sourcemap
+
+You can use - to read from stdin or (prefixed by -o) write to stdout.
 
 `);
   process.exit(0);
@@ -30,47 +43,221 @@ Options:
 ({ parse, compile, generate } = require("./main"));
 ({ prune } = generate);
 encoding = "utf8";
-process.stdin.setEncoding(encoding);
-fs = require("fs");
-readline = function() {
-  try {
-    return require("node:readline");
-  } catch (error) {
-    return require("readline");
+fs = require("fs/promises");
+path = require("path");
+parseArgs = function(args = process.argv.slice(2)) {
+  var arg, char, filenames, i, options, ref;
+  options = {};
+  filenames = [];
+  i = 0;
+  while (i < args.length) {
+    arg = args[i];
+    if (/^-\w{2,}$/.test(arg)) {
+      splice.apply(args, [i, i - i + 1].concat(ref = function() {
+        var j, len, ref1, results;
+        ref1 = arg.slice(1);
+        results = [];
+        for (j = 0, len = ref1.length; j < len; j++) {
+          char = ref1[j];
+          results.push(`-${char}`);
+        }
+        return results;
+      }())), ref;
+      continue;
+    }
+    switch (arg) {
+      case "-c":
+      case "--compile":
+        options.compile = true;
+        break;
+      case "-o":
+      case "--output":
+        options.output = args[++i];
+        break;
+      case "--ast":
+        options.ast = true;
+        break;
+      case "--no-cache":
+        options.noCache = true;
+        break;
+      case "--inline-map":
+        options.inlineMap = true;
+        break;
+      case "--js":
+        options.js = true;
+        break;
+      case "--":
+        filenames.push(...args.slice(++i));
+        i = args.length;
+        break;
+      default:
+        filenames.push(arg);
+    }
+    i++;
   }
-}();
-readLines = function(rl) {
-  return new Promise(function(resolve, reject) {
-    var parts;
-    parts = [];
-    rl.on("line", function(buffer) {
-      return parts.push(buffer + "\n");
-    });
-    rl.on("SIGINT", function() {
-      return reject("^C");
-    });
-    return rl.on("close", function() {
-      return resolve(parts.join(""));
-    });
+  return { filenames, options };
+};
+readFiles = async function* (filenames, options) {
+  var content, error, filename, j, len, lines, results, rl, stdin;
+  results = [];
+  for (j = 0, len = filenames.length; j < len; j++) {
+    filename = filenames[j];
+    stdin = filename === "-";
+    try {
+      if (stdin) {
+        process.stdin.setEncoding(encoding);
+        filename = "<stdin>";
+        try {
+          filename = await fs.realpath("/dev/stdin");
+        } catch (error1) {
+        }
+        lines = [];
+        rl = require("readline").createInterface(process.stdin, process.stdout);
+        rl.on("line", function(buffer) {
+          return lines.push(buffer + "\n");
+        });
+        content = await new Promise(function(resolve, reject) {
+          rl.on("SIGINT", function() {
+            return reject("^C");
+          });
+          return rl.on("close", function() {
+            return resolve(lines.join(""));
+          });
+        });
+      } else {
+        content = await fs.readFile(filename, { encoding });
+      }
+      results.push(yield { filename, content, stdin });
+    } catch (error1) {
+      error = error1;
+      results.push(yield { filename, error, stdin });
+    }
+  }
+  return results;
+};
+repl = function(options) {
+  var nodeRepl, r, vm;
+  console.log(`Civet ${version()} REPL.  Enter a blank line to execute code.`);
+  global.quit = global.exit = function() {
+    return process.exit(0);
+  };
+  nodeRepl = require("repl");
+  vm = require("vm");
+  return r = nodeRepl.start({
+    prompt: "\u{1F431}> ",
+    eval: function(input, context, filename, callback) {
+      var error, output, result;
+      if (input === "\n") {
+        return callback(null);
+      } else if (input === "quit\n" || input === "exit\n" || input === "quit()\n" || input === "exit()\n") {
+        return process.exit(0);
+      } else if (input.endsWith("\n\n")) {
+        try {
+          output = compile(input, { ...options, filename });
+        } catch (error1) {
+          error = error1;
+          return callback(error);
+        }
+        try {
+          result = vm.runInContext(output, context, { filename });
+        } catch (error1) {
+          error = error1;
+          return callback(error);
+        }
+        return callback(null, result);
+      } else {
+        return callback(new nodeRepl.Recoverable("Enter a blank line to execute code."));
+      }
+    }
   });
 };
-readLines(readline.createInterface(process.stdin, process.stdout)).then(function(input) {
-  var ast, filename, inlineMap, js, noCache, output;
-  ast = process.argv.includes("--ast");
-  noCache = process.argv.includes("--no-cache");
-  inlineMap = process.argv.includes("--inline-map");
-  js = process.argv.includes("--js");
-  filename = "unknown";
-  try {
-    filename = fs.realpathSync("/dev/stdin");
-  } catch (error) {
+cli = async function() {
+  var content, error, filename, filenames, options, optionsPath, output, outputFilename, outputPath, ref, results, stat, stdin, x;
+  ({ filenames, options } = parseArgs());
+  if (!filenames.length) {
+    options.compile = true;
+    if (process.stdin.isTTY) {
+      options.repl = true;
+    } else {
+      filenames = ["-"];
+    }
   }
-  output = compile(input, { ast, noCache, filename, inlineMap, js });
-  if (ast) {
-    output = JSON.stringify(output, null, 2);
+  options.run = !(options.ast || options.compile);
+  if (options.run) {
+    options.js = true;
+    options.inlineMap = true;
   }
-  return process.stdout.write(output);
-}).catch(function(e) {
-  console.error(e);
-  return process.exit(1);
-});
+  if (options.repl) {
+    return repl(options);
+  }
+  ref = readFiles(filenames, options);
+  results = [];
+  for await (x of ref) {
+    ({ filename, error, content, stdin } = x);
+    if (error) {
+      console.error(`${filename} failed to load:`);
+      console.error(error);
+      continue;
+    }
+    try {
+      output = compile(content, { ...options, filename });
+    } catch (error1) {
+      error = error1;
+      console.error(error);
+      continue;
+    }
+    if (options.ast) {
+      results.push(process.stdout.write(JSON.stringify(output, null, 2)));
+    } else if (options.compile) {
+      if (stdin && !options.output || options.output === "-") {
+        results.push(process.stdout.write(output));
+      } else {
+        outputPath = path.parse(filename);
+        delete outputPath.base;
+        if (options.js) {
+          outputPath.ext += ".jsx";
+        } else {
+          outputPath.ext += ".tsx";
+        }
+        if (options.output) {
+          optionsPath = path.parse(options.output);
+          try {
+            stat = await fs.stat(options.output);
+          } catch (error1) {
+            stat = null;
+          }
+          if (stat != null ? stat.isDirectory() : void 0) {
+            outputPath.dir = options.output;
+          } else if (/^(\.[^.]+)+$/.test(optionsPath.base)) {
+            outputPath.ext = optionsPath.base;
+            if (optionsPath.dir) {
+              outputPath.dir = optionsPath.dir;
+            }
+          } else {
+            outputPath = optionsPath;
+          }
+        }
+        outputFilename = path.format(outputPath);
+        try {
+          results.push(await fs.writeFile(outputFilename, output));
+        } catch (error1) {
+          error = error1;
+          console.error(`${outputFilename} failed to write:`);
+          results.push(console.error(error));
+        }
+      }
+    } else {
+      try {
+        results.push(require.main._compile(output, filename));
+      } catch (error1) {
+        error = error1;
+        console.error(`${filename} crashed while running:`);
+        results.push(console.error(error));
+      }
+    }
+  }
+  return results;
+};
+if (require.main === module) {
+  cli();
+}

package/dist/main.js

@@ -11112,8 +11112,10 @@ ${input.slice(result.pos)}
         return true;
       });
       if (classes.length) {
-        let braced = function(c) {
+        let isBraced = function(c) {
           return c[0] === "{" || c[0]?.token === "{";
+        }, unbrace = function(c) {
+          return c.slice(1, -1);
         }, parseClass = function(c) {
           c = c.token || c;
           if (c.startsWith("'")) {
@@ -11131,21 +11133,25 @@ ${input.slice(result.pos)}
           }
           return true;
         });
+        const strings = [], exprs = [];
+        classes.forEach((c) => {
+          if (isBraced(c)) {
+            exprs.push(unbrace(c));
+            exprs.push(", ");
+          } else {
+            strings.push(parseClass(c));
+          }
+        });
+        const stringPart = strings.filter(Boolean).join(" ");
         let classValue;
-        if (classes.some(braced)) {
-          classValue = ["{`"];
-          classes.forEach((c, i) => {
-            if (i > 0)
-              classValue.push(" ");
-            if (braced(c)) {
-              classValue.push("$", c);
-            } else {
-              classValue.push(parseClass(c));
-            }
-          });
-          classValue.push("`}");
+        if (exprs.length) {
+          exprs.pop();
+          if (stringPart) {
+            exprs.unshift(JSON.stringify(stringPart), ", ");
+          }
+          classValue = ["{[", ...exprs, '].filter(Boolean).join(" ")}'];
         } else {
-          classValue = JSON.stringify(classes.map(parseClass).join(" "));
+          classValue = JSON.stringify(stringPart);
         }
         attrs.splice(0, 0, [" ", [className, ["=", classValue]]]);
       }
@@ -12689,11 +12695,11 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var CivetPrologue$0 = $T($S($EXPECT($R50, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
+    var CivetPrologue$0 = $T($S($EXPECT($R50, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), $E(EOS)), function(value) {
       var content = value[2];
       return content;
     });
-    var CivetPrologue$1 = $T($S($EXPECT($R50, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
+    var CivetPrologue$1 = $T($S($EXPECT($R50, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), $E(EOS)), function(value) {
       var content = value[2];
       return content;
     });
@@ -15243,6 +15249,9 @@ module.exports = {
   compile: function(src, options = defaultOptions) {
     var ast, code, events, filename, sm, srcMapJSON;
     filename = options.filename || "unknown";
+    if (filename.endsWith(".coffee") && !/^(#![^\r\n]*(\r\n|\n|\r))?\s*['"]civet/.test(src)) {
+      src = `"civet coffeeCompat"; ${src}`;
+    }
     if (!options.noCache) {
       events = makeCache();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielx/civet",
-  "version": "0.5.17",
+  "version": "0.5.18",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "exports": {