@modern-js/app-tools 2.9.0 → 2.10.1-alpha.0

package/dist/esm/builder/builder-rspack/index.js

@@ -1,6 +1,174 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+var __generator = this && this.__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
 import { builderRspackProvider } from "@modern-js/builder-rspack-provider";
 import { generateBuilder } from "../generator";
 function createRspackBuilderForModern(options) {
-    return generateBuilder(options, builderRspackProvider);
+    return generateBuilder(options, builderRspackProvider, {
+        modifyBuilderInstance: function modifyBuilderInstance(builder) {
+            return _asyncToGenerator(function() {
+                return __generator(this, function(_state) {
+                    applyBuilderPlugins(builder, options);
+                    return [
+                        2
+                    ];
+                });
+            })();
+        }
+    });
+}
+function applyBuilderPlugins(builder, options) {
+    return _applyBuilderPlugins.apply(this, arguments);
+}
+function _applyBuilderPlugins() {
+    _applyBuilderPlugins = _asyncToGenerator(function(builder, options) {
+        var normalizedConfig, builderPluginNodePolyfill;
+        return __generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    normalizedConfig = options.normalizedConfig;
+                    if (!!normalizedConfig.output.disableNodePolyfill) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        import("@modern-js/builder-plugin-node-polyfill")
+                    ];
+                case 1:
+                    builderPluginNodePolyfill = _state.sent().builderPluginNodePolyfill;
+                    builder.addPlugins([
+                        builderPluginNodePolyfill()
+                    ]);
+                    _state.label = 2;
+                case 2:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _applyBuilderPlugins.apply(this, arguments);
 }
 export { createRspackBuilderForModern };

package/dist/esm/builder/index.js

@@ -123,26 +123,27 @@ var __generator = this && this.__generator || function(thisArg, body) {
     }
 };
 import { logger } from "@modern-js/utils";
