@ecopages/core 0.2.0-beta.9 → 0.2.0-rc.1

package/src/build/rolldown-plugin-bridge.js

@@ -1,211 +0,0 @@
-import path from "node:path";
-import { finalizeLoadResultWithSourceTransforms } from "./rolldown-source-transform-pass.js";
-import { escapeRegExp } from "./browser-runtime-plugin-helpers.js";
-const NAMESPACE_SEPARATOR = ":";
-function joinNamespace(namespace, value) {
-  return namespace ? `${namespace}${NAMESPACE_SEPARATOR}${value}` : value;
-}
-function splitNamespace(id) {
-  const separatorIndex = id.indexOf(NAMESPACE_SEPARATOR);
-  if (separatorIndex <= 0) {
-    return { namespace: void 0, path: id };
-  }
-  return {
-    namespace: id.slice(0, separatorIndex),
-    path: id.slice(separatorIndex + 1)
-  };
-}
-function inferRolldownModuleTypeFromPath(filePath) {
-  const extension = path.extname(filePath).toLowerCase();
-  switch (extension) {
-    case ".ts":
-      return "ts";
-    case ".tsx":
-      return "tsx";
-    case ".jsx":
-      return "jsx";
-    case ".json":
-      return "json";
-    case ".css":
-      return "css";
-    default:
-      return "js";
-  }
-}
-function normalizeRolldownModuleType(loader) {
-  switch (loader) {
-    case "js":
-    case "jsx":
-    case "ts":
-    case "tsx":
-    case "json":
-    case "css":
-    case "text":
-    case "base64":
-    case "dataurl":
-    case "binary":
-    case "empty":
-      return loader;
-    case "global-css":
-    case "local-css":
-      return "css";
-    case "file":
-    case "copy":
-      return "asset";
-    default:
-      return void 0;
-  }
-}
-function convertLoadResultToModuleSource(result) {
-  if (result.loader === "object" && result.exports && typeof result.exports === "object") {
-    return Object.entries(result.exports).map(
-      ([key, value]) => key === "default" ? `export default ${JSON.stringify(value)};` : `export const ${key} = ${JSON.stringify(value)};`
-    ).join("\n");
-  }
-  return void 0;
-}
-function buildIdFilter(filter, namespace) {
-  if (!namespace) {
-    return filter;
-  }
-  return new RegExp(`^${escapeRegExp(namespace)}${NAMESPACE_SEPARATOR}${filter.source.slice(1)}`);
-}
-function resolvePluginPath(value, importer, contextRoot) {
-  if (path.isAbsolute(value)) {
-    return value;
-  }
-  if (value.startsWith(".") || value.startsWith("..")) {
-    const baseDir = importer ? path.dirname(importer) : contextRoot;
-    return path.resolve(baseDir, value);
-  }
-  return value;
-}
-function convertPluginOnLoadResult(args, result) {
-  if (!result || typeof result !== "object") {
-    return void 0;
-  }
-  const candidate = result;
-  const { path: sourcePath } = splitNamespace(args.id);
-  const sourceFromExports = convertLoadResultToModuleSource(candidate);
-  if (sourceFromExports) {
-    const description = {
-      code: sourceFromExports,
-      moduleType: "js"
-    };
-    return description;
-  }
-  if (typeof candidate.contents === "string" || candidate.contents instanceof Uint8Array) {
-    const code = typeof candidate.contents === "string" ? candidate.contents : new TextDecoder().decode(candidate.contents);
-    const description = {
-      code,
-      moduleType: normalizeRolldownModuleType(candidate.loader) ?? inferRolldownModuleTypeFromPath(sourcePath)
-    };
-    return description;
-  }
-  return void 0;
-}
-function convertPluginOnResolveResult(result, importer, contextRoot) {
-  if (!result || typeof result !== "object") {
-    return void 0;
-  }
-  const candidate = result;
-  if (typeof candidate.path !== "string" && typeof candidate.namespace !== "string") {
-    if (typeof candidate.external !== "boolean") {
-      return void 0;
-    }
-  }
-  const partial = { id: "" };
-  if (typeof candidate.path === "string") {
-    partial.id = joinNamespace(candidate.namespace, resolvePluginPath(candidate.path, importer, contextRoot));
-  } else if (typeof candidate.namespace === "string") {
-    partial.id = joinNamespace(candidate.namespace, "");
-  }
-  if (typeof candidate.external === "boolean") {
-    partial.external = candidate.external;
-  }
-  return partial;
-}
-function createRolldownPluginBridge(plugins, contextRoot, sourceTransforms = []) {
-  if (plugins.length === 0) {
-    return [];
-  }
-  const moduleCounter = { value: 0 };
-  const resolveRegistrations = [];
-  const loadRegistrations = [];
-  const registerResolve = (filter, callback) => {
-    resolveRegistrations.push({ filter, callback });
-  };
-  const registerLoad = (filter, callback) => {
-    loadRegistrations.push({ filter, callback });
-  };
-  const resolveIdHandler = async (source, importer, _extraOptions) => {
-    for (const { filter, callback } of resolveRegistrations) {
-      if (!filter.test(source)) {
-        continue;
-      }
-      const { namespace, path: sourcePath } = splitNamespace(source);
-      const result = await callback({ path: sourcePath, importer, namespace });
-      const converted = convertPluginOnResolveResult(result, importer, contextRoot);
-      if (converted !== void 0) {
-        return converted;
-      }
-    }
-    return void 0;
-  };
-  const loadHandler = async (id) => {
-    let loadResult;
-    for (const { filter, callback } of loadRegistrations) {
-      if (!filter.test(id)) {
-        continue;
-      }
-      const { namespace: namespace2, path: sourcePath2 } = splitNamespace(id);
-      const result = await callback({ path: sourcePath2, namespace: namespace2 });
-      const converted = convertPluginOnLoadResult({ id }, result);
-      if (converted !== void 0) {
-        loadResult = converted;
-        break;
-      }
-    }
-    const { namespace, path: sourcePath } = splitNamespace(id);
-    return finalizeLoadResultWithSourceTransforms({
-      id,
-      namespace,
-      sourcePath,
-      loadResult,
-      sourceTransforms,
-      contextRoot,
-      inferModuleTypeFromPath: (filePath) => inferRolldownModuleTypeFromPath(filePath)
-    });
-  };
-  const plugin = {
-    name: "ecopages-plugin-bridge",
-    buildStart: async () => {
-      for (const ecoPlugin of plugins) {
-        const bridge = {
-          onResolve: (options, callback) => {
-            registerResolve(buildIdFilter(options.filter, options.namespace), callback);
-          },
-          onLoad: (options, callback) => {
-            registerLoad(buildIdFilter(options.filter, options.namespace), callback);
-          },
-          module: (specifier, callback) => {
-            const namespace = `ecopages-module-${moduleCounter.value}`;
-            moduleCounter.value += 1;
-            const filter = new RegExp(`^${escapeRegExp(specifier)}$`);
-            registerResolve(filter, async () => ({
-              path: joinNamespace(namespace, specifier)
-            }));
-            registerLoad(buildIdFilter(/.*/, namespace), async () => callback());
-          }
-        };
-        await ecoPlugin.setup(bridge);
-      }
-    },
-    resolveId: resolveIdHandler,
-    load: loadHandler
-  };
-  return [plugin];
-}
-export {
-  createRolldownPluginBridge
-};

