@modern-js/app-tools 2.21.1 → 2.22.1

package/dist/cjs/utils/createServer.js

@@ -10,11 +10,21 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-  getServer: () => getServer,
-  setServer: () => setServer,
-  closeServer: () => closeServer,
-  createServer: () => createServer,
-  injectDataLoaderPlugin: () => injectDataLoaderPlugin
+  getServer: function() {
+    return getServer;
+  },
+  setServer: function() {
+    return setServer;
+  },
+  closeServer: function() {
+    return closeServer;
+  },
+  createServer: function() {
+    return createServer;
+  },
+  injectDataLoaderPlugin: function() {
+    return injectDataLoaderPlugin;
+  }
 });
 const _server = require("@modern-js/server");
 let server = null;

package/dist/cjs/utils/env.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "getAutoInjectEnv", {
   enumerable: true,
-  get: () => getAutoInjectEnv
+  get: function() {
+    return getAutoInjectEnv;
+  }
 });
 function getAutoInjectEnv(appContext) {
   const { metaName } = appContext;

package/dist/cjs/utils/generateWatchFiles.js

@@ -10,8 +10,12 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-  addServerConfigToDeps: () => addServerConfigToDeps,
-  generateWatchFiles: () => generateWatchFiles
+  addServerConfigToDeps: function() {
+    return addServerConfigToDeps;
+  },
+  generateWatchFiles: function() {
+    return generateWatchFiles;
+  }
 });
 const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
 const _path = /* @__PURE__ */ _interop_require_default._(require("path"));

package/dist/cjs/utils/getSelectedEntries.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "getSelectedEntries", {
   enumerable: true,
-  get: () => getSelectedEntries
+  get: function() {
+    return getSelectedEntries;
+  }
 });
 const _utils = require("@modern-js/utils");
 const _locale = require("../locale");

package/dist/cjs/utils/getServerInternalPlugins.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "getServerInternalPlugins", {
   enumerable: true,
-  get: () => getServerInternalPlugins
+  get: function() {
+    return getServerInternalPlugins;
+  }
 });
 async function getServerInternalPlugins(api) {
   const hookRunners = api.useHookRunners();

package/dist/cjs/utils/printInstructions.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "printInstructions", {
   enumerable: true,
-  get: () => printInstructions
+  get: function() {
+    return printInstructions;
+  }
 });
 const _utils = require("@modern-js/utils");
 const printInstructions = async (hookRunners, appContext, config) => {

package/dist/cjs/utils/restart.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "restart", {
   enumerable: true,
-  get: () => restart
+  get: function() {
+    return restart;
+  }
 });
 const _core = require("@modern-js/core");
 const _utils = require("@modern-js/utils");

package/dist/cjs/utils/routes.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "generateRoutes", {
   enumerable: true,
-  get: () => generateRoutes
+  get: function() {
+    return generateRoutes;
+  }
 });
 const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
 const _path = /* @__PURE__ */ _interop_require_default._(require("path"));

package/dist/esm/analyze/generateCode.js

