@modern-js/app-tools 1.21.5 → 2.0.0-beta.1

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

@@ -0,0 +1,165 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import * as path from 'path';
+import { fs, getRouteId } from '@modern-js/utils';
+import { JS_EXTENSIONS } from "./constants";
+import { replaceWithAlias } from "./utils";
+var LAYOUT_FILE = 'layout';
+var PAGE_FILE = 'page';
+var LOADING_FILE = 'loading';
+var ERROR_FILE = 'error';
+var LOADER_FILE = 'loader';
+var conventionNames = [LAYOUT_FILE, PAGE_FILE, LOADING_FILE, ERROR_FILE, LOADER_FILE];
+var replaceDynamicPath = function replaceDynamicPath(routePath) {
+  return routePath.replace(/\[(.*?)\]/g, ':$1');
+};
+var createIndexRoute = function createIndexRoute(routeInfo, rootDir, filename, entryName) {
+  return createRoute(_objectSpread(_objectSpread({}, routeInfo), {}, {
+    index: true,
+    children: undefined
+  }), rootDir, filename, entryName);
+};
+var createRoute = function createRoute(routeInfo, rootDir, filename, entryName) {
+  var id = getRouteId(filename, rootDir, entryName);
+  return _objectSpread(_objectSpread({}, routeInfo), {}, {
+    id: id,
+    type: 'nested'
+  });
+};
+export var walk = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(dirname, rootDir, alias, entryName) {
+    var isDirectory, relativeDir, pathSegments, lastSegment, isRoot, isPathlessLayout, isWithoutLayoutPath, routePath, route, items, _iterator, _step, item, itemPath, extname, itemWithoutExt, _isDirectory, childRoute, _route$children, _route$children2, _childRoute, finalRoute;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return fs.pathExists(dirname);
+          case 2:
+            if (_context.sent) {
+              _context.next = 4;
+              break;
+            }
+            return _context.abrupt("return", null);
+          case 4:
+            _context.next = 6;
+            return fs.stat(dirname);
+          case 6:
+            isDirectory = _context.sent.isDirectory();
+            if (isDirectory) {
+              _context.next = 9;
+              break;
+            }
+            return _context.abrupt("return", null);
+          case 9:
+            relativeDir = path.relative(rootDir, dirname);
+            pathSegments = relativeDir.split(path.sep);
+            lastSegment = pathSegments[pathSegments.length - 1];
+            isRoot = lastSegment === '';
+            isPathlessLayout = lastSegment.startsWith('__');
+            isWithoutLayoutPath = lastSegment.includes('.');
+            routePath = isRoot || isPathlessLayout ? '/' : "".concat(lastSegment);
+            if (isWithoutLayoutPath) {
+              routePath = lastSegment.split('.').join('/');
+            }
+            routePath = replaceDynamicPath(routePath);
+            route = {
+              path: routePath,
+              children: []
+            };
+            _context.next = 21;
+            return fs.readdir(dirname);
+          case 21:
+            items = _context.sent;
+            _iterator = _createForOfIteratorHelper(items);
+            _context.prev = 23;
+            _iterator.s();
+          case 25:
+            if ((_step = _iterator.n()).done) {
+              _context.next = 47;
+              break;
+            }
+            item = _step.value;
+            itemPath = path.join(dirname, item);
+            extname = path.extname(item);
+            itemWithoutExt = item.slice(0, -extname.length);
+            _context.next = 32;
+            return fs.stat(itemPath);
+          case 32:
+            _isDirectory = _context.sent.isDirectory();
+            if (!_isDirectory) {
+              _context.next = 38;
+              break;
+            }
+            _context.next = 36;
+            return walk(itemPath, rootDir, alias, entryName);
+          case 36:
+            childRoute = _context.sent;
+            if (childRoute) {
+              (_route$children = route.children) === null || _route$children === void 0 ? void 0 : _route$children.push(childRoute);
+            }
+          case 38:
+            if (!(extname && (!JS_EXTENSIONS.includes(extname) || !conventionNames.includes(itemWithoutExt)))) {
+              _context.next = 40;
+              break;
+            }
+            return _context.abrupt("continue", 45);
+          case 40:
+            if (itemWithoutExt === LAYOUT_FILE) {
+              route._component = replaceWithAlias(alias.basename, itemPath, alias.name);
+            }
+            if (itemWithoutExt === PAGE_FILE) {
+              _childRoute = createIndexRoute({
+                _component: replaceWithAlias(alias.basename, itemPath, alias.name)
+              }, rootDir, itemPath, entryName);
+              (_route$children2 = route.children) === null || _route$children2 === void 0 ? void 0 : _route$children2.push(_childRoute);
+            }
+            if (itemWithoutExt === LOADER_FILE) {
+              route.loader = replaceWithAlias(alias.basename, itemPath, alias.name);
+            }
+            if (itemWithoutExt === LOADING_FILE) {
+              route.loading = replaceWithAlias(alias.basename, itemPath, alias.name);
+            }
+            if (itemWithoutExt === ERROR_FILE) {
+              route.error = replaceWithAlias(alias.basename, itemPath, alias.name);
+            }
+          case 45:
+            _context.next = 25;
+            break;
+          case 47:
+            _context.next = 52;
+            break;
+          case 49:
+            _context.prev = 49;
+            _context.t0 = _context["catch"](23);
+            _iterator.e(_context.t0);
+          case 52:
+            _context.prev = 52;
+            _iterator.f();
+            return _context.finish(52);
+          case 55:
+            finalRoute = createRoute(route, rootDir, path.join(dirname, "".concat(LAYOUT_FILE, ".ts")), entryName);
+            /**
+             * when the url is /, the __auth/layout.tsx component should not be rendered
+             * - routes
+             *  - __auth
+             *    - layout.tsx
+             *  - layout.tsx
+             */
+            if (isPathlessLayout) {
+              delete finalRoute.path;
+            }
+            return _context.abrupt("return", finalRoute);
+          case 58:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[23, 49, 52, 55]]);
+  }));
+  return function walk(_x, _x2, _x3, _x4) {
+    return _ref.apply(this, arguments);
+  };
+}();

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

