@danielx/civet 0.5.20 → 0.5.22

package/README.md

@@ -23,6 +23,8 @@ Quickstart Guide
 ```bash
 # Install
 npm install -g @danielx/civet
+# Run civet code directly in a REPL
+civet
 # Compile civet source file to typescript
 civet < source.civet > output.ts
 # Execute a civet source file in node using ts-node
@@ -140,6 +142,8 @@ Things Changed from CoffeeScript
 - `x?.y` now compiles to `x?.y` rather than the `if typeof x !== 'undefined' && x !== null` if check
 - Existential `x?` → `(x != null)` no longer checks for undeclared variables.
 - `x?()` → `x?.()` instead of `if (typeof x === 'function') { x() }`
+- Functions don't implicitly return the last value if there's a semicolon
+  at the end: `-> x` returns `x` but `-> x;` does not
 - Backtick embedded JS has been replaced with JS template literals.
 - No longer allowing multiple postfix `if/unless` on the same line (use `&&` or `and` to combine conditions).
 - `#{}` interpolation in `""` strings only when `"civet coffeeCompat"` or `"civet coffeeInterpolation"`
@@ -310,6 +314,16 @@ You can use these with `"civet coffeeCompat"` to opt in to all or use them bit b
 Another possibility is to slowly remove them to provide a way to migrate files a little at a time `"civet coffeeCompat -coffeeBooleans -coffeeComment -coffeeEq"`.
 Both camel case and hyphens work when specifying options `"civet coffee-compat"`. More options will be added over time until 97+% compatibility is achieved.
 
+ECMAScript Compatibility
+---
+
+You can also specify `"civet"` prologue directives to increase
+compatibility with ECMAScript/TypeScript:
+
+| Configuration       | What it enables |
+|---------------------|---------------------------------------|
+| -implicit-returns   | turn off implicit return of last value in functions |
+
 Other Options
 ---
 

package/dist/browser.js

@@ -441,6 +441,7 @@ ${input.slice(result.pos)}
         ParenthesizedExpression,
         ClassDeclaration,
         ClassExpression,
+        ClassBinding,
         ClassHeritage,
         ExtendsClause,
         ExtendsToken,
@@ -2204,7 +2205,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var ClassExpression$0 = $TS($S($E(Decorators), $E($S(Abstract, __)), Class, $E($S(BindingIdentifier, $E(TypeParameters))), $E(ClassHeritage), ClassBody), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+      var ClassExpression$0 = $TS($S($E(Decorators), $E($S(Abstract, __)), Class, $E(ClassBinding), $E(ClassHeritage), ClassBody), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
         return $0;
       });
       function ClassExpression(state) {
@@ -2225,6 +2226,27 @@ ${input.slice(result.pos)}
           return result;
         }
       }
+      var ClassBinding$0 = $T($S($N(EOS), BindingIdentifier, $E(TypeParameters)), function(value) {
+        return [value[1], value[2]];
+      });
+      function ClassBinding(state) {
+        if (state.events) {
+          const result = state.events.enter?.("ClassBinding", state);
+          if (result)
+            return result.cache;
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("ClassBinding", state, ClassBinding$0(state));
+          if (state.events)
+            state.events.exit?.("ClassBinding", state, result);
+          return result;
+        } else {
+          const result = ClassBinding$0(state);
+          if (state.events)
+            state.events.exit?.("ClassBinding", state, result);
+          return result;
+        }
+      }
       var ClassHeritage$0 = $S(ExtendsClause, $E(ImplementsClause));
       var ClassHeritage$1 = ImplementsClause;
       function ClassHeritage(state) {
@@ -5303,7 +5325,7 @@ ${input.slice(result.pos)}
           ts: true
         };
       });
