@danielx/civet 0.2.16 → 0.3.0

package/dist/main.js

@@ -4077,6 +4077,7 @@ var require_util = __commonJS({
 
 // source/main.coffee
 var SourceMap;
+var defaultOptions;
 var gen;
 var parse;
 var prune;
@@ -4084,12 +4085,13 @@ var util;
 ({ parse } = require_parser());
 ({ prune } = gen = require_generate());
 ({ SourceMap } = util = require_util());
+defaultOptions = {};
 module.exports = {
   parse,
-  compile: function(src, options) {
+  compile: function(src, options = defaultOptions) {
     var ast, code, sm;
     ast = prune(parse(src, {
-      filename: options != null ? options.filename : void 0
+      filename: options.filename
     }));
     if (options.sourceMap) {
       sm = SourceMap(src);

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@danielx/civet",
-  "version": "0.2.16",
+  "version": "0.3.0",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
+  "exports": {
+    ".": "./dist/main.js",
+    "./esm": "./register.mjs"
+  },
   "types": "dist/types.d.ts",
   "bin": {
     "civet": "dist/civet"

package/register.mjs

@@ -1,19 +1,21 @@
+import { readFile } from 'fs/promises';
 import { createRequire } from 'module';
-import { pathToFileURL } from 'url';
+import { pathToFileURL, fileURLToPath } from 'url';
 
 import { compile } from "./dist/main.js";
 
 const baseURL = pathToFileURL(process.cwd() + '/').href;
-
 const extensionsRegex = /\.civet$/;
 
+const cache = new Map
+
 export async function resolve(specifier, context, next) {
   const { parentURL = baseURL } = context;
 
   if (extensionsRegex.test(specifier)) {
     return {
       shortCircuit: true,
-      format: "module",
+      format: "civet",
       url: new URL(specifier, parentURL).href,
     };
   }
@@ -23,19 +25,44 @@ export async function resolve(specifier, context, next) {
 }
 
 export async function load(url, context, next) {
-  if (extensionsRegex.test(url)) {
-    const { source: rawSource } = await next(url, { format: "module" });
+  if (context.format === "civet") {
+    const path = fileURLToPath(url)
+    const source = await readFile(path, "utf8")
+    const tsSource = compile(source)
 
-    return {
+    // 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, ".ts"), {
+      // ts-node won't transpile unless this is module
+      // can't use commonjs since we don't rewrite imports
       format: "module",
-      source: compile(rawSource.toString(), { js: true }),
-    };
+      // NOTE: Setting the source in the context makes it available when ts-node uses defaultLoad
+      source: tsSource
+    });
+
+    // NOTE: If I don't set the format to 'commonjs' then I get
+    // "ReferenceError: exports is not defined in ES module scope"
+    // setting the format to commonjs causes the require.extensions
+    // handler to be invoked. So we cache the ts-node transpilation
+    // result, hook into require.extensions, and return the result there.
+    // Hopefully node loaders simplify this in the future.
+    result.format = "commonjs"
+    cache.set(path, result.source)
+
+    return result
   }
 
   // Let Node.js handle all other URLs.
   return next(url, context);
 }
 
-// Also transform CommonJS files.
+// Cache our double transpiled sources (.civet -> .ts -> .js)
 const require = createRequire(import.meta.url);
-require("./register.js")
+require.extensions[".civet"] = function (m, filename) {
+  const code = cache.get(filename)
+  if (!code) throw new Error(`Code for ${filename} wasn't in transpiled cache.`)
+
+  m._compile(code, filename)
+  // Module should be cached after the first load so we can release the memory
+  cache.delete(filename)
+}