@danielx/civet 0.6.26 → 0.6.28

package/dist/esbuild-plugin.js

@@ -1,124 +1,109 @@
-/**
-@file esbuild plugin for Civet language
-
-Simple zero config example
-
-@example
-```javascript
-import esbuild from 'esbuild'
-import civetPlugin from '@danielx/civet/esbuild-plugin'
-
-esbuild.build({
-  ...,
-  plugins: [
-    civetPlugin
-  ]
-}).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, 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")
-
-// NOTE: this function is named civet so esbuild gets "civet" as the name of the plugin
-function civet (options = {}) {
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// source/esbuild-plugin.civet
+var esbuild_plugin_exports = {};
+__export(esbuild_plugin_exports, {
+  default: () => esbuild_plugin_default
+});
+module.exports = __toCommonJS(esbuild_plugin_exports);
+var import_promises = require("fs/promises");
+var import_path = __toESM(require("path"));
+var import_main = require("./main.js");
+function civet(options = {}) {
   const {
-    filter=/\.civet$/,
-    inlineMap=true,
-    js=true,
+    filter = /\.civet$/,
+    inlineMap = true,
+    js = true,
     next
-  } = options
-
-  let nextTransform
-  let tmpPath
-
+  } = options;
+  let nextTransform;
+  let tmpPath;
   if (next) {
     next.setup({
-      onEnd() {; },
-      onStart() {; },
-      resolve() {; },
-      onResolve() {; },
-      initialOptions() {; },
-      esbuild() {; },
+      onEnd() {
+        ;
+      },
+      onStart() {
+        ;
+      },
+      resolve() {
+        ;
+      },
+      onResolve() {
+        ;
+      },
+      initialOptions() {
+        ;
+      },
+      esbuild() {
+        ;
+      },
       onLoad(_, handler) {
-        return nextTransform = 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-"))
+          const { tmpdir } = require("os");
+          tmpPath = await (0, import_promises.mkdtemp)(import_path.default.join(tmpdir(), "civet-"));
         }
-        return
-      })
-
+        return;
+      });
       build.onEnd(async function() {
         if (tmpPath) {
-          await rmdir(tmpPath, { recursive: true })
+          await (0, import_promises.rmdir)(tmpPath, { recursive: true });
         }
-        return
-      })
-
+        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, {
+          const source = await (0, import_promises.readFile)(args.path, "utf8");
+          const filename = import_path.default.relative(process.cwd(), args.path);
+          const compiled = (0, import_main.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)
+            const outputFileName = filename + js ? ".jsx" : ".tsx";
+            const outputFilePath = import_path.default.join(tmpPath, outputFileName);
+            await (0, import_promises.writeFile)(outputFilePath, compiled);
             return await nextTransform({
               ...args,
               path: outputFilePath
-            })
+            });
           }
-
           return {
-            contents: compiled,
-          }
-        }
-        catch (e) {
+            contents: compiled
+          };
+        } catch (e) {
           return {
             errors: [{
               text: e.message,
@@ -126,20 +111,18 @@ function civet (options = {}) {
                 file: args.path,
                 namespace: args.namespace,
                 line: e.line,
-                column: e.column,
+                column: e.column
               },
               detail: e
             }]
-          }
+          };
         }
-      })
+      });
     }
-  }
+  };
 }
-
-const defaultPlugin = civet()
-
-// Default zero-config plugin
-civet.setup = defaultPlugin.setup
-
-module.exports = civet
+var defaultPlugin = civet();
+civet.setup = defaultPlugin.setup;
+var esbuild_plugin_default = civet;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/esbuild.d.mts

@@ -0,0 +1,7 @@
+import * as esbuild from 'esbuild';
+import { PluginOptions } from './unplugin.mjs';
+import 'unplugin';
+
+declare const _default: (options?: PluginOptions | undefined) => esbuild.Plugin;
+
+export { _default as default };

package/dist/esbuild.d.ts

@@ -0,0 +1,7 @@
+import * as esbuild from 'esbuild';
+import { PluginOptions } from './unplugin.js';
+import 'unplugin';
+
+declare const _default: (options?: PluginOptions | undefined) => esbuild.Plugin;
+
+export { _default as default };

package/dist/esbuild.js

@@ -0,0 +1,176 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/esbuild.ts
+var esbuild_exports = {};
+__export(esbuild_exports, {
+  default: () => esbuild_default
+});
+module.exports = __toCommonJS(esbuild_exports);
+
+// src/index.ts
+var import_unplugin = require("unplugin");
+var import_civet = __toESM(require("@danielx/civet"));
+var fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_typescript = __toESM(require("typescript"));
+var tsvfs = __toESM(require("@typescript/vfs"));
+var formatHost = {
+  getCurrentDirectory: () => import_typescript.default.sys.getCurrentDirectory(),
+  getNewLine: () => import_typescript.default.sys.newLine,
+  getCanonicalFileName: import_typescript.default.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
+};
+var isCivet = (id) => /\.civet$/.test(id);
+var isCivetTranspiled = (id) => /\.civet\.(m?)(j|t)s(x?)$/.test(id);
+var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
+  if (options.dts && options.js) {
+    throw new Error("Can't have both `dts` and `js` be set to `true`.");
+  }
+  const transpileToJS = options.js ?? !options.dts;
+  const outExt = options.outputExtension ?? (transpileToJS ? ".jsx" : ".tsx");
+  let fsMap = /* @__PURE__ */ new Map();
+  let compilerOptions;
+  return {
+    name: "unplugin-civet",
+    enforce: "pre",
+    async buildStart() {
+      if (options.dts) {
+        const configPath = import_typescript.default.findConfigFile(process.cwd(), import_typescript.default.sys.fileExists);
+        if (!configPath) {
+          throw new Error("Could not find 'tsconfig.json'");
+        }
+        const { config, error } = import_typescript.default.readConfigFile(
+          configPath,
+          import_typescript.default.sys.readFile
+        );
+        if (error) {
+          console.error(import_typescript.default.formatDiagnostic(error, formatHost));
+          throw error;
+        }
+        const configContents = import_typescript.default.parseJsonConfigFileContent(
+          config,
+          import_typescript.default.sys,
+          process.cwd()
+        );
+        compilerOptions = {
+          ...configContents.options,
+          target: import_typescript.default.ScriptTarget.ESNext
+        };
+        fsMap = /* @__PURE__ */ new Map();
+      }
+    },
+    buildEnd() {
+      if (options.dts) {
+        const system = tsvfs.createFSBackedSystem(fsMap, process.cwd(), import_typescript.default);
+        const host = tsvfs.createVirtualCompilerHost(
+          system,
+          compilerOptions,
+          import_typescript.default
+        );
+        const program = import_typescript.default.createProgram({
+          rootNames: [...fsMap.keys()],
+          options: compilerOptions,
+          host: host.compilerHost
+        });
+        for (const file of fsMap.keys()) {
+          const sourceFile = program.getSourceFile(file);
+          program.emit(
+            sourceFile,
+            (filePath, content) => {
+              this.emitFile({
+                source: content,
+                fileName: import_path.default.relative(process.cwd(), filePath),
+                type: "asset"
+              });
+            },
+            void 0,
+            true
+          );
+        }
+      }
+    },
+    resolveId(id, importer) {
+      if (/\0/.test(id))
+        return null;
+      if (!isCivet(id))
+        return null;
+      const relativeId = import_path.default.relative(
+        process.cwd(),
+        import_path.default.resolve(import_path.default.dirname(importer ?? ""), id)
+      );
+      const relativePath = relativeId + outExt;
+      return relativePath;
+    },
+    loadInclude(id) {
+      return isCivetTranspiled(id);
+    },
+    async load(id) {
+      if (!isCivetTranspiled(id))
+        return null;
+      const filename = import_path.default.resolve(process.cwd(), id.slice(0, -outExt.length));
+      const code = await fs.promises.readFile(filename, "utf-8");
+      let transformed = {
+        code: import_civet.default.compile(code, {
+          inlineMap: true,
+          filename: id,
+          js: transpileToJS
+        }),
+        map: null
+      };
+      if (options.transformOutput)
+        transformed = await options.transformOutput(transformed.code, id);
+      return transformed;
+    },
+    transform(code, id) {
+      if (!/\.civet\.tsx?$/.test(id))
+        return null;
+      if (options.dts) {
+        fsMap.set(import_path.default.resolve(process.cwd(), id), code);
+      }
+      return null;
+    },
+    vite: {
+      config(_config, { command }) {
+        if (command === "build") {
+          return {
+            esbuild: {
+              include: [/\.civet$/],
+              loader: "tsx"
+            }
+          };
+        }
+        return null;
+      }
+    }
+  };
+});
+var src_default = civetUnplugin;
+
+// src/esbuild.ts
+var esbuild_default = src_default.esbuild;

