@modern-js/app-tools 2.5.0-alpha.1 → 2.5.1-alpha.0

package/dist/js/node/initialize/index.js

@@ -59,16 +59,15 @@ __export(initialize_exports, {
 module.exports = __toCommonJS(initialize_exports);
 var import_utils = require("@modern-js/utils");
 var import_schema = require("../schema");
+var import_transformNormalizedConfig = require("../config/initial/transformNormalizedConfig");
 var import_config = require("../config");
-var initialize_default = ({
-  bundler
-}) => ({
+var initialize_default = () => ({
   name: "@modern-js/plugin-initialize",
   setup(api) {
     const config = () => {
       const appContext = api.useAppContext();
       const userConfig = api.useConfigContext();
-      return (0, import_config.checkIsLegacyConfig)(userConfig) ? (0, import_config.createLegacyDefaultConfig)(appContext) : (0, import_config.createDefaultConfig)(appContext, bundler);
+      return (0, import_config.checkIsLegacyConfig)(userConfig) ? (0, import_config.createLegacyDefaultConfig)(appContext) : (0, import_config.createDefaultConfig)(appContext);
     };
     const validateSchema = () => {
       const userConfig = api.useConfigContext();
@@ -92,42 +91,36 @@ var initialize_default = ({
             )
           });
           api.setAppContext(appContext);
-          const normalizedConfig = (0, import_config.checkIsLegacyConfig)(resolved) ? (0, import_config.transformNormalizedConfig)(resolved) : resolved;
-          resolved._raw = userConfig;
-          resolved.server = __spreadProps(__spreadValues({}, normalizedConfig.server || {}), {
-            port
-          });
-          resolved.autoLoadPlugins = normalizedConfig.autoLoadPlugins || false;
-          stabilizeConfig(resolved, normalizedConfig, [
-            "source",
-            "bff",
-            "dev",
-            "html",
-            "output",
-            "tools",
-            "testing",
-            "plugins",
-            "builderPlugins",
-            "runtime",
-            "runtimeByEntries",
-            "deploy",
-            "performance"
-          ]);
-          if (bundler === "webpack") {
-            resolved.security = normalizedConfig.security || {};
-            resolved.experiments = normalizedConfig.experiments;
-          }
-          return { resolved };
+          const normalizedConfig = (0, import_config.checkIsLegacyConfig)(resolved) ? (0, import_transformNormalizedConfig.transformNormalizedConfig)(resolved) : resolved;
+          return {
+            resolved: {
+              _raw: userConfig,
+              source: normalizedConfig.source || {},
+              server: __spreadProps(__spreadValues({}, normalizedConfig.server || {}), {
+                port
+              }),
+              bff: normalizedConfig.bff || {},
+              dev: normalizedConfig.dev || {},
+              html: normalizedConfig.html || {},
+              output: normalizedConfig.output || {},
+              security: normalizedConfig.security || {},
+              tools: normalizedConfig.tools || {},
+              testing: normalizedConfig.testing || {},
+              plugins: normalizedConfig.plugins || [],
+              builderPlugins: normalizedConfig.builderPlugins || [],
+              runtime: normalizedConfig.runtime || {},
+              runtimeByEntries: normalizedConfig.runtimeByEntries || {},
+              deploy: normalizedConfig.deploy || {},
+              performance: normalizedConfig.performance || {},
+              experiments: normalizedConfig.experiments || {},
+              autoLoadPlugins: normalizedConfig.autoLoadPlugins || false
+            }
+          };
         });
       }
     };
   }
 });
