@danielx/civet 0.4.0 → 0.4.1-8.1

package/dist/esbuild-plugin.js

@@ -1,29 +1,35 @@
-const { readFile } = require('fs/promises');
-const path = require('path');
+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");
+const { compile } = require("../dist/main.js")
 
 module.exports = {
   name: 'civet',
   setup(build) {
-    build.onLoad({
-      filter: /\.civet$/,
+    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 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 }),
-        };
+          contents: compiled,
+        }
       }
       catch (e) {
         return {
           errors: [{
-            text: e.message,
+            text: e.message
           }],
-        };
-      };
-    });
+        }
+      }
+    })
   },
-};
+}

package/dist/esm.mjs

@@ -9,82 +9,82 @@ node --loader ts-node/esm --loader @danielx/civet/esm
 ```
 */
 
-import { readFileSync } from "fs";
-import { createRequire } from "module";
-import { pathToFileURL, fileURLToPath } from "url";
+import { readFileSync } from "fs"
+import { createRequire } from "module"
+import { pathToFileURL, fileURLToPath } from "url"
 
-import sourceMapSupport from "@cspotcode/source-map-support";
+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;
+import Civet from "../dist/main.js"
+const { compile, util } = Civet
+const { SourceMap } = util
 
-const baseURL = pathToFileURL(process.cwd() + '/').href;
-const extensionsRegex = /\.civet$/;
+const baseURL = pathToFileURL(process.cwd() + '/').href
+const extensionsRegex = /\.civet$/
 
-let registered = false;
-const outputCache = new Map;
+let registered = false
+const outputCache = new Map
 
-const directorySeparator = '/';
-const backslashRegExp = /\\/g;
+const directorySeparator = '/'
+const backslashRegExp = /\\/g
 /**
  * Replace backslashes with forward slashes.
  */
 function normalizeSlashes(value) {
   return value.replace(backslashRegExp, directorySeparator);
-};
+}
 
-const ensureRegister = function() {
-   if( registered) {return};
+function ensureRegister () {
+  if (registered)return
 
   const installation = {
     environment: 'node',
     retrieveFile(pathOrUrl) {
-      let path = 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);
+          path = fileURLToPath(path)
+        } catch(e) {}
+      }
+      path = normalizeSlashes(path)
 
-      return outputCache.get(path);
+      return outputCache.get(path)
     },
-  };
+  }
 
-  sourceMapSupport.install(installation);
+  sourceMapSupport.install(installation)
 
-  registered = true;
-};
+  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 async function load(url, context, next) {
   if (context.format === "civet") {
-    const path = fileURLToPath(url);
-    const source = readFileSync(path, "utf8");
+    const path = fileURLToPath(url)
+    const source = readFileSync(path, "utf8")
     const {code: tsSource, sourceMap} = compile(source, {
       filename: path,
       sourceMap: true,
-    });
+    })
 
-    const transpiledPath = url + ".ts";
+    const transpiledPath = url + ".ts"
 
     // NOTE: Assuming ts-node hook follows load hook
     const result = await next(transpiledPath, {
@@ -93,34 +93,34 @@ export async function load(url, context, next) {
       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();
+    ensureRegister()
 
     // parse source map from downstream (ts-node) result
     // compose with civet source map
-    result.source = SourceMap.remap(result.source, sourceMap, url, "");
+    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);
+    outputCache.set(normalizeSlashes(path), result.source)
 
-    return result;
-  };
+    return result
+  }
 
   // Other URLs continue unchanged.
-  return next(url, context);
-};
+  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,
     inlineMap: true,
-    js: 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)
+}