@danielx/civet 0.5.92 → 0.5.94

package/dist/civet

@@ -265,7 +265,6 @@ cli = async function() {
   if (options.run) {
     options.js = true;
     options.inlineMap = true;
-    require("../register.js");
   }
   if (options.repl) {
     return repl(options);
@@ -353,6 +352,7 @@ cli = async function() {
         }
         results.push(process.exit(child.status));
       } else {
+        require("../register.js");
         try {
           module.filename = await fs.realpath(filename);
         } catch (error1) {

package/dist/esbuild-plugin.js

@@ -1,6 +1,8 @@
 /**
 @file esbuild plugin for Civet language
 
+Simple zero config example
+
 @example
 ```javascript
 import esbuild from 'esbuild'
@@ -13,40 +15,131 @@ esbuild.build({
   ]
 }).catch(() => process.exit(1))
 ```
+
+Chain civet output into another esbuild plugin, solid for example
+
+@example
+```javascript
+import esbuild from 'esbuild'
+const { solidPlugin } = require('esbuild-plugin-solid');
+import civetPlugin from '@danielx/civet/esbuild-plugin'
+
+esbuild.build({
+  ...,
+  plugins: [
+    civetPlugin(
+      next: solidPlugin()
+    )
+  ]
+}).catch(() => process.exit(1))
+```
 */
 
-const { readFile } = require('fs/promises')
+
+
+;
+
+const { readFile, writeFile, mkdtemp, rmdir } = 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) {
-    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: compiled,
-        }
-      }
-      catch (e) {
-        return {
-          errors: [{
-            text: e.message
-          }]
-        }
+// NOTE: this function is named civet so esbuild gets "civet" as the name of the plugin
+function civet (options = {}) {
+  const {
+    filter=/\.civet$/,
+    inlineMap=true,
+    js=true,
+    next
+  } = options
+
+  let nextTransform
+  let tmpPath
+
+  if (next) {
+    next.setup({
+      onEnd() {; },
+      onStart() {; },
+      resolve() {; },
+      onResolve() {; },
+      initialOptions() {; },
+      esbuild() {; },
+      onLoad(_, handler) {
+        return nextTransform = handler
       }
     })
   }
+
+  return {
+    name: "civet",
+
+    setup(build) {
+
+      build.onStart(async function() {
+        if (next) {
+          const { tmpdir } = require('os')
+          tmpPath = await mkdtemp(path.join(tmpdir(), "civet-"))
+        }
+        return
+      })
+
+      build.onEnd(async function() {
+        if (tmpPath) {
+          await rmdir(tmpPath, { recursive: true })
+        }
+        return
+      })
+
+      return build.onLoad({ filter }, 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,
+            js
+          })
+
+          if (next && tmpPath) {
+            const outputFileName = filename + js ? '.jsx' : '.tsx'
+            const outputFilePath = path.join(tmpPath, outputFileName)
+
+            // I'd prefer not to use temp files but I can't find a way to pass a stream to fs.readFile which is what
+            // most esbuild plugins use
+            await writeFile(outputFilePath, compiled)
+            return await nextTransform({
+              ...args,
+              path: outputFilePath
+            })
+          }
+
+          return {
+            contents: compiled,
+          }
+        }
+        catch (e) {
+          return {
+            errors: [{
+              text: e.message,
+              location: {
+                file: args.path,
+                namespace: args.namespace,
+                line: e.line,
+                column: e.column,
+              },
+              detail: e
+            }]
+          }
+        }
+      })
+    }
+  }
 }
+
+const defaultPlugin = civet()
+
+// Default zero-config plugin
+civet.setup = defaultPlugin.setup
+
+module.exports = civet

package/dist/esm.mjs

@@ -44,7 +44,7 @@ function ensureRegister () {
       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://')) {
+      if (path.startsWith('file:')) {
         try {
           path = fileURLToPath(path)
         } catch(e) {}
@@ -85,10 +85,11 @@ export async function load(url, context, next) {
       js: true,
     })
 
-    const transpiledPath = url + ".tsx"
+    // NOTE: Append .tsx to URL so ts-node treats as TypeScript
+    const transpiledUrl = url + ".tsx"
 
     // NOTE: Assuming ts-node hook follows load hook
-    const result = await next(transpiledPath, {
+    const result = await next(transpiledUrl, {
       // ts-node won't transpile unless this is module
       // can't use commonjs since we don't rewrite imports
       format: "module",
@@ -99,9 +100,13 @@ export async function load(url, context, next) {
     // NOTE: we must install our source map support after ts-node does to take priority
     ensureRegister()
 
+    // Remove .tsx extension for final URL
+    result.responseURL = (result.responseURL ?? transpiledUrl)
+    .replace(/.tsx$/, '')
+
     // 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, result.responseURL)
     // NOTE: This path needs to match what ts-node uses so we can override the source map
     outputCache.set(normalizeSlashes(path), result.source)