@modern-js/app-tools 2.3.1-alpha.2 → 2.5.0-alpha.0

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

@@ -223,16 +223,17 @@ 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() {
+var analyze_default = function(param) {
+    var bundler = param.bundler;
     return {
         name: "@modern-js/plugin-analyze",
         setup: function(api) {
@@ -242,7 +243,7 @@ var analyze_default = function() {
             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, builder;
+                        var ref, appContext, resolvedConfig, hookRunners, apiOnly, ref1, routes2, ref2, getBundleEntry, getServerRoutes, generateCode, getHtmlTemplate, entrypoints, initialRoutes, routes, htmlTemplates, checkedEntries, entry, command, buildCommands, normalizedConfig, createBuilderForModern, builder;
                         return __generator(this, function(_state) {
                             switch(_state.label){
                                 case 0:
@@ -384,149 +385,153 @@ var analyze_default = function() {
                                     ];
                                     if (!buildCommands.includes(command)) return [
                                         3,
-                                        13
+                                        14
                                     ];
                                     normalizedConfig = api.useResolvedConfigContext();
+                                    return [
+                                        4,
+                                        createBuilderGenerator(bundler)
+                                    ];
+                                case 12:
+                                    createBuilderForModern = _state.sent();
                                     return [
                                         4,
                                         createBuilderForModern({
                                             normalizedConfig: normalizedConfig,
                                             appContext: appContext,
-                                            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);
-                                                                }
+                                            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 12:
+                                case 13:
                                     builder = _state.sent();
                                     builder.addPlugins(resolvedConfig.builderPlugins);
                                     appContext = _objectSpreadProps(_objectSpread({}, appContext), {
                                         builder: builder
                                     });
                                     api.setAppContext(appContext);
-                                    _state.label = 13;
-                                case 13:
+                                    _state.label = 14;
+                                case 14:
                                     return [
                                         2
                                     ];
@@ -560,7 +565,7 @@ var analyze_default = function() {
                 resolvedConfig: function resolvedConfig(param) {
                     var resolved = param.resolved;
                     var appContext = api.useAppContext();
-                    var config = initialNormalizedConfig(resolved, appContext);
+                    var config = initialNormalizedConfig(resolved, appContext, bundler);
                     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, childRoute1, path2;
+        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;
         return __generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -386,15 +386,6 @@ var walk = function() {
                             null
                         ];
                     }
-                    if (finalRoute.children && finalRoute.children.length === 1 && !finalRoute._component) {
-                        childRoute1 = finalRoute.children[0];
-                        if (childRoute1.path === "*") {
-                            path2 = "".concat(finalRoute.path || "", "/").concat(childRoute1.path || "");
-                            finalRoute = _objectSpreadProps(_objectSpread({}, childRoute1), {
-                                path: path2
-                            });
-                        }
-                    }
                     return [
                         2,
                         finalRoute

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

@@ -0,0 +1,6 @@
+import { builderRspackProvider } from "@modern-js/builder-rspack-provider";
+import { generateBuilder } from "../generator";
+function createRspackBuilderForModern(options) {
+    return generateBuilder(options, builderRspackProvider);
+}
+export { createRspackBuilderForModern };

package/dist/js/treeshaking/builder/builder-webpack/builderPlugins/compatModern.js

@@ -0,0 +1,64 @@
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+import { join } from "path";
+import { createCopyPattern } from "../../shared";
+import { RouterPlugin } from "../webpackPlugins";
+var PluginCompatModern = function(options) {
+    return {
+        name: "builder-plugin-compat-modern",
+        setup: function setup(api) {
+            var modernConfig = options.normalizedConfig, appContext = options.appContext;
+            api.modifyWebpackChain(function(chain, param) {
+                var CHAIN_ID = param.CHAIN_ID;
+                var ref;
+                chain.resolve.modules.add("node_modules").add(join(api.context.rootPath, "node_modules"));
+                if (chain.plugins.has(CHAIN_ID.PLUGIN.COPY)) {
+                    var defaultCopyPattern = createCopyPattern(appContext, modernConfig, "public", chain);
+                    chain.plugin(CHAIN_ID.PLUGIN.COPY).tap(function(args) {
+                        var ref;
+                        return [
+                            {
+                                patterns: _toConsumableArray(((ref = args[0]) === null || ref === void 0 ? void 0 : ref.patterns) || []).concat([
+                                    defaultCopyPattern
+                                ])
+                            }
+                        ];
+                    });
+                }
+                var entrypoints = appContext.entrypoints;
+                var existNestedRoutes = entrypoints.some(function(entrypoint) {
+                    return entrypoint.nestedRoutesEntry;
+                });
+                var routerConfig = modernConfig === null || modernConfig === void 0 ? void 0 : (ref = modernConfig.runtime) === null || ref === void 0 ? void 0 : ref.router;
+                var routerManifest = Boolean(routerConfig === null || routerConfig === void 0 ? void 0 : routerConfig.manifest);
+                if (existNestedRoutes || routerManifest) {
+                    chain.plugin("route-plugin").use(RouterPlugin);
+                }
+            });
+        }
+    };
+};
+export { PluginCompatModern };