@@ -94,21 +94,21 @@ export var createImportStatements = function(statements) {
 };
 export var generateCode = function() {
   var _ref = _async_to_generator(function(appContext, config, entrypoints, api) {
-    var internalDirectory, srcDirectory, internalDirAlias, internalSrcAlias, packageName, hookRunners, isV5, mountId, getRoutes;
+    var internalDirectory, srcDirectory, internalDirAlias, internalSrcAlias, packageName, hookRunners, isV5, getRoutes, importsStatemets;
     function generateEntryCode(entrypoint) {
       return _generateEntryCode.apply(this, arguments);
     }
     function _generateEntryCode() {
       _generateEntryCode = _async_to_generator(function(entrypoint) {
-        var entryName, isAutoMount, customBootstrap, fileSystemRoutes, _config_output, initialRoutes, nestedRoute, routes, _$config, ssr, useSSG, mode, hasPageRoute, code, _, _tmp, routesServerFile, code1, serverLoaderCombined, serverLoaderFile, _ref2, importStatements, plugins, _ref1, renderFunction, exportStatement, code2, entryFile, rawAsyncEntryCode, ssr1, _ref22, asyncEntryCode, bootstrapFile;
+        var entryName, isAutoMount, fileSystemRoutes, _config_output, initialRoutes, nestedRoute, routes, _$config, ssr, useSSG, mode, hasPageRoute, code, _, _tmp, routesServerFile, code1, serverLoaderCombined, serverLoaderFile, imports, entryFile;
         return _ts_generator(this, function(_state) {
           switch (_state.label) {
             case 0:
-              entryName = entrypoint.entryName, isAutoMount = entrypoint.isAutoMount, customBootstrap = entrypoint.customBootstrap, fileSystemRoutes = entrypoint.fileSystemRoutes;
+              entryName = entrypoint.entryName, isAutoMount = entrypoint.isAutoMount, fileSystemRoutes = entrypoint.fileSystemRoutes;
               if (!isAutoMount)
                 return [
                   3,
-                  18
+                  13
                 ];
               if (!fileSystemRoutes)
                 return [
@@ -248,76 +248,12 @@ export var generateCode = function() {
                 })
               ];
             case 12:
-              _ref2 = _state.sent(), importStatements = _ref2.imports;
-              return [
-                4,
-                hookRunners.modifyEntryRuntimePlugins({
-                  entrypoint: entrypoint,
-                  plugins: []
-                })
-              ];
-            case 13:
-              plugins = _state.sent().plugins;
-              return [
-                4,
-                hookRunners.modifyEntryRenderFunction({
-                  entrypoint: entrypoint,
-                  code: templates.renderFunction({
-                    plugins: plugins,
-                    customBootstrap: customBootstrap,
-                    fileSystemRoutes: fileSystemRoutes
-                  })
-                })
-              ];
-            case 14:
-              _ref1 = _state.sent(), renderFunction = _ref1.code;
-              return [
-                4,
-                hookRunners.modifyEntryExport({
-                  entrypoint: entrypoint,
-                  exportStatement: "export default AppWrapper;"
-                })
-              ];
-            case 15:
-              exportStatement = _state.sent().exportStatement;
-              code2 = templates.index({
-                mountId: mountId,
-                imports: createImportStatements(importStatements),
-                renderFunction: renderFunction,
-                exportStatement: exportStatement
-              });
+              imports = _state.sent().imports;
+              importsStatemets.set(entryName, imports);
               entryFile = path.resolve(internalDirectory, "./".concat(entryName, "/").concat(ENTRY_POINT_FILE_NAME));
-              entrypoint.entry = entryFile;
-              if (!config.source.enableAsyncEntry)
-                return [
-                  3,
-                  17
-                ];
-              rawAsyncEntryCode = "import('./".concat(ENTRY_BOOTSTRAP_FILE_NAME, "');");
-              ssr1 = getEntryOptions(entryName, config.server.ssr, config.server.ssrByEntries, packageName);
-              if (ssr1) {
-                rawAsyncEntryCode = "\n          export const ".concat(SERVER_RENDER_FUNCTION_NAME, " = async (...args) => {\n            let entry = await ").concat(rawAsyncEntryCode, ";\n            if (entry.default instanceof Promise){\n              entry = await entry.default;\n              return entry.default.").concat(SERVER_RENDER_FUNCTION_NAME, ".apply(null, args);\n            }\n            return entry.").concat(SERVER_RENDER_FUNCTION_NAME, ".apply(null, args);\n          };\n          if(typeof window!=='undefined'){\n            ").concat(rawAsyncEntryCode, "\n          }\n          ");
-              }
-              return [
-                4,
-                hookRunners.modifyAsyncEntry({
-                  entrypoint: entrypoint,
-                  code: rawAsyncEntryCode
-                })
-              ];
-            case 16:
-              _ref22 = _state.sent(), asyncEntryCode = _ref22.code;
-              fs.outputFileSync(entryFile, asyncEntryCode, "utf8");
-              bootstrapFile = path.resolve(internalDirectory, "./".concat(entryName, "/").concat(ENTRY_BOOTSTRAP_FILE_NAME));
-              fs.outputFileSync(bootstrapFile, code2, "utf8");
-              return [
-                3,
-                18
-              ];
-            case 17:
-              fs.outputFileSync(entryFile, code2, "utf8");
-              _state.label = 18;
-            case 18:
+              entrypoint.internalEntry = entryFile;
+              _state.label = 13;
+            case 13:
               return [
                 2
               ];
@@ -332,8 +268,8 @@ export var generateCode = function() {
           internalDirectory = appContext.internalDirectory, srcDirectory = appContext.srcDirectory, internalDirAlias = appContext.internalDirAlias, internalSrcAlias = appContext.internalSrcAlias, packageName = appContext.packageName;
           hookRunners = api.useHookRunners();
           isV5 = isRouterV5(config);
-          mountId = config.html.mountId;
           getRoutes = isV5 ? getClientRoutesLegacy : getClientRoutes;
+          importsStatemets = /* @__PURE__ */ new Map();
           return [
             4,
             Promise.all(entrypoints.map(generateEntryCode))
@@ -341,7 +277,10 @@ export var generateCode = function() {
         case 1:
           _state.sent();
           return [
-            2
+            2,
+            {
+              importsStatemets: importsStatemets
+            }
           ];
       }
     });
@@ -350,3 +289,120 @@ export var generateCode = function() {
     return _ref.apply(this, arguments);
   };
 }();
+export var generateIndexCode = function() {
+  var _ref = _async_to_generator(function(param) {
+    var appContext, api, entrypoints, config, importsStatemets, bundlerConfigs, hookRunners, mountId, internalDirectory, packageName;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          appContext = param.appContext, api = param.api, entrypoints = param.entrypoints, config = param.config, importsStatemets = param.importsStatemets, bundlerConfigs = param.bundlerConfigs;
+          hookRunners = api.useHookRunners();
+          mountId = config.html.mountId;
+          internalDirectory = appContext.internalDirectory, packageName = appContext.packageName;
+          return [
+            4,
+            Promise.all(entrypoints.map(function() {
+              var _ref2 = _async_to_generator(function(entrypoint) {
+                var entryName, isAutoMount, customBootstrap, fileSystemRoutes, plugins, _ref3, renderFunction, exportStatement, imports, code, entryFile, rawAsyncEntryCode, ssr, _ref1, asyncEntryCode, bootstrapFile;
+                return _ts_generator(this, function(_state2) {
+                  switch (_state2.label) {
+                    case 0:
+                      entryName = entrypoint.entryName, isAutoMount = entrypoint.isAutoMount, customBootstrap = entrypoint.customBootstrap, fileSystemRoutes = entrypoint.fileSystemRoutes;
+                      if (!isAutoMount)
+                        return [
+                          3,
+                          6
+                        ];
+                      return [
+                        4,
+                        hookRunners.modifyEntryRuntimePlugins({
+                          entrypoint: entrypoint,
+                          plugins: [],
+                          bundlerConfigs: bundlerConfigs
+                        })
+                      ];
+                    case 1:
+                      plugins = _state2.sent().plugins;
+                      return [
+                        4,
+                        hookRunners.modifyEntryRenderFunction({
+                          entrypoint: entrypoint,
+                          code: templates.renderFunction({
+                            plugins: plugins,
+                            customBootstrap: customBootstrap,
+                            fileSystemRoutes: fileSystemRoutes
+                          })
+                        })
+                      ];
+                    case 2:
+                      _ref3 = _state2.sent(), renderFunction = _ref3.code;
+                      return [
+                        4,
+                        hookRunners.modifyEntryExport({
+                          entrypoint: entrypoint,
+                          exportStatement: "export default AppWrapper;"
+                        })
+                      ];
+                    case 3:
+                      exportStatement = _state2.sent().exportStatement;
+                      imports = importsStatemets.get(entryName);
+                      code = templates.index({
+                        mountId: mountId,
+                        imports: createImportStatements(imports),
+                        renderFunction: renderFunction,
+                        exportStatement: exportStatement
+                      });
+                      entryFile = path.resolve(internalDirectory, "./".concat(entryName, "/").concat(ENTRY_POINT_FILE_NAME));
+                      if (!config.source.enableAsyncEntry)
+                        return [
+                          3,
+                          5
+                        ];
+                      rawAsyncEntryCode = "import('./".concat(ENTRY_BOOTSTRAP_FILE_NAME, "');");
+                      ssr = getEntryOptions(entryName, config.server.ssr, config.server.ssrByEntries, packageName);
+                      if (ssr) {
+                        rawAsyncEntryCode = "\n        export const ".concat(SERVER_RENDER_FUNCTION_NAME, " = async (...args) => {\n          let entry = await ").concat(rawAsyncEntryCode, ";\n          if (entry.default instanceof Promise){\n            entry = await entry.default;\n            return entry.default.").concat(SERVER_RENDER_FUNCTION_NAME, ".apply(null, args);\n          }\n          return entry.").concat(SERVER_RENDER_FUNCTION_NAME, ".apply(null, args);\n        };\n        if(typeof window!=='undefined'){\n          ").concat(rawAsyncEntryCode, "\n        }\n        ");
+                      }
+                      return [
+                        4,
+                        hookRunners.modifyAsyncEntry({
+                          entrypoint: entrypoint,
+                          code: rawAsyncEntryCode
+                        })
+                      ];
+                    case 4:
+                      _ref1 = _state2.sent(), asyncEntryCode = _ref1.code;
+                      fs.outputFileSync(entryFile, asyncEntryCode, "utf8");
+                      bootstrapFile = path.resolve(internalDirectory, "./".concat(entryName, "/").concat(ENTRY_BOOTSTRAP_FILE_NAME));
+                      fs.outputFileSync(bootstrapFile, code, "utf8");
+                      return [
+                        3,
+                        6
+                      ];
+                    case 5:
+                      fs.outputFileSync(entryFile, code, "utf8");
+                      _state2.label = 6;
+                    case 6:
+                      return [
+                        2
+                      ];
+                  }
+                });
+              });
+              return function(entrypoint) {
+                return _ref2.apply(this, arguments);
+              };
+            }()))
+          ];
+        case 1:
+          _state.sent();
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function generateIndexCode2(_) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/esm/analyze/index.js

@@ -4,7 +4,7 @@ import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
 import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import * as path from "path";
-import { createDebugger, findExists, fs, isApiOnly, minimist, getCommand, isDevCommand, getArgv } from "@modern-js/utils";
+import { createDebugger, findExists, fs, isApiOnly, minimist, isDevCommand, getArgv } from "@modern-js/utils";
 import { cloneDeep } from "@modern-js/utils/lodash";
 import { printInstructions } from "../utils/printInstructions";
 import { generateRoutes } from "../utils/routes";
@@ -12,8 +12,9 @@ import { emitResolvedConfig } from "../utils/config";
 import { getSelectedEntries } from "../utils/getSelectedEntries";
 import { initialNormalizedConfig } from "../config";
 import { createBuilderGenerator } from "../builder";
-import { isPageComponentFile, parseModule, replaceWithAlias } from "./utils";
+import { checkIsBuildCommands, isPageComponentFile, parseModule, replaceWithAlias } from "./utils";
 import { APP_CONFIG_NAME, APP_INIT_EXPORTED, APP_INIT_IMPORTED } from "./constants";
+import { generateIndexCode } from "./generateCode";
 var debug = createDebugger("plugin-analyze");
 export default function(param) {
   var bundler = param.bundler;
@@ -26,7 +27,7 @@ export default function(param) {
       return {
         prepare: function prepare() {
           return _async_to_generator(function() {
-            var _resolvedConfig_source, appContext, resolvedConfig, hookRunners, apiOnly, routes, _ref, getBundleEntry, getServerRoutes, generateCode, getHtmlTemplate, entrypoints, initialRoutes, routes1, htmlTemplates, checkedEntries, entry, command, buildCommands, normalizedConfig, createBuilderForModern, builder;
+            var _resolvedConfig_source, appContext, resolvedConfig, hookRunners, apiOnly, routes, _ref, getBundleEntry, getServerRoutes, generateCode, getHtmlTemplate, entrypoints, initialRoutes, routes1, importsStatemets, htmlTemplates, checkedEntries, entry, normalizedConfig, createBuilderForModern, builder;
             return _ts_generator(this, function(_state) {
               switch (_state.label) {
                 case 0:
@@ -34,7 +35,9 @@ export default function(param) {
                   resolvedConfig = api.useResolvedConfigContext();
                   hookRunners = api.useHookRunners();
                   try {
-                    fs.emptydirSync(appContext.internalDirectory);
+                    if (checkIsBuildCommands()) {
+                      fs.emptydirSync(appContext.internalDirectory);
+                    }
                   } catch (e) {
                   }
                   return [
@@ -120,7 +123,7 @@ export default function(param) {
                     generateCode(appContext, resolvedConfig, entrypoints, api)
                   ];
                 case 7:
-                  _state.sent();
+                  importsStatemets = _state.sent().importsStatemets;
                   return [
                     4,
                     getHtmlTemplate(entrypoints, api, {
@@ -163,15 +166,7 @@ export default function(param) {
                     htmlTemplates: htmlTemplates
                   });
                   api.setAppContext(appContext);
-                  command = getCommand();
-                  buildCommands = [
-                    "dev",
-                    "start",
-                    "build",
-                    "inspect",
-                    "deploy"
-                  ];
-                  if (!buildCommands.includes(command))
+                  if (!checkIsBuildCommands())
                     return [
                       3,
                       14
@@ -276,11 +271,24 @@ export default function(param) {
                                 hookRunners2 = api.useHookRunners();
                                 return [
                                   4,
-                                  hookRunners2.beforeCreateCompiler({
+                                  generateIndexCode({
+                                    appContext: appContext,
+                                    config: resolvedConfig,
+                                    entrypoints: entrypoints,
+                                    api: api,
+                                    importsStatemets: importsStatemets,
                                     bundlerConfigs: bundlerConfigs
                                   })
                                 ];
                               case 1:
+                                _state2.sent();
+                                return [
+                                  4,
+                                  hookRunners2.beforeCreateCompiler({
+                                    bundlerConfigs: bundlerConfigs
+                                  })
+                                ];
+                              case 2:
                                 _state2.sent();
                                 return [
                                   2

package/dist/esm/analyze/utils.js

@@ -4,7 +4,7 @@ import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import fs from "fs";
 import path from "path";
-import { isReact18, normalizeToPosixPath, fs as fse } from "@modern-js/utils";
+import { isReact18, normalizeToPosixPath, fs as fse, getCommand } from "@modern-js/utils";
 import { transform } from "esbuild";
 import { parse } from "es-module-lexer";
 import { FILE_SYSTEM_ROUTES_FILE_NAME, JS_EXTENSIONS, LOADER_EXPORT_NAME } from "./constants";
@@ -201,3 +201,14 @@ export var getServerLoadersFile = function(internalDirectory, entryName) {
 export var getServerCombinedModueFile = function(internalDirectory, entryName) {
   return path.join(internalDirectory, entryName, "server-loader-combined.js");
 };
+export var checkIsBuildCommands = function() {
+  var buildCommands = [
+    "dev",
+    "start",
+    "build",
+    "inspect",
+    "deploy"
+  ];
+  var command = getCommand();
+  return buildCommands.includes(command);
+};

package/dist/esm/builder/generator/createBuilderOptions.js

@@ -4,15 +4,16 @@ export function createBuilderOptions(target, appContext) {
   var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
   try {
     for (var _iterator = entrypoints[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-      var _step_value = _step.value, entryName = _step_value.entryName, entry = _step_value.entry;
+      var _step_value = _step.value, entryName = _step_value.entryName, internalEntry = _step_value.internalEntry, entry = _step_value.entry;
       if (checkedEntries && !checkedEntries.includes(entryName)) {
         continue;
       }
+      var finalEntry = internalEntry || entry;
       if (entryName in entries) {
-        entries[entryName].push(entry);
+        entries[entryName].push(finalEntry);
       } else {
         entries[entryName] = [
-          entry
+          finalEntry
         ];
       }
     }

package/dist/esm/builder/generator/createBuilderProviderConfig.js

@@ -3,7 +3,7 @@ import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
 export function createBuilderProviderConfig(resolveConfig, appContext, modifyBuilderConfig) {
   var htmlConfig = _object_spread({}, resolveConfig.html);
   if (!htmlConfig.template) {
-    htmlConfig.templateByEntries = _object_spread({}, htmlConfig.templateByEntries, appContext.htmlTemplates);
+    htmlConfig.templateByEntries = _object_spread({}, appContext.htmlTemplates, htmlConfig.templateByEntries);
   }
   var config = _object_spread_props(_object_spread({}, resolveConfig), {
     dev: _object_spread_props(_object_spread({}, resolveConfig.dev), {