@modern-js/app-tools 2.3.1-alpha.2 → 2.5.0-alpha.0

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

@@ -0,0 +1,227 @@
+import path from "path";
+import { fs, getEntryOptions, logger } from "@modern-js/utils";
+import {
+  useResolvedConfigContext
+} from "@modern-js/core";
+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, getServerLoadersFile } from "./utils";
+import { walk } from "./nestedRoutes";
+const createImportSpecifier = (specifiers) => {
+  let defaults = "";
+  const named = [];
+  for (const { local, imported } of specifiers) {
+    if (local && imported) {
+      named.push(`${imported} as ${local}`);
+    } else if (local) {
+      defaults = local;
+    } else {
+      named.push(imported);
+    }
+  }
+  if (defaults && named.length) {
+    return `${defaults}, { ${named.join(", ")} }`;
+  } else if (defaults) {
+    return defaults;
+  } else {
+    return `{ ${named.join(", ")} }`;
+  }
+};
+const createImportStatements = (statements) => {
+  var _a, _b;
+  const deDuplicated = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const { value, specifiers, initialize } of statements) {
+    if (!seen.has(value)) {
+      deDuplicated.push({
+        value,
+        specifiers,
+        initialize
+      });
+      seen.set(value, specifiers);
+    } else {
+      seen.get(value).push(...specifiers);
+      const modifyIndex = deDuplicated.findIndex((v) => v.value === value);
+      const originInitialize = (_b = (_a = deDuplicated[modifyIndex]) == null ? void 0 : _a.initialize) != null ? _b : "";
+      deDuplicated[modifyIndex].initialize = originInitialize.concat(
+        `
+${initialize || ""}`
+      );
+    }
+  }
+  return deDuplicated.map(
+    ({ value, specifiers, initialize }) => `import ${createImportSpecifier(specifiers)} from '${value}';
+${initialize || ""}`
+  ).join("\n");
+};
+const generateCode = async (appContext, config, entrypoints, api) => {
+  var _a, _b, _c;
+  const {
+    internalDirectory,
+    srcDirectory,
+    internalDirAlias,
+    internalSrcAlias,
+    packageName,
+    metaName
+  } = appContext;
+  const hookRunners = api.useHookRunners();
+  const isV5 = typeof ((_a = config.runtime) == null ? void 0 : _a.router) !== "boolean" && ((_c = (_b = config == null ? void 0 : config.runtime) == null ? void 0 : _b.router) == null ? void 0 : _c.mode) === "react-router-5";
+  const { mountId } = config.html;
+  const getRoutes = isV5 ? getClientRoutesLegacy : getClientRoutes;
+  await Promise.all(entrypoints.map(generateEntryCode));
+  async function generateEntryCode(entrypoint) {
+    const { entryName, isAutoMount, customBootstrap, fileSystemRoutes } = entrypoint;
+    if (isAutoMount) {
+      if (fileSystemRoutes) {
+        let initialRoutes = [];
+        let nestedRoute = null;
+        if (entrypoint.entry) {
+          initialRoutes = getRoutes({
+            entrypoint,
+            srcDirectory,
+            srcAlias: internalSrcAlias,
+            internalDirectory,
+            internalDirAlias
+          });
+        }
+        if (entrypoint.nestedRoutesEntry) {
+          if (!isV5) {
+            nestedRoute = await walk(
+              entrypoint.nestedRoutesEntry,
+              entrypoint.nestedRoutesEntry,
+              {
+                name: internalSrcAlias,
+                basename: srcDirectory
+              },
+              entrypoint.entryName
+            );
+            if (nestedRoute) {
+              initialRoutes.unshift(nestedRoute);
+            }
+          } else {
+            logger.error("Nested routes is not supported in legacy mode.");
+            process.exit(1);
+          }
+        }
+        const { routes } = await hookRunners.modifyFileSystemRoutes({
+          entrypoint,
+          routes: initialRoutes
+        });
+        const config2 = useResolvedConfigContext();
+        const ssr = getEntryOptions(
+          entryName,
+          config2.server.ssr,
+          config2.server.ssrByEntries,
+          packageName
+        );
+        let mode;
+        if (ssr) {
+          mode = typeof ssr === "object" ? ssr.mode || "string" : "string";
+        } else {
+          mode = false;
+        }
+        if (mode === "stream") {
+          const hasPageRoute = routes.some(
+            (route) => "type" in route && route.type === "page"
+          );
+          if (hasPageRoute) {
+            logger.error(
+              "Streaming ssr is not supported when pages dir exists"
+            );
+            process.exit(1);
+          }
+        }
+        const { code: code2 } = await hookRunners.beforeGenerateRoutes({
+          entrypoint,
+          code: await templates.fileSystemRoutes({
+            routes,
+            ssrMode: mode,
+            nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+            entryName: entrypoint.entryName,
+            internalDirectory
+          })
+        });
+        if (entrypoint.nestedRoutesEntry && mode) {
+          const routesServerFile = getServerLoadersFile(
+            internalDirectory,
+            entryName
+          );
+          const code3 = templates.routesForServer({
+            routes,
+            metaName
+          });
+          await fs.ensureFile(routesServerFile);
+          await fs.writeFile(routesServerFile, code3);
+        }
+        fs.outputFileSync(
+          path.resolve(
+            internalDirectory,
+            `./${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`
+          ),
+          code2,
+          "utf8"
+        );
+      }
+      const { imports: importStatements } = await hookRunners.modifyEntryImports({
+        entrypoint,
+        imports: getDefaultImports({
+          entrypoint,
+          srcDirectory,
+          internalSrcAlias,
+          internalDirAlias,
+          internalDirectory
+        })
+      });
+      const { plugins } = await hookRunners.modifyEntryRuntimePlugins({
+        entrypoint,
+        plugins: []
+      });
+      const { code: renderFunction } = await hookRunners.modifyEntryRenderFunction({
+        entrypoint,
+        code: templates.renderFunction({
+          plugins,
+          customBootstrap,
+          fileSystemRoutes
+        })
+      });
+      const { exportStatement } = await hookRunners.modifyEntryExport({
+        entrypoint,
+        exportStatement: "export default AppWrapper;"
+      });
+      const code = templates.index({
+        mountId,
+        imports: createImportStatements(importStatements),
+        renderFunction,
+        exportStatement
+      });
+      const entryFile = path.resolve(
+        internalDirectory,
+        `./${entryName}/${ENTRY_POINT_FILE_NAME}`
+      );
+      entrypoint.entry = entryFile;
+      if (config.source.enableAsyncEntry) {
+        const { code: asyncEntryCode } = await hookRunners.modifyAsyncEntry({
+          entrypoint,
+          code: `import('./${ENTRY_BOOTSTRAP_FILE_NAME}');`
+        });
+        fs.outputFileSync(entryFile, asyncEntryCode, "utf8");
+        const bootstrapFile = path.resolve(
+          internalDirectory,
+          `./${entryName}/${ENTRY_BOOTSTRAP_FILE_NAME}`
+        );
+        fs.outputFileSync(bootstrapFile, code, "utf8");
+      } else {
+        fs.outputFileSync(entryFile, code, "utf8");
+      }
+    }
+  }
+};
+export {
+  createImportStatements,
+  generateCode
+};

