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

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

@@ -0,0 +1,214 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import * as path from 'path';
+import { createAsyncWaterfall } from '@modern-js/plugin';
+import { createDebugger, fs, isApiOnly } from '@modern-js/utils';
+import { cloneDeep } from '@modern-js/utils/lodash';
+import { isRouteComponentFile } from "./utils";
+var debug = createDebugger('plugin-analyze');
+export var modifyEntryImports = createAsyncWaterfall();
+export var modifyEntryExport = createAsyncWaterfall();
+export var addRuntimeExports = createAsyncWaterfall();
+export var modifyEntryRuntimePlugins = createAsyncWaterfall();
+export var modifyEntryRenderFunction = createAsyncWaterfall();
+export var modifyAsyncEntry = createAsyncWaterfall();
+export var modifyFileSystemRoutes = createAsyncWaterfall();
+export var modifyServerRoutes = createAsyncWaterfall();
+export var htmlPartials = createAsyncWaterfall();
+export var beforeGenerateRoutes = createAsyncWaterfall();
+export var addDefineTypes = createAsyncWaterfall();
+export default (function () {
+  return {
+    name: '@modern-js/plugin-analyze',
+    registerHook: {
+      modifyAsyncEntry: modifyAsyncEntry,
+      modifyEntryImports: modifyEntryImports,
+      modifyEntryExport: modifyEntryExport,
+      modifyEntryRuntimePlugins: modifyEntryRuntimePlugins,
+      modifyEntryRenderFunction: modifyEntryRenderFunction,
+      modifyFileSystemRoutes: modifyFileSystemRoutes,
+      modifyServerRoutes: modifyServerRoutes,
+      htmlPartials: htmlPartials,
+      addRuntimeExports: addRuntimeExports,
+      beforeGenerateRoutes: beforeGenerateRoutes,
+      addDefineTypes: addDefineTypes
+    },
+    setup: function setup(api) {
+      var pagesDir = [];
+      var originEntrypoints = [];
+      return {
+        prepare: function prepare() {
+          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+            var _resolvedConfig$sourc;
+
+            var appContext, resolvedConfig, hookRunners, apiOnly, _yield$hookRunners$mo, _routes, _yield$Promise$all, _yield$Promise$all2, getBundleEntry, getServerRoutes, generateCode, getHtmlTemplate, entrypoints, defaultChecked, initialRoutes, _yield$hookRunners$mo2, routes, nestedRouteEntries, htmlTemplates;
+
+            return _regeneratorRuntime().wrap(function _callee$(_context) {
+              while (1) {
+                switch (_context.prev = _context.next) {
+                  case 0:
+                    appContext = api.useAppContext();
+                    resolvedConfig = api.useResolvedConfigContext();
+                    hookRunners = api.useHookRunners();
+
+                    try {
+                      fs.emptydirSync(appContext.internalDirectory);
+                    } catch (_unused) {// FIXME:
+                    }
+
+                    _context.next = 6;
+                    return isApiOnly(appContext.appDirectory, resolvedConfig === null || resolvedConfig === void 0 ? void 0 : (_resolvedConfig$sourc = resolvedConfig.source) === null || _resolvedConfig$sourc === void 0 ? void 0 : _resolvedConfig$sourc.entriesDir);
+
+                  case 6:
+                    apiOnly = _context.sent;
+                    _context.next = 9;
+                    return hookRunners.addRuntimeExports();
+
+                  case 9:
+                    if (!apiOnly) {
+                      _context.next = 17;
+                      break;
+                    }
+
+                    _context.next = 12;
+                    return hookRunners.modifyServerRoutes({
+                      routes: []
+                    });
+
+                  case 12:
+                    _yield$hookRunners$mo = _context.sent;
+                    _routes = _yield$hookRunners$mo.routes;
+                    debug("server routes: %o", _routes);
+                    api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
+                      apiOnly: apiOnly,
+                      serverRoutes: _routes
+                    }));
+                    return _context.abrupt("return");
+
+                  case 17:
+                    _context.next = 19;
+                    return Promise.all([import("./getBundleEntry"), import("./getServerRoutes"), import("./generateCode"), import("./getHtmlTemplate")]);
+
+                  case 19:
+                    _yield$Promise$all = _context.sent;
+                    _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 4);
+                    getBundleEntry = _yield$Promise$all2[0].getBundleEntry;
+                    getServerRoutes = _yield$Promise$all2[1].getServerRoutes;
+                    generateCode = _yield$Promise$all2[2].generateCode;
+                    getHtmlTemplate = _yield$Promise$all2[3].getHtmlTemplate;
+                    entrypoints = getBundleEntry(appContext, resolvedConfig);
+                    defaultChecked = entrypoints.map(function (point) {
+                      return point.entryName;
+                    });
+                    debug("entrypoints: %o", entrypoints);
+                    initialRoutes = getServerRoutes(entrypoints, {
+                      appContext: appContext,
+                      config: resolvedConfig
+                    });
+                    _context.next = 31;
+                    return hookRunners.modifyServerRoutes({
+                      routes: initialRoutes
+                    });
+
+                  case 31:
+                    _yield$hookRunners$mo2 = _context.sent;
+                    routes = _yield$hookRunners$mo2.routes;
+                    debug("server routes: %o", routes);
+                    api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
+                      entrypoints: entrypoints,
+                      serverRoutes: routes
+                    }));
+                    nestedRouteEntries = entrypoints.map(function (point) {
+                      return point.nestedRoutesEntry;
+                    }).filter(Boolean);
+                    pagesDir = entrypoints.map(function (point) {
+                      return point.entry;
+                    }).filter(Boolean).concat(nestedRouteEntries);
+                    originEntrypoints = cloneDeep(entrypoints);
+                    _context.next = 40;
+                    return generateCode(appContext, resolvedConfig, entrypoints, api);
+
+                  case 40:
+                    _context.next = 42;
+                    return getHtmlTemplate(entrypoints, api, {
+                      appContext: appContext,
+                      config: resolvedConfig
+                    });
+
+                  case 42:
+                    htmlTemplates = _context.sent;
+                    debug("html templates: %o", htmlTemplates);
+                    _context.next = 46;
+                    return hookRunners.addDefineTypes();
+
+                  case 46:
+                    debug("add Define Types");
+                    api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
+                      entrypoints: entrypoints,
+                      checkedEntries: defaultChecked,
+                      apiOnly: apiOnly,
+                      serverRoutes: routes,
+                      htmlTemplates: htmlTemplates
+                    }));
+
+                  case 48:
+                  case "end":
+                    return _context.stop();
+                }
+              }
+            }, _callee);
+          }))();
+        },
+        watchFiles: function watchFiles() {
+          return pagesDir;
+        },
+        fileChange: function fileChange(e) {
+          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+            var appContext, appDirectory, filename, eventType, isPageFile, absoluteFilePath, isRouteComponent, resolvedConfig, _yield$import, generateCode, entrypoints;
+
+            return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+              while (1) {
+                switch (_context2.prev = _context2.next) {
+                  case 0:
+                    appContext = api.useAppContext();
+                    appDirectory = appContext.appDirectory;
+                    filename = e.filename, eventType = e.eventType;
+
+                    isPageFile = function isPageFile(name) {
+                      return pagesDir.some(function (pageDir) {
+                        return name.includes(pageDir);
+                      });
+                    };
+
+                    absoluteFilePath = path.resolve(appDirectory, filename);
+                    isRouteComponent = isPageFile(absoluteFilePath) && isRouteComponentFile(absoluteFilePath);
+
+                    if (!(isRouteComponent && (eventType === 'add' || eventType === 'unlink'))) {
+                      _context2.next = 14;
+                      break;
+                    }
+
+                    resolvedConfig = api.useResolvedConfigContext();
+                    _context2.next = 10;
+                    return import("./generateCode");
+
+                  case 10:
+                    _yield$import = _context2.sent;
+                    generateCode = _yield$import.generateCode;
+                    entrypoints = cloneDeep(originEntrypoints);
+                    generateCode(appContext, resolvedConfig, entrypoints, api);
+
+                  case 14:
+                  case "end":
+                    return _context2.stop();
+                }
+              }
+            }, _callee2);
+          }))();
+        }
+      };
+    }
+  };
+});