+import { getRspackVersion } from "@modern-js/builder-rspack-provider";
 function createBuilderGenerator(bundler) {
     return _createBuilderGenerator.apply(this, arguments);
 }
 function _createBuilderGenerator() {
     _createBuilderGenerator = _asyncToGenerator(function(bundler) {
-        var createRspackBuilderForModern, _, createWebpackBuilderForModern;
+        var createRspackBuilderForModern, version, _, createWebpackBuilderForModern;
         return __generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     if (!(bundler === "rspack")) return [
                         3,
-                        4
+                        5
                     ];
                     _state.label = 1;
                 case 1:
                     _state.trys.push([
                         1,
-                        3,
+                        4,
                         ,
-                        4
+                        5
                     ]);
                     return [
                         4,
@@ -150,20 +151,26 @@ function _createBuilderGenerator() {
                     ];
                 case 2:
                     createRspackBuilderForModern = _state.sent().createRspackBuilderForModern;
-                    logger.info("Using Rspack ✨");
+                    return [
+                        4,
+                        getRspackVersion()
+                    ];
+                case 3:
+                    version = _state.sent();
+                    logger.info("Using Rspack v".concat(version, " \uD83E\uDD80"));
                     return [
                         2,
                         createRspackBuilderForModern
                     ];
-                case 3:
+                case 4:
                     _ = _state.sent();
                     throw new Error("Failed to use Rspack, please check if you have `@modern-js/builder-rspack-provider` installed");
-                case 4:
+                case 5:
                     return [
                         4,
                         import("./builder-webpack")
                     ];
-                case 5:
+                case 6:
                     createWebpackBuilderForModern = _state.sent().createWebpackBuilderForModern;
                     return [
                         2,

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

@@ -123,7 +123,7 @@ var __generator = this && this.__generator || function(thisArg, body) {
     }
 };
 import { mergeBuilderConfig } from "@modern-js/builder-shared";
-import { fs } from "@modern-js/utils";
+import { isSSR, fs } from "@modern-js/utils";
 import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins";
 import { getServerCombinedModueFile } from "../../../analyze/utils";
 import { isHtmlEnabled } from "./adapterHtml";
@@ -144,12 +144,17 @@ var builderPluginAdapterSSR = function(options) {
             });
             api.modifyBundlerChain(function() {
                 var _ref = _asyncToGenerator(function(chain, param) {
-                    var target, CHAIN_ID, isProd, HtmlBundlerPlugin, isServer, builderConfig;
+                    var target, CHAIN_ID, isProd, HtmlBundlerPlugin, isServer, builderConfig, normalizedConfig2;
                     return __generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
                                 target = param.target, CHAIN_ID = param.CHAIN_ID, isProd = param.isProd, HtmlBundlerPlugin = param.HtmlPlugin, isServer = param.isServer;
                                 builderConfig = api.getNormalizedConfig();
+                                normalizedConfig2 = options.normalizedConfig;
+                                if (!isSSR(normalizedConfig2)) return [
+                                    3,
+                                    2
+                                ];
                                 applyRouterPlugin(chain, options);
                                 return [
                                     4,
@@ -157,6 +162,8 @@ var builderPluginAdapterSSR = function(options) {
                                 ];
                             case 1:
                                 _state.sent();
+                                _state.label = 2;
+                            case 2:
                                 if ([
                                     "node",
                                     "service-worker"
@@ -164,7 +171,7 @@ var builderPluginAdapterSSR = function(options) {
                                     applyFilterEntriesBySSRConfig({
                                         isProd: isProd,
                                         chain: chain,
-                                        appNormalizedConfig: options.normalizedConfig
+                                        appNormalizedConfig: normalizedConfig2
                                     });
                                 }
                                 if (isHtmlEnabled(builderConfig, target)) {

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

@@ -200,7 +200,9 @@ var __generator = this && this.__generator || function(thisArg, body) {
     }
 };
 import path from "path";
-import { fs, ROUTE_MANIFEST, logger, ROUTE_MINIFEST_FILE } from "@modern-js/utils";
+import { fs, logger } from "@modern-js/utils";
+import { ROUTE_MANIFEST_FILE } from "@modern-js/utils/constants";
+import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
 var PLUGIN_NAME = "ModernjsRoutePlugin";
 var RouterPlugin = /*#__PURE__*/ function() {
     "use strict";
@@ -240,8 +242,12 @@ var RouterPlugin = /*#__PURE__*/ function() {
                             switch(_state.label){
                                 case 0:
                                     stats = compilation.getStats().toJson({
+                                        all: false,
+                                        publicPath: true,
+                                        assets: true,
                                         chunkGroups: true,
-                                        chunks: true
+                                        chunks: true,
+                                        ids: true
                                     });
                                     publicPath = stats.publicPath, _stats_chunks = stats.chunks, chunks = _stats_chunks === void 0 ? [] : _stats_chunks;
                                     routeAssets = {};
@@ -282,7 +288,12 @@ var RouterPlugin = /*#__PURE__*/ function() {
                                     manifest = {
                                         routeAssets: routeAssets
                                     };
-                                    injectedContent = "\n            ;(function(){\n              window.".concat(ROUTE_MANIFEST, " = ").concat(JSON.stringify(manifest), ";\n            })();\n          ");
+                                    injectedContent = "\n            ;(function(){\n              window.".concat(ROUTE_MANIFEST, " = ").concat(JSON.stringify(manifest, function(k, v) {
+                                        if (k === "assets") {
+                                            return void 0;
+                                        }
+                                        return v;
+                                    }), ";\n            })();\n          ");
                                     entrypointsArray = Array.from(compilation.entrypoints.entries());
                                     entryChunkIds = entrypointsArray.map(function(entrypoint) {
                                         return entrypoint[0];
@@ -325,7 +336,7 @@ var RouterPlugin = /*#__PURE__*/ function() {
                                             }
                                         }
                                     }
-                                    filename = path.join(outputPath, ROUTE_MINIFEST_FILE);
+                                    filename = path.join(outputPath, ROUTE_MANIFEST_FILE);
                                     return [
                                         4,
                                         fs.ensureFile(filename)

package/dist/esm/commands/serve.js

@@ -27,6 +27,58 @@ function _asyncToGenerator(fn) {
         });
     };
 }
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 var __generator = this && this.__generator || function(thisArg, body) {
     var f, y, t, g, _ = {
         label: 0,
@@ -129,7 +181,7 @@ import { injectDataLoaderPlugin } from "../utils/createServer";
 import { getServerInternalPlugins } from "../utils/getServerInternalPlugins";
 var start = function() {
     var _ref = _asyncToGenerator(function(api) {
-        var _userConfig_source, appContext, userConfig, hookRunners, appDirectory, port, serverConfigFile, apiOnly, serverInternalPlugins, app;
+        var _userConfig_source, _userConfig_output_distPath, appContext, userConfig, hookRunners, appDirectory, port, serverConfigFile, apiOnly, serverInternalPlugins, app;
         return __generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -154,7 +206,12 @@ var start = function() {
                         4,
                         server({
                             pwd: appDirectory,
-                            config: userConfig,
+                            config: _objectSpreadProps(_objectSpread({}, userConfig), {
+                                dev: userConfig.dev,
+                                output: _objectSpread({
+                                    path: (_userConfig_output_distPath = userConfig.output.distPath) === null || _userConfig_output_distPath === void 0 ? void 0 : _userConfig_output_distPath.root
+                                }, userConfig.output || {})
+                            }),
                             appContext: {
                                 sharedDirectory: getTargetDir(appContext.sharedDirectory, appContext.appDirectory, appContext.distDirectory),
                                 apiDirectory: getTargetDir(appContext.apiDirectory, appContext.appDirectory, appContext.distDirectory),

package/dist/esm-node/analyze/generateCode.js

@@ -81,6 +81,7 @@ const generateCode = async (appContext, config, entrypoints, api) => {
   const getRoutes = isV5 ? getClientRoutesLegacy : getClientRoutes;
   await Promise.all(entrypoints.map(generateEntryCode));
   async function generateEntryCode(entrypoint) {
+    var _a;
     const { entryName, isAutoMount, customBootstrap, fileSystemRoutes } = entrypoint;
     if (isAutoMount) {
       if (fileSystemRoutes) {
@@ -143,7 +144,8 @@ const generateCode = async (appContext, config, entrypoints, api) => {
             ssrMode: useSSG ? "string" : mode,
             nestedRoutesEntry: entrypoint.nestedRoutesEntry,
             entryName: entrypoint.entryName,
-            internalDirectory
+            internalDirectory,
+            splitRouteChunks: (_a = config2 == null ? void 0 : config2.output) == null ? void 0 : _a.splitRouteChunks
           })
         });
         if (entrypoint.nestedRoutesEntry && isUseSSRBundle(config2)) {

package/dist/esm-node/analyze/index.js

@@ -227,6 +227,14 @@ var analyze_default = ({
           imports
         };
       },
+      validateSchema() {
+        return {
+          target: "output.splitRouteChunks",
+          schema: {
+            type: "boolean"
+          }
+        };
+      },
       async fileChange(e) {
         const appContext = api.useAppContext();
         const { appDirectory } = appContext;

package/dist/esm-node/analyze/templates.js

@@ -139,13 +139,16 @@ const routesForServer = ({
     ${routesCode}
   `;
 };
+const createMatchReg = (keyword) => new RegExp(`("${keyword}":\\s)"([^,]+)"`, "g");
 const fileSystemRoutes = async ({
   routes,
   ssrMode,
   nestedRoutesEntry,
   entryName,
-  internalDirectory
+  internalDirectory,
+  splitRouteChunks = true
 }) => {
+  const components = [];
   const loadings = [];
   const errors = [];
   const loaders = [];
@@ -204,20 +207,30 @@ const fileSystemRoutes = async ({
         };
       }
       if (route._component) {
-        if (route.isRoot) {
-          rootLayoutCode = `import RootLayout from '${route._component}'`;
-          component = `RootLayout`;
-        } else if (ssrMode === "string") {
-          lazyImport = `() => import(/* webpackChunkName: "${route.id}" */  '${route._component}')`;
-          component = `loadable(${lazyImport})`;
+        if (splitRouteChunks) {
+          if (route.isRoot) {
+            rootLayoutCode = `import RootLayout from '${route._component}'`;
+            component = `RootLayout`;
+          } else if (ssrMode === "string") {
+            lazyImport = `() => import(/* webpackChunkName: "${route.id}" */  '${route._component}')`;
+            component = `loadable(${lazyImport})`;
+          } else {
+            lazyImport = `() => import(/* webpackChunkName: "${route.id}" */  '${route._component}')`;
+            component = `lazy(${lazyImport})`;
+          }
         } else {
-          lazyImport = `() => import(/* webpackChunkName: "${route.id}" */  '${route._component}')`;
-          component = `lazy(${lazyImport})`;
+          components.push(route._component);
+          component = `component_${components.length - 1}`;
         }
       }
     } else if (route._component) {
-      lazyImport = `() => import('${route._component}')`;
-      component = `loadable(${lazyImport})`;
+      if (splitRouteChunks) {
+        lazyImport = `() => import('${route._component}')`;
+        component = `loadable(${lazyImport})`;
+      } else {
+        components.push(route._component);
+        component = `component_${components.length - 1}`;
+      }
     }
     const finalRoute = {
       ...route,
@@ -238,20 +251,38 @@ const fileSystemRoutes = async ({
   for (const route of routes) {
     if ("type" in route) {
       const newRoute = traverseRouteTree(route);
-      routeComponentsCode += `${JSON.stringify(newRoute, null, 2).replace(/"(loadable.*\))"/g, "$1").replace(/"(loadableLazy.*\))"/g, "$1").replace(/"(\(\)[^,]+)",/g, "$1,").replace(/"(lazy\(.*\))"/g, "$1").replace(/"(loading_[^"]+)"/g, "$1").replace(/"(loader_[^"]+)"/g, "$1").replace(/"(RootLayout)"/g, "$1").replace(/"(error_[^"]+)"/g, "$1").replace(/\\"/g, '"')},`;
+      const routeStr = JSON.stringify(newRoute, null, 2);
+      const keywords = [
+        "component",
+        "lazyImport",
+        "loader",
+        "loading",
+        "error"
+      ];
+      const regs = keywords.map(createMatchReg);
+      const newRouteStr = regs.reduce((acc, reg) => acc.replace(reg, "$1$2"), routeStr).replace(/"(RootLayout)"/g, "$1").replace(/\\"/g, '"');
+      routeComponentsCode += `${newRouteStr},`;
     } else {
       const component = `loadable(() => import('${route._component}'))`;
       const finalRoute = {
         ...route,
         component
       };
-      routeComponentsCode += `${JSON.stringify(finalRoute, null, 2).replace(/"(loadable[^"]*)"/g, "$1").replace(/"(lazy[^"]*)"/g, "$1")},`;
+      const keywords = ["component", "lazyImport"];
+      const routeStr = JSON.stringify(finalRoute, null, 2);
+      const regs = keywords.map(createMatchReg);
+      const newRouteStr = regs.reduce((acc, reg) => acc.replace(reg, "$1$2"), routeStr).replace(/\\"/g, '"');
+      routeComponentsCode += `${newRouteStr},`;
     }
   }
   routeComponentsCode += `
 ];`;
   const importLoadingCode = loadings.map((loading, index2) => {
     return `import loading_${index2} from '${loading}';
+`;
+  }).join("");
+  const importComponentsCode = components.map((component, index2) => {
+    return `import component_${index2} from '${component}';
 `;
   }).join("");
   const importErrorComponentsCode = errors.map((error, index2) => {
@@ -276,6 +307,7 @@ const fileSystemRoutes = async ({
   await fs.writeJSON(loadersMapFile, loadersMap);
   return `
     ${importLazyCode}
+    ${importComponentsCode}
     ${rootLayoutCode}
     ${importLoadingCode}
     ${importErrorComponentsCode}

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

@@ -1,7 +1,18 @@
 import { builderRspackProvider } from "@modern-js/builder-rspack-provider";
 import { generateBuilder } from "../generator";
 function createRspackBuilderForModern(options) {
-  return generateBuilder(options, builderRspackProvider);
+  return generateBuilder(options, builderRspackProvider, {
+    async modifyBuilderInstance(builder) {
+      applyBuilderPlugins(builder, options);
+    }
+  });
+}
+async function applyBuilderPlugins(builder, options) {
+  const { normalizedConfig } = options;
+  if (!normalizedConfig.output.disableNodePolyfill) {
+    const { builderPluginNodePolyfill } = await import("@modern-js/builder-plugin-node-polyfill");
+    builder.addPlugins([builderPluginNodePolyfill()]);
+  }
 }
 export {
   createRspackBuilderForModern

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

@@ -1,9 +1,11 @@
 import { logger } from "@modern-js/utils";
+import { getRspackVersion } from "@modern-js/builder-rspack-provider";
 async function createBuilderGenerator(bundler) {
   if (bundler === "rspack") {
     try {
       const { createRspackBuilderForModern } = await import("./builder-rspack");
-      logger.info("Using Rspack ✨");
+      const version = await getRspackVersion();
+      logger.info(`Using Rspack v${version} 🦀`);
       return createRspackBuilderForModern;
     } catch (_) {
       throw new Error(

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

@@ -1,7 +1,7 @@
 import {
   mergeBuilderConfig
 } from "@modern-js/builder-shared";
-import { fs } from "@modern-js/utils";
+import { isSSR, fs } from "@modern-js/utils";
 import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins";
 import { getServerCombinedModueFile } from "../../../analyze/utils";
 import { isHtmlEnabled } from "./adapterHtml";
@@ -22,13 +22,16 @@ const builderPluginAdapterSSR = (options) => ({
     api.modifyBundlerChain(
       async (chain, { target, CHAIN_ID, isProd, HtmlPlugin: HtmlBundlerPlugin, isServer }) => {
         const builderConfig = api.getNormalizedConfig();
-        applyRouterPlugin(chain, options);
-        await applySSRLoaderEntry(chain, options, isServer);
+        const { normalizedConfig: normalizedConfig2 } = options;
+        if (isSSR(normalizedConfig2)) {
+          applyRouterPlugin(chain, options);
+          await applySSRLoaderEntry(chain, options, isServer);
+        }
         if (["node", "service-worker"].includes(target)) {
           applyFilterEntriesBySSRConfig({
             isProd,
             chain,
-            appNormalizedConfig: options.normalizedConfig
+            appNormalizedConfig: normalizedConfig2
           });
         }
         if (isHtmlEnabled(builderConfig, target)) {

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

@@ -1,10 +1,7 @@
 import path from "path";
-import {
-  fs,
-  ROUTE_MANIFEST,
-  logger,
-  ROUTE_MINIFEST_FILE
-} from "@modern-js/utils";
+import { fs, logger } from "@modern-js/utils";
+import { ROUTE_MANIFEST_FILE } from "@modern-js/utils/constants";
+import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
 const PLUGIN_NAME = "ModernjsRoutePlugin";
 class RouterPlugin {
   apply(compiler) {
@@ -35,8 +32,12 @@ class RouterPlugin {
         },
         async () => {
           const stats = compilation.getStats().toJson({
+            all: false,
+            publicPath: true,
+            assets: true,
             chunkGroups: true,
-            chunks: true
+            chunks: true,
+            ids: true
           });
           const { publicPath, chunks = [] } = stats;
           const routeAssets = {};
@@ -62,7 +63,12 @@ class RouterPlugin {
           };
           const injectedContent = `
             ;(function(){
-              window.${ROUTE_MANIFEST} = ${JSON.stringify(manifest)};
+              window.${ROUTE_MANIFEST} = ${JSON.stringify(manifest, (k, v) => {
+            if (k === "assets") {
+              return void 0;
+            }
+            return v;
+          })};
             })();
           `;
           const entrypointsArray = Array.from(
@@ -92,7 +98,7 @@ class RouterPlugin {
               void 0
             );
           }
-          const filename = path.join(outputPath, ROUTE_MINIFEST_FILE);
+          const filename = path.join(outputPath, ROUTE_MANIFEST_FILE);
           await fs.ensureFile(filename);
           await fs.writeFile(filename, JSON.stringify(manifest, null, 2));
         }