package/dist/esbuild.mjs

@@ -0,0 +1,9 @@
+import {
+  src_default
+} from "./unplugin-shared.mjs";
+
+// src/esbuild.ts
+var esbuild_default = src_default.esbuild;
+export {
+  esbuild_default as default
+};

package/dist/esm.mjs

@@ -1,132 +1,85 @@
-/**
-@file Civet ESM loader.
-
-Currently depends on ts-node esm loader being downstream
-
-@example
-```bash
-node --loader ts-node/esm --loader @danielx/civet/esm source.civet
-```
-*/
-
+// source/esm.civet
 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.
- */
+import { pathToFileURL, fileURLToPath } from "url";
+import sourceMapSupport from "@cspotcode/source-map-support";
+import Civet from "./main.js";
+var { compile, util } = Civet;
+var { SourceMap } = util;
+var baseURL = pathToFileURL(process.cwd() + "/").href;
+var extensionsRegex = /\.civet$/;
+var registered = false;
+var outputCache = /* @__PURE__ */ new Map();
+var directorySeparator = "/";
+var backslashRegExp = /\\/g;
 function normalizeSlashes(value) {
   return value.replace(backslashRegExp, directorySeparator);
 }
-
-function ensureRegister () {
-  if (registered) { return }
-
+function ensureRegister() {
+  if (registered) {
+    return;
+  }
   const installation = {
-    environment: 'node',
+    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:')) {
+      let path = pathOrUrl;
+      if (path.startsWith("file:")) {
         try {
-          path = fileURLToPath(path)
-        } catch(e) {}
+          path = fileURLToPath(path);
+        } catch (e) {
+        }
       }
-      path = normalizeSlashes(path)
-
-      return outputCache.get(path)
+      path = normalizeSlashes(path);
+      return outputCache.get(path);
     }
-  }
-
-  sourceMapSupport.install(installation)
-
-  return registered = true
+  };
+  sourceMapSupport.install(installation);
+  return registered = true;
 }