@@ -0,0 +1,170 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+export var index = function index(_ref) {
+  var mountId = _ref.mountId,
+    imports = _ref.imports,
+    renderFunction = _ref.renderFunction,
+    exportStatement = _ref.exportStatement;
+  return "\nconst IS_BROWSER = typeof window !== 'undefined' && window.name !== 'nodejs';\nconst IS_REACT18 = process.env.IS_REACT18 === 'true';\nconst MOUNT_ID = '".concat(mountId, "';\n\n").concat(imports, "\n\nlet AppWrapper = null;\n\nlet root = null;\n\nfunction render() {\n  ").concat(renderFunction, "\n}\n\nAppWrapper = render();\n\n").concat(exportStatement, ";\n");
+};
+export var renderFunction = function renderFunction(_ref2) {
+  var plugins = _ref2.plugins,
+    customBootstrap = _ref2.customBootstrap,
+    fileSystemRoutes = _ref2.fileSystemRoutes;
+  return "\n  AppWrapper = createApp({\n    plugins: [\n     ".concat(plugins.map(function (_ref3) {
+    var name = _ref3.name,
+      options = _ref3.options,
+      args = _ref3.args;
+    return "".concat(name, "({...").concat(options, ", ...App?.config?.").concat(args || name, "}),");
+  }).join('\n'), "\n    ]\n  })(").concat(fileSystemRoutes ? '' : "App", ")\n\n  if (IS_BROWSER) {\n    ").concat(customBootstrap ? "customBootstrap(AppWrapper);" : "bootstrap(AppWrapper, MOUNT_ID, root, ReactDOM);", "\n  }\n\n  return AppWrapper\n");
+};
+export var html = function html(partials) {
+  return "\n<!DOCTYPE html>\n<html>\n<head>\n  <%= meta %>\n  <title><%= title %></title>\n\n  ".concat(partials.top.join('\n'), "\n\n  <script>\n    window.__assetPrefix__ = '<%= assetPrefix %>';\n  </script>\n  ").concat(partials.head.join('\n'), "\n\n  <!--<?- chunksMap.css ?>-->\n</head>\n\n<body>\n  <noscript>\n    We're sorry but react app doesn't work properly without JavaScript enabled. Please enable it to continue.\n  </noscript>\n  <div id=\"<%= mountId %>\"><!--<?- html ?>--></div>\n  ").concat(partials.body.join('\n'), "\n  <!--<?- chunksMap.js ?>-->\n  <!--<?- SSRDataScript ?>-->\n  <!--<?- bottomTemplate ?>-->\n</body>\n\n</html>\n");
+};
+export var routesForServer = function routesForServer(_ref4) {
+  var routes = _ref4.routes,
+    alias = _ref4.alias;
+  var name = alias.name,
+    basename = alias.basename;
+  var loaders = [];
+  var traverseRouteTree = function traverseRouteTree(route) {
+    var children;
+    if ('children' in route && route.children) {
+      var _route$children;
+      children = route === null || route === void 0 ? void 0 : (_route$children = route.children) === null || _route$children === void 0 ? void 0 : _route$children.map(traverseRouteTree);
+    }
+    var loader;
+    if (route.type === 'nested') {
+      if (route.loader) {
+        loaders.push(route.loader);
+        loader = "loader_".concat(loaders.length - 1);
+      }
+    }
+    var finalRoute = _objectSpread(_objectSpread({}, route), {}, {
+      loader: loader,
+      children: children
+    });
+    return finalRoute;
+  };
+  var routesCode = "\n  export const routes = [\n  ";
+  var _iterator = _createForOfIteratorHelper(routes),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var route = _step.value;
+      if ('type' in route) {
+        var newRoute = traverseRouteTree(route);
+        routesCode += "".concat(JSON.stringify(newRoute, null, 2).replace(/"(loader_[^"])"/g, '$1'), ",");
+      } else {
+        routesCode += "".concat(JSON.stringify(route, null, 2));
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  routesCode += "\n];";
+  var importLoadersCode = loaders.map(function (loader, index) {
+    var realLoaderPath = loader.replace(name, basename);
+    return "import loader_".concat(index, " from '").concat(realLoaderPath, "';\n");
+  }).join('');
+  return "\n    ".concat(importLoadersCode, "\n    ").concat(routesCode, "\n  ");
+};
+export var fileSystemRoutes = function fileSystemRoutes(_ref5) {
+  var routes = _ref5.routes,
+    ssrMode = _ref5.ssrMode,
+    nestedRoutesEntry = _ref5.nestedRoutesEntry,
+    entryName = _ref5.entryName;
+  // The legacy mode and pages dir routes should use loadable
+  // nested routes + renderTostring should use loadable.lazy
+  // nested routes + renderToStream should use react.lazy
+  var importLazyCode = "\n    import { lazy } from \"react\";\n    import loadable, { lazy as loadableLazy } from \"@modern-js/runtime/loadable\"\n  ";
+  var dataLoaderPath = '';
+  if (ssrMode) {
+    dataLoaderPath = require.resolve("@modern-js/plugin-data-loader/loader");
+    if (nestedRoutesEntry) {
+      dataLoaderPath = "".concat(dataLoaderPath, "?routesDir=").concat(nestedRoutesEntry, "&entryName=").concat(entryName, "!");
+    }
+  }
+  var loadings = [];
+  var errors = [];
+  var loaders = [];
+  var traverseRouteTree = function traverseRouteTree(route) {
+    var children;
+    if ('children' in route && route.children) {
+      var _route$children2;
+      children = route === null || route === void 0 ? void 0 : (_route$children2 = route.children) === null || _route$children2 === void 0 ? void 0 : _route$children2.map(traverseRouteTree);
+    }
+    var loading;
+    var error;
+    var loader;
+    var component = '';
+    if (route.type === 'nested') {
+      if (route.loading) {
+        loadings.push(route.loading);
+        loading = "loading_".concat(loadings.length - 1);
+      }
+      if (route.error) {
+        errors.push(route.error);
+        error = "error_".concat(errors.length - 1);
+      }
+      if (route.loader) {
+        loaders.push(route.loader);
+        loader = "loader_".concat(loaders.length - 1);
+      }
+      if (route._component) {
+        if (ssrMode === 'stream') {
+          component = "lazy(() => import(/* webpackChunkName: \"".concat(route.id, "\" */  /* webpackMode: \"lazy-once\" */ '").concat(route._component, "'))");
+        } else {
+          component = "loadable(() => import(/* webpackChunkName: \"".concat(route.id, "\" */  /* webpackMode: \"lazy-once\" */ '").concat(route._component, "'))");
+        }
+      }
+    } else if (route._component) {
+      component = "loadable(() => import('".concat(route._component, "'))");
+    }
+    var finalRoute = _objectSpread(_objectSpread({}, route), {}, {
+      loading: loading,
+      loader: loader,
+      error: error,
+      children: children
+    });
+    if (route._component) {
+      finalRoute.component = component;
+    }
+    return finalRoute;
+  };
+  var routeComponentsCode = "\n    export const routes = [\n  ";
+  var _iterator2 = _createForOfIteratorHelper(routes),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var route = _step2.value;
+      if ('type' in route) {
+        var newRoute = traverseRouteTree(route);
+        routeComponentsCode += "".concat(JSON.stringify(newRoute, null, 2).replace(/"(loadable.*\))"/g, '$1').replace(/"(loadableLazy.*\))"/g, '$1').replace(/"(lazy.*\))"/g, '$1').replace(/"(loading_[^"])"/g, '$1').replace(/"(loader_[^"])"/g, '$1').replace(/"(error_[^"])"/g, '$1').replace(/\\"/g, '"'), ",");
+      } else {
+        var component = "loadable(() => import('".concat(route._component, "'))");
+        var finalRoute = _objectSpread(_objectSpread({}, route), {}, {
+          component: component
+        });
+        routeComponentsCode += "".concat(JSON.stringify(finalRoute, null, 2).replace(/"(loadable[^"]*)"/g, '$1').replace(/"(lazy[^"]*)"/g, '$1'), ",");
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  routeComponentsCode += "\n];";
+  var importLoadingCode = loadings.map(function (loading, index) {
+    return "import loading_".concat(index, " from '").concat(loading, "';\n");
+  }).join('');
+  var importErrorComponentsCode = errors.map(function (error, index) {
+    return "import error_".concat(index, " from '").concat(error, "';\n");
+  }).join('');
+  var importLoaderComponentsCode = loaders.map(function (loader, index) {
+    return "import loader_".concat(index, " from '").concat(dataLoaderPath).concat(loader, "';\n");
+  }).join('');
+  return "\n    ".concat(importLazyCode, "\n    ").concat(importLoadingCode, "\n    ").concat(importErrorComponentsCode, "\n    ").concat(importLoaderComponentsCode, "\n    ").concat(routeComponentsCode, "\n  ");
+};

