@danielx/civet 0.3.16 → 0.4.1-8.1

package/dist/esbuild-plugin.js

@@ -1,28 +1,35 @@
-const { readFile } = require('fs/promises');
-const path = require('path');
-// This is the path to the file when both are in /dist
-const { compile } = require("./main.js");
+const { readFile } = require('fs/promises')
+const path = require('path')
+
+// NOTE: this references the built version of the module, not the source
+const { compile } = require("../dist/main.js")
 
 module.exports = {
   name: 'civet',
   setup(build) {
-    build.onLoad({
-      filter: /\.civet$/,
-    }, function(args) {
-      return readFile(args.path, 'utf8')
-      .then(function(source) {
-        const filename = path.relative(process.cwd(), args.path);
+    return build.onLoad({
+      filter: /\.civet$/
+    }, async function(args) {
+      try {
+        const source = await readFile(args.path, 'utf8')
+        const filename = path.relative(process.cwd(), args.path)
+        const compiled = compile(source, {
+          filename,
+          inlineMap: true,
+          js: true
+        })
+
         return {
-          contents: compile(source, { filename, js: true }),
-        };
-      })
-      .catch(function(e) {
+          contents: compiled,
+        }
+      }
+      catch (e) {
         return {
           errors: [{
-            text: e.message,
+            text: e.message
           }],
-        };
-      });
-    });
+        }
+      }
+    })
   },
-};
+}

package/dist/esm.mjs

@@ -1,61 +1,126 @@
-import { readFileSync } from 'fs';
-import { createRequire } from 'module';
-import { pathToFileURL, fileURLToPath } from 'url';
+/**
+@file Civet ESM loader.
 
-//@ts-ignore Note: this is the compiled name
-import { compile } from "./main.js";
+Currently depends on ts-node esm loader being downstream
 
-const baseURL = pathToFileURL(process.cwd() + '/').href;
-const extensionsRegex = /\.civet$/;
+@example
+```bash
+node --loader ts-node/esm --loader @danielx/civet/esm
+```
+*/
+
+import { readFileSync } from "fs"
+import { createRequire } from "module"
+import { pathToFileURL, fileURLToPath } from "url"
+
+import sourceMapSupport from "@cspotcode/source-map-support"
+
+// NOTE: this references the built version of the module, not the source
+import Civet from "../dist/main.js"
+const { compile, util } = Civet
+const { SourceMap } = util
+
+const baseURL = pathToFileURL(process.cwd() + '/').href
+const extensionsRegex = /\.civet$/
+
+let registered = false
+const outputCache = new Map
+
+const directorySeparator = '/'
+const backslashRegExp = /\\/g
+/**
+ * Replace backslashes with forward slashes.
+ */
+function normalizeSlashes(value) {
+  return value.replace(backslashRegExp, directorySeparator);
+}
+
+function ensureRegister () {
+  if (registered)return
+
+  const installation = {
+    environment: 'node',
+    retrieveFile(pathOrUrl) {
+      let path = pathOrUrl
+      // If it's a file URL, convert to local path
+      // I could not find a way to handle non-URLs except to swallow an error
+      if (path.startsWith('file://')) {
+        try {
+          path = fileURLToPath(path)
+        } catch(e) {}
+      }
+      path = normalizeSlashes(path)
+
+      return outputCache.get(path)
+    },
+  }
+
+  sourceMapSupport.install(installation)
+
+  return registered = true
+}
 
 export function resolve(specifier, context, next) {
-  const { parentURL = baseURL } = context;
+  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);
-};
+  return next(specifier, context)
+}
 
-export function load(url, context, next) {
+export async function load(url, context, next) {
   if (context.format === "civet") {
-    const path = fileURLToPath(url);
-    const source = readFileSync(path, "utf8");
-    const tsSource = compile(source, {
+    const path = fileURLToPath(url)
+    const source = readFileSync(path, "utf8")
+    const {code: tsSource, sourceMap} = compile(source, {
       filename: path,
-    });
+      sourceMap: true,
+    })
+
+    const transpiledPath = url + ".ts"
 
     // 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)
-    return next(url.replace(extensionsRegex, ".ts"), {
+    const result = await next(transpiledPath, {
       // 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,
-    });
-  };
+    })
+
+    // NOTE: we must install our source map support after ts-node does to take priority
+    ensureRegister()
+
+    // parse source map from downstream (ts-node) result
+    // compose with civet source map
+    result.source = SourceMap.remap(result.source, sourceMap, url, "")
+    // NOTE: This path needs to match what ts-node uses so we can override the source map
+    outputCache.set(normalizeSlashes(path), result.source)
 
-  // Let Node.js handle all other URLs.
-  return next(url, context);
-};
+    return result
+  }
 
+  // Other URLs continue unchanged.
+  return next(url, context)
+}
 
 // commonjs hook
-const require = createRequire(import.meta.url);
+const require = createRequire(import.meta.url)
 require.extensions[".civet"] = function(m, filename) {
-  const source = readFileSync(filename, "utf8");
+  const source = readFileSync(filename, "utf8")
   const code = compile(source, {
     filename,
-    js: true,
-  });
+    inlineMap: true,
+    js: true
+  })
 
   //@ts-ignore TODO: Figure out how to load types from inculde folders in Civet LSP
-  m._compile(code, filename);
-};
+  return m._compile(code, filename)
+}