@danielx/civet 0.4.0 → 0.4.1-8.2

package/dist/civet

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 "use strict";
-var ast, compile, encoding, fs, generate, inlineMap, input, js, output, parse, prune;
+var compile, encoding, fs, generate, parse, prune, read;
 if (process.argv.includes("--version")) {
   process.stdout.write(require("../package.json").version + "\n");
   process.exit(0);
@@ -9,14 +9,30 @@ if (process.argv.includes("--version")) {
 ({ prune } = generate);
 encoding = "utf8";
 fs = require("fs");
-input = fs.readFileSync(process.stdin.fd, encoding);
-process.argv.includes("--ast");
-js = process.argv.includes("--js");
-inlineMap = process.argv.includes("--inline-map");
-if (ast) {
-  ast = prune(parse(input));
-  process.stdout.write(JSON.stringify(ast, null, 2));
-  process.exit(0);
-}
-output = compile(input, { js, inlineMap });
-process.stdout.write(output);
+read = function(stream, encoding2) {
+  return new Promise(function(resolve, reject) {
+    var parts;
+    parts = [];
+    stream.resume();
+    stream.on("data", function(buffer) {
+      return parts.push(buffer);
+    });
+    stream.on("error", reject);
+    return stream.on("end", function() {
+      return resolve(Buffer.concat(parts).toString(encoding2));
+    });
+  });
+};
+read(process.stdin, encoding).then(function(input) {
+  var ast, inlineMap, js, output;
+  process.argv.includes("--ast");
+  js = process.argv.includes("--js");
+  inlineMap = process.argv.includes("--inline-map");
+  if (ast) {
+    ast = prune(parse(input));
+    process.stdout.write(JSON.stringify(ast, null, 2));
+    process.exit(0);
+  }
+  output = compile(input, { js, inlineMap });
+  return process.stdout.write(output);
+});

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)
+}