@modern-js/app-tools 2.58.2 → 2.59.0

package/dist/esm-node/builder/shared/builderPlugins/adapterBasic.js

@@ -0,0 +1,48 @@
+import path from "path";
+import { SERVICE_WORKER_ENVIRONMENT_NAME } from "@modern-js/uni-builder";
+const builderPluginAdapterBasic = () => ({
+  name: "builder-plugin-adapter-modern-basic",
+  setup(api) {
+    api.modifyBundlerChain((chain, { target, CHAIN_ID, environment }) => {
+      const isServiceWorker = environment.name === SERVICE_WORKER_ENVIRONMENT_NAME;
+      if (target === "node" || isServiceWorker) {
+        applyNodeCompat(isServiceWorker, chain);
+      }
+      if (target === "web") {
+        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"));
+      }
+      chain.resolve.modules.add("node_modules").add(path.join(api.context.rootPath, "node_modules"));
+    });
+  }
+});
+function applyNodeCompat(isServiceWorker, chain) {
+  const nodeExts = [
+    ".node.js",
+    ".node.jsx",
+    ".node.ts",
+    ".node.tsx",
+    ".server.js",
+    ".server.jsx",
+    ".server.ts",
+    ".server.tsx"
+  ];
+  const webWorkerExts = [
+    ".worker.js",
+    ".worker.jsx",
+    ".worker.ts",
+    ".worker.tsx"
+  ];
+  for (const ext of nodeExts) {
+    chain.resolve.extensions.prepend(ext);
+  }
+  if (isServiceWorker) {
+    for (const ext of webWorkerExts) {
+      chain.resolve.extensions.prepend(ext);
+    }
+  }
+}
+export {
+  builderPluginAdapterBasic
+};

package/dist/esm-node/builder/shared/builderPlugins/adapterHtml.js

@@ -0,0 +1,60 @@
+import { isHtmlDisabled } from "@modern-js/uni-builder";
+import { MAIN_ENTRY_NAME, getEntryOptions, removeTailSlash } from "@modern-js/utils";
+import { template as lodashTemplate } from "@modern-js/utils/lodash";
+import { BottomTemplatePlugin } from "../bundlerPlugins";
+const createVirtualModule = (content) => `data:text/javascript,${content}`;
+const builderPluginAdapterHtml = (options) => ({
+  name: "builder-plugin-adapter-modern-html",
+  setup(api) {
+    api.modifyBundlerChain(async (chain, { CHAIN_ID, target, HtmlPlugin: HtmlBundlerPlugin, environment }) => {
+      const builderConfig = environment.config;
+      if (!isHtmlDisabled(builderConfig, target)) {
+        applyBottomHtmlPlugin({
+          options,
+          chain,
+          CHAIN_ID,
+          HtmlBundlerPlugin,
+          htmlPaths: environment.htmlPaths
+        });
+        await injectAssetPrefix({
+          chain
+        });
+      }
+    });
+  }
+});
+async function injectAssetPrefix({ chain }) {
+  const entries = chain.entryPoints.entries() || {};
+  const entryNames = Object.keys(entries);
+  const assetPrefix = removeTailSlash(chain.output.get("publicPath") || "");
+  const code = `window.__assetPrefix__ = '${assetPrefix}';`;
+  entryNames.forEach((entryName) => {
+    entries[entryName].prepend(createVirtualModule(code));
+  });
+}
+function applyBottomHtmlPlugin({ chain, options, CHAIN_ID, HtmlBundlerPlugin, htmlPaths }) {
+  const { normalizedConfig: modernConfig, appContext } = options;
+  for (const entryName of Object.keys(htmlPaths)) {
+    const { source: { mainEntryName } } = modernConfig;
+    const isMainEntry = entryName === (mainEntryName || MAIN_ENTRY_NAME);
+    const baseTemplateParams = {
+      entryName,
+      title: getEntryOptions(entryName, isMainEntry, modernConfig.html.title, modernConfig.html.titleByEntries, appContext.packageName),
+      mountId: modernConfig.html.mountId,
+      ...getEntryOptions(entryName, isMainEntry, modernConfig.html.templateParameters, modernConfig.html.templateParametersByEntries, appContext.packageName)
+    };
+    chain.plugin(`${CHAIN_ID.PLUGIN.HTML}-${entryName}`).tap((args) => [
+      {
+        ...args[0] || {},
+        __internal__: true,
+        bottomTemplate: appContext.htmlTemplates[`__${entryName}-bottom__`] && lodashTemplate(appContext.htmlTemplates[`__${entryName}-bottom__`])(baseTemplateParams)
+      }
+    ]);
+  }
+  chain.plugin("bottom-template").use(BottomTemplatePlugin, [
+    HtmlBundlerPlugin
+  ]);
+}
+export {
+  builderPluginAdapterHtml
+};

