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

package/dist/js/treeshaking/analyze/generateCode.js

@@ -0,0 +1,412 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import path from 'path';
+import { fs, logger } from '@modern-js/utils';
+import { useResolvedConfigContext } from '@modern-js/core';
+import esbuild from 'esbuild';
+import { getCommand } from "../utils/commands";
+import * as templates from "./templates";
+import { getClientRoutes, getClientRoutesLegacy } from "./getClientRoutes";
+import { FILE_SYSTEM_ROUTES_FILE_NAME, ENTRY_POINT_FILE_NAME, ENTRY_BOOTSTRAP_FILE_NAME } from "./constants";
+import { getDefaultImports } from "./utils";
+import { walk } from "./nestedRoutes";
+
+var createImportSpecifier = function createImportSpecifier(specifiers) {
+  var defaults = '';
+  var named = [];
+
+  var _iterator = _createForOfIteratorHelper(specifiers),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _step.value,
+          local = _step$value.local,
+          imported = _step$value.imported;
+
+      if (local && imported) {
+        named.push("".concat(imported, " as ").concat(local));
+      } else if (local) {
+        defaults = local;
+      } else {
+        named.push(imported);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  if (defaults && named.length) {
+    return "".concat(defaults, ", { ").concat(named.join(', '), " }");
+  } else if (defaults) {
+    return defaults;
+  } else {
+    return "{ ".concat(named.join(', '), " }");
+  }
+};
+
+export var createImportStatements = function createImportStatements(statements) {
+  // merge import statements with the same value.
+  var deDuplicated = [];
+  var seen = new Map();
+
+  var _iterator2 = _createForOfIteratorHelper(statements),
+      _step2;
+
+  try {
+    var _loop = function _loop() {
+      var _step2$value = _step2.value,
+          value = _step2$value.value,
+          specifiers = _step2$value.specifiers,
+          initialize = _step2$value.initialize;
+
+      if (!seen.has(value)) {
+        deDuplicated.push({
+          value: value,
+          specifiers: specifiers,
+          initialize: initialize
+        });
+        seen.set(value, specifiers);
+      } else {
+        var _seen$get, _deDuplicated$modifyI, _deDuplicated$modifyI2;
+
+        (_seen$get = seen.get(value)).push.apply(_seen$get, _toConsumableArray(specifiers)); // make "initialize" param can be connected when multiple plugins were imported from same package
+
+
+        var modifyIndex = deDuplicated.findIndex(function (v) {
+          return v.value === value;
+        });
+        var originInitialize = (_deDuplicated$modifyI = (_deDuplicated$modifyI2 = deDuplicated[modifyIndex]) === null || _deDuplicated$modifyI2 === void 0 ? void 0 : _deDuplicated$modifyI2.initialize) !== null && _deDuplicated$modifyI !== void 0 ? _deDuplicated$modifyI : '';
+        deDuplicated[modifyIndex].initialize = originInitialize.concat("\n".concat(initialize || ''));
+      }
+    };
+
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      _loop();
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+
+  return deDuplicated.map(function (_ref) {
+    var value = _ref.value,
+        specifiers = _ref.specifiers,
+        initialize = _ref.initialize;
+    return "import ".concat(createImportSpecifier(specifiers), " from '").concat(value, "';\n").concat(initialize || '');
+  }).join('\n');
+};
+
+var buildLoader = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(entry, outfile) {
+    var loader, EXTERNAL_REGEXP, command;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            loader = {
+              '.js': 'jsx',
+              '.ts': 'tsx'
+            };
+            EXTERNAL_REGEXP = /^[^./]|^\.[^./]|^\.\.[^/]/;
+            command = getCommand();
+            _context.next = 5;
+            return esbuild.build({
+              format: 'cjs',
+              platform: 'node',
+              target: 'esnext',
+              loader: loader,
+              watch: command === 'dev' && {},
+              bundle: true,
+              logLevel: 'error',
+              entryPoints: [entry],
+              outfile: outfile,
+              plugins: [{
+                name: 'make-all-packages-external',
+                setup: function setup(build) {
+                  // https://github.com/evanw/esbuild/issues/619#issuecomment-751995294
+                  build.onResolve({
+                    filter: EXTERNAL_REGEXP
+                  }, function (args) {
+                    var external = true; // FIXME: windows external entrypoint
+
+                    if (args.kind === 'entry-point') {
+                      external = false;
+                    }
+
+                    return {
+                      path: args.path,
+                      external: external
+                    };
+                  });
+                }
+              }]
+            });
+
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function buildLoader(_x, _x2) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+export var generateCode = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(appContext, config, entrypoints, api) {
+    var _config$runtime, _config$runtime$route;
+
+    var internalDirectory, distDirectory, srcDirectory, internalDirAlias, internalSrcAlias, hookRunners, islegacy, mountId, getRoutes, generateEntryCode, _generateEntryCode;
+
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _generateEntryCode = function _generateEntryCode3() {
+              _generateEntryCode = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(entrypoint) {
+                var entryName, isAutoMount, customBootstrap, fileSystemRoutes, initialRoutes, nestedRoute, _yield$hookRunners$mo, routes, _config, ssr, mode, _yield$hookRunners$be, _code, routesServerFile, outputRoutesServerFile, _code2, _yield$hookRunners$mo2, importStatements, _yield$hookRunners$mo3, plugins, _yield$hookRunners$mo4, renderFunction, _yield$hookRunners$mo5, exportStatement, code, entryFile, _yield$hookRunners$mo6, asyncEntryCode, bootstrapFile;
+
+                return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+                  while (1) {
+                    switch (_context2.prev = _context2.next) {
+                      case 0:
+                        entryName = entrypoint.entryName, isAutoMount = entrypoint.isAutoMount, customBootstrap = entrypoint.customBootstrap, fileSystemRoutes = entrypoint.fileSystemRoutes;
+
+                        if (!isAutoMount) {
+                          _context2.next = 68;
+                          break;
+                        }
+
+                        if (!fileSystemRoutes) {
+                          _context2.next = 38;
+                          break;
+                        }
+
+                        initialRoutes = [];
+                        nestedRoute = null;
+
+                        if (entrypoint.entry) {
+                          initialRoutes = getRoutes({
+                            entrypoint: entrypoint,
+                            srcDirectory: srcDirectory,
+                            srcAlias: internalSrcAlias,
+                            internalDirectory: internalDirectory,
+                            internalDirAlias: internalDirAlias
+                          });
+                        }
+
+                        if (!entrypoint.nestedRoutesEntry) {
+                          _context2.next = 16;
+                          break;
+                        }
+
+                        if (islegacy) {
+                          _context2.next = 14;
+                          break;
+                        }
+
+                        _context2.next = 10;
+                        return walk(entrypoint.nestedRoutesEntry, entrypoint.nestedRoutesEntry, {
+                          name: internalSrcAlias,
+                          basename: srcDirectory
+                        });
+
+                      case 10:
+                        nestedRoute = _context2.sent;
+
+                        if (nestedRoute) {
+                          initialRoutes.unshift(nestedRoute);
+                        }
+
+                        _context2.next = 16;
+                        break;
+
+                      case 14:
+                        logger.error('Nested routes is not supported in legacy mode.'); // eslint-disable-next-line no-process-exit
+
+                        process.exit(1);
+
+                      case 16:
+                        _context2.next = 18;
+                        return hookRunners.modifyFileSystemRoutes({
+                          entrypoint: entrypoint,
+                          routes: initialRoutes
+                        });
+
+                      case 18:
+                        _yield$hookRunners$mo = _context2.sent;
+                        routes = _yield$hookRunners$mo.routes;
+                        _config = useResolvedConfigContext();
+                        ssr = _config === null || _config === void 0 ? void 0 : _config.server.ssr;
+
+                        if (ssr) {
+                          mode = _typeof(ssr) === 'object' ? ssr.mode || 'string' : 'string';
+                        } else {
+                          mode = false;
+                        }
+
+                        _context2.next = 25;
+                        return hookRunners.beforeGenerateRoutes({
+                          entrypoint: entrypoint,
+                          code: templates.fileSystemRoutes({
+                            routes: routes,
+                            ssrMode: mode,
+                            nestedRoutesEntry: entrypoint.nestedRoutesEntry
+                          })
+                        });
+
+                      case 25:
+                        _yield$hookRunners$be = _context2.sent;
+                        _code = _yield$hookRunners$be.code;
+
+                        if (!entrypoint.nestedRoutesEntry) {
+                          _context2.next = 37;
+                          break;
+                        }
+
+                        routesServerFile = path.join(internalDirectory, entryName, 'routes.server.js');
+                        outputRoutesServerFile = path.join(distDirectory, 'loader-routes', entryName, 'index.js');
+                        _code2 = templates.routesForServer({
+                          routes: routes,
+                          alias: {
+                            name: internalSrcAlias,
+                            basename: srcDirectory
+                          }
+                        });
+                        _context2.next = 33;
+                        return fs.ensureFile(routesServerFile);
+
+                      case 33:
+                        _context2.next = 35;
+                        return fs.writeFile(routesServerFile, _code2);
+
+                      case 35:
+                        _context2.next = 37;
+                        return buildLoader(routesServerFile, outputRoutesServerFile);
+
+                      case 37:
+                        fs.outputFileSync(path.resolve(internalDirectory, "./".concat(entryName, "/").concat(FILE_SYSTEM_ROUTES_FILE_NAME)), _code, 'utf8');
+
+                      case 38:
+                        _context2.next = 40;
+                        return hookRunners.modifyEntryImports({
+                          entrypoint: entrypoint,
+                          imports: getDefaultImports({
+                            entrypoint: entrypoint,
+                            srcDirectory: srcDirectory,
+                            internalSrcAlias: internalSrcAlias,
+                            internalDirAlias: internalDirAlias,
+                            internalDirectory: internalDirectory
+                          })
+                        });
+
+                      case 40:
+                        _yield$hookRunners$mo2 = _context2.sent;
+                        importStatements = _yield$hookRunners$mo2.imports;
+                        _context2.next = 44;
+                        return hookRunners.modifyEntryRuntimePlugins({
+                          entrypoint: entrypoint,
+                          plugins: []
+                        });
+
+                      case 44:
+                        _yield$hookRunners$mo3 = _context2.sent;
+                        plugins = _yield$hookRunners$mo3.plugins;
+                        _context2.next = 48;
+                        return hookRunners.modifyEntryRenderFunction({
+                          entrypoint: entrypoint,
+                          code: templates.renderFunction({
+                            plugins: plugins,
+                            customBootstrap: customBootstrap,
+                            fileSystemRoutes: fileSystemRoutes
+                          })
+                        });
+
+                      case 48:
+                        _yield$hookRunners$mo4 = _context2.sent;
+                        renderFunction = _yield$hookRunners$mo4.code;
+                        _context2.next = 52;
+                        return hookRunners.modifyEntryExport({
+                          entrypoint: entrypoint,
+                          exportStatement: 'export default AppWrapper;'
+                        });
+
+                      case 52:
+                        _yield$hookRunners$mo5 = _context2.sent;
+                        exportStatement = _yield$hookRunners$mo5.exportStatement;
+                        code = templates.index({
+                          mountId: mountId,
+                          imports: createImportStatements(importStatements),
+                          renderFunction: renderFunction,
+                          exportStatement: exportStatement
+                        });
+                        entryFile = path.resolve(internalDirectory, "./".concat(entryName, "/").concat(ENTRY_POINT_FILE_NAME));
+                        entrypoint.entry = entryFile; // generate entry file.
+
+                        if (!config.source.enableAsyncEntry) {
+                          _context2.next = 67;
+                          break;
+                        }
+
+                        _context2.next = 60;
+                        return hookRunners.modifyAsyncEntry({
+                          entrypoint: entrypoint,
+                          code: "import('./".concat(ENTRY_BOOTSTRAP_FILE_NAME, "');")
+                        });
+
+                      case 60:
+                        _yield$hookRunners$mo6 = _context2.sent;
+                        asyncEntryCode = _yield$hookRunners$mo6.code;
+                        fs.outputFileSync(entryFile, asyncEntryCode, 'utf8');
+                        bootstrapFile = path.resolve(internalDirectory, "./".concat(entryName, "/").concat(ENTRY_BOOTSTRAP_FILE_NAME));
+                        fs.outputFileSync(bootstrapFile, code, 'utf8');
+                        _context2.next = 68;
+                        break;
+
+                      case 67:
+                        fs.outputFileSync(entryFile, code, 'utf8');
+
+                      case 68:
+                      case "end":
+                        return _context2.stop();
+                    }
+                  }
+                }, _callee2);
+              }));
+              return _generateEntryCode.apply(this, arguments);
+            };
+
+            generateEntryCode = function _generateEntryCode2(_x7) {
+              return _generateEntryCode.apply(this, arguments);
+            };
+
+            internalDirectory = appContext.internalDirectory, distDirectory = appContext.distDirectory, srcDirectory = appContext.srcDirectory, internalDirAlias = appContext.internalDirAlias, internalSrcAlias = appContext.internalSrcAlias;
+            hookRunners = api.useHookRunners();
+            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);
+            mountId = config.output.mountId;
+            getRoutes = islegacy ? getClientRoutesLegacy : getClientRoutes;
+            _context3.next = 9;
+            return Promise.all(entrypoints.map(generateEntryCode));
+
+          case 9:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+
+  return function generateCode(_x3, _x4, _x5, _x6) {
+    return _ref3.apply(this, arguments);
+  };
+}();

