@modern-js/app-tools 2.35.1 → 2.35.2-alpha.0

package/dist/js/node/analyze/utils.js

@@ -0,0 +1,172 @@
+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);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var utils_exports = {};
+__export(utils_exports, {
+  getDefaultImports: () => getDefaultImports,
+  getServerLoadersFile: () => getServerLoadersFile,
+  hasLoader: () => hasLoader,
+  isPageComponentFile: () => isPageComponentFile,
+  parseModule: () => parseModule,
+  replaceWithAlias: () => replaceWithAlias,
+  walkDirectory: () => walkDirectory
+});
+module.exports = __toCommonJS(utils_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_esbuild = require("esbuild");
+var import_es_module_lexer = require("es-module-lexer");
+var import_constants = require("./constants");
+const walkDirectory = (dir) => import_fs.default.readdirSync(dir).reduce((previous, filename) => {
+  const filePath = import_path.default.join(dir, filename);
+  if (import_fs.default.statSync(filePath).isDirectory()) {
+    return [...previous, ...walkDirectory(filePath)];
+  } else {
+    return [...previous, filePath];
+  }
+}, []);
+const getDefaultImports = ({
+  entrypoint,
+  srcDirectory,
+  internalSrcAlias,
+  internalDirAlias,
+  internalDirectory
+}) => {
+  const { entryName, fileSystemRoutes, customBootstrap, entry } = entrypoint;
+  const imports = [
+    {
+      specifiers: [{ local: "React" }],
+      value: "react"
+    },
+    {
+      specifiers: [{ local: "ReactDOM" }],
+      value: (0, import_utils.isReact18)(import_path.default.join(internalDirectory, "../../")) ? "react-dom/client" : "react-dom"
+    },
+    {
+      specifiers: [{ imported: "createApp" }, { imported: "bootstrap" }],
+      value: "@modern-js/runtime"
+    },
+    customBootstrap && {
+      specifiers: [{ local: "customBootstrap" }],
+      value: (0, import_utils.normalizeToPosixPath)(
+        customBootstrap.replace(srcDirectory, internalSrcAlias)
+      )
+    }
+  ].filter(Boolean);
+  if (fileSystemRoutes) {
+    const route = {
+      specifiers: [{ imported: "routes" }],
+      value: (0, import_utils.normalizeToPosixPath)(
+        `${internalDirAlias}/${entryName}/${import_constants.FILE_SYSTEM_ROUTES_FILE_NAME.replace(
+          ".js",
+          ""
+        )}`
+      )
+    };
+    if (fileSystemRoutes.globalApp) {
+      imports.push({
+        specifiers: [{ local: "App" }],
+        value: (0, import_utils.normalizeToPosixPath)(
+          fileSystemRoutes.globalApp.replace(srcDirectory, internalSrcAlias)
+        )
+      });
+    } else {
+      route.initialize = "const App = false;";
+    }
+    imports.push(route);
+  } else {
+    imports.push({
+      specifiers: [{ local: "App" }],
+      value: (0, import_utils.normalizeToPosixPath)(
+        entry.replace(srcDirectory, internalSrcAlias)
+      )
+    });
+  }
+  return imports;
+};
+const isPageComponentFile = (filePath) => {
+  if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) {
+    return false;
+  }
+  if ([".js", ".jsx", ".ts", ".tsx"].includes(import_path.default.extname(filePath))) {
+    return true;
+  }
+  return false;
+};
+const replaceWithAlias = (base, filePath, alias) => (0, import_utils.normalizeToPosixPath)(import_path.default.join(alias, import_path.default.relative(base, filePath)));
+const parseModule = (_0) => __async(void 0, [_0], function* ({
+  source,
+  filename
+}) {
+  let content = source;
+  if (import_constants.JS_EXTENSIONS.some((ext) => filename.endsWith(ext))) {
+    const result = yield (0, import_esbuild.transform)(content, {
+      loader: import_path.default.extname(filename).slice(1),
+      format: "esm"
+    });
+    content = result.code;
+  }
+  return yield (0, import_es_module_lexer.parse)(content);
+});
+const hasLoader = (filename) => __async(void 0, null, function* () {
+  const source = yield import_utils.fs.readFile(filename);
+  const [, moduleExports] = yield parseModule({
+    source: source.toString(),
+    filename
+  });
+  return moduleExports.some((e) => e.n === import_constants.LOADER_EXPORT_NAME);
+});
+const getServerLoadersFile = (internalDirectory, entryName) => {
+  return import_path.default.join(internalDirectory, entryName, "route-server-loaders.js");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDefaultImports,
+  getServerLoadersFile,
+  hasLoader,
+  isPageComponentFile,
+  parseModule,
+  replaceWithAlias,
+  walkDirectory
+});