package/dist/js/treeshaking/analyze/isDefaultExportFunction.js

@@ -0,0 +1,32 @@
+import fs from 'fs';
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+
+var isFunction = function isFunction(node) {
+  return t.isFunctionDeclaration(node) || t.isFunctionExpression(node) || t.isArrowFunctionExpression(node);
+};
+
+export var isDefaultExportFunction = function isDefaultExportFunction(file) {
+  if (!file || !fs.existsSync(file)) {
+    return false;
+  }
+
+  var ast = parse(fs.readFileSync(file, 'utf8'), {
+    sourceType: 'unambiguous',
+    plugins: ['jsx', 'typescript', 'classProperties', 'dynamicImport', 'exportDefaultFrom', 'exportNamespaceFrom', 'decorators-legacy', 'functionBind', 'classPrivateMethods', ['pipelineOperator', {
+      proposal: 'minimal'
+    }], 'optionalChaining', 'optionalCatchBinding', 'objectRestSpread', 'numericSeparator']
+  });
+  var isExportFunction = false;
+  traverse(ast, {
+    ExportDefaultDeclaration: function ExportDefaultDeclaration(path) {
+      var declaration = path.node.declaration;
+
+      if (isFunction(declaration)) {
+        isExportFunction = true;
+      }
+    }
+  });
+  return isExportFunction;
+};