package/dist/js/treeshaking/analyze/getBundleEntry.js

@@ -0,0 +1,77 @@
+import path from 'path';
+import { ensureAbsolutePath, fs, findExists, MAIN_ENTRY_NAME } from '@modern-js/utils';
+import { getFileSystemEntry } from "./getFileSystemEntry";
+import { JS_EXTENSIONS } from "./constants";
+
+var ensureExtensions = function ensureExtensions(file) {
+  if (!path.extname(file)) {
+    return findExists(JS_EXTENSIONS.map(function (ext) {
+      return "".concat(file).concat(ext);
+    })) || file;
+  }
+
+  return file;
+};
+
+var ifAlreadyExists = function ifAlreadyExists(entrypoints, checked) {
+  return entrypoints.some(function (entrypoint) {
+    if (ensureExtensions(entrypoint.entry) === ensureExtensions(checked.entry)) {
+      // reset entryName
+      checked.entryName = entrypoint.entryName;
+      return true;
+    } // filesystem routes entrypoint conflict with normal entrypoint.
+
+
+    if (entrypoint.entry.startsWith(checked.entry) || checked.entry.startsWith(entrypoint.entry)) {
+      throw new Error("Entry configuration conflicts\n Your configuration: ".concat(checked.entry, ".\n Default entrypoint: ").concat(entrypoint.entry, "\n Please reset source.entries or set source.disableDefaultEntries to disable the default entry rules."));
+    }
+
+    return false;
+  });
+};
+
+export var getBundleEntry = function getBundleEntry(appContext, config) {
+  var appDirectory = appContext.appDirectory,
+      packageName = appContext.packageName;
+  var _config$source = config.source,
+      disableDefaultEntries = _config$source.disableDefaultEntries,
+      entries = _config$source.entries,
+      entriesDir = _config$source.entriesDir;
+  var defaults = disableDefaultEntries ? [] : getFileSystemEntry(appContext, config); // merge entrypoints from user config with directory convention.
+
+  if (entries) {
+    Object.keys(entries).forEach(function (name) {
+      var value = entries[name];
+      var entrypoint = typeof value === 'string' ? {
+        entryName: name,
+        entry: ensureAbsolutePath(appDirectory, value),
+        isAutoMount: true,
+        fileSystemRoutes: fs.statSync(ensureAbsolutePath(appDirectory, value)).isDirectory() ? {} : undefined
+      } : {
+        entryName: name,
+        entry: ensureAbsolutePath(appDirectory, value.entry),
+        isAutoMount: !value.disableMount,
+        fileSystemRoutes: value.enableFileSystemRoutes ? {} : undefined
+      };
+
+      if (!ifAlreadyExists(defaults, entrypoint)) {
+        defaults.push(entrypoint);
+      }
+    });
+  }
+
+  if (!disableDefaultEntries) {
+    // find main entry point which server route is '/'.
+    var entriesDirAbs = ensureAbsolutePath(appDirectory, entriesDir);
+    var found = defaults.find(function (_ref) {
+      var entryName = _ref.entryName,
+          entry = _ref.entry,
+          _ref$nestedRoutesEntr = _ref.nestedRoutesEntry,
+          nestedRoutesEntry = _ref$nestedRoutesEntr === void 0 ? '' : _ref$nestedRoutesEntr;
+      return entryName === packageName || path.dirname(entry) === entriesDirAbs || path.dirname(nestedRoutesEntry) === entriesDirAbs;
+    });
+    found && (found.entryName = MAIN_ENTRY_NAME);
+  }
+
+  return defaults;
+};

