@b9g/shovel 0.2.0-beta.10 → 0.2.0-beta.11

package/src/_chunks/chunk-JJFM7PO2.js

@@ -0,0 +1,468 @@
+// src/plugins/assets.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { createHash } from "crypto";
+import { join, basename, extname, relative, dirname } from "path";
+import mime from "mime";
+import * as ESBuild from "esbuild";
+import { getLogger } from "@logtape/logtape";
+import { NodeModulesPolyfillPlugin } from "@esbuild-plugins/node-modules-polyfill";
+import { NodeGlobalsPolyfillPlugin } from "@esbuild-plugins/node-globals-polyfill";
+var TRANSPILABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".jsx",
+  ".mts",
+  ".cts"
+]);
+var CSS_EXTENSIONS = /* @__PURE__ */ new Set([".css"]);
+var logger = getLogger(["shovel"]);
+var DEFAULT_CONFIG = {
+  outDir: "dist",
+  clientBuild: {}
+};
+var HASH_LENGTH = 16;
+function mergeConfig(userConfig = {}) {
+  return {
+    ...DEFAULT_CONFIG,
+    ...userConfig
+  };
+}
+function normalizePath(basePath) {
+  if (!basePath.startsWith("/")) {
+    basePath = "/" + basePath;
+  }
+  if (!basePath.endsWith("/")) {
+    basePath = basePath + "/";
+  }
+  return basePath;
+}
+function assetsPlugin(options = {}) {
+  const config = mergeConfig(options);
+  const manifest = {
+    assets: {},
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    config: {
+      outDir: config.outDir
+    }
+  };
+  const contexts = /* @__PURE__ */ new Map();
+  return {
+    name: "shovel-assets",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, (_args) => {
+        return null;
+      });
+      async function getContext(absPath, buildOptions) {
+        let ctx = contexts.get(absPath);
+        if (!ctx) {
+          ctx = await ESBuild.context(buildOptions);
+          contexts.set(absPath, ctx);
+        }
+        return ctx;
+      }
+      build.onLoad({ filter: /.*/ }, async (args) => {
+        if (!args.with?.assetBase || typeof args.with.assetBase !== "string") {
+          return null;
+        }
+        try {
+          const ext = extname(args.path);
+          const name = basename(args.path, ext);
+          const wantsCSS = args.with.type === "css";
+          const needsTranspilation = TRANSPILABLE_EXTENSIONS.has(ext);
+          const needsCSSBundling = CSS_EXTENSIONS.has(ext);
+          if (wantsCSS && !needsTranspilation) {
+            return {
+              errors: [
+                {
+                  text: `type: "css" can only be used with transpilable files (.ts, .tsx, .jsx, etc.), not ${ext}`
+                }
+              ]
+            };
+          }
+          let content;
+          let outputExt = ext;
+          let mimeType;
+          if (needsTranspilation) {
+            const clientOpts = config.clientBuild;
+            const defaultPlugins = [
+              NodeModulesPolyfillPlugin(),
+              NodeGlobalsPolyfillPlugin({
+                process: true,
+                buffer: true
+              })
+            ];
+            const plugins = clientOpts.plugins ? [...clientOpts.plugins, ...defaultPlugins] : defaultPlugins;
+            const ctx = await getContext(args.path, {
+              entryPoints: [args.path],
+              bundle: true,
+              format: "esm",
+              target: "es2022",
+              platform: "browser",
+              write: false,
+              minify: true,
+              // outdir is required for esbuild to know where to put extracted CSS
+              outdir: config.outDir,
+              // Apply polyfills and user-provided client build options
+              plugins,
+              define: clientOpts.define,
+              inject: clientOpts.inject,
+              external: clientOpts.external,
+              alias: clientOpts.alias,
+              // Apply JSX configuration (defaults to @b9g/crank automatic runtime)
+              jsx: clientOpts.jsx ?? "automatic",
+              jsxFactory: clientOpts.jsxFactory,
+              jsxFragment: clientOpts.jsxFragment,
+              jsxImportSource: clientOpts.jsxImportSource ?? "@b9g/crank"
+            });
+            const result = await ctx.rebuild();
+            if (!result.outputFiles) {
+              return {
+                errors: [{ text: `No output files generated for ${args.path}` }]
+              };
+            }
+            if (wantsCSS) {
+              const cssOutput = result.outputFiles.find(
+                (f) => f.path.endsWith(".css")
+              );
+              if (!cssOutput) {
+                return {
+                  errors: [
+                    {
+                      text: `No CSS was extracted from ${args.path}. The file must import CSS for type: "css" to work.`
+                    }
+                  ]
+                };
+              }
+              content = Buffer.from(cssOutput.text);
+              outputExt = ".css";
+              mimeType = "text/css";
+            } else {
+              const jsOutput = result.outputFiles.find(
+                (f) => f.path.endsWith(".js")
+              );
+              if (!jsOutput) {
+                return {
+                  errors: [
+                    {
+                      text: `No JavaScript output was generated for ${args.path}`
+                    }
+                  ]
+                };
+              }
+              content = Buffer.from(jsOutput.text);
+              outputExt = ".js";
+              mimeType = "application/javascript";
+            }
+          } else if (needsCSSBundling) {
+            const entryPath = args.path;
+            const externalAbsolutePathsPlugin = {
+              name: "external-absolute-paths",
+              setup(build2) {
+                build2.onResolve({ filter: /^\// }, (resolveArgs) => {
+                  if (resolveArgs.kind === "entry-point") {
+                    return null;
+                  }
+                  return {
+                    path: resolveArgs.path,
+                    external: true
+                  };
+                });
+              }
+            };
+            const ctx = await getContext(entryPath, {
+              entryPoints: [entryPath],
+              bundle: true,
+              write: false,
+              minify: true,
+              // outdir required for esbuild to generate output paths
+              outdir: config.outDir,
+              plugins: [externalAbsolutePathsPlugin],
+              // Loaders for web assets referenced in CSS via url()
+              loader: {
+                // Fonts
+                ".woff": "file",
+                ".woff2": "file",
+                ".ttf": "file",
+                ".eot": "file",
+                // Images
+                ".svg": "file",
+                ".png": "file",
+                ".jpg": "file",
+                ".jpeg": "file",
+                ".gif": "file",
+                ".webp": "file",
+                ".ico": "file",
+                // Media
+                ".mp4": "file",
+                ".webm": "file",
+                ".mp3": "file",
+                ".ogg": "file"
+              }
+            });
+            const result = await ctx.rebuild();
+            const cssOutput = result.outputFiles?.find(
+              (f) => f.path.endsWith(".css")
+            );
+            if (!cssOutput) {
+              return {
+                errors: [{ text: `No CSS output generated for ${args.path}` }]
+              };
+            }
+            const basePath2 = normalizePath(args.with.assetBase);
+            const cssOutputDir = join(config.outDir, "public", basePath2);
+            if (!existsSync(cssOutputDir)) {
+              mkdirSync(cssOutputDir, { recursive: true });
+            }
+            for (const file of result.outputFiles || []) {
+              if (file === cssOutput)
+                continue;
+              const assetFilename = file.path.split("/").pop();
+              const assetPath = join(cssOutputDir, assetFilename);
+              writeFileSync(assetPath, file.contents);
+              const assetUrl = `${basePath2}${assetFilename}`;
+              const assetHash = createHash("sha256").update(file.contents).digest("hex").slice(0, HASH_LENGTH);
+              manifest.assets[assetFilename] = {
+                source: assetFilename,
+                output: assetFilename,
+                url: assetUrl,
+                hash: assetHash,
+                size: file.contents.length,
+                type: mime.getType(assetFilename) || void 0
+              };
+            }
+            content = Buffer.from(cssOutput.text);
+            outputExt = ".css";
+            mimeType = "text/css";
+          } else {
+            content = readFileSync(args.path);
+            mimeType = mime.getType(args.path) || void 0;
+          }
+          const hash = createHash("sha256").update(content).digest("hex").slice(0, HASH_LENGTH);
+          let filename;
+          if (args.with.assetName && typeof args.with.assetName === "string") {
+            filename = args.with.assetName.replace(/\[name\]/g, name).replace(/\[ext\]/g, outputExt.slice(1));
+          } else {
+            filename = `${name}-${hash}${outputExt}`;
+          }
+          const basePath = normalizePath(args.with.assetBase);
+          const publicURL = `${basePath}${filename}`;
+          const outputDir = join(config.outDir, "public", basePath);
+          if (!existsSync(outputDir)) {
+            mkdirSync(outputDir, { recursive: true });
+          }
+          const outputPath = join(outputDir, filename);
+          writeFileSync(outputPath, content);
+          const sourcePath = relative(process.cwd(), args.path);
+          const manifestEntry = {
+            source: sourcePath,
+            output: filename,
+            url: publicURL,
+            hash,
+            size: content.length,
+            type: mimeType
+          };
+          manifest.assets[sourcePath] = manifestEntry;
+          return {
+            contents: `export default ${JSON.stringify(publicURL)};`,
+            loader: "js"
+          };
+        } catch (error) {
+          return {
+            errors: [
+              {
+                text: `Failed to process asset: ${error.message}`,
+                detail: error
+              }
+            ]
+          };
+        }
+      });
+      build.onEnd(async () => {
+        for (const ctx of contexts.values()) {
+          await ctx.dispose();
+        }
+        contexts.clear();
+        try {
+          const manifestPath = join(config.outDir, "server", "assets.json");
+          const manifestDir = dirname(manifestPath);
+          if (!existsSync(manifestDir)) {
+            mkdirSync(manifestDir, { recursive: true });
+          }
+          writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+          logger.debug("Generated asset manifest", {
+            path: manifestPath,
+            assetCount: Object.keys(manifest.assets).length
+          });
+        } catch (error) {
+          logger.warn("Failed to write asset manifest: {error}", { error });
+        }
+      });
+    }
+  };
+}
+
+// src/plugins/import-meta.ts
+import { readFile } from "fs/promises";
+import { dirname as dirname2 } from "path";
+import { pathToFileURL } from "url";
+function importMetaPlugin() {
+  return {
+    name: "import-meta-transform",
+    setup(build) {
+      build.onLoad({ filter: /\.[jt]sx?$/, namespace: "file" }, async (args) => {
+        if (args.path.includes("node_modules") || args.path.includes("/packages/")) {
+          return null;
+        }
+        const contents = await readFile(args.path, "utf8");
+        if (!contents.includes("import.meta.url") && !contents.includes("import.meta.dirname") && !contents.includes("import.meta.filename")) {
+          return null;
+        }
+        const fileUrl = pathToFileURL(args.path).href;
+        const fileDirname = dirname2(args.path);
+        const fileFilename = args.path;
+        let transformed = contents;
+        transformed = transformed.replace(
+          /\bimport\.meta\.url\b/g,
+          JSON.stringify(fileUrl)
+        );
+        transformed = transformed.replace(
+          /\bimport\.meta\.dirname\b/g,
+          JSON.stringify(fileDirname)
+        );
+        transformed = transformed.replace(
+          /\bimport\.meta\.filename\b/g,
+          JSON.stringify(fileFilename)
+        );
+        const ext = args.path.split(".").pop();
+        let loader = "js";
+        if (ext === "ts")
+          loader = "ts";
+        else if (ext === "tsx")
+          loader = "tsx";
+        else if (ext === "jsx")
+          loader = "jsx";
+        return {
+          contents: transformed,
+          loader
+        };
+      });
+    }
+  };
+}
+
+// src/utils/jsx-config.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2, dirname as dirname3 } from "path";
+import { existsSync as existsSync2 } from "fs";
+var CRANK_JSX_DEFAULTS = {
+  jsx: "automatic",
+  jsxImportSource: "@b9g/crank"
+};
+async function findTsConfig(startDir) {
+  let dir = startDir;
+  while (dir !== dirname3(dir)) {
+    const tsconfigPath = join2(dir, "tsconfig.json");
+    if (existsSync2(tsconfigPath)) {
+      return tsconfigPath;
+    }
+    dir = dirname3(dir);
+  }
+  return null;
+}
+async function parseTsConfig(tsconfigPath) {
+  const content = await readFile2(tsconfigPath, "utf8");
+  const stripped = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  const config = JSON.parse(stripped);
+  if (config.extends) {
+    const baseDir = dirname3(tsconfigPath);
+    let extendsPath = config.extends;
+    if (extendsPath.startsWith(".")) {
+      extendsPath = join2(baseDir, extendsPath);
+    } else {
+      extendsPath = join2(baseDir, "node_modules", extendsPath);
+    }
+    if (!extendsPath.endsWith(".json")) {
+      extendsPath += ".json";
+    }
+    if (existsSync2(extendsPath)) {
+      const baseConfig = await parseTsConfig(extendsPath);
+      return {
+        ...baseConfig,
+        ...config,
+        compilerOptions: {
+          ...baseConfig.compilerOptions,
+          ...config.compilerOptions
+        }
+      };
+    }
+  }
+  return config;
+}
+function mapTSConfigToESBuild(compilerOptions) {
+  const options = {};
+  if (compilerOptions.jsx) {
+    switch (compilerOptions.jsx) {
+      case "react":
+      case "react-native":
+        options.jsx = "transform";
+        break;
+      case "react-jsx":
+      case "react-jsxdev":
+        options.jsx = "automatic";
+        break;
+      case "preserve":
+        options.jsx = "preserve";
+        break;
+    }
+  }
+  if (compilerOptions.jsxFactory) {
+    options.jsxFactory = compilerOptions.jsxFactory;
+  }
+  if (compilerOptions.jsxFragmentFactory) {
+    options.jsxFragment = compilerOptions.jsxFragmentFactory;
+  }
+  if (compilerOptions.jsxImportSource) {
+    options.jsxImportSource = compilerOptions.jsxImportSource;
+  }
+  return options;
+}
+async function loadJSXConfig(projectRoot) {
+  const tsconfigPath = await findTsConfig(projectRoot);
+  if (tsconfigPath) {
+    const config = await parseTsConfig(tsconfigPath);
+    const compilerOptions = config.compilerOptions || {};
+    const hasJSXConfig = compilerOptions.jsx || compilerOptions.jsxFactory || compilerOptions.jsxFragmentFactory || compilerOptions.jsxImportSource;
+    if (hasJSXConfig) {
+      const tsOptions = mapTSConfigToESBuild(compilerOptions);
+      return {
+        ...CRANK_JSX_DEFAULTS,
+        ...tsOptions
+      };
+    }
+  }
+  return { ...CRANK_JSX_DEFAULTS };
+}
+function applyJSXOptions(buildOptions, jsxOptions) {
+  if (jsxOptions.jsx) {
+    buildOptions.jsx = jsxOptions.jsx;
+  }
+  if (jsxOptions.jsxFactory) {
+    buildOptions.jsxFactory = jsxOptions.jsxFactory;
+  }
+  if (jsxOptions.jsxFragment) {
+    buildOptions.jsxFragment = jsxOptions.jsxFragment;
+  }
+  if (jsxOptions.jsxImportSource) {
+    buildOptions.jsxImportSource = jsxOptions.jsxImportSource;
+  }
+  if (jsxOptions.jsxSideEffects !== void 0) {
+    buildOptions.jsxSideEffects = jsxOptions.jsxSideEffects;
+  }
+}
+
+export {
+  assetsPlugin,
+  importMetaPlugin,
+  loadJSXConfig,
+  applyJSXOptions
+};