package/dist/esm-node/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";
+const ensureExtensions = (file) => {
+  if (!path.extname(file)) {
+    return findExists(JS_EXTENSIONS.map((ext) => `${file}${ext}`)) || file;
+  }
+  return file;
+};
+const ifAlreadyExists = (entrypoints, checked) => entrypoints.some((entrypoint) => {
+  if (ensureExtensions(entrypoint.entry) === ensureExtensions(checked.entry)) {
+    checked.entryName = entrypoint.entryName;
+    return true;
+  }
+  if (entrypoint.entry.startsWith(checked.entry) || checked.entry.startsWith(entrypoint.entry)) {
+    throw new Error(
+      `Entry configuration conflicts
+ Your configuration: ${checked.entry}.
+ Default entrypoint: ${entrypoint.entry}
+ Please reset source.entries or set source.disableDefaultEntries to disable the default entry rules.`
+    );
+  }
+  return false;
+});
+const getBundleEntry = (appContext, config) => {
+  const { appDirectory, packageName } = appContext;
+  const {
+    source: { disableDefaultEntries, entries, entriesDir }
+  } = config;
+  const defaults = disableDefaultEntries ? [] : getFileSystemEntry(appContext, config);
+  if (entries) {
+    Object.keys(entries).forEach((name) => {
+      const value = entries[name];
+      const entrypoint = typeof value === "string" ? {
+        entryName: name,
+        entry: ensureAbsolutePath(appDirectory, value),
+        absoluteEntryDir: path.dirname(
+          ensureAbsolutePath(appDirectory, value)
+        ),
+        isAutoMount: true,
+        fileSystemRoutes: fs.statSync(ensureAbsolutePath(appDirectory, value)).isDirectory() ? {} : void 0
+      } : {
+        entryName: name,
+        entry: ensureAbsolutePath(appDirectory, value.entry),
+        absoluteEntryDir: path.dirname(
+          ensureAbsolutePath(appDirectory, value.entry)
+        ),
+        isAutoMount: !value.disableMount,
+        customBootstrap: value.customBootstrap && ensureAbsolutePath(appDirectory, value.customBootstrap),
+        fileSystemRoutes: fs.statSync(ensureAbsolutePath(appDirectory, value.entry)).isDirectory() ? {} : void 0
+      };
+      if (entrypoint.fileSystemRoutes) {
+        entrypoint.nestedRoutesEntry = entrypoint.entry;
+      }
+      if (!ifAlreadyExists(defaults, entrypoint)) {
+        defaults.push(entrypoint);
+      }
+    });
+  }
+  if (!disableDefaultEntries) {
+    const entriesDirAbs = ensureAbsolutePath(appDirectory, entriesDir || "");
+    const found = defaults.find(
+      ({ entryName, entry, nestedRoutesEntry = "" }) => entryName === packageName || path.dirname(entry) === entriesDirAbs || path.dirname(nestedRoutesEntry) === entriesDirAbs
+    );
+    found && (found.entryName = MAIN_ENTRY_NAME);
+  }
+  return defaults;
+};
+export {
+  getBundleEntry
+};