-      var MethodDefinition$1 = $TS($S(MethodSignature, BracedBlock), function($skip, $loc, $0, $1, $2) {
+      var MethodDefinition$1 = $TS($S(MethodSignature, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2) {
         var signature = $1;
         var block = $2;
         return {
@@ -14634,6 +14656,8 @@ ${input.slice(result.pos)}
                 insertBeforeAssignment(node, ["let ", undeclaredIdentifiers.join(", "), "\n"]);
               }
             } else if (node.type == "Declaration") {
+              if (node.children && node.children.length)
+                createLetDecs(node.children, scopes);
               node.names.forEach((name) => currentScope.add(name));
             } else {
               let block = node;

package/dist/civet

@@ -186,6 +186,7 @@ cli = async function() {
   if (options.run) {
     options.js = true;
     options.inlineMap = true;
+    require("../register.js");
   }
   if (options.repl) {
     return repl(options);
@@ -247,8 +248,10 @@ cli = async function() {
         }
       }
     } else {
+      module.filename = await fs.realpath(filename);
+      module.paths = require("module")._nodeModulePaths(path.dirname(module.filename));
       try {
-        results.push(require.main._compile(output, filename));
+        results.push(module._compile(output, module.filename));
       } catch (error1) {
         error = error1;
         console.error(`${filename} crashed while running:`);

package/dist/esm.mjs

@@ -5,7 +5,7 @@ Currently depends on ts-node esm loader being downstream
 
 @example
 ```bash
-node --loader ts-node/esm --loader @danielx/civet/esm
+node --loader ts-node/esm --loader @danielx/civet/esm source.civet
 ```
 */
 

package/dist/main.js

@@ -440,6 +440,7 @@ ${input.slice(result.pos)}
       ParenthesizedExpression,
       ClassDeclaration,
       ClassExpression,
+      ClassBinding,
       ClassHeritage,
       ExtendsClause,
       ExtendsToken,
@@ -2203,7 +2204,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ClassExpression$0 = $TS($S($E(Decorators), $E($S(Abstract, __)), Class, $E($S(BindingIdentifier, $E(TypeParameters))), $E(ClassHeritage), ClassBody), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+    var ClassExpression$0 = $TS($S($E(Decorators), $E($S(Abstract, __)), Class, $E(ClassBinding), $E(ClassHeritage), ClassBody), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
       return $0;
     });
     function ClassExpression(state) {
@@ -2224,6 +2225,27 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var ClassBinding$0 = $T($S($N(EOS), BindingIdentifier, $E(TypeParameters)), function(value) {
+      return [value[1], value[2]];
+    });
+    function ClassBinding(state) {
+      if (state.events) {
+        const result = state.events.enter?.("ClassBinding", state);
+        if (result)
+          return result.cache;
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ClassBinding", state, ClassBinding$0(state));
+        if (state.events)
+          state.events.exit?.("ClassBinding", state, result);
+        return result;
+      } else {
+        const result = ClassBinding$0(state);
+        if (state.events)
+          state.events.exit?.("ClassBinding", state, result);
+        return result;
+      }
+    }
     var ClassHeritage$0 = $S(ExtendsClause, $E(ImplementsClause));
     var ClassHeritage$1 = ImplementsClause;
     function ClassHeritage(state) {
@@ -5302,7 +5324,7 @@ ${input.slice(result.pos)}
         ts: true
       };
     });
-    var MethodDefinition$1 = $TS($S(MethodSignature, BracedBlock), function($skip, $loc, $0, $1, $2) {
+    var MethodDefinition$1 = $TS($S(MethodSignature, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2) {
       var signature = $1;
       var block = $2;
       return {
@@ -14633,6 +14655,8 @@ ${input.slice(result.pos)}
               insertBeforeAssignment(node, ["let ", undeclaredIdentifiers.join(", "), "\n"]);
             }
           } else if (node.type == "Declaration") {
+            if (node.children && node.children.length)
+              createLetDecs(node.children, scopes);
             node.names.forEach((name) => currentScope.add(name));
           } else {
             let block = node;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielx/civet",
-  "version": "0.5.20",
+  "version": "0.5.22",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "exports": {
@@ -22,8 +22,9 @@
   },
   "scripts": {
     "build": "bash ./build/build.sh",
-    "civet.dev": "bash ./build/site.sh",
-    "npm-release": "bash ./build/npm-release.sh",
+    "docs:dev": "vitepress dev civet.dev",
+    "docs:build": "vitepress build civet.dev",
+    "docs:preview": "vitepress preview civet.dev",
     "prepublishOnly": "yarn build && yarn test",
     "test": "c8 mocha"
   },
@@ -35,6 +36,7 @@
     "@types/coffeescript": "^2.5.2",
     "@types/mocha": "^9.1.1",
     "@types/node": "^18.7.8",
+    "axios": "^1.2.2",
     "c8": "^7.12.0",
     "esbuild": "^0.14.49",
     "esbuild-coffeescript": "^2.1.0",
@@ -42,7 +44,9 @@
     "mocha": "^10.0.0",
     "ts-node": "^10.9.1",
     "tslib": "^2.4.0",
-    "typescript": "^4.7.4"
+    "typescript": "^4.7.4",
+    "vitepress": "^1.0.0-alpha.35",
+    "vue": "^3.2.45"
   },
   "c8": {
     "all": true,

package/register.js

@@ -1,10 +1,23 @@
+/**
+@file Civet CJS registration
+
+`require`ing this file will register the `.civet` extension with
+Node.js's `require`.
+
+@example
+```bash
+node -r @danielx/civet/register.js source.civet
+```
+*/
+
 if (require.extensions) {
   const fs = require("fs");
   const { compile } = require("./");
 
   require.extensions[".civet"] = function (module, filename) {
     const js = compile(fs.readFileSync(filename, 'utf8'), {
-      js: true
+      js: true,
+      inlineMap: true,
     });
     module._compile(js, filename);
     return;

package/register.mjs

@@ -1,56 +0,0 @@
-import { readFileSync } from 'fs';
-import { readFile } from 'fs/promises';
-import { createRequire } from 'module';
-import { pathToFileURL, fileURLToPath } from 'url';
-
-import { compile } from "./dist/main.js";
-
-const baseURL = pathToFileURL(process.cwd() + '/').href;
-const extensionsRegex = /\.civet$/;
-
-export async function resolve(specifier, context, next) {
-  const { parentURL = baseURL } = context;
-
-  if (extensionsRegex.test(specifier)) {
-    return {
-      shortCircuit: true,
-      format: "civet",
-      url: new URL(specifier, parentURL).href,
-    };
-  }
-
-  // Let Node.js handle all other specifiers.
-  return next(specifier, context);
-}
-
-export async function load(url, context, next) {
-  if (context.format === "civet") {
-    const path = fileURLToPath(url)
-    const source = await readFile(path, "utf8")
-    const tsSource = compile(source, { filename: path })
-
-    // NOTE: Assuming ts-node hook follows load hook
-    // NOTE: This causes .civet files to show up as .ts in ts-node error reporting (TODO: May be able to add a sourcemapping)
-    const result = await next(url.replace(extensionsRegex, ".tsx"), {
-      // ts-node won't transpile unless this is module
-      // can't use commonjs since we don't rewrite imports
-      format: "module",
-      // NOTE: Setting the source in the context makes it available when ts-node uses defaultLoad
-      source: tsSource
-    });
-
-    return result
-  }
-
-  // Let Node.js handle all other URLs.
-  return next(url, context);
-}
-
-const require = createRequire(import.meta.url);
-require.extensions[".civet"] = function (m, filename) {
-  // We end up here when being required from cjs
-  const source = readFileSync(filename, "utf8")
-  const code = compile(source, { filename, js: true })
-
-  m._compile(code, filename)
-}