-function stabilizeConfig(resolve, config, keys) {
-  keys.forEach((key) => {
-    resolve[key] = config[key] || {};
-  });
-}
 function getServerPort(config) {
   return __async(this, null, function* () {
     const prodPort = config.server.port || 8080;

package/dist/js/node/locale/zh.js

@@ -39,7 +39,7 @@ const ZH_LOCALE = {
     serve: { describe: "应用启动命令" },
     deploy: { describe: "部署应用命令" },
     new: {
-      describe: "Web App 项目中执行生成器",
+      describe: "MWA 项目中执行生成器",
       debug: "开启 Debug 模式，打印调试日志信息",
       config: "生成器运行默认配置(JSON 字符串)",
       distTag: "生成器使用特殊的 npm Tag 版本",

package/dist/js/treeshaking/analyze/constants.js

@@ -32,9 +32,7 @@ var NESTED_ROUTE = {
     PAGE_LOADER_FILE: "page.loader",
     LOADING_FILE: "loading",
     ERROR_FILE: "error",
-    LOADER_FILE: "loader",
-    SPLATE_FILE: "$",
-    SPLATE_LOADER_FILE: "$.loader"
+    LOADER_FILE: "loader"
 };
 var APP_CONFIG_NAME = "config";
 var APP_INIT_EXPORTED = "init";

package/dist/js/treeshaking/analyze/index.js

@@ -223,17 +223,16 @@ var __generator = this && this.__generator || function(thisArg, body) {
 import * as path from "path";
 import { createDebugger, findExists, fs, getEntryOptions, isApiOnly, minimist, getCommand, isDevCommand } from "@modern-js/utils";
 import { cloneDeep } from "@modern-js/utils/lodash";
+import { createBuilderForModern } from "../builder";
 import { printInstructions } from "../utils/printInstructions";
 import { generateRoutes } from "../utils/routes";
 import { emitResolvedConfig } from "../utils/config";
 import { getSelectedEntries } from "../utils/getSelectedEntries";
 import { initialNormalizedConfig } from "../config";
-import { createBuilderGenerator } from "../builder";
 import { getServerLoadersFile, isPageComponentFile, parseModule, replaceWithAlias } from "./utils";
 import { APP_CONFIG_NAME, APP_INIT_EXPORTED, APP_INIT_IMPORTED } from "./constants";
 var debug = createDebugger("plugin-analyze");
-var analyze_default = function(param) {
-    var bundler = param.bundler;
+var analyze_default = function() {
     return {
         name: "@modern-js/plugin-analyze",
         setup: function(api) {
@@ -243,7 +242,7 @@ var analyze_default = function(param) {
             return {
                 prepare: function prepare() {
                     return _asyncToGenerator(function() {
-                        var ref, appContext, resolvedConfig, hookRunners, apiOnly, ref1, routes2, ref2, getBundleEntry, getServerRoutes, generateCode, getHtmlTemplate, entrypoints, initialRoutes, routes, htmlTemplates, checkedEntries, entry, command, buildCommands, normalizedConfig, createBuilderForModern, builder;
+                        var ref, appContext, resolvedConfig, hookRunners, apiOnly, ref1, routes2, ref2, getBundleEntry, getServerRoutes, generateCode, getHtmlTemplate, entrypoints, initialRoutes, routes, htmlTemplates, checkedEntries, entry, command, buildCommands, normalizedConfig, builder;
                         return __generator(this, function(_state) {
                             switch(_state.label){
                                 case 0:
@@ -385,153 +384,149 @@ var analyze_default = function(param) {
                                     ];
                                     if (!buildCommands.includes(command)) return [
                                         3,
-                                        14
+                                        13
                                     ];
                                     normalizedConfig = api.useResolvedConfigContext();
-                                    return [
-                                        4,
-                                        createBuilderGenerator(bundler)
-                                    ];
-                                case 12:
-                                    createBuilderForModern = _state.sent();
                                     return [
                                         4,
                                         createBuilderForModern({
                                             normalizedConfig: normalizedConfig,
                                             appContext: appContext,
-                                            onBeforeBuild: function onBeforeBuild(param) {
-                                                var bundlerConfigs = param.bundlerConfigs;
-                                                return _asyncToGenerator(function() {
-                                                    var hookRunners2;
-                                                    return __generator(this, function(_state) {
-                                                        switch(_state.label){
-                                                            case 0:
-                                                                hookRunners2 = api.useHookRunners();
-                                                                return [
-                                                                    4,
-                                                                    generateRoutes(appContext)
-                                                                ];
-                                                            case 1:
-                                                                _state.sent();
-                                                                return [
-                                                                    4,
-                                                                    hookRunners2.beforeBuild({
-                                                                        bundlerConfigs: bundlerConfigs
-                                                                    })
-                                                                ];
-                                                            case 2:
-                                                                _state.sent();
-                                                                return [
-                                                                    2
-                                                                ];
-                                                        }
-                                                    });
-                                                })();
-                                            },
-                                            onAfterBuild: function onAfterBuild(param) {
-                                                var stats = param.stats;
-                                                return _asyncToGenerator(function() {
-                                                    var hookRunners2;
-                                                    return __generator(this, function(_state) {
-                                                        switch(_state.label){
-                                                            case 0:
-                                                                hookRunners2 = api.useHookRunners();
-                                                                return [
-                                                                    4,
-                                                                    hookRunners2.afterBuild({
-                                                                        stats: stats
-                                                                    })
-                                                                ];
-                                                            case 1:
-                                                                _state.sent();
-                                                                return [
-                                                                    4,
-                                                                    emitResolvedConfig(appContext.appDirectory, normalizedConfig)
-                                                                ];
-                                                            case 2:
-                                                                _state.sent();
-                                                                return [
-                                                                    2
-                                                                ];
-                                                        }
-                                                    });
-                                                })();
-                                            },
-                                            onDevCompileDone: function onDevCompileDone(param) {
-                                                var isFirstCompile = param.isFirstCompile;
-                                                return _asyncToGenerator(function() {
-                                                    var hookRunners2;
-                                                    return __generator(this, function(_state) {
-                                                        hookRunners2 = api.useHookRunners();
-                                                        if (process.stdout.isTTY || isFirstCompile) {
-                                                            hookRunners2.afterDev();
-                                                            if (isFirstCompile) {
-                                                                printInstructions(hookRunners2, appContext, normalizedConfig);
+                                            compatPluginConfig: {
+                                                onBeforeBuild: function onBeforeBuild(param) {
+                                                    var bundlerConfigs = param.bundlerConfigs;
+                                                    return _asyncToGenerator(function() {
+                                                        var hookRunners2;
+                                                        return __generator(this, function(_state) {
+                                                            switch(_state.label){
+                                                                case 0:
+                                                                    hookRunners2 = api.useHookRunners();
+                                                                    return [
+                                                                        4,
+                                                                        generateRoutes(appContext)
+                                                                    ];
+                                                                case 1:
+                                                                    _state.sent();
+                                                                    return [
+                                                                        4,
+                                                                        hookRunners2.beforeBuild({
+                                                                            bundlerConfigs: bundlerConfigs
+                                                                        })
+                                                                    ];
+                                                                case 2:
+                                                                    _state.sent();
+                                                                    return [
+                                                                        2
+                                                                    ];
+                                                            }
+                                                        });
+                                                    })();
+                                                },
+                                                onAfterBuild: function onAfterBuild(param) {
+                                                    var stats = param.stats;
+                                                    return _asyncToGenerator(function() {
+                                                        var hookRunners2;
+                                                        return __generator(this, function(_state) {
+                                                            switch(_state.label){
+                                                                case 0:
+                                                                    hookRunners2 = api.useHookRunners();
+                                                                    return [
+                                                                        4,
+                                                                        hookRunners2.afterBuild({
+                                                                            stats: stats
+                                                                        })
+                                                                    ];
+                                                                case 1:
+                                                                    _state.sent();
+                                                                    return [
+                                                                        4,
+                                                                        emitResolvedConfig(appContext.appDirectory, normalizedConfig)
+                                                                    ];
+                                                                case 2:
+                                                                    _state.sent();
+                                                                    return [
+                                                                        2
+                                                                    ];
+                                                            }
+                                                        });
+                                                    })();
+                                                },
+                                                onDevCompileDone: function onDevCompileDone(param) {
+                                                    var isFirstCompile = param.isFirstCompile;
+                                                    return _asyncToGenerator(function() {
+                                                        var hookRunners2;
+                                                        return __generator(this, function(_state) {
+                                                            hookRunners2 = api.useHookRunners();
+                                                            if (process.stdout.isTTY || isFirstCompile) {
+                                                                hookRunners2.afterDev();
+                                                                if (isFirstCompile) {
+                                                                    printInstructions(hookRunners2, appContext, normalizedConfig);
+                                                                }
                                                             }
-                                                        }
-                                                        return [
-                                                            2
-                                                        ];
-                                                    });
-                                                })();
-                                            },
-                                            onBeforeCreateCompiler: function onBeforeCreateCompiler(param) {
-                                                var bundlerConfigs = param.bundlerConfigs;
-                                                return _asyncToGenerator(function() {
-                                                    var hookRunners2;
-                                                    return __generator(this, function(_state) {
-                                                        switch(_state.label){
-                                                            case 0:
-                                                                hookRunners2 = api.useHookRunners();
-                                                                return [
-                                                                    4,
-                                                                    hookRunners2.beforeCreateCompiler({
-                                                                        bundlerConfigs: bundlerConfigs
-                                                                    })
-                                                                ];
-                                                            case 1:
-                                                                _state.sent();
-                                                                return [
-                                                                    2
-                                                                ];
-                                                        }
-                                                    });
-                                                })();
-                                            },
-                                            onAfterCreateCompiler: function onAfterCreateCompiler(param) {
-                                                var compiler = param.compiler;
-                                                return _asyncToGenerator(function() {
-                                                    var hookRunners2;
-                                                    return __generator(this, function(_state) {
-                                                        switch(_state.label){
-                                                            case 0:
-                                                                hookRunners2 = api.useHookRunners();
-                                                                return [
-                                                                    4,
-                                                                    hookRunners2.afterCreateCompiler({
-                                                                        compiler: compiler
-                                                                    })
-                                                                ];
-                                                            case 1:
-                                                                _state.sent();
-                                                                return [
-                                                                    2
-                                                                ];
-                                                        }
-                                                    });
-                                                })();
+                                                            return [
+                                                                2
+                                                            ];
+                                                        });
+                                                    })();
+                                                },
+                                                onBeforeCreateCompiler: function onBeforeCreateCompiler(param) {
+                                                    var bundlerConfigs = param.bundlerConfigs;
+                                                    return _asyncToGenerator(function() {
+                                                        var hookRunners2;
+                                                        return __generator(this, function(_state) {
+                                                            switch(_state.label){
+                                                                case 0:
+                                                                    hookRunners2 = api.useHookRunners();
+                                                                    return [
+                                                                        4,
+                                                                        hookRunners2.beforeCreateCompiler({
+                                                                            bundlerConfigs: bundlerConfigs
+                                                                        })
+                                                                    ];
+                                                                case 1:
+                                                                    _state.sent();
+                                                                    return [
+                                                                        2
+                                                                    ];
+                                                            }
+                                                        });
+                                                    })();
+                                                },
+                                                onAfterCreateCompiler: function onAfterCreateCompiler(param) {
+                                                    var compiler = param.compiler;
+                                                    return _asyncToGenerator(function() {
+                                                        var hookRunners2;
+                                                        return __generator(this, function(_state) {
+                                                            switch(_state.label){
+                                                                case 0:
+                                                                    hookRunners2 = api.useHookRunners();
+                                                                    return [
+                                                                        4,
+                                                                        hookRunners2.afterCreateCompiler({
+                                                                            compiler: compiler
+                                                                        })
+                                                                    ];
+                                                                case 1:
+                                                                    _state.sent();
+                                                                    return [
+                                                                        2
+                                                                    ];
+                                                            }
+                                                        });
+                                                    })();
+                                                }
                                             }
                                         })
                                     ];
-                                case 13:
+                                case 12:
                                     builder = _state.sent();
                                     builder.addPlugins(resolvedConfig.builderPlugins);
                                     appContext = _objectSpreadProps(_objectSpread({}, appContext), {
                                         builder: builder
                                     });
                                     api.setAppContext(appContext);
-                                    _state.label = 14;
-                                case 14:
+                                    _state.label = 13;
+                                case 13:
                                     return [
                                         2
                                     ];
@@ -565,7 +560,7 @@ var analyze_default = function(param) {
                 resolvedConfig: function resolvedConfig(param) {
                     var resolved = param.resolved;
                     var appContext = api.useAppContext();
-                    var config = initialNormalizedConfig(resolved, appContext, bundler);
+                    var config = initialNormalizedConfig(resolved, appContext);
                     return {
                         resolved: config
                     };

package/dist/js/treeshaking/analyze/nestedRoutes.js

@@ -197,7 +197,7 @@ var createRoute = function(routeInfo, rootDir, filename, entryName) {
 };
 var walk = function() {
     var _ref = _asyncToGenerator(function(dirname, rootDir, alias, entryName) {
-        var ref, isDirectory, relativeDir, pathSegments, lastSegment, isRoot, isPathlessLayout, isWithoutLayoutPath, routePath, route, pageLoaderFile, pageRoute, splatLoaderFile, splatRoute, items, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, item, itemPath, extname, itemWithoutExt, isDirectory2, childRoute, ref1, ref2, ref3, err, finalRoute;
+        var ref, isDirectory, relativeDir, pathSegments, lastSegment, isRoot, isPathlessLayout, isWithoutLayoutPath, routePath, route, pageLoaderFile, pageRoute, items, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, item, itemPath, extname, itemWithoutExt, isDirectory2, childRoute, ref1, ref2, err, finalRoute;
         return __generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -242,8 +242,6 @@ var walk = function() {
                     };
                     pageLoaderFile = "";
                     pageRoute = null;
-                    splatLoaderFile = "";
-                    splatRoute = null;
                     return [
                         4,
                         fs.readdir(dirname)
@@ -319,20 +317,6 @@ var walk = function() {
                         }
                         (ref2 = route.children) === null || ref2 === void 0 ? void 0 : ref2.push(pageRoute);
                     }
-                    if (itemWithoutExt === NESTED_ROUTE.SPLATE_LOADER_FILE) {
-                        splatLoaderFile = itemPath;
-                    }
-                    if (itemWithoutExt === NESTED_ROUTE.SPLATE_FILE) {
-                        ;
-                        splatRoute = createRoute({
-                            _component: replaceWithAlias(alias.basename, itemPath, alias.name),
-                            path: "*"
-                        }, rootDir, itemPath, entryName);
-                        if (splatLoaderFile) {
-                            splatRoute.loader = splatLoaderFile;
-                        }
-                        (ref3 = route.children) === null || ref3 === void 0 ? void 0 : ref3.push(splatRoute);
-                    }
                     if (itemWithoutExt === NESTED_ROUTE.LOADING_FILE) {
                         route.loading = replaceWithAlias(alias.basename, itemPath, alias.name);
                     }

package/dist/js/treeshaking/analyze/templates.js

@@ -296,7 +296,7 @@ var routesForServer = function(param) {
 };
 var fileSystemRoutes = function() {
     var _ref = _asyncToGenerator(function(param) {
-        var routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, loadings, errors, loaders, loadersMap, loadersMapFile, importLazyCode, rootLayoutCode, getDataLoaderPath, traverseRouteTree, routeComponentsCode, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, route, newRoute, component, finalRoute, importLoadingCode, importErrorComponentsCode, importLoadersCode, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, _value, key, loaderInfo;
+        var routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, loadings, errors, loaders, loadersMap, loadersMapFile, importLazyCode, rootLayoutCode, componentLoaderPath, getDataLoaderPath, traverseRouteTree, routeComponentsCode, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, route, newRoute, component, finalRoute, importLoadingCode, importErrorComponentsCode, importLoadersCode, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, _value, key, loaderInfo;
         return __generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -308,6 +308,7 @@ var fileSystemRoutes = function() {
                     loadersMapFile = path.join(internalDirectory, entryName, TEMP_LOADERS_DIR, "map.json");
                     importLazyCode = '\n    import { lazy } from "react";\n    import loadable, { lazy as loadableLazy } from "@modern-js/runtime/loadable"\n  ';
                     rootLayoutCode = "";
+                    componentLoaderPath = "";
                     getDataLoaderPath = function(loaderId) {
                         if (!ssrMode) {
                             return "";
@@ -318,6 +319,9 @@ var fileSystemRoutes = function() {
                         }
                         return dataLoaderPath;
                     };
+                    if (ssrMode) {
+                        componentLoaderPath = "".concat(path.join(__dirname, "../builder/loaders/routerLoader"), "!");
+                    }
                     traverseRouteTree = function(route) {
                         var children;
                         if ("children" in route && route.children) {
@@ -353,10 +357,10 @@ var fileSystemRoutes = function() {
                                     rootLayoutCode = "import RootLayout from '".concat(route._component, "'");
                                     component = "RootLayout";
                                 } else if (ssrMode === "string") {
-                                    lazyImport = '() => import(/* webpackChunkName: "'.concat(route.id, "\" */  '").concat(route._component, "')");
+                                    lazyImport = '() => import(/* webpackChunkName: "'.concat(route.id, "\" */  '").concat(componentLoaderPath).concat(route._component, "')");
                                     component = "loadable(".concat(lazyImport, ")");
                                 } else {
-                                    lazyImport = '() => import(/* webpackChunkName: "'.concat(route.id, "\" */  '").concat(route._component, "')");
+                                    lazyImport = '() => import(/* webpackChunkName: "'.concat(route.id, "\" */  '").concat(componentLoaderPath).concat(route._component, "')");
                                     component = "lazy(".concat(lazyImport, ")");
                                 }
                             }