package/dist/esm-node/analyze/getClientRoutes/getRoutes.js

@@ -0,0 +1,201 @@
+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";
+const compName = (srcDirectory, filePath) => {
+  const legalCompName = makeLegalIdentifier(
+    path.relative(srcDirectory, filePath)
+  );
+  return `Comp_${legalCompName}`;
+};
+const layoutNameAbbr = (filePath) => {
+  const prefix = "L_";
+  const dirName = path.dirname(filePath).split("/").pop() || "";
+  return `${prefix}${makeLegalIdentifier(dirName)}`;
+};
+const parents = [];
+const recursiveReadDir = ({
+  dir,
+  routes,
+  basePath = "/",
+  srcDirectory,
+  srcAlias
+}) => {
+  let hasDynamicRoute = false;
+  let resetParent = false;
+  let parent = parents[parents.length - 1];
+  const layout = findLayout(dir);
+  if (layout) {
+    if (basePath === "/") {
+      throw new Error(`should use _app instead of _layout in ${dir}`);
+    } else {
+      const alias = replaceWithAlias(srcDirectory, layout, srcAlias);
+      const componentName = compName(srcDirectory, layout);
+      const route = {
+        path: `${basePath.substring(0, basePath.length - 1)}`,
+        children: [],
+        _component: alias,
+        component: componentName,
+        parent,
+        type: "page"
+      };
+      parent = route;
+      resetParent = true;
+      routes.push(route);
+      parents.push(route);
+      routes = route.children;
+    }
+  }
+  for (const relative of fs.readdirSync(dir)) {
+    const filePath = path.join(dir, relative);
+    if (!shouldSkip(filePath)) {
+      const filename = path.basename(filePath, path.extname(filePath));
+      const alias = replaceWithAlias(srcDirectory, filePath, srcAlias);
+      const componentName = compName(srcDirectory, filePath);
+      const dynamicRouteMatched = FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP.exec(filename);
+      if (dynamicRouteMatched) {
+        if (hasDynamicRoute) {
+          throw new Error(
+            `Can't set two dynamic route in one directory: ${dir}`
+          );
+        } else {
+          hasDynamicRoute = true;
+        }
+      }
+      const route = {
+        path: `${basePath}${dynamicRouteMatched ? `:${dynamicRouteMatched[1]}${dynamicRouteMatched[2]}` : filename}`,
+        _component: alias,
+        component: componentName,
+        parent,
+        type: "page"
+      };
+      if (fs.statSync(filePath).isDirectory()) {
+        recursiveReadDir({
+          dir: filePath,
+          routes,
+          basePath: `${route.path}/`,
+          srcDirectory,
+          srcAlias
+        });
+        continue;
+      }
+      if (filename === FILE_SYSTEM_ROUTES_LAYOUT) {
+        continue;
+      }
+      if (filename === FILE_SYSTEM_ROUTES_INDEX) {
+        route.path = basePath === "/" ? basePath : `${basePath.substring(0, basePath.length - 1)}`;
+      }
+      if (filename === "404" && basePath === "/") {
+        route.path = "*";
+      }
+      routes.push(route);
+    }
+  }
+  if (resetParent) {
+    parents.pop();
+  }
+};
+const normalizeNestedRoutes = (nested, internalComponentsDir, internalDirectory, internalDirAlias) => {
+  const flat = (routes) => routes.reduce(
+    (memo, route) => memo.concat(
+      Array.isArray(route.children) ? flat(route.children) : [route]
+    ),
+    []
+  );
+  const generate = (route) => {
+    const codes = [];
+    let lastComponent = route.component;
+    const imports = [
+      `import React from 'react';`,
+      `import ${lastComponent} from '${route._component}'`
+    ];
+    while (route = route.parent) {
+      const layoutComponent = route.component;
+      const layoutComponentAbbr = layoutNameAbbr(route._component);
+      imports.push(`import ${layoutComponent} from '${route._component}';`);
+      const currentComponent = `${layoutComponentAbbr}_${lastComponent}`;
+      codes.push(
+        `const ${currentComponent} = props => <${layoutComponent} Component={${lastComponent}} {...props} />;`
+      );
+      lastComponent = currentComponent;
+    }
+    const file = path.resolve(internalComponentsDir, `${lastComponent}.jsx`);
+    fs.outputFileSync(
+      file,
+      `${imports.join("\n")}
+${codes.join(
+        "\n"
+      )}
+export default ${lastComponent}`
+    );
+    return {
+      component: lastComponent,
+      _component: replaceWithAlias(internalDirectory, file, internalDirAlias)
+    };
+  };
+  const normalized = flat(nested).map(
+    (route) => route.parent ? { ...route, ...generate(route), parent: void 0 } : { ...route, parent: void 0 }
+  );
+  return normalized;
+};
+const getClientRoutes = ({
+  entrypoint,
+  srcDirectory,
+  srcAlias,
+  internalDirectory,
+  internalDirAlias
+}) => {
+  const { entryName, pageRoutesEntry } = entrypoint;
+  if (!pageRoutesEntry) {
+    return [];
+  }
+  if (!fs.existsSync(pageRoutesEntry)) {
+    throw new Error(
+      `generate file system routes error, ${pageRoutesEntry} directory not found.`
+    );
+  }
+  if (!(fs.existsSync(pageRoutesEntry) && fs.statSync(pageRoutesEntry).isDirectory())) {
+    throw new Error(
+      `generate file system routes error, ${pageRoutesEntry} should be directory.`
+    );
+  }
+  let routes = [];
+  recursiveReadDir({
+    dir: pageRoutesEntry,
+    routes,
+    basePath: "/",
+    srcDirectory,
+    srcAlias
+  });
+  const internalComponentsDir = path.resolve(
+    internalDirectory,
+    `${entryName}/${FILE_SYSTEM_ROUTES_COMPONENTS_DIR}`
+  );
+  fs.emptyDirSync(internalComponentsDir);
+  routes = normalizeNestedRoutes(
+    routes,
+    internalComponentsDir,
+    internalDirectory,
+    internalDirAlias
+  );
+  parents.length = 0;
+  routes.sort((a, b) => {
+    const 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;
+};
+export {
+  getClientRoutes
+};

package/dist/esm-node/analyze/getClientRoutes/getRoutesLegacy.js

@@ -0,0 +1,197 @@
+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";
+const compName = (srcDirectory, filePath) => {
+  const legalCompName = makeLegalIdentifier(
+    path.relative(srcDirectory, filePath)
+  );
+  return `Comp_${legalCompName}`;
+};
+const layoutNameAbbr = (filePath) => {
+  const prefix = "L_";
+  const dirName = path.dirname(filePath).split("/").pop() || "";
+  return `${prefix}${makeLegalIdentifier(dirName)}`;
+};
+const parents = [];
+const recursiveReadDirLegacy = ({
+  dir,
+  routes,
+  basePath = "/",
+  srcDirectory,
+  srcAlias
+}) => {
+  let hasDynamicRoute = false;
+  let resetParent = false;
+  let parent = parents[parents.length - 1];
+  const layout = findLayout(dir);
+  if (layout) {
+    if (basePath === "/") {
+      throw new Error(`should use _app instead of _layout in ${dir}`);
+    } else {
+      const alias = replaceWithAlias(srcDirectory, layout, srcAlias);
+      const componentName = compName(srcDirectory, layout);
+      const route = {
+        path: `${basePath.substring(0, basePath.length - 1)}`,
+        exact: false,
+        routes: [],
+        _component: alias,
+        component: componentName,
+        parent
+      };
+      parent = route;
+      resetParent = true;
+      routes.push(route);
+      parents.push(route);
+      routes = route.routes;
+    }
+  }
+  for (const relative of fs.readdirSync(dir)) {
+    const filePath = path.join(dir, relative);
+    if (!shouldSkip(filePath)) {
+      const filename = path.basename(filePath, path.extname(filePath));
+      const alias = replaceWithAlias(srcDirectory, filePath, srcAlias);
+      const componentName = compName(srcDirectory, filePath);
+      const dynamicRouteMatched = FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP.exec(filename);
+      if (dynamicRouteMatched) {
+        if (hasDynamicRoute) {
+          throw new Error(
+            `Can't set two dynamic route in one directory: ${dir}`
+          );
+        } else {
+          hasDynamicRoute = true;
+        }
+      }
+      const route = {
+        path: `${basePath}${dynamicRouteMatched ? `:${dynamicRouteMatched[1]}${dynamicRouteMatched[2]}` : filename}`,
+        _component: alias,
+        component: componentName,
+        exact: true,
+        parent
+      };
+      if (fs.statSync(filePath).isDirectory()) {
+        recursiveReadDirLegacy({
+          dir: filePath,
+          routes,
+          basePath: `${route.path}/`,
+          srcDirectory,
+          srcAlias
+        });
+        continue;
+      }
+      if (filename === FILE_SYSTEM_ROUTES_LAYOUT) {
+        continue;
+      }
+      if (filename === FILE_SYSTEM_ROUTES_INDEX) {
+        route.path = basePath === "/" ? basePath : `${basePath.substring(0, basePath.length - 1)}`;
+      }
+      if (filename === "404" && basePath === "/") {
+        route.path = "*";
+        route.exact = false;
+      }
+      routes.push(route);
+    }
+  }
+  if (resetParent) {
+    parents.pop();
+  }
+};
+const normalizeNestedRoutes = (nested, internalComponentsDir, internalDirectory, internalDirAlias) => {
+  const flat = (routes) => routes.reduce(
+    (memo, route) => memo.concat(Array.isArray(route.routes) ? flat(route.routes) : [route]),
+    []
+  );
+  const generate = (route) => {
+    const codes = [];
+    let lastComponent = route.component;
+    const imports = [
+      `import React from 'react';`,
+      `import ${lastComponent} from '${route._component}'`
+    ];
+    while (route = route.parent) {
+      const layoutComponent = route.component;
+      const layoutComponentAbbr = layoutNameAbbr(route._component);
+      imports.push(`import ${layoutComponent} from '${route._component}';`);
+      const currentComponent = `${layoutComponentAbbr}_${lastComponent}`;
+      codes.push(
+        `const ${currentComponent} = props => <${layoutComponent} Component={${lastComponent}} {...props} />;`
+      );
+      lastComponent = currentComponent;
+    }
+    const file = path.resolve(internalComponentsDir, `${lastComponent}.jsx`);
+    fs.outputFileSync(
+      file,
+      `${imports.join("\n")}
+${codes.join(
+        "\n"
+      )}
+export default ${lastComponent}`
+    );
+    return {
+      component: lastComponent,
+      _component: replaceWithAlias(internalDirectory, file, internalDirAlias)
+    };
+  };
+  const normalized = flat(nested).map(
+    (route) => route.parent ? { ...route, ...generate(route), parent: void 0 } : { ...route, parent: void 0 }
+  );
+  return normalized;
+};
+const getClientRoutes = ({
+  entrypoint,
+  srcDirectory,
+  srcAlias,
+  internalDirectory,
+  internalDirAlias
+}) => {
+  const { entry, entryName } = entrypoint;
+  if (!fs.existsSync(entry)) {
+    throw new Error(
+      `generate file system routes error, ${entry} directory not found.`
+    );
+  }
+  if (!(fs.existsSync(entry) && fs.statSync(entry).isDirectory())) {
+    throw new Error(
+      `generate file system routes error, ${entry} should be directory.`
+    );
+  }
+  let routes = [];
+  recursiveReadDirLegacy({
+    dir: entry,
+    routes,
+    basePath: "/",
+    srcDirectory,
+    srcAlias
+  });
+  const internalComponentsDir = path.resolve(
+    internalDirectory,
+    `${entryName}/${FILE_SYSTEM_ROUTES_COMPONENTS_DIR}`
+  );
+  fs.emptyDirSync(internalComponentsDir);
+  routes = normalizeNestedRoutes(
+    routes,
+    internalComponentsDir,
+    internalDirectory,
+    internalDirAlias
+  );
+  parents.length = 0;
+  routes.sort((a, b) => {
+    const 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;
+};
+export {
+  getClientRoutes
+};

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

@@ -0,0 +1,6 @@
+import { getClientRoutes } from "./getRoutes";
+import { getClientRoutes as getClientRoutes2 } from "./getRoutesLegacy";
+export {
+  getClientRoutes,
+  getClientRoutes2 as getClientRoutesLegacy
+};