package/dist/js/treeshaking/analyze/getClientRoutes/getRoutes.js

@@ -0,0 +1,210 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import path from 'path';
+import { fs } from '@modern-js/utils';
+import { makeLegalIdentifier } from "../makeLegalIdentifier";
+import { FILE_SYSTEM_ROUTES_COMPONENTS_DIR, FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP, FILE_SYSTEM_ROUTES_INDEX, FILE_SYSTEM_ROUTES_LAYOUT } from "../constants";
+import { replaceWithAlias } from "../utils";
+import { debug, findLayout, shouldSkip, getRouteWeight } from "./utils";
+
+var compName = function compName(srcDirectory, filePath) {
+  var legalCompName = makeLegalIdentifier(path.relative(srcDirectory, filePath));
+  return "Comp_".concat(legalCompName);
+};
+
+var layoutNameAbbr = function layoutNameAbbr(filePath) {
+  var prefix = 'L_';
+  var dirName = path.dirname(filePath).split('/').pop() || '';
+  return "".concat(prefix).concat(makeLegalIdentifier(dirName));
+};
+
+var parents = [];
+/* eslint-disable no-param-reassign */
+
+var recursiveReadDir = function recursiveReadDir(_ref) {
+  var dir = _ref.dir,
+      routes = _ref.routes,
+      _ref$basePath = _ref.basePath,
+      basePath = _ref$basePath === void 0 ? '/' : _ref$basePath,
+      srcDirectory = _ref.srcDirectory,
+      srcAlias = _ref.srcAlias;
+  var hasDynamicRoute = false;
+  var resetParent = false;
+  var parent = parents[parents.length - 1];
+  var layout = findLayout(dir);
+
+  if (layout) {
+    if (basePath === '/') {
+      throw new Error("should use _app instead of _layout in ".concat(dir));
+    } else {
+      var alias = replaceWithAlias(srcDirectory, layout, srcAlias);
+      var componentName = compName(srcDirectory, layout);
+      var route = {
+        path: "".concat(basePath.substring(0, basePath.length - 1)),
+        children: [],
+        _component: alias,
+        component: componentName,
+        parent: parent,
+        type: 'page'
+      };
+      parent = route;
+      resetParent = true;
+      routes.push(route);
+      parents.push(route);
+      routes = route.children;
+    }
+  }
+
+  var _iterator = _createForOfIteratorHelper(fs.readdirSync(dir)),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var relative = _step.value;
+      var filePath = path.join(dir, relative);
+
+      if (!shouldSkip(filePath)) {
+        var filename = path.basename(filePath, path.extname(filePath));
+
+        var _alias = replaceWithAlias(srcDirectory, filePath, srcAlias);
+
+        var _componentName = compName(srcDirectory, filePath);
+
+        var dynamicRouteMatched = FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP.exec(filename);
+
+        if (dynamicRouteMatched) {
+          if (hasDynamicRoute) {
+            throw new Error("Can't set two dynamic route in one directory: ".concat(dir));
+          } else {
+            hasDynamicRoute = true;
+          }
+        }
+
+        var _route = {
+          path: "".concat(basePath).concat(dynamicRouteMatched ? ":".concat(dynamicRouteMatched[1]).concat(dynamicRouteMatched[2]) : filename),
+          _component: _alias,
+          component: _componentName,
+          parent: parent,
+          type: 'page'
+        };
+
+        if (fs.statSync(filePath).isDirectory()) {
+          recursiveReadDir({
+            dir: filePath,
+            routes: routes,
+            basePath: "".concat(_route.path, "/"),
+            srcDirectory: srcDirectory,
+            srcAlias: srcAlias
+          });
+          continue;
+        }
+
+        if (filename === FILE_SYSTEM_ROUTES_LAYOUT) {
+          continue;
+        }
+
+        if (filename === FILE_SYSTEM_ROUTES_INDEX) {
+          _route.path = basePath === '/' ? basePath : "".concat(basePath.substring(0, basePath.length - 1));
+        }
+
+        if (filename === '404' && basePath === '/') {
+          _route.path = '*';
+        }
+
+        routes.push(_route);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  if (resetParent) {
+    parents.pop();
+  }
+};
+/* eslint-enable  no-param-reassign */
+
+
+var normalizeNestedRoutes = function normalizeNestedRoutes(nested, internalComponentsDir, internalDirectory, internalDirAlias) {
+  var flat = function flat(routes) {
+    return routes.reduce(function (memo, route) {
+      return memo.concat(Array.isArray(route.children) ? flat(route.children) : [route]);
+    }, []);
+  };
+
+  var generate = function generate(route) {
+    var codes = [];
+    var lastComponent = route.component;
+    var imports = ["import React from 'react';", "import ".concat(lastComponent, " from '").concat(route._component, "'")]; // eslint-disable-next-line no-param-reassign, no-cond-assign
+
+    while (route = route.parent) {
+      var layoutComponent = route.component;
+      var layoutComponentAbbr = layoutNameAbbr(route._component);
+      imports.push("import ".concat(layoutComponent, " from '").concat(route._component, "';"));
+      var currentComponent = "".concat(layoutComponentAbbr, "_").concat(lastComponent);
+      codes.push("const ".concat(currentComponent, " = props => <").concat(layoutComponent, " Component={").concat(lastComponent, "} {...props} />;"));
+      lastComponent = currentComponent;
+    }
+
+    var file = path.resolve(internalComponentsDir, "".concat(lastComponent, ".jsx"));
+    fs.outputFileSync(file, "".concat(imports.join('\n'), "\n").concat(codes.join('\n'), "\nexport default ").concat(lastComponent));
+    return {
+      component: lastComponent,
+      _component: replaceWithAlias(internalDirectory, file, internalDirAlias)
+    };
+  };
+
+  var normalized = flat(nested).map(function (route) {
+    return route.parent ? _objectSpread(_objectSpread(_objectSpread({}, route), generate(route)), {}, {
+      parent: undefined
+    }) : _objectSpread(_objectSpread({}, route), {}, {
+      parent: undefined
+    });
+  });
+  return normalized;
+};
+
+export var getClientRoutes = function getClientRoutes(_ref2) {
+  var entrypoint = _ref2.entrypoint,
+      srcDirectory = _ref2.srcDirectory,
+      srcAlias = _ref2.srcAlias,
+      internalDirectory = _ref2.internalDirectory,
+      internalDirAlias = _ref2.internalDirAlias;
+  var entry = entrypoint.entry,
+      entryName = entrypoint.entryName;
+
+  if (!fs.existsSync(entry)) {
+    throw new Error("generate file system routes error, ".concat(entry, " directory not found."));
+  }
+
+  if (!(fs.existsSync(entry) && fs.statSync(entry).isDirectory())) {
+    throw new Error("generate file system routes error, ".concat(entry, " should be directory."));
+  }
+
+  var routes = [];
+  recursiveReadDir({
+    dir: entry,
+    routes: routes,
+    basePath: '/',
+    srcDirectory: srcDirectory,
+    srcAlias: srcAlias
+  });
+  var internalComponentsDir = path.resolve(internalDirectory, "".concat(entryName, "/").concat(FILE_SYSTEM_ROUTES_COMPONENTS_DIR));
+  fs.emptyDirSync(internalComponentsDir);
+  routes = normalizeNestedRoutes(routes, internalComponentsDir, internalDirectory, internalDirAlias);
+  parents.length = 0; // FIXME: support more situations
+
+  routes.sort(function (a, b) {
+    var delta = getRouteWeight(a.path) - getRouteWeight(b.path);
+
+    if (delta === 0) {
+      return a.path.length - b.path.length;
+    }
+
+    return delta;
+  });
+  debug("fileSystem routes: %o", routes);
+  return routes;
+};