@ecopages/core 0.2.0-alpha.9 → 0.2.1-beta.0

package/src/build/browser-runtime-plugin.js

@@ -0,0 +1,173 @@
+import path from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { cachedParseSync } from "../cache/module-parse-cache.js";
+import { getBrowserRuntimeSpecifierMap } from "./browser-runtime-manifest.js";
+import { buildSpecifierFilter } from "./browser-runtime-plugin-helpers.js";
+const BROWSER_RUNTIME_IMPORT_REWRITE_MAP = /* @__PURE__ */ Symbol.for("ecopages.browserRuntimeImportRewriteMap");
+const DEFAULT_BROWSER_RUNTIME_PLUGIN_NAME = "browser-runtime-plugin";
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object";
+}
+function inferLoaderFromPath(filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+  switch (extension) {
+    case ".mts":
+    case ".cts":
+    case ".ts":
+      return "ts";
+    case ".tsx":
+      return "tsx";
+    case ".jsx":
+      return "jsx";
+    default:
+      return "js";
+  }
+}
+function queueReplacement(options) {
+  if (!isRecord(options.source) || typeof options.source.value !== "string") {
+    return;
+  }
+  const mappedPath = options.specifierMap.get(options.source.value);
+  if (!mappedPath || typeof options.source.start !== "number" || typeof options.source.end !== "number") {
+    return;
+  }
+  const quote = options.code[options.source.start] === "'" ? "'" : '"';
+  options.edits.push({
+    start: options.source.start,
+    end: options.source.end,
+    replacement: `${quote}${mappedPath}${quote}`
+  });
+}
+function rewriteBrowserRuntimeImports(code, specifierMap, filePath = "browser-runtime-imports.js") {
+  if (specifierMap.size === 0) {
+    return code;
+  }
+  const edits = [];
+  try {
+    const result = cachedParseSync(filePath, code, {
+      sourceType: "module",
+      lang: path.extname(filePath).endsWith("x") ? "tsx" : "ts"
+    });
+    const walk = (node) => {
+      if (!isRecord(node)) {
+        return;
+      }
+      if (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") {
+        queueReplacement({ code, source: node.source, specifierMap, edits });
+      }
+      if (node.type === "ImportExpression" && isRecord(node.source)) {
+        if (node.source.type === "StringLiteral" || node.source.type === "Literal") {
+          queueReplacement({ code, source: node.source, specifierMap, edits });
+        }
+      }
+      for (const value of Object.values(node)) {
+        if (Array.isArray(value)) {
+          for (const child of value) {
+            walk(child);
+          }
+        } else {
+          walk(value);
+        }
+      }
+    };
+    walk(result.program);
+  } catch {
+    return code;
+  }
+  if (edits.length === 0) {
+    return code;
+  }
+  edits.sort((left, right) => right.start - left.start);
+  let rewritten = code;
+  for (const edit of edits) {
+    rewritten = rewritten.slice(0, edit.start) + edit.replacement + rewritten.slice(edit.end);
+  }
+  return rewritten;
+}
+function getBrowserRuntimeImportRewriteMap(plugin) {
+  return plugin[BROWSER_RUNTIME_IMPORT_REWRITE_MAP];
+}
+function collectBrowserRuntimeImportRewriteMap(plugins) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const plugin of plugins ?? []) {
+    const specifierMap = getBrowserRuntimeImportRewriteMap(plugin);
+    if (!specifierMap) {
+      continue;
+    }
+    for (const [specifier, publicPath] of specifierMap.entries()) {
+      if (!merged.has(specifier)) {
+        merged.set(specifier, publicPath);
+      }
+    }
+  }
+  return merged;
+}
+function createBrowserRuntimePlugin(options) {
+  const { manifest } = options;
+  const specifierMap = getBrowserRuntimeSpecifierMap(manifest);
+  const specifierFilter = buildSpecifierFilter(specifierMap);
+  if (!specifierFilter) {
+    return null;
+  }
+  const external = options.external ?? true;
+  const rewriteImports = options.rewriteImports ?? true;
+  const matchPublicPaths = options.matchPublicPaths ?? true;
+  const publicPathSet = new Set(specifierMap.values());
+  const specifierKeys = Array.from(specifierMap.keys());
+  const plugin = {
+    name: options.name ?? DEFAULT_BROWSER_RUNTIME_PLUGIN_NAME,
+    setup(build) {
+      build.onResolve({ filter: specifierFilter }, (args) => {
+        const mappedPath = specifierMap.get(args.path);
+        if (!mappedPath) {
+          return void 0;
+        }
+        return {
+          path: mappedPath,
+          external
+        };
+      });
+      if (matchPublicPaths) {
+        build.onResolve({ filter: /^\// }, (args) => {
+          if (!publicPathSet.has(args.path)) {
+            return void 0;
+          }
+          return {
+            path: args.path,
+            external: true
+          };
+        });
+      }
+      if (rewriteImports) {
+        build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, (args) => {
+          if (!path.isAbsolute(args.path) || !existsSync(args.path)) {
+            return void 0;
+          }
+          const code = readFileSync(args.path, "utf-8");
+          if (!specifierKeys.some((specifier) => code.includes(specifier))) {
+            return void 0;
+          }
+          const rewritten = rewriteBrowserRuntimeImports(code, specifierMap, args.path);
+          if (rewritten === code) {
+            return void 0;
+          }
+          return {
+            contents: rewritten,
+            loader: inferLoaderFromPath(args.path),
+            resolveDir: path.dirname(args.path)
+          };
+        });
+      }
+    }
+  };
+  plugin[BROWSER_RUNTIME_IMPORT_REWRITE_MAP] = specifierMap;
+  return plugin;
+}
+export {
+  BROWSER_RUNTIME_IMPORT_REWRITE_MAP,
+  DEFAULT_BROWSER_RUNTIME_PLUGIN_NAME,
+  collectBrowserRuntimeImportRewriteMap,
+  createBrowserRuntimePlugin,
+  getBrowserRuntimeImportRewriteMap,
+  rewriteBrowserRuntimeImports
+};