@modern-js/app-tools 1.21.3 → 2.0.0-beta.0

package/dist/js/modern/commands/dev.js

@@ -4,12 +4,12 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-import { fs, logger, chalk, isSSR } from '@modern-js/utils';
+import { logger, isSSR } from '@modern-js/utils';
 import { ResolvedConfigContext } from '@modern-js/core';
-import { createCompiler } from "../utils/createCompiler";
-import { createServer } from "../utils/createServer";
-import { generateRoutes } from "../utils/routes";
 import { printInstructions } from "../utils/printInstructions";
+import { createDevCompiler } from "../utils/createCompiler";
+import { createServer, injectDataLoaderPlugin } from "../utils/createServer";
+import { generateRoutes } from "../utils/routes";
 import { getSpecifiedEntries } from "../utils/getSpecifiedEntries";
 import { buildServerConfig } from "../utils/config";
 export const dev = async (api, options) => {
@@ -26,14 +26,14 @@ export const dev = async (api, options) => {
     port,
     apiOnly,
     entrypoints,
-    serverConfigFile
+    serverConfigFile,
+    serverInternalPlugins
   } = appContext;
   const checkedEntries = await getSpecifiedEntries(options.entry || false, entrypoints);
   api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
     checkedEntries
   }));
   appContext.checkedEntries = checkedEntries;