package/dist/js/treeshaking/analyze/utils.js

@@ -0,0 +1,88 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import fs from 'fs';
+import path from 'path';
+import { isReact18, normalizeToPosixPath } from '@modern-js/utils';
+import { FILE_SYSTEM_ROUTES_FILE_NAME } from "./constants";
+export var walkDirectory = function walkDirectory(dir) {
+  return fs.readdirSync(dir).reduce(function (previous, filename) {
+    var filePath = path.join(dir, filename);
+    if (fs.statSync(filePath).isDirectory()) {
+      return [].concat(_toConsumableArray(previous), _toConsumableArray(walkDirectory(filePath)));
+    } else {
+      return [].concat(_toConsumableArray(previous), [filePath]);
+    }
+  }, []);
+};
+export var getDefaultImports = function getDefaultImports(_ref) {
+  var entrypoint = _ref.entrypoint,
+    srcDirectory = _ref.srcDirectory,
+    internalSrcAlias = _ref.internalSrcAlias,
+    internalDirAlias = _ref.internalDirAlias,
+    internalDirectory = _ref.internalDirectory;
+  var entryName = entrypoint.entryName,
+    fileSystemRoutes = entrypoint.fileSystemRoutes,
+    customBootstrap = entrypoint.customBootstrap,
+    entry = entrypoint.entry;
+  var imports = [{
+    specifiers: [{
+      local: 'React'
+    }],
+    value: 'react'
+  }, {
+    specifiers: [{
+      local: 'ReactDOM'
+    }],
+    value: isReact18(path.join(internalDirectory, '../../')) ? 'react-dom/client' : 'react-dom'
+  }, {
+    specifiers: [{
+      imported: 'createApp'
+    }, {
+      imported: 'bootstrap'
+    }],
+    value: '@modern-js/runtime'
+  }, customBootstrap && {
+    specifiers: [{
+      local: 'customBootstrap'
+    }],
+    value: normalizeToPosixPath(customBootstrap.replace(srcDirectory, internalSrcAlias))
+  }].filter(Boolean);
+  if (fileSystemRoutes) {
+    var route = {
+      specifiers: [{
+        imported: 'routes'
+      }],
+      value: normalizeToPosixPath("".concat(internalDirAlias, "/").concat(entryName, "/").concat(FILE_SYSTEM_ROUTES_FILE_NAME))
+    };
+    if (fileSystemRoutes.globalApp) {
+      imports.push({
+        specifiers: [{
+          local: 'App'
+        }],
+        value: normalizeToPosixPath(fileSystemRoutes.globalApp.replace(srcDirectory, internalSrcAlias))
+      });
+    } else {
+      route.initialize = 'const App = false;';
+    }
+    imports.push(route);
+  } else {
+    imports.push({
+      specifiers: [{
+        local: 'App'
+      }],
+      value: normalizeToPosixPath(entry.replace(srcDirectory, internalSrcAlias))
+    });
+  }
+  return imports;
+};
+export var isRouteComponentFile = function isRouteComponentFile(filePath) {
+  if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) {
+    return false;
+  }
+  if (['.js', '.jsx', '.ts', '.tsx'].includes(path.extname(filePath))) {
+    return true;
+  }
+  return false;
+};
+export var replaceWithAlias = function replaceWithAlias(base, filePath, alias) {
+  return normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
+};

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