-
-export function resolve(specifier, context, next) {
-  const { parentURL = baseURL } = context
-
+function resolve(specifier, context, next) {
+  const { parentURL = baseURL } = context;
   if (extensionsRegex.test(specifier)) {
     return {
       shortCircuit: true,
       format: "civet",
-      url: new URL(specifier, parentURL).href,
-    }
+      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) {
+async function load(url, context, next) {
   if (context.format === "civet") {
-    const path = fileURLToPath(url)
+    const path = fileURLToPath(url);
     const source = readFileSync(path, "utf8");
-    const {code: tsSource, sourceMap} = compile(source, {
+    const { code: tsSource, sourceMap } = compile(source, {
       filename: path,
       sourceMap: true,
-      js: true,
-    })
-
-    // NOTE: Append .tsx to URL so ts-node treats as TypeScript
-    const transpiledUrl = url + ".tsx"
-
-    // NOTE: Assuming ts-node hook follows load hook
+      js: true
+    });
+    const transpiledUrl = url + ".tsx";
     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",
-      // 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()
-
-    // 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.responseURL)
-    // 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
+      source: tsSource
+    });
+    ensureRegister();
+    result.responseURL = (result.responseURL ?? transpiledUrl).replace(/.tsx$/, "");
+    result.source = SourceMap.remap(result.source, sourceMap, url, result.responseURL);
+    outputCache.set(normalizeSlashes(path), result.source);
+    return result;
   }
-
-  // Other URLs continue unchanged.
-  return next(url, context)
+  return next(url, context);
 }
-
-// commonjs hook
-const require = createRequire(import.meta.url)
-require.extensions[".civet"] = function(m, filename) {
-  const source = readFileSync(filename, "utf8")
+var require2 = createRequire(import.meta.url);
+require2.extensions[".civet"] = function(m, filename) {
+  const source = readFileSync(filename, "utf8");
   const code = compile(source, {
     filename,
     inlineMap: true,
     js: true
-  })
-
-  //@ts-ignore TODO: Figure out how to load types from inculde folders in Civet LSP
-  return m._compile(code, filename)
-}
+  });
+  return m._compile(code, filename);
+};
+export {
+  load,
+  resolve
+};