package/src/build/rolldown-source-transform-pass.js

@@ -1,58 +0,0 @@
-import path from "node:path";
-import { fileSystem } from "@ecopages/file-system";
-import { applySourceTransforms, normalizeTransformId } from "../plugins/source-transform.js";
-const TRANSFORMABLE_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mdx"]);
-function shouldApplySourceTransforms(namespace, sourcePath) {
-  if (namespace !== void 0) {
-    return false;
-  }
-  const normalizedPath = normalizeTransformId(sourcePath);
-  return TRANSFORMABLE_SOURCE_EXTENSIONS.has(path.extname(normalizedPath).toLowerCase());
-}
-function shouldTransformLoadedModule(moduleType) {
-  return moduleType !== "css" && moduleType !== "asset";
-}
-function applyTransformsToLoadedSource(sourceTransforms, id, sourcePath, code) {
-  if (sourceTransforms.length === 0) {
-    return code;
-  }
-  return applySourceTransforms(sourceTransforms, code, sourcePath);
-}
-async function finalizeLoadResultWithSourceTransforms(options) {
-  const { id, namespace, sourcePath, loadResult, sourceTransforms, contextRoot, inferModuleTypeFromPath } = options;
-  if (!shouldApplySourceTransforms(namespace, sourcePath)) {
-    return loadResult;
-  }
-  if (typeof loadResult === "object" && loadResult !== null && "code" in loadResult && typeof loadResult.code === "string") {
-    if (!shouldTransformLoadedModule(loadResult.moduleType)) {
-      return loadResult;
-    }
-    const transformedCode2 = applyTransformsToLoadedSource(sourceTransforms, id, sourcePath, loadResult.code);
-    if (transformedCode2 === loadResult.code) {
-      return loadResult;
-    }
-    return {
-      code: transformedCode2,
-      moduleType: loadResult.moduleType
-    };
-  }
-  if (loadResult !== void 0 || sourceTransforms.length === 0) {
-    return loadResult;
-  }
-  const normalizedPath = path.isAbsolute(sourcePath) ? sourcePath : path.resolve(contextRoot, sourcePath);
-  if (!fileSystem.exists(normalizedPath)) {
-    return loadResult;
-  }
-  const originalCode = fileSystem.readFileSync(normalizedPath);
-  const transformedCode = applyTransformsToLoadedSource(sourceTransforms, id, sourcePath, originalCode);
-  if (transformedCode === originalCode) {
-    return loadResult;
-  }
-  return {
-    code: transformedCode,
-    moduleType: inferModuleTypeFromPath(normalizedPath)
-  };
-}
-export {
-  finalizeLoadResultWithSourceTransforms
-};

