@danielx/civet 0.3.15 → 0.4.0

package/dist/civet

@@ -1,20 +1,22 @@
 #!/usr/bin/env node
 "use strict";
-var ast, encoding, fs, generate, input, js, output, parse, prune;
+var ast, compile, encoding, fs, generate, inlineMap, input, js, output, parse, prune;
 if (process.argv.includes("--version")) {
   process.stdout.write(require("../package.json").version + "\n");
   process.exit(0);
 }
-({ parse, generate } = require("./main"));
+({ parse, compile, generate } = require("./main"));
 ({ prune } = generate);
 encoding = "utf8";
 fs = require("fs");
 input = fs.readFileSync(process.stdin.fd, encoding);
-ast = prune(parse(input));
+process.argv.includes("--ast");
 js = process.argv.includes("--js");
-if (process.argv.includes("--ast")) {
+inlineMap = process.argv.includes("--inline-map");
+if (ast) {
+  ast = prune(parse(input));
   process.stdout.write(JSON.stringify(ast, null, 2));
-  return;
+  process.exit(0);
 }
-output = generate(ast, { js });
+output = compile(input, { js, inlineMap });
 process.stdout.write(output);

package/dist/esbuild-plugin.js

@@ -1,28 +1,29 @@
 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");
+
+// 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) {
+      filter: /\.civet$/,
+    }, async function(args) {
+      try {
+        const source = await readFile(args.path, 'utf8');
         const filename = path.relative(process.cwd(), args.path);
         return {
           contents: compile(source, { filename, js: true }),
         };
-      })
-      .catch(function(e) {
+      }
+      catch (e) {
         return {
           errors: [{
             text: e.message,
           }],
         };
-      });
+      };
     });
   },
 };

package/dist/esm.mjs

@@ -1,13 +1,65 @@
-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
+
+@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);
+};
+
+const ensureRegister = function() {
+   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 {};
+      };
+      path = normalizeSlashes(path);
+
+      return outputCache.get(path);
+    },
+  };
+
+  sourceMapSupport.install(installation);
+
+  registered = true;
+};
+
 export function resolve(specifier, context, next) {
   const { parentURL = baseURL } = context;
 
@@ -23,36 +75,49 @@ export function resolve(specifier, context, next) {
   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 {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);
+
+    return result;
   };
 
-  // Let Node.js handle all other URLs.
+  // Other URLs continue unchanged.
   return next(url, context);
 };
 
-
 // commonjs hook
 const require = createRequire(import.meta.url);
 require.extensions[".civet"] = function(m, filename) {
   const source = readFileSync(filename, "utf8");
   const code = compile(source, {
     filename,
+    inlineMap: true,
     js: true,
   });