package/dist/js/treeshaking/analyze/makeLegalIdentifier.js

@@ -0,0 +1,18 @@
+/**
+ * modified from https://github.com/rollup/plugins/blob/master/packages/pluginutils
+ * license at https://github.com/rollup/plugins/blob/master/LICENSE
+ */
+var reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
+var builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+var forbidList = new Set("".concat(reservedWords, " ").concat(builtins).split(' '));
+export function makeLegalIdentifier(str) {
+  var identifier = str.replace(/-(\w)/g, function (_, letter) {
+    return letter.toUpperCase();
+  }).replace(/[^$_a-zA-Z0-9]/g, '_');
+
+  if (/\d/.test(identifier[0]) || forbidList.has(identifier)) {
+    return "_".concat(identifier);
+  }
+
+  return identifier || '_';
+}

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

@@ -0,0 +1,207 @@
+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) {
+  return createRoute(_objectSpread(_objectSpread({}, routeInfo), {}, {
+    index: true,
+    children: undefined
+  }), rootDir, filename);
+};
+
+var createRoute = function createRoute(routeInfo, rootDir, filename) {
+  var id = getRouteId(filename, rootDir);
+  return _objectSpread(_objectSpread({}, routeInfo), {}, {
+    id: id,
+    type: 'nested'
+  });
+};
+
+export var walk = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(dirname, rootDir, alias) {
+    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);
+
+          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);
+              (_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")));
+            /**
+             * 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) {
+    return _ref.apply(this, arguments);
+  };
+}();

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

@@ -0,0 +1,189 @@
+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;
+  var importLazyCode = ssrMode === 'stream' ? 'import { lazy } from "react";' : "import loadable from '@modern-js/runtime/loadable'";
+  var dataLoaderPath = '';
+
+  if (ssrMode) {
+    dataLoaderPath = require.resolve("@modern-js/plugin-data-loader/loader");
+
+    if (nestedRoutesEntry) {
+      dataLoaderPath = "".concat(dataLoaderPath, "?routesDir=").concat(nestedRoutesEntry, "!");
+    }
+  }
+
+  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;
+
+    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);
+      }
+    }
+
+    var finalRoute = _objectSpread(_objectSpread({}, route), {}, {
+      loading: loading,
+      loader: loader,
+      error: error,
+      children: children
+    });
+
+    if (route._component) {
+      var component = ssrMode === 'stream' ? "lazy(() => import('".concat(route._component, "'))") : "loadable(() => import('".concat(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(/"(lazy[^"]*)"/g, '$1').replace(/"(loading_[^"])"/g, '$1').replace(/"(loader_[^"])"/g, '$1').replace(/"(error_[^"])"/g, '$1'), ",");
+      } else {
+        var component = ssrMode === 'stream' ? "lazy(() => import('".concat(route._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  ");
+};