package/src/build/runtime-build-executor.d.ts

@@ -1,15 +0,0 @@
-import type { EcoPagesAppConfig } from '../types/internal-types.js';
-import { type BuildExecutor } from './build-adapter.js';
-/**
- * Installs the app-owned runtime build executors for one app instance.
- *
- * @remarks
- * Route-module and HMR browser builds run through a {@link ParallelBuildExecutor}
- * so independent compiles can overlap. Server-entry bundling continues to call
- * the raw adapter directly and stays single-flight by design.
- *
- * Idempotent across calls: re-invoking replaces the existing executors on
- * `appConfig.runtime` with fresh wrappers.
- */
-export declare function installAppRuntimeBuildExecutor(appConfig: EcoPagesAppConfig): BuildExecutor;
-export declare function getInstalledServerEntryBuildExecutor(appConfig: EcoPagesAppConfig): BuildExecutor;

package/src/build/runtime-build-executor.js

@@ -1,43 +0,0 @@
-import { availableParallelism } from "node:os";
-import {
-  getAppBuildAdapter,
-  getAppServerBuildPlugins,
-  setAppBuildExecutor,
-  setAppHmrBuildExecutor,
-  setAppRouteModuleBuildExecutor,
-  withBuildExecutorPlugins
-} from "./build-adapter.js";
-import { ParallelBuildExecutor } from "./parallel-build-executor.js";
-import { SerializedBuildExecutor } from "./serialized-build-executor.js";
-function createPluginWrappedExecutor(appConfig) {
-  return withBuildExecutorPlugins(getAppBuildAdapter(appConfig), () => getAppServerBuildPlugins(appConfig));
-}
-function resolveParallelismLimit() {
-  return Math.max(1, availableParallelism() - 1);
-}
-function installAppRuntimeBuildExecutor(appConfig) {
-  const pluginWrappedExecutor = createPluginWrappedExecutor(appConfig);
-  const parallelismLimit = resolveParallelismLimit();
-  const routeModuleBuildExecutor = new ParallelBuildExecutor(pluginWrappedExecutor, parallelismLimit);
-  const hmrBuildExecutor = new ParallelBuildExecutor(pluginWrappedExecutor, Math.min(3, parallelismLimit));
-  setAppRouteModuleBuildExecutor(appConfig, routeModuleBuildExecutor);
-  setAppHmrBuildExecutor(appConfig, hmrBuildExecutor);
-  setAppBuildExecutor(appConfig, routeModuleBuildExecutor);
-  return routeModuleBuildExecutor;
-}
-function getInstalledServerEntryBuildExecutor(appConfig) {
-  const existing = appConfig.runtime?.serverEntryBuildExecutor;
-  if (existing) {
-    return existing;
-  }
-  const serverEntryBuildExecutor = new SerializedBuildExecutor(createPluginWrappedExecutor(appConfig));
-  appConfig.runtime = {
-    ...appConfig.runtime ?? {},
-    serverEntryBuildExecutor
-  };
-  return serverEntryBuildExecutor;
-}
-export {
-  getInstalledServerEntryBuildExecutor,
-  installAppRuntimeBuildExecutor
-};

