@modern-js/app-tools 2.7.1-alpha.0 → 2.8.0

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

@@ -1,5 +1,131 @@
+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 { mergeBuilderConfig } from "@modern-js/builder-shared";
+import { fs } from "@modern-js/utils";
 import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins";
+import { getServerCombinedModueFile } from "../../../analyze/utils";
 import { isHtmlEnabled } from "./adapterHtml";
 var builderPluginAdapterSSR = function(options) {
     return {
@@ -16,29 +142,49 @@ var builderPluginAdapterSSR = function(options) {
                 }
                 return config;
             });
-            api.modifyBundlerChain(function(chain, param) {
-                var target = param.target, CHAIN_ID = param.CHAIN_ID, isProd = param.isProd, HtmlBundlerPlugin = param.HtmlPlugin;
-                var builderConfig = api.getNormalizedConfig();
-                applyRouterPlugin(chain, options);
-                if ([
-                    "node",
-                    "service-worker"
-                ].includes(target)) {
-                    applyFilterEntriesBySSRConfig({
-                        isProd: isProd,
-                        chain: chain,
-                        appNormalizedConfig: options.normalizedConfig
-                    });
-                }
-                if (isHtmlEnabled(builderConfig, target)) {
-                    applyAsyncChunkHtmlPlugin({
-                        chain: chain,
-                        modernConfig: options.normalizedConfig,
-                        CHAIN_ID: CHAIN_ID,
-                        HtmlBundlerPlugin: HtmlBundlerPlugin
+            api.modifyBundlerChain(function() {
+                var _ref = _asyncToGenerator(function(chain, param) {
+                    var target, CHAIN_ID, isProd, HtmlBundlerPlugin, isServer, builderConfig;
+                    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();
+                                applyRouterPlugin(chain, options);
+                                return [
+                                    4,
+                                    applySSRLoaderEntry(chain, options, isServer)
+                                ];
+                            case 1:
+                                _state.sent();
+                                if ([
+                                    "node",
+                                    "service-worker"
+                                ].includes(target)) {
+                                    applyFilterEntriesBySSRConfig({
+                                        isProd: isProd,
+                                        chain: chain,
+                                        appNormalizedConfig: options.normalizedConfig
+                                    });
+                                }
+                                if (isHtmlEnabled(builderConfig, target)) {
+                                    applyAsyncChunkHtmlPlugin({
+                                        chain: chain,
+                                        modernConfig: options.normalizedConfig,
+                                        CHAIN_ID: CHAIN_ID,
+                                        HtmlBundlerPlugin: HtmlBundlerPlugin
+                                    });
+                                }
+                                return [
+                                    2
+                                ];
+                        }
                     });
-                }
-            });
+                });
+                return function(chain, _) {
+                    return _ref.apply(this, arguments);
+                };
+            }());
         }
     };
 };
@@ -128,4 +274,77 @@ function applyFilterEntriesBySSRConfig(param) {
         }
     });
 }