-  fs.emptyDirSync(distDirectory);
   await buildServerConfig({
     appDirectory,
     distDirectory,
@@ -48,15 +48,11 @@ export const dev = async (api, options) => {
   let compiler = null;
 
   if (!apiOnly) {
-    const {
-      getWebpackConfig,
-      WebpackConfigTarget
-    } = await import('@modern-js/webpack');
-    const webpackConfigs = [isSSR(userConfig) && getWebpackConfig(WebpackConfigTarget.NODE, appContext, userConfig), getWebpackConfig(WebpackConfigTarget.CLIENT, appContext, userConfig)].filter(Boolean);
-    compiler = await createCompiler({
+    const target = isSSR(userConfig) ? ['web', 'node'] : ['web'];
+    compiler = await createDevCompiler({
+      target,
       api,
-      webpackConfigs,
-      userConfig,
+      normalizedConfig: userConfig,
       appContext
     });
   }
@@ -79,17 +75,17 @@ export const dev = async (api, options) => {
     pwd: appDirectory,
     config: userConfig,
     serverConfigFile,
-    plugins: appContext.plugins.filter(p => p.server).map(p => p.server)
+    internalPlugins: injectDataLoaderPlugin(serverInternalPlugins)
   });
   app.listen(port, async err => {
     if (err) {
       throw err;
     }
 
-    if (apiOnly) {
-      return printInstructions(hookRunners, appContext, userConfig);
+    if (!apiOnly) {
+      logger.info(`Starting dev server...`);
+    } else {
+      printInstructions(hookRunners, appContext, userConfig);
     }
-
-    return logger.log(chalk.cyan(`Starting the development server...`));
   });
 };

package/dist/js/modern/commands/inspect.js

@@ -1,69 +1,28 @@
-import path from 'path';
-import { getWebpackConfig, WebpackConfigTarget } from '@modern-js/webpack';
-import { fs, logger, isUseSSRBundle, chalk } from '@modern-js/utils';
-import WebpackChain from '@modern-js/utils/webpack-chain';
-export const formatWebpackConfig = (config, verbose) => {
-  const stringify = WebpackChain.toString;
-  return `module.exports = ${stringify(config, {
-    verbose
-  })};`;
-};
-export const inspect = (api, options) => {
-  process.env.NODE_ENV = options.env;
+import { join } from 'path';
+import { isUseSSRBundle } from '@modern-js/utils';
+import createBuilder from "../builder";
+export const inspect = async (api, options) => {
   const resolvedConfig = api.useResolvedConfigContext();
   const appContext = api.useAppContext();
-  const outputFiles = [];
-  outputFiles.push(printInspectResult(WebpackConfigTarget.CLIENT, appContext, resolvedConfig, options));
+  const targets = ['web'];
 
   if (resolvedConfig.output.enableModernMode) {
-    outputFiles.push(printInspectResult(WebpackConfigTarget.MODERN, appContext, resolvedConfig, options));
+    targets.push('modern-web');
   }
 
   if (isUseSSRBundle(resolvedConfig)) {
-    outputFiles.push(printInspectResult(WebpackConfigTarget.NODE, appContext, resolvedConfig, options));
+    targets.push('node');
   }
 
-  logger.success('Inspect succeed, you can open following files to view the full webpack config: \n');
-  outputFiles.forEach(file => {
-    logger.log(`  - ${chalk.yellow(path.relative(appContext.appDirectory, file))}`);
+  const builder = await createBuilder({
+    target: targets,
+    appContext,
+    normalizedConfig: resolvedConfig
+  });
+  return builder.inspectConfig({
+    env: options.env,
+    verbose: options.verbose,
+    outputPath: join(builder.context.distPath, options.output),
+    writeToDisk: true
   });
-  logger.log();
-};
-export const getTagByWebpackTarget = webpackTarget => {
-  switch (webpackTarget) {
-    case WebpackConfigTarget.CLIENT:
-      return 'client';
-
-    case WebpackConfigTarget.MODERN:
-      return 'modern';
-
-    case WebpackConfigTarget.NODE:
-      return 'ssr';
-
-    default:
-      throw Error(`Unsupported webpack target: ${webpackTarget}`);
-  }
-};
-export const printInspectResult = (webpackTarget, appContext, resolvedConfig, options) => {
-  const webpackConfig = getWebpackConfig(webpackTarget, appContext, resolvedConfig);
-  const {
-    output,
-    verbose,
-    console = true
-  } = options;
-  const outputPath = output ? path.posix.join(appContext.distDirectory, output) : appContext.distDirectory;
-  const tag = getTagByWebpackTarget(webpackTarget);
-  const outputFile = `webpack.${tag}.inspect.js`;
-  const outputFilePath = path.posix.join(outputPath, outputFile);
-  const rawWebpackConfig = formatWebpackConfig(webpackConfig, verbose);
-  fs.outputFileSync(outputFilePath, rawWebpackConfig);
-
-  if (console) {
-    logger.log(`
-webpack config for ${tag} build:
-${rawWebpackConfig}
-    `);
-  }
-
-  return outputFilePath;
 };

package/dist/js/modern/commands/start.js

@@ -1,6 +1,7 @@
 import { logger, chalk, isApiOnly } from '@modern-js/utils';
 import server from '@modern-js/prod-server';
 import { printInstructions } from "../utils/printInstructions";
+import { injectDataLoaderPlugin } from "../utils/createServer";
 export const start = async api => {
   var _userConfig$source;
 
@@ -17,8 +18,8 @@ export const start = async api => {
   const app = await server({
     pwd: appDirectory,
     config: userConfig,
-    plugins: appContext.plugins.filter(p => p.server).map(p => p.server),
     serverConfigFile,
+    internalPlugins: injectDataLoaderPlugin(appContext.serverInternalPlugins),
     apiOnly
   });
   app.listen(port, async err => {

package/dist/js/modern/index.js

@@ -7,16 +7,17 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 import path from 'path';
 import { defineConfig, cli } from '@modern-js/core';
 import LintPlugin from '@modern-js/plugin-jarvis';
-import { cleanRequireCache, Import } from '@modern-js/utils';
+import { cleanRequireCache, emptyDir, Import } from '@modern-js/utils';
 import AnalyzePlugin from "./analyze";
 import { hooks } from "./hooks";
 import { i18n, localeKeys } from "./locale";
 import { getLocaleLanguage } from "./utils/language";
-export { defineConfig };
+import { getCommand } from "./utils/commands";
+export { defineConfig, hooks };
 const upgradeModel = Import.lazy('@modern-js/upgrade', require);
 export default (() => ({
   name: '@modern-js/app-tools',
-  post: ['@modern-js/plugin-analyze', '@modern-js/plugin-ssr', '@modern-js/plugin-state', '@modern-js/plugin-router', '@modern-js/plugin-polyfill'],
+  post: ['@modern-js/plugin-analyze', '@modern-js/plugin-ssr', '@modern-js/plugin-state', '@modern-js/plugin-router', '@modern-js/plugin-router-legacy', '@modern-js/plugin-polyfill'],
   registerHook: hooks,
   usePlugins: [AnalyzePlugin(), LintPlugin()],
   setup: api => {
@@ -69,7 +70,7 @@ export default (() => ({
             locale
           }));
         });
-        program.command('inspect').description('inspect internal webpack config').option(`--env <env>`, i18n.t(localeKeys.command.inspect.env), 'development').option('--output <output>', i18n.t(localeKeys.command.inspect.output), '/').option('--no-console', i18n.t(localeKeys.command.inspect.noConsole)).option('--verbose', i18n.t(localeKeys.command.inspect.verbose)).option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).action(async options => {
+        program.command('inspect').description('inspect internal webpack config').option(`--env <env>`, i18n.t(localeKeys.command.inspect.env), 'development').option('--output <output>', i18n.t(localeKeys.command.inspect.output), '/').option('--verbose', i18n.t(localeKeys.command.inspect.verbose)).option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).action(async options => {
           const {
             inspect
           } = await import("./commands/inspect");
@@ -78,6 +79,15 @@ export default (() => ({
         upgradeModel.defineCommand(program.command('upgrade'));
       },
 
+      async prepare() {
+        const command = getCommand();
+
+        if (command === 'dev' || command === 'build') {
+          const appContext = api.useAppContext();
+          await emptyDir(appContext.distDirectory);
+        }
+      },
+
       // 这里会被 core/initWatcher 监听的文件变动触发，如果是 src 目录下的文件变动，则不做 restart
       async fileChange(e) {
         const {

package/dist/js/modern/locale/en.js

@@ -28,7 +28,6 @@ export const EN_LOCALE = {
     inspect: {
       env: 'specify env mode',
       output: 'specify inspect content output path',
-      noConsole: 'do not log the result in terminal',
       verbose: 'show full function definitions in output'
     }
   }

package/dist/js/modern/locale/zh.js

@@ -28,7 +28,6 @@ export const ZH_LOCALE = {
     inspect: {
       env: '查看指定环境下的配置',
       output: '指定在 dist 目录下输出的路径',
-      noConsole: '不在终端中输出完整结果',
       verbose: '在结果中展示函数的完整内容'
     }
   }

package/dist/js/modern/utils/commands.js

@@ -0,0 +1,5 @@
+export const getCommand = () => {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  return command;
+};

package/dist/js/modern/utils/createCompiler.js

@@ -1,55 +1,52 @@
-import { webpack } from '@modern-js/webpack';
-import { chalk, logger, formatWebpackMessages, clearConsole } from '@modern-js/utils';
+import { chalk, logger } from '@modern-js/utils';
+import createBuilder from "../builder";
 import { printInstructions } from "./printInstructions";
-export const createCompiler = async ({
+export const createDevCompiler = async ({
   api,
-  webpackConfigs,
-  // TODO: params
-  userConfig,
+  target,
+  normalizedConfig,
   appContext
 }) => {
   try {
     const hookRunners = api.useHookRunners();
-    await hookRunners.beforeCreateCompiler({
-      webpackConfigs
-    });
-    const compiler = webpack(webpackConfigs);
-    await hookRunners.afterCreateCompiler({
-      compiler
-    });
-    let isFirstCompile = true;
-    compiler.hooks.invalid.tap('invalid', () => {
-      clearConsole();
-      logger.log('Compiling...');
-    });
-    compiler.hooks.done.tap('done', async stats => {
-      const statsData = stats.toJson({
-        preset: 'errors-warnings'
-      });
-      const {
-        errors,
-        warnings
-      } = formatWebpackMessages(statsData);
+    const builder = await createBuilder({
+      target,
+      normalizedConfig,
+      appContext,
+      compatPluginConfig: {
+        async onDevCompileDone({
+          isFirstCompile
+        }) {
+          if (process.stdout.isTTY || isFirstCompile) {
+            hookRunners.afterDev();
 
-      if (errors.length) {
-        logger.log(chalk.red(`Failed to compile.\n`));
-        logger.log(errors.join('\n\n'));
-        logger.log();
-      } else if (process.stdout.isTTY || isFirstCompile) {
-        await hookRunners.afterDev();
+            if (isFirstCompile) {
+              printInstructions(hookRunners, appContext, normalizedConfig);
+            }
+          }
+        },
 
-        if (warnings.length) {
-          logger.log(chalk.yellow(`Compiled with warnings.\n`));
-          logger.log(warnings.join('\n\n'));
-          logger.log();
+        async onBeforeCreateCompiler({
+          bundlerConfigs
+        }) {
+          // run modernjs framework `beforeCreateCompiler` hook
+          await hookRunners.beforeCreateCompiler({
+            bundlerConfigs
+          });
+        },
+
+        async onAfterCreateCompiler({
+          compiler
+        }) {
+          // run modernjs framework afterCreateCompiler hooks
+          await hookRunners.afterCreateCompiler({
+            compiler
+          });
         }
 
-        await printInstructions(hookRunners, appContext, userConfig);
       }
-
-      isFirstCompile = false;
     });
-    return compiler;
+    return builder.createCompiler();
   } catch (err) {
     logger.log(chalk.red(`Failed to compile.`));
     logger.log();

package/dist/js/modern/utils/createServer.js

@@ -1,3 +1,9 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
 import { Server } from '@modern-js/server';
 let server = null;
 export const getServer = () => server;
@@ -15,4 +21,14 @@ export const createServer = async options => {
   server = new Server(options);
   const app = await server.init();
   return app;
+};
+export const injectDataLoaderPlugin = internalPlugins => {
+  const DataLoaderPlugin = require.resolve('@modern-js/plugin-data-loader/server');
+
+  return _objectSpread(_objectSpread({}, internalPlugins), {}, {
+    '@modern-js/plugin-data-loader': {
+      path: DataLoaderPlugin,
+      forced: true
+    }
+  });
 };

package/dist/js/modern/utils/printInstructions.js

@@ -7,5 +7,5 @@ export const printInstructions = async (hookRunners, appContext, config) => {
   } = await hookRunners.beforePrintInstructions({
     instructions: message
   });
-  logger.log(instructions);
+  logger.info(instructions);
 };

package/dist/js/node/analyze/constants.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.PAGES_DIR_NAME = exports.JS_EXTENSIONS = exports.INDEX_FILE_NAME = exports.HTML_PARTIALS_FOLDER = exports.HTML_PARTIALS_EXTENSIONS = exports.FILE_SYSTEM_ROUTES_LAYOUT = exports.FILE_SYSTEM_ROUTES_INDEX = exports.FILE_SYSTEM_ROUTES_IGNORED_REGEX = exports.FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT = exports.FILE_SYSTEM_ROUTES_FILE_NAME = exports.FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = exports.FILE_SYSTEM_ROUTES_COMPONENTS_DIR = exports.ENTRY_POINT_FILE_NAME = exports.ENTRY_BOOTSTRAP_FILE_NAME = exports.APP_FILE_NAME = void 0;
+exports.PAGES_DIR_NAME = exports.NESTED_ROUTES_DIR = exports.JS_EXTENSIONS = exports.INDEX_FILE_NAME = exports.HTML_PARTIALS_FOLDER = exports.HTML_PARTIALS_EXTENSIONS = exports.FILE_SYSTEM_ROUTES_LAYOUT = exports.FILE_SYSTEM_ROUTES_INDEX = exports.FILE_SYSTEM_ROUTES_IGNORED_REGEX = exports.FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT = exports.FILE_SYSTEM_ROUTES_FILE_NAME = exports.FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = exports.FILE_SYSTEM_ROUTES_COMPONENTS_DIR = exports.ENTRY_POINT_FILE_NAME = exports.ENTRY_BOOTSTRAP_FILE_NAME = exports.APP_FILE_NAME = void 0;
 const JS_EXTENSIONS = ['.js', '.ts', '.jsx', '.tsx'];
 exports.JS_EXTENSIONS = JS_EXTENSIONS;
 const INDEX_FILE_NAME = 'index';
@@ -12,6 +12,8 @@ const APP_FILE_NAME = 'App';
 exports.APP_FILE_NAME = APP_FILE_NAME;
 const PAGES_DIR_NAME = 'pages';
 exports.PAGES_DIR_NAME = PAGES_DIR_NAME;
+const NESTED_ROUTES_DIR = 'routes';
+exports.NESTED_ROUTES_DIR = NESTED_ROUTES_DIR;
 const FILE_SYSTEM_ROUTES_FILE_NAME = 'routes.js';
 exports.FILE_SYSTEM_ROUTES_FILE_NAME = FILE_SYSTEM_ROUTES_FILE_NAME;
 const ENTRY_POINT_FILE_NAME = 'index.js';

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

@@ -9,6 +9,12 @@ var _path = _interopRequireDefault(require("path"));
 
 var _utils = require("@modern-js/utils");
 
+var _core = require("@modern-js/core");
+
+var _esbuild = _interopRequireDefault(require("esbuild"));
+
+var _commands = require("../utils/commands");
+
 var templates = _interopRequireWildcard(require("./templates"));
 
 var _getClientRoutes = require("./getClientRoutes");
@@ -17,6 +23,8 @@ var _constants = require("./constants");
 
 var _utils2 = require("./utils");
 
+var _nestedRoutes = require("./nestedRoutes");
+
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
@@ -86,21 +94,67 @@ const createImportStatements = statements => {
 
 exports.createImportStatements = createImportStatements;
 
+const buildLoader = async (entry, outfile) => {
+  const loader = {
+    '.js': 'jsx',
+    '.ts': 'tsx'
+  };
+  const EXTERNAL_REGEXP = /^[^./]|^\.[^./]|^\.\.[^/]/;
+  const command = (0, _commands.getCommand)();
+  await _esbuild.default.build({
+    format: 'cjs',
+    platform: 'node',
+    target: 'esnext',
+    loader,
+    watch: command === 'dev' && {},
+    bundle: true,
+    logLevel: 'error',
+    entryPoints: [entry],
+    outfile,
+    plugins: [{
+      name: 'make-all-packages-external',
+
+      setup(build) {
+        // https://github.com/evanw/esbuild/issues/619#issuecomment-751995294
+        build.onResolve({
+          filter: EXTERNAL_REGEXP
+        }, args => {
+          let external = true; // FIXME: windows external entrypoint
+
+          if (args.kind === 'entry-point') {
+            external = false;
+          }
+
+          return {
+            path: args.path,
+            external
+          };
+        });
+      }
+
+    }]
+  });
+};
+
 const generateCode = async (appContext, config, entrypoints, api) => {
+  var _config$runtime, _config$runtime$route;
+
   const {
     internalDirectory,
+    distDirectory,
     srcDirectory,
     internalDirAlias,
     internalSrcAlias
   } = appContext;
   const hookRunners = api.useHookRunners();
+  const islegacy = Boolean(config === null || config === void 0 ? void 0 : (_config$runtime = config.runtime) === null || _config$runtime === void 0 ? void 0 : (_config$runtime$route = _config$runtime.router) === null || _config$runtime$route === void 0 ? void 0 : _config$runtime$route.legacy);
   const {
-    output: {
-      mountId
-    }
-  } = config;
+    mountId
+  } = config.output;
+  const getRoutes = islegacy ? _getClientRoutes.getClientRoutesLegacy : _getClientRoutes.getClientRoutes;
+  await Promise.all(entrypoints.map(generateEntryCode));
 
-  for (const entrypoint of entrypoints) {
+  async function generateEntryCode(entrypoint) {
     const {
       entryName,
       isAutoMount,
@@ -111,27 +165,80 @@ const generateCode = async (appContext, config, entrypoints, api) => {
     if (isAutoMount) {
       // generate routes file for file system routes entrypoint.
       if (fileSystemRoutes) {
-        const initialRoutes = (0, _getClientRoutes.getClientRoutes)({
-          entrypoint,
-          srcDirectory,
-          srcAlias: internalSrcAlias,
-          internalDirectory,
-          internalDirAlias
-        });
+        let initialRoutes = [];
+        let nestedRoute = null;
+
+        if (entrypoint.entry) {
+          initialRoutes = getRoutes({
+            entrypoint,
+            srcDirectory,
+            srcAlias: internalSrcAlias,
+            internalDirectory,
+            internalDirAlias
+          });
+        }
+
+        if (entrypoint.nestedRoutesEntry) {
+          if (!islegacy) {
+            nestedRoute = await (0, _nestedRoutes.walk)(entrypoint.nestedRoutesEntry, entrypoint.nestedRoutesEntry, {
+              name: internalSrcAlias,
+              basename: srcDirectory
+            });
+
+            if (nestedRoute) {
+              initialRoutes.unshift(nestedRoute);
+            }
+          } else {
+            _utils.logger.error('Nested routes is not supported in legacy mode.'); // eslint-disable-next-line no-process-exit
+
+
+            process.exit(1);
+          }
+        }
+
         const {
           routes
         } = await hookRunners.modifyFileSystemRoutes({
           entrypoint,
           routes: initialRoutes
         });
+        const config = (0, _core.useResolvedConfigContext)();
+        const ssr = config === null || config === void 0 ? void 0 : config.server.ssr;
+        let mode;
+
+        if (ssr) {
+          mode = typeof ssr === 'object' ? ssr.mode || 'string' : 'string';
+        } else {
+          mode = false;
+        }
+
         const {
           code
         } = await hookRunners.beforeGenerateRoutes({
           entrypoint,
           code: templates.fileSystemRoutes({
-            routes
+            routes,
+            ssrMode: mode,
+            nestedRoutesEntry: entrypoint.nestedRoutesEntry
           })
-        });
+        }); // extract nested router loaders
+
+        if (entrypoint.nestedRoutesEntry) {
+          const routesServerFile = _path.default.join(internalDirectory, entryName, 'routes.server.js');
+
+          const outputRoutesServerFile = _path.default.join(distDirectory, 'loader-routes', entryName, 'index.js');
+
+          const code = templates.routesForServer({
+            routes: routes,
+            alias: {
+              name: internalSrcAlias,
+              basename: srcDirectory
+            }
+          });
+          await _utils.fs.ensureFile(routesServerFile);
+          await _utils.fs.writeFile(routesServerFile, code);
+          await buildLoader(routesServerFile, outputRoutesServerFile);
+        }
 
         _utils.fs.outputFileSync(_path.default.resolve(internalDirectory, `./${entryName}/${_constants.FILE_SYSTEM_ROUTES_FILE_NAME}`), code, 'utf8');
       } // call modifyEntryImports hook

package/dist/js/node/analyze/getBundleEntry.js

@@ -78,8 +78,9 @@ const getBundleEntry = (appContext, config) => {
     const entriesDirAbs = (0, _utils.ensureAbsolutePath)(appDirectory, entriesDir);
     const found = defaults.find(({
       entryName,
-      entry
-    }) => entryName === packageName || _path.default.dirname(entry) === entriesDirAbs);
+      entry,
+      nestedRoutesEntry: _nestedRoutesEntry = ''
+    }) => entryName === packageName || _path.default.dirname(entry) === entriesDirAbs || _path.default.dirname(_nestedRoutesEntry) === entriesDirAbs);
     found && (found.entryName = _utils.MAIN_ENTRY_NAME);
   }