package/src/build/runtime-build-output-normalizer.js

@@ -1,203 +0,0 @@
-import { createRequire } from "node:module";
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-const corePackageRequire = createRequire(new URL("../../package.json", import.meta.url));
-const appDeclaredPackageCache = /* @__PURE__ */ new Map();
-const appWorkspacePackageCache = /* @__PURE__ */ new Map();
-const CORE_RUNTIME_BARE_SPECIFIER_PACKAGES = /* @__PURE__ */ new Set(["ws"]);
-function tryResolveRuntimeImport(specifier, resolver) {
-  try {
-    return resolver.resolve(specifier);
-  } catch {
-    return void 0;
-  }
-}
-function isBareRuntimeImport(specifier) {
-  return !specifier.startsWith(".") && !path.isAbsolute(specifier) && !specifier.startsWith("/") && !specifier.startsWith("node:") && !specifier.startsWith("@/") && !specifier.startsWith("~/") && !specifier.startsWith("#") && !specifier.includes(":");
-}
-function extractPackageNameFromFileUrl(specifier) {
-  if (!specifier.startsWith("file://")) {
-    return void 0;
-  }
-  const lastNodeModulesIndex = specifier.lastIndexOf("/node_modules/");
-  if (lastNodeModulesIndex === -1) {
-    return void 0;
-  }
-  const afterNodeModules = specifier.slice(lastNodeModulesIndex + "/node_modules/".length);
-  const parts = afterNodeModules.split("/");
-  if (parts.length === 0) {
-    return void 0;
-  }
-  if (parts[0]?.startsWith("@") && parts.length > 1) {
-    return `${parts[0]}/${parts[1]}`;
-  }
-  return parts[0];
-}
-function getPackageNameFromSpecifier(specifier) {
-  if (specifier.startsWith("@")) {
-    return specifier.split("/").slice(0, 2).join("/");
-  }
-  return specifier.split("/")[0] ?? specifier;
-}
-function getDeclaredAppPackages(rootDir) {
-  const cacheKey = path.resolve(rootDir);
-  const cached = appDeclaredPackageCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-  const packageJsonPath = path.resolve(rootDir, "package.json");
-  const declaredPackages = /* @__PURE__ */ new Set();
-  try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-    for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
-      const entries = packageJson[field];
-      if (!entries || typeof entries !== "object") {
-        continue;
-      }
-      for (const packageName of Object.keys(entries)) {
-        declaredPackages.add(packageName);
-      }
-    }
-  } catch {
-    appDeclaredPackageCache.set(cacheKey, declaredPackages);
-    return declaredPackages;
-  }
-  appDeclaredPackageCache.set(cacheKey, declaredPackages);
-  return declaredPackages;
-}
-function getWorkspacePackages(rootDir) {
-  const cacheKey = path.resolve(rootDir);
-  const cached = appWorkspacePackageCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-  const packageJsonPath = path.resolve(rootDir, "package.json");
-  const workspacePackages = /* @__PURE__ */ new Set();
-  try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-    for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
-      const entries = packageJson[field];
-      if (!entries || typeof entries !== "object") {
-        continue;
-      }
-      for (const [packageName, version] of Object.entries(entries)) {
-        if (typeof version === "string" && version.startsWith("workspace:")) {
-          workspacePackages.add(packageName);
-        }
-      }
-    }
-  } catch {
-    appWorkspacePackageCache.set(cacheKey, workspacePackages);
-    return workspacePackages;
-  }
-  appWorkspacePackageCache.set(cacheKey, workspacePackages);
-  return workspacePackages;
-}
-function isWorkspacePackageImport(specifier, rootDir) {
-  return getWorkspacePackages(rootDir).has(getPackageNameFromSpecifier(specifier));
-}
-function isDeclaredAppPackageImport(specifier, rootDir) {
-  return getDeclaredAppPackages(rootDir).has(getPackageNameFromSpecifier(specifier));
-}
-function isDeclaredInResolutionChain(specifier, rootDir) {
-  const packageName = getPackageNameFromSpecifier(specifier);
-  if (CORE_RUNTIME_BARE_SPECIFIER_PACKAGES.has(packageName)) {
-    return true;
-  }
-  return isDeclaredAppPackageImport(specifier, rootDir);
-}
-function rewriteRuntimeImportSpecifier(specifier, quote, rootDir) {
-  if (!isBareRuntimeImport(specifier)) {
-    return void 0;
-  }
-  if (isDeclaredInResolutionChain(specifier, rootDir)) {
-    return void 0;
-  }
-  const resolvedPath = tryResolveRuntimeImport(specifier, corePackageRequire);
-  if (!resolvedPath || !/\.(?:[cm]?[jt]s|tsx|jsx)$/u.test(resolvedPath)) {
-    return void 0;
-  }
-  return `${quote}${pathToFileURL(resolvedPath).href}${quote}`;
-}
-function rewriteRuntimeBuildOutputImports(code, rootDir) {
-  const rewriteSpecifier = (prefix, quote, specifier) => {
-    const rewrittenSpecifier = rewriteRuntimeImportSpecifier(specifier, quote, rootDir);
-    return `${prefix}${rewrittenSpecifier ?? `${quote}${specifier}${quote}`}`;
-  };
-  const rewriteFileUrl = (prefix, quote, specifier) => {
-    const packageName = extractPackageNameFromFileUrl(specifier);
-    if (!packageName) {
-      return `${prefix}${quote}${specifier}${quote}`;
-    }
-    if (!isDeclaredInResolutionChain(packageName, rootDir)) {
-      return `${prefix}${quote}${specifier}${quote}`;
-    }
-    const lastNodeModulesIndex = specifier.lastIndexOf("/node_modules/");
-    if (lastNodeModulesIndex === -1) {
-      return `${prefix}${quote}${specifier}${quote}`;
-    }
-    const afterNodeModules = specifier.slice(lastNodeModulesIndex + "/node_modules/".length);
-    const afterPackage = afterNodeModules.slice(packageName.length);
-    const bareSpecifier = packageName + afterPackage;
-    return `${prefix}${quote}${bareSpecifier}${quote}`;
-  };
-  const withResolvedPackages = code.replace(
-    /(\bfrom\s+)(['"])([^'"\\]+)\2/g,
-    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
-  ).replace(
-    /(\bimport\s+)(['"])([^'"\\]+)\2/g,
-    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
-  ).replace(
-    /(\bimport\s*\(\s*)(['"])([^'"\\]+)\2/g,
-    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
-  );
-  const withBareSpecifiers = withResolvedPackages.replace(
-    /(\bfrom\s+)(['"])(file:\/\/[^'"\\]+)\2/g,
-    (_match, prefix, quote, specifier) => rewriteFileUrl(prefix, quote, specifier)
-  ).replace(
-    /(\bimport\s+)(['"])(file:\/\/[^'"\\]+)\2/g,
-    (_match, prefix, quote, specifier) => rewriteFileUrl(prefix, quote, specifier)
-  ).replace(
-    /(\bimport\s*\(\s*)(['"])(file:\/\/[^'"\\]+)\2/g,
-    (_match, prefix, quote, specifier) => rewriteFileUrl(prefix, quote, specifier)
-  );
-  return withBareSpecifiers.replace(
-    /(['"])(@oxc-project\/runtime\/(?:helpers(?:\/esm)?\/[^'"\\]+))\1/g,
-    (match, quote, specifier) => {
-      const resolvedPath = tryResolveRuntimeImport(specifier, corePackageRequire);
-      return resolvedPath ? `${quote}${pathToFileURL(resolvedPath).href}${quote}` : match;
-    }
-  );
-}
-function normalizeNodeRuntimeBuildOutputFile(filePath, rootDir) {
-  if (process.env.ECOPAGES_LOGGER_DEBUG === "true") {
-    console.log(`[normalizeNodeRuntimeBuildOutputFile] Checking ${filePath}`);
-  }
-  if (!/\.(?:[cm]?js)$/u.test(filePath)) {
-    return;
-  }
-  const fileSystem = corePackageRequire("node:fs");
-  if (!fileSystem.existsSync(filePath)) {
-    return;
-  }
-  const code = fileSystem.readFileSync(filePath, "utf-8");
-  const rewritten = rewriteRuntimeBuildOutputImports(code, rootDir);
-  if (rewritten !== code) {
-    if (process.env.ECOPAGES_LOGGER_DEBUG === "true") {
-      console.log(`[normalizeNodeRuntimeBuildOutputFile] Rewriting ${filePath}`);
-    }
-    fileSystem.writeFileSync(filePath, rewritten);
-  }
-}
-function normalizeNodeRuntimeBuildOutputs(outputPaths, rootDir) {
-  for (const outputPath of outputPaths) {
-    normalizeNodeRuntimeBuildOutputFile(outputPath, rootDir);
-  }
-}
-export {
-  isDeclaredAppPackageImport,
-  isWorkspacePackageImport,
-  normalizeNodeRuntimeBuildOutputFile,
-  normalizeNodeRuntimeBuildOutputs
-};

package/src/build/serialized-build-executor.js

@@ -1,63 +0,0 @@
-class SerializedBuildExecutor {
-  inner;
-  tail = Promise.resolve();
-  constructor(inner) {
-    this.inner = inner;
-  }
-  /**
-   * Run a build through the serialized queue. The returned promise
-   * resolves with the inner executor's `BuildResult`. A rejected
-   * inner build does not block the queue — the next caller can
-   * proceed.
-   */
-  build(options) {
-    return this.run(() => this.inner.build(options));
-  }
-  /**
-   * Run an arbitrary async operation through the serialized queue.
-   *
-   * Use this when the work is not a `build()` call against a wrapped
-   * executor (e.g. when composing with a coordinator that needs to
-   * inject recovery around the inner call). The returned promise
-   * resolves with the operation's result. A rejected operation does
-   * not block the queue.
-   */
-  run(operation) {
-    const next = this.tail.catch(() => void 0).then(() => operation());
-    this.tail = next.catch(() => void 0);
-    return next;
-  }
-  /**
-   * Returns the wrapped executor. Tests use this to assert the
-   * delegation chain.
-   */
-  unwrap() {
-    return this.inner;
-  }
-  /**
-   * Reset the queue to an empty state. Tests use this to recover
-   * from a poisoned tail.
-   */
-  resetForTests() {
-    this.tail = Promise.resolve();
-  }
-  /**
-   * Overrides the internal queue tail for fault-recovery tests. The
-   * supplied promise is awaited before the next enqueued operation
-   * starts.
-   */
-  setBuildQueueForTests(queue) {
-    this.tail = queue;
-  }
-  /**
-   * Returns the current internal queue tail for fault-recovery
-   * tests. Tests await this to assert that recovery has cleared a
-   * wedged queue.
-   */
-  getBuildQueueForTests() {
-    return this.tail;
-  }
-}
-export {
-  SerializedBuildExecutor
-};