@@ -0,0 +1,212 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { join } from 'path';
+import { mergeBuilderConfig } from '@modern-js/builder-shared';
+import { template as lodashTemplate } from '@modern-js/utils/lodash';
+import HtmlWebpackPlugin from '@modern-js/builder-webpack-provider/html-webpack-plugin';
+import { getEntryOptions } from '@modern-js/utils';
+import { BottomTemplatePlugin } from "../webpackPlugins/htmlBottomTemplate";
+import { HtmlAsyncChunkPlugin } from "../webpackPlugins/htmlAsyncChunkPlugin";
+import { createCopyPattern } from "../share";
+import RouterPlugin from "../webpackPlugins/routerPlugin";
+/**
+ * Provides default configuration consistent with `@modern-js/webpack`
+ */
+export var PluginCompatModern = function PluginCompatModern(appContext, modernConfig, options) {
+  return {
+    name: 'builder-plugin-compat-modern',
+    setup: function setup(api) {
+      api.modifyBuilderConfig(function (config) {
+        if (isStreamingSSR(modernConfig)) {
+          return mergeBuilderConfig(config, {
+            html: {
+              inject: 'body'
+            }
+          });
+        }
+        return config;
+      });
+      api.modifyWebpackChain(function (chain, _ref) {
+        var target = _ref.target,
+          CHAIN_ID = _ref.CHAIN_ID,
+          isProd = _ref.isProd;
+        var builderNormalizedConfig = api.getNormalizedConfig();
+        // set webpack config name
+        if (target === 'node') {
+          chain.name('server');
+        } else if (target === 'modern-web') {
+          chain.name('modern');
+        } else {
+          chain.name('client');
+        }
+        chain.resolve.modules.add('node_modules').add(join(api.context.rootPath, 'node_modules'));
+
+        // apply node compat
+        if (target === 'node') {
+          applyNodeCompat(chain, modernConfig, isProd);
+        }
+        if (isHtmlEnabled(builderNormalizedConfig, target)) {
+          applyBottomHtmlWebpackPlugin({
+            api: api,
+            chain: chain,
+            CHAIN_ID: CHAIN_ID,
+            appContext: appContext,
+            modernConfig: modernConfig
+          });
+          applyAsyncChunkHtmlPlugin({
+            chain: chain,
+            CHAIN_ID: CHAIN_ID,
+            modernConfig: modernConfig
+          });
+        }
+
+        // apply copy plugin
+        // const copyPatterns = createCopyPatterns(chain, appContext, modernConfig);
+        var defaultCopyPattern = createCopyPattern(appContext, modernConfig, 'public', chain);
+        chain.plugin(CHAIN_ID.PLUGIN.COPY).tap(function (args) {
+          var _args$;
+          return [{
+            patterns: [].concat(_toConsumableArray(((_args$ = args[0]) === null || _args$ === void 0 ? void 0 : _args$.patterns) || []), [defaultCopyPattern])
+          }];
+        });
+        var entrypoints = appContext.entrypoints;
+        var existNestedRoutes = entrypoints.some(function (entrypoint) {
+          return entrypoint.nestedRoutesEntry;
+        });
+        chain.plugin('route-plugin').use(RouterPlugin, [{
+          existNestedRoutes: existNestedRoutes
+        }]);
+        function isHtmlEnabled(config, target) {
+          var _config$tools;
+          return ((_config$tools = config.tools) === null || _config$tools === void 0 ? void 0 : _config$tools.htmlPlugin) !== false && target !== 'node' && target !== 'web-worker';
+        }
+      });
+      if (options) {
+        applyCallbacks(api, options);
+      }
+    }
+  };
+};
+
+/**
+ * register builder hooks callback
+ */
+function applyCallbacks(api, options) {
+  options.onAfterBuild && api.onAfterBuild(options.onAfterBuild);
+  options.onAfterCreateCompiler && api.onAfterCreateCompiler(options.onAfterCreateCompiler);
+  options.onAfterStartDevServer && api.onAfterStartDevServer(options.onAfterStartDevServer);
+  options.onBeforeBuild && api.onBeforeBuild(options.onBeforeBuild);
+  options.onBeforeCreateCompiler && api.onBeforeCreateCompiler(options.onBeforeCreateCompiler);
+  options.onBeforeStartDevServer && api.onBeforeStartDevServer(options.onBeforeStartDevServer);
+  options.onDevCompileDone && api.onDevCompileDone(options.onDevCompileDone);
+  options.onExit && api.onExit(options.onExit);
+}
+
+/**
+ * compat some config, if target is `node`
+ */
+function applyNodeCompat(chain, modernConfig, isProd) {
+  // apply node resolve extensions
+  for (var _i = 0, _arr = ['.node.js', '.node.jsx', '.node.ts', '.node.tsx']; _i < _arr.length; _i++) {
+    var ext = _arr[_i];
+    chain.resolve.extensions.prepend(ext);
+  }
+
+  // apply filterEntriesBySSRConfig
+  filterEntriesBySSRConfig(isProd, chain, modernConfig.server, modernConfig.output);
+  function filterEntriesBySSRConfig(isProd, chain, serverConfig, outputConfig) {
+    var _outputConfig$ssg;
+    var entries = chain.entryPoints.entries();
+    // if prod and ssg config is true or function
+    if (isProd && ((outputConfig === null || outputConfig === void 0 ? void 0 : outputConfig.ssg) === true || typeof (outputConfig === null || outputConfig === void 0 ? void 0 : (_outputConfig$ssg = outputConfig.ssg) === null || _outputConfig$ssg === void 0 ? void 0 : _outputConfig$ssg[0]) === 'function')) {
+      return;
+    }
+
+    // if single entry has ssg config
+    // `ssg: {}` is not allowed if multi entry
+    var entryNames = Object.keys(entries);
+    if (isProd && entryNames.length === 1 && outputConfig !== null && outputConfig !== void 0 && outputConfig.ssg) {
+      return;
+    }
+
+    // collect all ssg entries
+    var ssgEntries = [];
+    if (isProd && outputConfig !== null && outputConfig !== void 0 && outputConfig.ssg) {
+      var ssg = outputConfig.ssg;
+      entryNames.forEach(function (name) {
+        if (ssg[name]) {
+          ssgEntries.push(name);
+        }
+      });
+    }
+    var _ref2 = serverConfig || {},
+      ssr = _ref2.ssr,
+      ssrByEntries = _ref2.ssrByEntries;
+    entryNames.forEach(function (name) {
+      if (!ssgEntries.includes(name) && (ssr && (ssrByEntries === null || ssrByEntries === void 0 ? void 0 : ssrByEntries[name]) === false || !ssr && !(ssrByEntries !== null && ssrByEntries !== void 0 && ssrByEntries[name]))) {
+        chain.entryPoints["delete"](name);
+      }
+    });
+  }
+}
+
+/**
+ * inject bottom template
+ */
+function applyBottomHtmlWebpackPlugin(_ref3) {
+  var api = _ref3.api,
+    chain = _ref3.chain,
+    modernConfig = _ref3.modernConfig,
+    appContext = _ref3.appContext,
+    CHAIN_ID = _ref3.CHAIN_ID;
+  var _loop = function _loop() {
+    var entryName = _Object$keys[_i2];
+    // FIXME: the only need necessary
+    var baseTemplateParams = _objectSpread({
+      entryName: entryName,
+      title: getEntryOptions(entryName, modernConfig.output.title, modernConfig.output.titleByEntries, appContext.packageName),
+      mountId: modernConfig.output.mountId
+    }, getEntryOptions(entryName, modernConfig.output.templateParameters, modernConfig.output.templateParametersByEntries, appContext.packageName));
+    chain.plugin("".concat(CHAIN_ID.PLUGIN.HTML, "-").concat(entryName)).tap(function (args) {
+      return [_objectSpread(_objectSpread({}, args[0] || {}), {}, {
+        __internal__: true,
+        bottomTemplate: appContext.htmlTemplates["__".concat(entryName, "-bottom__")] && lodashTemplate(appContext.htmlTemplates["__".concat(entryName, "-bottom__")])(baseTemplateParams)
+      })];
+    });
+  };
+  // inject bottomTemplate into html-webpack-plugin
+  for (var _i2 = 0, _Object$keys = Object.keys(api.context.entry); _i2 < _Object$keys.length; _i2++) {
+    _loop();
+  }
+  chain.plugin(CHAIN_ID.PLUGIN.BOTTOM_TEMPLATE).use(BottomTemplatePlugin, [HtmlWebpackPlugin]);
+}
+var isStreamingSSR = function isStreamingSSR(userConfig) {
+  var isStreaming = function isStreaming(ssr) {
+    return ssr && _typeof(ssr) === 'object' && ssr.mode === 'stream';
+  };
+  var server = userConfig.server;
+  if (isStreaming(server.ssr)) {
+    return true;
+  }
+
+  // Since we cannot apply different plugins for different entries,
+  // we regard the whole app as streaming ssr only if one entry meets the requirement.
+  if (server !== null && server !== void 0 && server.ssrByEntries && _typeof(server.ssrByEntries) === 'object') {
+    for (var _i3 = 0, _Object$keys2 = Object.keys(server.ssrByEntries); _i3 < _Object$keys2.length; _i3++) {
+      var name = _Object$keys2[_i3];
+      if (isStreaming(server.ssrByEntries[name])) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+function applyAsyncChunkHtmlPlugin(_ref4) {
+  var chain = _ref4.chain,
+    modernConfig = _ref4.modernConfig,
+    CHAIN_ID = _ref4.CHAIN_ID;
+  if (isStreamingSSR(modernConfig)) {
+    chain.plugin(CHAIN_ID.PLUGIN.HTML_ASYNC_CHUNK).use(HtmlAsyncChunkPlugin, [HtmlWebpackPlugin]);
+  }
+}