package/dist/js/node/builder/builderPlugins/compatModern.js

@@ -0,0 +1,258 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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);
+var compatModern_exports = {};
+__export(compatModern_exports, {
+  PluginCompatModern: () => PluginCompatModern
+});
+module.exports = __toCommonJS(compatModern_exports);
+var import_path = require("path");
+var import_builder_shared = require("@modern-js/builder-shared");
+var import_lodash = require("@modern-js/utils/lodash");
+var import_html_webpack_plugin = __toESM(require("@modern-js/builder-webpack-provider/html-webpack-plugin"));
+var import_utils = require("@modern-js/utils");
+var import_htmlBottomTemplate = require("../webpackPlugins/htmlBottomTemplate");
+var import_htmlAsyncChunkPlugin = require("../webpackPlugins/htmlAsyncChunkPlugin");
+var import_share = require("../share");
+var import_routerPlugin = __toESM(require("../webpackPlugins/routerPlugin"));
+const PluginCompatModern = (appContext, modernConfig, options) => ({
+  name: "builder-plugin-compat-modern",
+  setup(api) {
+    api.modifyBuilderConfig((config) => {
+      if (isStreamingSSR(modernConfig)) {
+        return (0, import_builder_shared.mergeBuilderConfig)(config, {
+          html: {
+            inject: "body"
+          }
+        });
+      }
+      return config;
+    });
+    api.modifyWebpackChain((chain, { target, CHAIN_ID, isProd }) => {
+      var _a;
+      const builderNormalizedConfig = api.getNormalizedConfig();
+      if (target === "node") {
+        chain.name("server");
+      } else if (target === "modern-web") {
+        chain.name("modern");
+      } else {
+        chain.name("client");
+      }
+      chain.resolve.modules.add("node_modules").add((0, import_path.join)(api.context.rootPath, "node_modules"));
+      if (target === "node") {
+        applyNodeCompat(chain, modernConfig, isProd);
+      }
+      if (isHtmlEnabled(builderNormalizedConfig, target)) {
+        applyBottomHtmlWebpackPlugin({
+          api,
+          chain,
+          CHAIN_ID,
+          appContext,
+          modernConfig
+        });
+        applyAsyncChunkHtmlPlugin({
+          chain,
+          CHAIN_ID,
+          modernConfig
+        });
+      }
+      if (chain.plugins.has(CHAIN_ID.PLUGIN.COPY)) {
+        const defaultCopyPattern = (0, import_share.createCopyPattern)(
+          appContext,
+          modernConfig,
+          "public",
+          chain
+        );
+        chain.plugin(CHAIN_ID.PLUGIN.COPY).tap((args) => {
+          var _a2;
+          return [
+            {
+              patterns: [...((_a2 = args[0]) == null ? void 0 : _a2.patterns) || [], defaultCopyPattern]
+            }
+          ];
+        });
+      }
+      const { entrypoints } = appContext;
+      const existNestedRoutes = entrypoints.some(
+        (entrypoint) => entrypoint.nestedRoutesEntry
+      );
+      const routerConfig = (_a = modernConfig == null ? void 0 : modernConfig.runtime) == null ? void 0 : _a.router;
+      const routerManifest = Boolean(routerConfig == null ? void 0 : routerConfig.manifest);
+      if (existNestedRoutes || routerManifest) {
+        chain.plugin("route-plugin").use(import_routerPlugin.default);
+      }
+      if (target !== "node") {
+        const bareServerModuleReg = /\.(server|node)\.[tj]sx?$/;
+        chain.module.rule(CHAIN_ID.RULE.JS).exclude.add(bareServerModuleReg);
+        chain.module.rule("bare-server-module").test(bareServerModuleReg).use("server-module-loader").loader(require.resolve("../loaders/serverModuleLoader"));
+      }
+      function isHtmlEnabled(config, target2) {
+        var _a2;
+        return ((_a2 = config.tools) == null ? void 0 : _a2.htmlPlugin) !== false && target2 !== "node" && target2 !== "web-worker";
+      }
+    });
+    if (options) {
+      applyCallbacks(api, options);
+    }
+  }
+});
+function applyCallbacks(api, options) {
+  options.onAfterBuild && api.onAfterBuild(options.onAfterBuild);
+  options.onAfterCreateCompiler && api.onAfterCreateCompiler(options.onAfterCreateCompiler);
+  options.onAfterStartDevServer && api.onAfterStartDevServer(options.onAfterStartDevServer);
+  options.onBeforeBuild && api.onBeforeBuild(options.onBeforeBuild);
+  options.onBeforeCreateCompiler && api.onBeforeCreateCompiler(options.onBeforeCreateCompiler);
+  options.onBeforeStartDevServer && api.onBeforeStartDevServer(options.onBeforeStartDevServer);
+  options.onDevCompileDone && api.onDevCompileDone(options.onDevCompileDone);
+  options.onExit && api.onExit(options.onExit);
+}
+function applyNodeCompat(chain, modernConfig, isProd) {
+  for (const ext of [
+    ".node.js",
+    ".node.jsx",
+    ".node.ts",
+    ".node.tsx",
+    ".server.js",
+    ".server.ts",
+    ".server.ts",
+    ".server.tsx"
+  ]) {
+    chain.resolve.extensions.prepend(ext);
+  }
+  filterEntriesBySSRConfig(
+    isProd,
+    chain,
+    modernConfig.server,
+    modernConfig.output
+  );
+  function filterEntriesBySSRConfig(isProd2, chain2, serverConfig, outputConfig) {
+    var _a;
+    const entries = chain2.entryPoints.entries();
+    if (isProd2 && ((outputConfig == null ? void 0 : outputConfig.ssg) === true || typeof ((_a = outputConfig == null ? void 0 : outputConfig.ssg) == null ? void 0 : _a[0]) === "function")) {
+      return;
+    }
+    if (typeof entries === "undefined") {
+      throw new Error(
+        "No entry found, one of src/routes/layout.tsx, src/App.tsx, src/index.tsx is required"
+      );
+    }
+    const entryNames = Object.keys(entries);
+    if (isProd2 && entryNames.length === 1 && (outputConfig == null ? void 0 : outputConfig.ssg)) {
+      return;
+    }
+    const ssgEntries = [];
+    if (isProd2 && (outputConfig == null ? void 0 : outputConfig.ssg)) {
+      const { ssg } = outputConfig;
+      entryNames.forEach((name) => {
+        if (ssg[name]) {
+          ssgEntries.push(name);
+        }
+      });
+    }
+    const { ssr, ssrByEntries } = serverConfig || {};
+    entryNames.forEach((name) => {
+      if (!ssgEntries.includes(name) && (ssr && (ssrByEntries == null ? void 0 : ssrByEntries[name]) === false || !ssr && !(ssrByEntries == null ? void 0 : ssrByEntries[name]))) {
+        chain2.entryPoints.delete(name);
+      }
+    });
+  }
+}
+function applyBottomHtmlWebpackPlugin({
+  api,
+  chain,
+  modernConfig,
+  appContext,
+  CHAIN_ID
+}) {
+  for (const entryName of Object.keys(api.context.entry)) {
+    const baseTemplateParams = __spreadValues({
+      entryName,
+      title: (0, import_utils.getEntryOptions)(
+        entryName,
+        modernConfig.html.title,
+        modernConfig.html.titleByEntries,
+        appContext.packageName
+      ),
+      mountId: modernConfig.html.mountId
+    }, (0, import_utils.getEntryOptions)(
+      entryName,
+      modernConfig.html.templateParameters,
+      modernConfig.html.templateParametersByEntries,
+      appContext.packageName
+    ));
+    chain.plugin(`${CHAIN_ID.PLUGIN.HTML}-${entryName}`).tap((args) => [
+      __spreadProps(__spreadValues({}, args[0] || {}), {
+        __internal__: true,
+        bottomTemplate: appContext.htmlTemplates[`__${entryName}-bottom__`] && (0, import_lodash.template)(appContext.htmlTemplates[`__${entryName}-bottom__`])(
+          baseTemplateParams
+        )
+      })
+    ]);
+  }
+  chain.plugin(CHAIN_ID.PLUGIN.BOTTOM_TEMPLATE).use(import_htmlBottomTemplate.BottomTemplatePlugin, [import_html_webpack_plugin.default]);
+}
+const isStreamingSSR = (userConfig) => {
+  const isStreaming = (ssr) => ssr && typeof ssr === "object" && ssr.mode === "stream";
+  const { server } = userConfig;
+  if (isStreaming(server.ssr)) {
+    return true;
+  }
+  if ((server == null ? void 0 : server.ssrByEntries) && typeof server.ssrByEntries === "object") {
+    for (const name of Object.keys(server.ssrByEntries)) {
+      if (isStreaming(server.ssrByEntries[name])) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+function applyAsyncChunkHtmlPlugin({
+  chain,
+  modernConfig,
+  CHAIN_ID
+}) {
+  if (isStreamingSSR(modernConfig)) {
+    chain.plugin(CHAIN_ID.PLUGIN.HTML_ASYNC_CHUNK).use(import_htmlAsyncChunkPlugin.HtmlAsyncChunkPlugin, [import_html_webpack_plugin.default]);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginCompatModern
+});

package/dist/js/node/builder/index.js

@@ -0,0 +1,177 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var builder_exports = {};
+__export(builder_exports, {
+  createBuilderForModern: () => createBuilderForModern,
+  createBuilderOptions: () => createBuilderOptions,
+  createBuilderProviderConfig: () => createBuilderProviderConfig
+});
+module.exports = __toCommonJS(builder_exports);
+var import_builder = require("@modern-js/builder");
+var import_builder_webpack_provider = require("@modern-js/builder-webpack-provider");
+var import_utils = require("@modern-js/utils");
+var import_compatModern = require("./builderPlugins/compatModern");
+var import_share = require("./share");
+function getBuilderTargets(normalizedConfig) {
+  const targets = ["web"];
+  const useNodeTarget = (0, import_utils.isProd)() ? (0, import_utils.isUseSSRBundle)(normalizedConfig) : (0, import_utils.isSSR)(normalizedConfig);
+  if (useNodeTarget) {
+    targets.push("node");
+  }
+  return targets;
+}
+function createBuilderForModern(_0) {
+  return __async(this, arguments, function* ({
+    normalizedConfig,
+    appContext,
+    compatPluginConfig
+  }) {
+    const builderConfig = createBuilderProviderConfig(
+      normalizedConfig,
+      appContext
+    );
+    const webpackProvider = (0, import_builder_webpack_provider.builderWebpackProvider)({
+      builderConfig
+    });
+    const target = getBuilderTargets(normalizedConfig);
+    const builderOptions = createBuilderOptions(target, appContext);
+    const builder = yield (0, import_builder.createBuilder)(webpackProvider, builderOptions);
+    yield applyBuilderPlugins(
+      builder,
+      normalizedConfig,
+      appContext,
+      compatPluginConfig
+    );
+    return builder;
+  });
+}
+function createBuilderProviderConfig(normalizedConfig, appContext) {
+  const output = createOutputConfig(normalizedConfig, appContext);
+  const htmlConfig = __spreadValues({}, normalizedConfig.html);
+  if (!htmlConfig.template) {
+    htmlConfig.templateByEntries = __spreadValues(__spreadValues({}, htmlConfig.templateByEntries), appContext.htmlTemplates);
+  }
+  return __spreadProps(__spreadValues({}, normalizedConfig), {
+    output,
+    dev: __spreadProps(__spreadValues({}, normalizedConfig.dev), {
+      port: appContext.port
+    }),
+    html: htmlConfig
+  });
+  function createOutputConfig(config, appContext2) {
+    const defaultCopyPattern = (0, import_share.createCopyPattern)(appContext2, config, "upload");
+    const { copy } = config.output;
+    const copyOptions = Array.isArray(copy) ? copy : copy == null ? void 0 : copy.patterns;
+    const builderCopy = [...copyOptions || [], defaultCopyPattern];
+    return __spreadProps(__spreadValues({}, config.output), {
+      copy: builderCopy,
+      cleanDistPath: false
+    });
+  }
+}
+function createBuilderOptions(target, appContext) {
+  const entries = {};
+  const { entrypoints = [], checkedEntries } = appContext;
+  for (const { entryName, entry } of entrypoints) {
+    if (checkedEntries && !checkedEntries.includes(entryName)) {
+      continue;
+    }
+    if (entryName in entries) {
+      entries[entryName].push(entry);
+    } else {
+      entries[entryName] = [entry];
+    }
+  }
+  return {
+    cwd: appContext.appDirectory,
+    target,
+    configPath: appContext.configFile || void 0,
+    entry: entries,
+    framework: appContext.metaName
+  };
+}
+function applyBuilderPlugins(builder, normalizedConfig, appContext, compatPluginConfig) {
+  return __async(this, null, function* () {
+    if (!normalizedConfig.output.disableNodePolyfill) {
+      const { builderPluginNodePolyfill } = yield Promise.resolve().then(() => __toESM(require("@modern-js/builder-plugin-node-polyfill")));
+      builder.addPlugins([builderPluginNodePolyfill()]);
+    }
+    if (normalizedConfig.tools.esbuild) {
+      const { esbuild: esbuildOptions } = normalizedConfig.tools;
+      const { builderPluginEsbuild } = yield Promise.resolve().then(() => __toESM(require("@modern-js/builder-plugin-esbuild")));
+      builder.addPlugins([
+        builderPluginEsbuild({
+          loader: false,
+          minimize: (0, import_utils.applyOptionsChain)({}, esbuildOptions)
+        })
+      ]);
+    }
+    builder.addPlugins([
+      (0, import_compatModern.PluginCompatModern)(appContext, normalizedConfig, compatPluginConfig)
+    ]);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBuilderForModern,
+  createBuilderOptions,
+  createBuilderProviderConfig
+});

package/dist/js/node/builder/loaders/routerLoader.js

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var routerLoader_exports = {};
+__export(routerLoader_exports, {
+  default: () => routerLoader_default
+});
+module.exports = __toCommonJS(routerLoader_exports);
+var import_utils = require("@modern-js/utils");
+function loader(source) {
+  this.cacheable();
+  const { target } = this._compiler.options;
+  if (target === "node" || Array.isArray(target) && target.includes("node")) {
+    return source;
+  }
+  const { resourcePath } = this;
+  const code = `
+    export { default } from "${(0, import_utils.slash)(resourcePath)}";
+  `;
+  return code;
+}
+var routerLoader_default = loader;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/js/node/builder/loaders/serverModuleLoader.js

@@ -0,0 +1,28 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serverModuleLoader_exports = {};
+__export(serverModuleLoader_exports, {
+  default: () => serverModuleLoader_default
+});
+module.exports = __toCommonJS(serverModuleLoader_exports);
+function loader() {
+  return `module.exports = {}`;
+}
+var serverModuleLoader_default = loader;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});