+function applySSRLoaderEntry(chain, optinos, isServer) {
+    return _applySSRLoaderEntry.apply(this, arguments);
+}
+function _applySSRLoaderEntry() {
+    _applySSRLoaderEntry = _asyncToGenerator(function(chain, optinos, isServer) {
+        var appContext, internalDirectory, entrypoints;
+        return __generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    appContext = optinos.appContext;
+                    internalDirectory = appContext.internalDirectory;
+                    entrypoints = appContext.entrypoints;
+                    return [
+                        4,
+                        Promise.all(entrypoints.map(function() {
+                            var _ref = _asyncToGenerator(function(entrypoint) {
+                                var entryName, serverLoadersFile, err;
+                                return __generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            entryName = entrypoint.entryName;
+                                            serverLoadersFile = getServerCombinedModueFile(internalDirectory, entryName);
+                                            if (!isServer) return [
+                                                3,
+                                                4
+                                            ];
+                                            _state.label = 1;
+                                        case 1:
+                                            _state.trys.push([
+                                                1,
+                                                3,
+                                                ,
+                                                4
+                                            ]);
+                                            return [
+                                                4,
+                                                fs.access(serverLoadersFile, fs.constants.F_OK)
+                                            ];
+                                        case 2:
+                                            _state.sent();
+                                            chain.entry("".concat(entryName, "-server-loaders")).add(serverLoadersFile);
+                                            return [
+                                                3,
+                                                4
+                                            ];
+                                        case 3:
+                                            err = _state.sent();
+                                            return [
+                                                3,
+                                                4
+                                            ];
+                                        case 4:
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            });
+                            return function(entrypoint) {
+                                return _ref.apply(this, arguments);
+                            };
+                        }()))
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _applySSRLoaderEntry.apply(this, arguments);
+}
 export { builderPluginAdapterSSR };

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

@@ -14,7 +14,11 @@ import {
   ENTRY_POINT_FILE_NAME,
   ENTRY_BOOTSTRAP_FILE_NAME
 } from "./constants";
-import { getDefaultImports, getServerLoadersFile } from "./utils";
+import {
+  getDefaultImports,
+  getServerLoadersFile,
+  getServerCombinedModueFile
+} from "./utils";
 import { walk } from "./nestedRoutes";
 const createImportSpecifier = (specifiers) => {
   let defaults = "";
@@ -77,7 +81,6 @@ 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) {
@@ -140,8 +143,7 @@ const generateCode = async (appContext, config, entrypoints, api) => {
             ssrMode: useSSG ? "string" : mode,
             nestedRoutesEntry: entrypoint.nestedRoutesEntry,
             entryName: entrypoint.entryName,
-            internalDirectory,
-            splitRoutesChunks: (_a = config2 == null ? void 0 : config2.output) == null ? void 0 : _a.splitRoutesChunks
+            internalDirectory
           })
         });
         if (entrypoint.nestedRoutesEntry && isUseSSRBundle(config2)) {
@@ -155,6 +157,19 @@ const generateCode = async (appContext, config, entrypoints, api) => {
           await fs.ensureFile(routesServerFile);
           await fs.writeFile(routesServerFile, code3);
         }
+        const serverLoaderCombined = templates.ssrLoaderCombinedModule(
+          entrypoints,
+          entrypoint,
+          config2,
+          appContext
+        );
+        if (serverLoaderCombined) {
+          const serverLoaderFile = getServerCombinedModueFile(
+            internalDirectory,
+            entryName
+          );
+          await fs.outputFile(serverLoaderFile, serverLoaderCombined);
+        }
         fs.outputFileSync(
           path.resolve(
             internalDirectory,

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

@@ -3,27 +3,19 @@ import {
   createDebugger,
   findExists,
   fs,
-  getEntryOptions,
   isApiOnly,
   minimist,
   getCommand,
-  isDevCommand,
-  isSSGEntry
+  isDevCommand
 } from "@modern-js/utils";
 import { cloneDeep } from "@modern-js/utils/lodash";
-import { createVirtualModule } from "@modern-js/builder-shared";
 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 { isPageComponentFile, parseModule, replaceWithAlias } from "./utils";
 import {
   APP_CONFIG_NAME,
   APP_INIT_EXPORTED,
@@ -177,42 +169,6 @@ var analyze_default = ({
       watchFiles() {
         return pagesDir;
       },
-      config() {
-        return {
-          tools: {
-            webpackChain: (chain, { name }) => {
-              const appContext = api.useAppContext();
-              const resolvedConfig = api.useResolvedConfigContext();
-              const { entrypoints, internalDirectory, packageName } = appContext;
-              entrypoints.forEach((entrypoint) => {
-                const { entryName } = entrypoint;
-                const ssr = getEntryOptions(
-                  entryName,
-                  resolvedConfig.server.ssr,
-                  resolvedConfig.server.ssrByEntries,
-                  packageName
-                );
-                const useSSG = isSSGEntry(
-                  resolvedConfig,
-                  entryName,
-                  entrypoints
-                );
-                if (entrypoint.nestedRoutesEntry && (ssr || useSSG) && name === "server") {
-                  const serverLoaderRuntime = require.resolve("@modern-js/plugin-data-loader/runtime");
-                  const serverLoadersFile = getServerLoadersFile(
-                    internalDirectory,
-                    entryName
-                  );
-                  const combinedModule = createVirtualModule(
-                    `export * from "${serverLoaderRuntime}"; export * from "${serverLoadersFile}"`
-                  );
-                  chain.entry(`${entryName}-server-loaders`).add(combinedModule);
-                }
-              });
-            }
-          }
-        };
-      },
       resolvedConfig({ resolved }) {
         const appContext = api.useAppContext();
         const config = initialNormalizedConfig(resolved, appContext, bundler);
@@ -271,14 +227,6 @@ var analyze_default = ({
           imports
         };
       },
-      validateSchema() {
-        return {
-          target: "output.splitRoutesChunks",
-          schema: {
-            type: "boolean"
-          }
-        };
-      },
       async fileChange(e) {
         const appContext = api.useAppContext();
         const { appDirectory } = appContext;

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

@@ -1,6 +1,7 @@
 import path from "path";
-import { fs, slash } from "@modern-js/utils";
+import { fs, getEntryOptions, isSSGEntry, slash } from "@modern-js/utils";
 import { APP_CONFIG_NAME, TEMP_LOADERS_DIR } from "./constants";
+import { getServerLoadersFile } from "./utils";
 const index = ({
   mountId,
   imports,
@@ -144,14 +145,12 @@ const fileSystemRoutes = async ({
   ssrMode,
   nestedRoutesEntry,
   entryName,
-  internalDirectory,
-  splitRoutesChunks = true
+  internalDirectory
 }) => {
   const loadings = [];
   const errors = [];
   const loaders = [];
   const loadersMap = {};
-  const webpackMode = splitRoutesChunks ? "lazy" : "eager";
   const loadersMapFile = path.join(
     internalDirectory,
     entryName,
@@ -210,15 +209,15 @@ const fileSystemRoutes = async ({
           rootLayoutCode = `import RootLayout from '${route._component}'`;
           component = `RootLayout`;
         } else if (ssrMode === "string") {
-          lazyImport = `() => import(/* webpackChunkName: "${route.id}" */ /* webpackMode: "${webpackMode}" */  '${route._component}')`;
+          lazyImport = `() => import(/* webpackChunkName: "${route.id}" */  '${route._component}')`;
           component = `loadable(${lazyImport})`;
         } else {
-          lazyImport = `() => import(/* webpackChunkName: "${route.id}" */ /* webpackMode: "${webpackMode}" */  '${route._component}')`;
+          lazyImport = `() => import(/* webpackChunkName: "${route.id}" */  '${route._component}')`;
           component = `lazy(${lazyImport})`;
         }
       }
     } else if (route._component) {
-      lazyImport = `() => import( /* webpackMode: "${webpackMode}" */ '${route._component}')`;
+      lazyImport = `() => import('${route._component}')`;
       component = `loadable(${lazyImport})`;
     }
     const finalRoute = {
@@ -285,10 +284,32 @@ const fileSystemRoutes = async ({
     ${routeComponentsCode}
   `;
 };
+function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
+  const { entryName } = entrypoint;
+  const { packageName, internalDirectory } = appContext;
+  const ssr = getEntryOptions(
+    entryName,
+    config.server.ssr,
+    config.server.ssrByEntries,
+    packageName
+  );
+  const ssg = isSSGEntry(config, entryName, entrypoints);
+  if (entrypoint.nestedRoutesEntry && (ssr || ssg)) {
+    const serverLoaderRuntime = require.resolve("@modern-js/plugin-data-loader/runtime");
+    const serverLoadersFile = getServerLoadersFile(
+      internalDirectory,
+      entryName
+    );
+    const combinedModule = `export * from "${serverLoaderRuntime}"; export * from "${serverLoadersFile}"`;
+    return combinedModule;
+  }
+  return null;
+}
 export {
   fileSystemRoutes,
   html,
   index,
   renderFunction,
-  routesForServer
+  routesForServer,
+  ssrLoaderCombinedModule
 };

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

@@ -110,8 +110,12 @@ const hasLoader = async (filename) => {
 const getServerLoadersFile = (internalDirectory, entryName) => {
   return path.join(internalDirectory, entryName, "route-server-loaders.js");
 };
+const getServerCombinedModueFile = (internalDirectory, entryName) => {
+  return path.join(internalDirectory, entryName, "server-loader-combined.js");
+};
 export {
   getDefaultImports,
+  getServerCombinedModueFile,
   getServerLoadersFile,
   hasLoader,
   isPageComponentFile,

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

@@ -5,7 +5,7 @@ async function createBuilderGenerator(bundler) {
       return createRspackBuilderForModern;
     } catch (_) {
       throw new Error(
-        "Failed to use rspack, please check if you have `@modern-js/builder-rspack-provider` installed"
+        "Failed to use Rspack, please check if you have `@modern-js/builder-rspack-provider` installed"
       );
     }
   }

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

@@ -1,7 +1,9 @@
 import {
   mergeBuilderConfig
 } from "@modern-js/builder-shared";
+import { fs } from "@modern-js/utils";
 import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins";
+import { getServerCombinedModueFile } from "../../../analyze/utils";
 import { isHtmlEnabled } from "./adapterHtml";
 const builderPluginAdapterSSR = (options) => ({
   name: "builder-plugin-adapter-modern-ssr",
@@ -18,9 +20,10 @@ const builderPluginAdapterSSR = (options) => ({
       return config;
     });
     api.modifyBundlerChain(
-      (chain, { target, CHAIN_ID, isProd, HtmlPlugin: HtmlBundlerPlugin }) => {
+      async (chain, { target, CHAIN_ID, isProd, HtmlPlugin: HtmlBundlerPlugin, isServer }) => {
         const builderConfig = api.getNormalizedConfig();
         applyRouterPlugin(chain, options);
+        await applySSRLoaderEntry(chain, options, isServer);
         if (["node", "service-worker"].includes(target)) {
           applyFilterEntriesBySSRConfig({
             isProd,
@@ -114,6 +117,27 @@ function applyFilterEntriesBySSRConfig({
     }
   });
 }
+async function applySSRLoaderEntry(chain, optinos, isServer) {
+  const { appContext } = optinos;
+  const { internalDirectory } = appContext;
+  const { entrypoints } = appContext;
+  await Promise.all(
+    entrypoints.map(async (entrypoint) => {
+      const { entryName } = entrypoint;
+      const serverLoadersFile = getServerCombinedModueFile(
+        internalDirectory,
+        entryName
+      );
+      if (isServer) {
+        try {
+          await fs.access(serverLoadersFile, fs.constants.F_OK);
+          chain.entry(`${entryName}-server-loaders`).add(serverLoadersFile);
+        } catch (err) {
+        }
+      }
+    })
+  );
+}
 export {
   builderPluginAdapterSSR
 };

package/dist/types/analyze/templates.d.ts

@@ -1,5 +1,5 @@
 import type { Entrypoint, NestedRoute, PageRoute, RouteLegacy, SSRMode } from '@modern-js/types';
-import type { RuntimePlugin } from '../types';
+import type { AppNormalizedConfig, IAppContext, RuntimePlugin } from '../types';
 export declare const index: ({
   mountId,
   imports,
@@ -35,13 +35,12 @@ export declare const fileSystemRoutes: ({
   ssrMode,
   nestedRoutesEntry,
   entryName,
-  internalDirectory,
-  splitRoutesChunks
+  internalDirectory
 }: {
   routes: RouteLegacy[] | (NestedRoute | PageRoute)[];
   ssrMode?: SSRMode | undefined;
   nestedRoutesEntry?: string | undefined;
   entryName: string;
   internalDirectory: string;
-  splitRoutesChunks?: boolean | undefined;
-}) => Promise<string>;
+}) => Promise<string>;
+export declare function ssrLoaderCombinedModule(entrypoints: Entrypoint[], entrypoint: Entrypoint, config: AppNormalizedConfig<'shared'>, appContext: IAppContext): string | null;

package/dist/types/analyze/utils.d.ts

@@ -24,4 +24,5 @@ export declare const parseModule: ({
   filename: string;
 }) => Promise<readonly [imports: readonly import("es-module-lexer").ImportSpecifier[], exports: readonly import("es-module-lexer").ExportSpecifier[], facade: boolean]>;
 export declare const hasLoader: (filename: string) => Promise<boolean>;
-export declare const getServerLoadersFile: (internalDirectory: string, entryName: string) => string;
+export declare const getServerLoadersFile: (internalDirectory: string, entryName: string) => string;
+export declare const getServerCombinedModueFile: (internalDirectory: string, entryName: string) => string;

package/dist/types/types/config/output.d.ts

@@ -7,7 +7,6 @@ export type BuilderOutputConfig = UnwrapBuilderConfig<BuilderConfig, 'output'>;
 export type RsBuilderOutputConfig = UnwrapBuilderConfig<RsBuilderConfig, 'output'>;
 export interface SharedOutputConfig extends BuilderSharedOutputConfig {
   ssg?: SSGConfig;
-  splitRoutesChunks?: boolean;
   disableNodePolyfill?: boolean;
 }
 export interface OutputUserConfig extends BuilderOutputConfig, SharedOutputConfig {}