package/dist/esm-node/builder/shared/builderPlugins/adapterSSR.js

@@ -0,0 +1,151 @@
+import * as path from "path";
+import { SERVICE_WORKER_ENVIRONMENT_NAME, isHtmlDisabled } from "@modern-js/uni-builder";
+import { fs, isUseSSRBundle } from "@modern-js/utils";
+import { mergeRsbuildConfig } from "@rsbuild/core";
+import { getServerCombinedModueFile } from "../../../plugins/analyze/utils";
+import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins";
+const builderPluginAdapterSSR = (options) => ({
+  name: "builder-plugin-adapter-modern-ssr",
+  setup(api) {
+    const { normalizedConfig } = options;
+    api.modifyRsbuildConfig((config) => {
+      return mergeRsbuildConfig(config, {
+        html: {
+          inject: isStreamingSSR(normalizedConfig) ? "body" : void 0
+        },
+        server: {
+          // the http-compression can't handler stream http.
+          // so we disable compress when user use stream ssr temporarily.
+          compress: isStreamingSSR(normalizedConfig) ? false : void 0
+        }
+      });
+    });
+    api.modifyBundlerChain(async (chain, { target, isProd, HtmlPlugin: HtmlBundlerPlugin, isServer, environment }) => {
+      const builderConfig = environment.config;
+      const { normalizedConfig: normalizedConfig2 } = options;
+      applyRouterPlugin(chain, "route-plugin", options, HtmlBundlerPlugin);
+      const isServiceWorker = environment.name === SERVICE_WORKER_ENVIRONMENT_NAME;
+      if (target === "node" || isServiceWorker) {
+        applyFilterEntriesBySSRConfig({
+          isProd,
+          chain,
+          appNormalizedConfig: normalizedConfig2
+        });
+      }
+      if (isUseSSRBundle(normalizedConfig2)) {
+        await applySSRLoaderEntry(chain, options, isServer);
+        applySSRDataLoader(chain, options);
+      }
+      if (!isHtmlDisabled(builderConfig, target)) {
+        applyAsyncChunkHtmlPlugin({
+          chain,
+          modernConfig: options.normalizedConfig,
+          HtmlBundlerPlugin
+        });
+      }
+    });
+  }
+});
+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 || server === void 0 ? 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, HtmlBundlerPlugin }) {
+  if (isStreamingSSR(modernConfig)) {
+    chain.plugin("html-async-chunk").use(HtmlAsyncChunkPlugin, [
+      HtmlBundlerPlugin
+    ]);
+  }
+}
+function applyRouterPlugin(chain, pluginName, options, HtmlBundlerPlugin) {
+  var _normalizedConfig_runtime, _normalizedConfig_deploy_worker;
+  const { appContext, normalizedConfig } = options;
+  const { entrypoints } = appContext;
+  const existNestedRoutes = entrypoints.some((entrypoint) => entrypoint.nestedRoutesEntry);
+  const routerConfig = normalizedConfig === null || normalizedConfig === void 0 ? void 0 : (_normalizedConfig_runtime = normalizedConfig.runtime) === null || _normalizedConfig_runtime === void 0 ? void 0 : _normalizedConfig_runtime.router;
+  const routerManifest = Boolean(routerConfig === null || routerConfig === void 0 ? void 0 : routerConfig.manifest);
+  const workerSSR = Boolean((_normalizedConfig_deploy_worker = normalizedConfig.deploy.worker) === null || _normalizedConfig_deploy_worker === void 0 ? void 0 : _normalizedConfig_deploy_worker.ssr);
+  const { enableInlineRouteManifests, disableInlineRouteManifests } = normalizedConfig.output;
+  const inlineRouteManifests = disableInlineRouteManifests ? !disableInlineRouteManifests : enableInlineRouteManifests;
+  if (existNestedRoutes || routerManifest || workerSSR) {
+    var _normalizedConfig_output_distPath, _normalizedConfig_output, _normalizedConfig_output1, _normalizedConfig_html, _normalizedConfig_security;
+    chain.plugin(pluginName).use(RouterPlugin, [
+      {
+        HtmlBundlerPlugin,
+        enableInlineRouteManifests: inlineRouteManifests,
+        staticJsDir: (_normalizedConfig_output = normalizedConfig.output) === null || _normalizedConfig_output === void 0 ? void 0 : (_normalizedConfig_output_distPath = _normalizedConfig_output.distPath) === null || _normalizedConfig_output_distPath === void 0 ? void 0 : _normalizedConfig_output_distPath.js,
+        disableFilenameHash: (_normalizedConfig_output1 = normalizedConfig.output) === null || _normalizedConfig_output1 === void 0 ? void 0 : _normalizedConfig_output1.disableFilenameHash,
+        scriptLoading: (_normalizedConfig_html = normalizedConfig.html) === null || _normalizedConfig_html === void 0 ? void 0 : _normalizedConfig_html.scriptLoading,
+        nonce: (_normalizedConfig_security = normalizedConfig.security) === null || _normalizedConfig_security === void 0 ? void 0 : _normalizedConfig_security.nonce
+      }
+    ]);
+  }
+}
+function applyFilterEntriesBySSRConfig({ isProd, chain, appNormalizedConfig }) {
+  var _this;
+  const { server: serverConfig, output: outputConfig } = appNormalizedConfig;
+  const entries = chain.entryPoints.entries();
+  if (isProd && ((outputConfig === null || outputConfig === void 0 ? void 0 : outputConfig.ssg) === true || typeof ((_this = outputConfig === null || outputConfig === void 0 ? void 0 : outputConfig.ssg) === null || _this === void 0 ? void 0 : _this[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 (isProd && entryNames.length === 1 && (outputConfig === null || outputConfig === void 0 ? void 0 : outputConfig.ssg)) {
+    return;
+  }
+  const ssgEntries = [];
+  if (isProd && (outputConfig === null || outputConfig === void 0 ? 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) && !name.includes("server-loaders") && (ssr && (ssrByEntries === null || ssrByEntries === void 0 ? void 0 : ssrByEntries[name]) === false || !ssr && !(ssrByEntries === null || ssrByEntries === void 0 ? void 0 : ssrByEntries[name]))) {
+      chain.entryPoints.delete(name);
+    }
+  });
+}
+async function applySSRLoaderEntry(chain, optinos, isServer) {
+  const { appContext } = optinos;
+  const { internalDirectory } = appContext;
+  const { entrypoints } = appContext;
+  await Promise.all(entrypoints.map(async (entrypoint) => {
+    const { entryName } = entrypoint;
+    const serverLoadersFile = getServerCombinedModueFile(internalDirectory, entryName);
+    if (isServer) {
+      try {
+        await fs.access(serverLoadersFile, fs.constants.F_OK);
+        chain.entry(`${entryName}-server-loaders`).add(serverLoadersFile);
+      } catch (err) {
+      }
+    }
+  }));
+}
+function applySSRDataLoader(chain, options) {
+  const { normalizedConfig, appContext } = options;
+  const { appDirectory } = appContext;
+  const { entriesDir = "./src" } = normalizedConfig.source;
+  const absolutePath = path.resolve(appDirectory, entriesDir).split(path.sep).join("(\\\\|/)");
+  const reg = new RegExp(`${absolutePath}.*\\.(loader|data|data.client)\\.[t|j]sx?$`);
+  chain.module.rule("ssr-data-loader").test(reg).use("data-loader").loader(require.resolve("@modern-js/plugin-data-loader/loader")).end();
+}
+export {
+  builderPluginAdapterSSR
+};

package/dist/esm-node/builder/shared/builderPlugins/index.js

@@ -0,0 +1,3 @@
+export * from "./adapterBasic";
+export * from "./adapterHtml";
+export * from "./adapterSSR";

package/dist/esm-node/builder/shared/bundlerPlugins/HtmlAsyncChunkPlugin.js

@@ -0,0 +1,30 @@
+class HtmlAsyncChunkPlugin {
+  apply(compiler) {
+    compiler.hooks.compilation.tap(this.name, (compilation) => {
+      const hooks = this.htmlWebpackPlugin.getHooks(compilation);
+      hooks.alterAssetTagGroups.tap(this.name, (assets) => {
+        const tags = [
+          ...assets.headTags,
+          ...assets.bodyTags
+        ];
+        for (const tag of tags) {
+          if (tag.tagName === "script") {
+            const { attributes } = tag;
+            if (attributes && attributes.defer === true) {
+              attributes.async = true;
+              delete attributes.defer;
+            }
+          }
+        }
+        return assets;
+      });
+    });
+  }
+  constructor(htmlWebpackPlugin) {
+    this.name = "HtmlAsyncChunkPlugin";
+    this.htmlWebpackPlugin = htmlWebpackPlugin;
+  }
+}
+export {
+  HtmlAsyncChunkPlugin
+};

package/dist/esm-node/builder/shared/bundlerPlugins/HtmlBottomTemplate.js

@@ -0,0 +1,31 @@
+class BottomTemplatePlugin {
+  apply(compiler) {
+    compiler.hooks.compilation.tap(this.name, (compilation) => {
+      this.htmlWebpackPlugin.getHooks(compilation).beforeEmit.tap(this.name, (data) => {
+        var _data_plugin_options;
+        if (!((_data_plugin_options = data.plugin.options) === null || _data_plugin_options === void 0 ? void 0 : _data_plugin_options.__internal__)) {
+          return data;
+        }
+        if (this.bottomTemplateReg.test(data.html)) {
+          data.html = data.html.replace(this.bottomTemplateReg, "");
+          const { bottomTemplate } = data.plugin.options;
+          if (bottomTemplate) {
+            data.html = data.html.replace(this.bodyRegExp, (match) => `
+${bottomTemplate}
+${match}`);
+          }
+        }
+        return data;
+      });
+    });
+  }
+  constructor(htmlWebpackPlugin) {
+    this.bottomTemplateReg = /<!--<\?-\s*bottomTemplate\s*\?>-->/;
+    this.bodyRegExp = /(<\/\s*body\s*>)/i;
+    this.htmlWebpackPlugin = htmlWebpackPlugin;
+    this.name = "bottom-template";
+  }
+}
+export {
+  BottomTemplatePlugin
+};

package/dist/esm-node/builder/shared/bundlerPlugins/RouterPlugin.js

@@ -0,0 +1,228 @@
+import { createHash } from "crypto";
+import { ROUTE_MANIFEST_FILE } from "@modern-js/utils";
+import { merge, mergeWith } from "@modern-js/utils/lodash";
+import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
+const PLUGIN_NAME = "ModernjsRoutePlugin";
+const generateContentHash = (content) => {
+  return createHash("md5").update(content).digest("hex").slice(0, 8);
+};
+class RouterPlugin {
+  isTargetNodeOrWebWorker(target) {
+    if (target === "node" || Array.isArray(target) && target.includes("node")) {
+      return true;
+    }
+    if (target === "webworker" || Array.isArray(target) && target.includes("webworker")) {
+      return true;
+    }
+    return false;
+  }
+  getEntryChunks(compilation, chunks) {
+    const entrypointsArray = Array.from(compilation.entrypoints.entries());
+    const entryChunkIds = entrypointsArray.map((entrypoint) => entrypoint[0]);
+    const entryChunks = [
+      ...chunks
+    ].filter((chunk) => {
+      var _chunk_names;
+      return (_chunk_names = chunk.names) === null || _chunk_names === void 0 ? void 0 : _chunk_names.some((name) => entryChunkIds.includes(name));
+    });
+    return entryChunks;
+  }
+  getEntryChunkFiles(entryChunks) {
+    return entryChunks.map((chunk) => [
+      ...chunk.files || []
+    ].find((fname) => fname.includes(".js")));
+  }
+  apply(compiler) {
+    const { target } = compiler.options;
+    if (this.isTargetNodeOrWebWorker(target)) {
+      return;
+    }
+    const { webpack } = compiler;
+    const isRspack = "rspackVersion" in webpack;
+    const { Compilation, sources } = webpack;
+    const { RawSource } = sources;
+    const normalizePath = (path) => {
+      if (!path.endsWith("/")) {
+        return `${path}/`;
+      }
+      return path;
+    };
+    const chunksToHtmlName = /* @__PURE__ */ new Map();
+    const ROUTE_MANIFEST_HOLDER = `route-manifest`;
+    const placeholder = `<!--<?- ${ROUTE_MANIFEST_HOLDER} ?>-->`;
+    compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+      this.HtmlBundlerPlugin.getHooks(compilation).beforeEmit.tapAsync("RouterManifestPlugin", (data, callback) => {
+        const { outputName } = data;
+        const { chunks } = data.plugin.options;
+        chunksToHtmlName.set(chunks, outputName);
+        data.html = data.html.replace("</script>", `</script>${placeholder}`);
+        callback(null, data);
+      });
+      compilation.hooks.processAssets.tapPromise({
+        name: PLUGIN_NAME,
+        stage: Compilation.PROCESS_ASSETS_STAGE_REPORT
+      }, async () => {
+        const stats = compilation.getStats().toJson({
+          all: false,
+          publicPath: true,
+          assets: true,
+          chunkGroups: true,
+          chunks: true,
+          ids: true
+        });
+        const { publicPath, chunks = [], namedChunkGroups } = stats;
+        const routeAssets = {};
+        if (!namedChunkGroups) {
+          return;
+        }
+        const prevManifestAsset = compilation.getAsset(ROUTE_MANIFEST_FILE);
+        const prevManifestStr = prevManifestAsset ? prevManifestAsset.source.source().toString() : JSON.stringify({
+          routeAssets: {}
+        });
+        const prevManifest = JSON.parse(prevManifestStr);
+        const asyncEntryNames = [];
+        for (const [name, chunkGroup] of Object.entries(namedChunkGroups)) {
+          if (name.startsWith("async-")) {
+            asyncEntryNames.push(name);
+          }
+          const assets = chunkGroup.assets.map((asset) => {
+            const filename = asset.name;
+            return publicPath ? normalizePath(publicPath) + filename : filename;
+          });
+          const referenceCssAssets = assets.filter((asset) => /\.css$/.test(asset));
+          routeAssets[name] = {
+            chunkIds: chunkGroup.chunks,
+            assets,
+            referenceCssAssets
+          };
+          if (prevManifest.routeAssets[name]) {
+            mergeWith(routeAssets[name], prevManifest.routeAssets[name], (obj, source) => {
+              if (Array.isArray(obj)) {
+                return obj.concat(source);
+              }
+              return Object.assign(source, obj);
+            });
+          }
+        }
+        if (asyncEntryNames.length > 0) {
+          for (const asyncEntryName of asyncEntryNames) {
+            const syncEntryName = asyncEntryName.replace("async-", "");
+            const syncEntry = routeAssets[syncEntryName];
+            const asyncEntry = routeAssets[asyncEntryName];
+            merge(syncEntry, asyncEntry);
+          }
+        }
+        const manifest = {
+          routeAssets
+        };
+        const entryNames = Array.from(compilation.entrypoints.keys());
+        let entryChunks = [];
+        if (isRspack) {
+          entryChunks = this.getEntryChunks(compilation, chunks);
+        } else {
+          const orignalEntryIds = Object.keys(compilation.options.entry).map((entryName) => {
+            const chunk = compilation.namedChunks.get(entryName);
+            if (chunk) {
+              return chunk.id;
+            }
+            return entryName;
+          });
+          entryChunks = this.getEntryChunks(compilation, chunks).filter((chunk) => orignalEntryIds.includes(chunk.id));
+        }
+        const entryChunkFiles = this.getEntryChunkFiles(entryChunks);
+        const entryChunkFileIds = entryChunks.map((chunk) => chunk.id);
+        for (let i = 0; i < entryChunkFiles.length; i++) {
+          const entryName = entryNames[i];
+          const file = entryChunkFiles[i];
+          const chunkNames = entryChunks[i].names;
+          const chunkId = entryChunkFileIds[i];
+          const asset = compilation.assets[file];
+          if (!asset || !chunkId) {
+            continue;
+          }
+          let relatedAssets = {};
+          if (entryChunkFiles.length > 1) {
+            Object.keys(routeAssets).forEach((routeId) => {
+              const segments = routeId.split("_");
+              const chunkName = segments[0];
+              if (chunkNames === null || chunkNames === void 0 ? void 0 : chunkNames.includes(chunkName)) {
+                relatedAssets[routeId] = routeAssets[routeId];
+              }
+            });
+          } else {
+            relatedAssets = routeAssets;
+          }
+          const manifest2 = {
+            routeAssets: relatedAssets
+          };
+          const injectedContent = `
+            ;(function(){
+              window.${ROUTE_MANIFEST} = ${JSON.stringify(manifest2, (k, v) => {
+            if ((k === "assets" || k === "referenceCssAssets") && Array.isArray(v)) {
+              return v.map((item) => {
+                return item.replace(publicPath, "");
+              });
+            }
+            return v;
+          })};
+            })();
+          `;
+          let htmlName;
+          for (const [chunks2, name] of chunksToHtmlName.entries()) {
+            if (Array.isArray(chunkNames) && Array.isArray(chunks2) && chunkNames.every((value, index) => value === chunks2[index])) {
+              htmlName = name;
+              break;
+            }
+          }
+          const oldHtml = compilation.assets[htmlName];
+          const { enableInlineRouteManifests, disableFilenameHash, staticJsDir, scriptLoading, nonce } = this;
+          const nonceAttr = nonce ? `nonce="${nonce}"` : "";
+          if (oldHtml) {
+            if (enableInlineRouteManifests) {
+              compilation.updateAsset(
+                htmlName,
+                new RawSource(oldHtml.source().toString().replace(placeholder, `<script ${nonceAttr}>${injectedContent}</script>`)),
+                // FIXME: The arguments third of updatgeAsset is a optional function in webpack.
+                void 0
+              );
+            } else {
+              const scriptPath = `${staticJsDir}/${ROUTE_MANIFEST_HOLDER}-${entryName}${disableFilenameHash ? ".js" : `.${generateContentHash(injectedContent)}.js`}`;
+              const scriptUrl = `${publicPath}${scriptPath}`;
+              const scriptLoadingAttr = scriptLoading === "defer" ? scriptLoading : scriptLoading === "module" ? `type="module"` : "";
+              const script = `<script ${scriptLoadingAttr} ${nonceAttr} src="${scriptUrl}"></script>`;
+              compilation.updateAsset(
+                htmlName,
+                new RawSource(oldHtml.source().toString().replace(placeholder, script)),
+                // FIXME: The arguments third of updatgeAsset is a optional function in webpack.
+                void 0
+              );
+              compilation.emitAsset(scriptPath, new RawSource(injectedContent));
+            }
+          }
+        }
+        if (prevManifestAsset) {
+          compilation.updateAsset(
+            ROUTE_MANIFEST_FILE,
+            new RawSource(JSON.stringify(manifest, null, 2)),
+            // FIXME: The arguments third of updatgeAsset is a optional function in webpack.
+            void 0
+          );
+        } else {
+          compilation.emitAsset(ROUTE_MANIFEST_FILE, new RawSource(JSON.stringify(manifest, null, 2)));
+        }
+      });
+    });
+  }
+  constructor({ staticJsDir = "static/js", HtmlBundlerPlugin, enableInlineRouteManifests, disableFilenameHash = false, scriptLoading = "defer", nonce }) {
+    this.name = "RouterPlugin";
+    this.HtmlBundlerPlugin = HtmlBundlerPlugin;
+    this.enableInlineRouteManifests = enableInlineRouteManifests;
+    this.staticJsDir = staticJsDir;
+    this.disableFilenameHash = disableFilenameHash;
+    this.scriptLoading = scriptLoading;
+    this.nonce = nonce;
+  }
+}
+export {
+  RouterPlugin
+};

package/dist/esm-node/builder/shared/bundlerPlugins/index.js

@@ -0,0 +1,3 @@
+export * from "./HtmlAsyncChunkPlugin";
+export * from "./HtmlBottomTemplate";
+export * from "./RouterPlugin";

package/dist/esm-node/builder/shared/createCopyInfo.js

@@ -0,0 +1,14 @@
+import path from "path";
+function createCopyInfo(appContext, config) {
+  const configDir = path.resolve(appContext.appDirectory, config.source.configDir || "./config");
+  const uploadDir = path.posix.join(configDir.replace(/\\/g, "/"), "upload");
+  const publicDir = path.posix.join(configDir.replace(/\\/g, "/"), "public");
+  return {
+    configDir,
+    uploadDir,
+    publicDir
+  };
+}
+export {
+  createCopyInfo
+};

package/dist/esm-node/builder/shared/index.js

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./builderPlugins";
+export * from "./createCopyInfo";

package/dist/esm-node/builder/shared/loaders/serverModuleLoader.js

@@ -0,0 +1,7 @@
+function loader() {
+  return `module.exports = {}`;
+}
+var serverModuleLoader_default = loader;
+export {
+  serverModuleLoader_default as default
+};

package/dist/esm-node/commands/build.js

@@ -0,0 +1,64 @@
+import { ResolvedConfigContext } from "@modern-js/core";
+import { logger } from "@modern-js/utils";
+import { buildServerConfig } from "../utils/config";
+import { loadServerPlugins } from "../utils/loadPlugins";
+import { registerCompiler } from "../utils/register";
+import { generateRoutes } from "../utils/routes";
+const build = async (api, options) => {
+  var _resolvedConfig_source;
+  if (options === null || options === void 0 ? void 0 : options.analyze) {
+    process.env.BUNDLE_ANALYZE = "true";
+  }
+  let resolvedConfig = api.useResolvedConfigContext();
+  const appContext = api.useAppContext();
+  const hookRunners = api.useHookRunners();
+  await loadServerPlugins(api, appContext.appDirectory, appContext.metaName);
+  if (appContext.moduleType && appContext.moduleType === "module") {
+    var _resolvedConfig_source1;
+    const { registerEsm } = await import("../esm/register-esm.mjs");
+    await registerEsm({
+      appDir: appContext.appDirectory,
+      distDir: appContext.distDirectory,
+      alias: (_resolvedConfig_source1 = resolvedConfig.source) === null || _resolvedConfig_source1 === void 0 ? void 0 : _resolvedConfig_source1.alias
+    });
+  }
+  await registerCompiler(appContext.appDirectory, appContext.distDirectory, resolvedConfig === null || resolvedConfig === void 0 ? void 0 : (_resolvedConfig_source = resolvedConfig.source) === null || _resolvedConfig_source === void 0 ? void 0 : _resolvedConfig_source.alias);
+  const { apiOnly } = appContext;
+  if (apiOnly) {
+    const { appDirectory: appDirectory2, distDirectory: distDirectory2, serverConfigFile: serverConfigFile2 } = appContext;
+    await hookRunners.beforeBuild({
+      // "null" bundlerConfigs
+      bundlerConfigs: void 0
+    });
+    await buildServerConfig({
+      appDirectory: appDirectory2,
+      distDirectory: distDirectory2,
+      configFile: serverConfigFile2
+    });
+    await generateRoutes(appContext);
+    await hookRunners.afterBuild({
+      // "null" stats
+      stats: void 0
+    });
+    return;
+  }
+  resolvedConfig = {
+    ...resolvedConfig,
+    cliOptions: options
+  };
+  ResolvedConfigContext.set(resolvedConfig);
+  const { distDirectory, appDirectory, serverConfigFile } = appContext;
+  await buildServerConfig({
+    appDirectory,
+    distDirectory,
+    configFile: serverConfigFile
+  });
+  logger.info("Starting production build...");
+  if (!appContext.builder) {
+    throw new Error("Expect the Builder to have been initialized, But the appContext.builder received `undefined`");
+  }
+  await appContext.builder.build();
+};
+export {
+  build
+};

package/dist/esm-node/commands/deploy.js

@@ -0,0 +1,12 @@
+import { getServerPlugins } from "../utils/loadPlugins";
+const deploy = async (api, options) => {
+  const hookRunners = api.useHookRunners();
+  const { metaName } = api.useAppContext();
+  await getServerPlugins(api, metaName);
+  await hookRunners.beforeDeploy(options);
+  await hookRunners.deploy(options);
+  await hookRunners.afterDeploy(options);
+};
+export {
+  deploy
+};