@modern-js/app-tools 2.53.1-alpha.3 → 2.54.0

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

@@ -1,259 +0,0 @@
-import * as path from "path";
-import { fs, normalizeToPosixPath } from "@modern-js/utils";
-import { getPathWithoutExt } from "../utils/routes";
-import { JS_EXTENSIONS, NESTED_ROUTE } from "./constants";
-import { hasAction, replaceWithAlias } from "./utils";
-const conventionNames = Object.values(NESTED_ROUTE);
-const replaceDynamicPath = (routePath) => {
-  return routePath.replace(/\[(.*?)\]/g, ":$1");
-};
-const getRouteId = (componentPath, routesDir, entryName, isMainEntry) => {
-  const relativePath = normalizeToPosixPath(path.relative(routesDir, componentPath));
-  const pathWithoutExt = getPathWithoutExt(relativePath);
-  let id = ``;
-  if (isMainEntry) {
-    id = pathWithoutExt;
-  } else {
-    id = `${entryName}_${pathWithoutExt}`;
-  }
-  return id.replace(/\[(.*?)\]/g, "($1)");
-};
-const createIndexRoute = (routeInfo, rootDir, filename, entryName, isMainEntry) => {
-  return createRoute({
-    ...routeInfo,
-    index: true,
-    children: void 0
-  }, rootDir, filename, entryName, isMainEntry);
-};
-const createRoute = (routeInfo, rootDir, filename, entryName, isMainEntry) => {
-  const id = getRouteId(filename, rootDir, entryName, isMainEntry);
-  return {
-    ...routeInfo,
-    id,
-    type: "nested"
-  };
-};
-const optimizeRoute = (routeTree) => {
-  if (!routeTree.children || routeTree.children.length === 0) {
-    return [
-      routeTree
-    ];
-  }
-  const { children } = routeTree;
-  if (!routeTree._component && !routeTree.error && !routeTree.loading && !routeTree.config && !routeTree.clientData) {
-    const newRoutes = children.map((child) => {
-      const routePath = `${routeTree.path ? routeTree.path : ""}${child.path ? `/${child.path}` : ""}`;
-      const newRoute = {
-        ...child,
-        path: routePath.replace(/\/\//g, "/")
-      };
-      if (routePath.length > 0) {
-        delete newRoute.index;
-      } else {
-        delete newRoute.path;
-      }
-      return newRoute;
-    });
-    return Array.from(new Set(newRoutes)).flatMap(optimizeRoute);
-  } else {
-    const optimizedChildren = routeTree.children.flatMap(optimizeRoute);
-    return [
-      {
-        ...routeTree,
-        children: optimizedChildren
-      }
-    ];
-  }
-};
-const walk = async (dirname, rootDir, alias, entryName, isMainEntry, oldVersion) => {
-  var _finalRoute_children;
-  if (!await fs.pathExists(dirname)) {
-    return null;
-  }
-  const isDirectory = (await fs.stat(dirname)).isDirectory();
-  if (!isDirectory) {
-    return null;
-  }
-  const relativeDir = path.relative(rootDir, dirname);
-  const pathSegments = relativeDir.split(path.sep);
-  const lastSegment = pathSegments[pathSegments.length - 1];
-  const isRoot = lastSegment === "";
-  const isPathlessLayout = lastSegment.startsWith("__");
-  const isWithoutLayoutPath = lastSegment.includes(".");
-  let routePath = isRoot || isPathlessLayout ? "/" : `${lastSegment}`;
-  if (isWithoutLayoutPath) {
-    routePath = lastSegment.split(".").join("/");
-  }
-  routePath = replaceDynamicPath(routePath);
-  const route = {
-    path: routePath === null || routePath === void 0 ? void 0 : routePath.replace(/\$$/, "?"),
-    children: [],
-    isRoot
-  };
-  let pageLoaderFile = "";
-  let pageRoute = null;
-  let pageConfigFile = "";
-  let pageClientData = "";
-  let pageData = "";
-  let pageAction = "";
-  let splatLoaderFile = "";
-  let splatRoute = null;
-  let splatConfigFile = "";
-  let splatClientData = "";
-  let splatData = "";
-  let splatAction = "";
-  const items = await fs.readdir(dirname);
-  for (const item of items) {
-    const itemPath = path.join(dirname, item);
-    const itemPathWithAlias = getPathWithoutExt(replaceWithAlias(alias.basename, itemPath, alias.name));
-    const extname = path.extname(item);
-    const itemWithoutExt = item.slice(0, -extname.length);
-    const isDirectory2 = (await fs.stat(itemPath)).isDirectory();
-    if (isDirectory2) {
-      const childRoute = await walk(itemPath, rootDir, alias, entryName, isMainEntry, oldVersion);
-      if (childRoute && !Array.isArray(childRoute)) {
-        var _route_children;
-        (_route_children = route.children) === null || _route_children === void 0 ? void 0 : _route_children.push(childRoute);
-      }
-    }
-    if (extname && (!JS_EXTENSIONS.includes(extname) || !conventionNames.includes(itemWithoutExt))) {
-      continue;
-    }
-    if (itemWithoutExt === NESTED_ROUTE.LAYOUT_LOADER_FILE) {
-      if (!route.loader) {
-        route.loader = itemPathWithAlias;
-      }
-    }
-    if (itemWithoutExt === NESTED_ROUTE.LAYOUT_CLIENT_LOADER) {
-      route.clientData = itemPathWithAlias;
-    }
-    if (itemWithoutExt === NESTED_ROUTE.LAYOUT_DATA_FILE) {
-      route.data = itemPathWithAlias;
-      if (await hasAction(itemPath)) {
-        route.action = itemPathWithAlias;
-      }
-    }
-    if (itemWithoutExt === NESTED_ROUTE.LAYOUT_CONFIG_FILE) {
-      if (!route.config) {
-        route.config = itemPathWithAlias;
-      }
-    }
-    if (itemWithoutExt === NESTED_ROUTE.LAYOUT_FILE) {
-      route._component = itemPathWithAlias;
-    }
-    if (itemWithoutExt === NESTED_ROUTE.PAGE_LOADER_FILE) {
-      pageLoaderFile = itemPathWithAlias;
-    }
-    if (itemWithoutExt === NESTED_ROUTE.PAGE_CLIENT_LOADER) {
-      pageClientData = itemPathWithAlias;
-    }
-    if (itemWithoutExt === NESTED_ROUTE.PAGE_DATA_FILE) {
-      pageData = itemPathWithAlias;
-      if (await hasAction(itemPath)) {
-        pageAction = itemPathWithAlias;
-      }
-    }
-    if (itemWithoutExt === NESTED_ROUTE.PAGE_CONFIG_FILE) {
-      pageConfigFile = itemPathWithAlias;
-    }
-    if (itemWithoutExt === NESTED_ROUTE.PAGE_FILE) {
-      var _route_children1;
-      pageRoute = createIndexRoute({
-        _component: itemPathWithAlias
-      }, rootDir, itemPath, entryName, isMainEntry);
-      if (pageLoaderFile) {
-        pageRoute.loader = pageLoaderFile;
-      }
-      if (pageConfigFile) {
-        pageRoute.config = pageConfigFile;
-      }
-      if (pageData) {
-        pageRoute.data = pageData;
-      }
-      if (pageClientData) {
-        pageRoute.clientData = pageClientData;
-      }
-      if (pageAction) {
-        pageRoute.action = pageAction;
-      }
-      (_route_children1 = route.children) === null || _route_children1 === void 0 ? void 0 : _route_children1.push(pageRoute);
-    }
-    if (itemWithoutExt === NESTED_ROUTE.SPLATE_LOADER_FILE) {
-      splatLoaderFile = itemPathWithAlias;
-    }
-    if (itemWithoutExt === NESTED_ROUTE.SPLATE_CLIENT_DATA) {
-      splatClientData = itemPathWithAlias;
-    }
-    if (itemWithoutExt === NESTED_ROUTE.SPLATE_CONFIG_FILE) {
-      if (!route.config) {
-        splatConfigFile = replaceWithAlias(alias.basename, itemPath, alias.name);
-      }
-    }
-    if (itemWithoutExt === NESTED_ROUTE.SPLATE_DATA_FILE) {
-      splatData = itemPathWithAlias;
-      if (await hasAction(itemPath)) {
-        splatAction = itemPathWithAlias;
-      }
-    }
-    if (itemWithoutExt === NESTED_ROUTE.SPLATE_FILE) {
-      var _route_children2;
-      splatRoute = createRoute({
-        _component: itemPathWithAlias,
-        path: "*"
-      }, rootDir, itemPath, entryName, isMainEntry);
-      if (splatLoaderFile) {
-        splatRoute.loader = splatLoaderFile;
-      }
-      if (splatClientData) {
-        splatRoute.clientData = splatClientData;
-      }
-      if (splatData) {
-        splatRoute.data = splatData;
-      }
-      if (splatConfigFile) {
-        splatRoute.config = splatConfigFile;
-      }
-      if (splatAction) {
-        splatRoute.action = splatAction;
-      }
-      (_route_children2 = route.children) === null || _route_children2 === void 0 ? void 0 : _route_children2.push(splatRoute);
-    }
-    if (itemWithoutExt === NESTED_ROUTE.LOADING_FILE) {
-      route.loading = itemPathWithAlias;
-    }
-    if (itemWithoutExt === NESTED_ROUTE.ERROR_FILE) {
-      route.error = itemPathWithAlias;
-    }
-  }
-  let finalRoute = createRoute(route, rootDir, path.join(dirname, `${NESTED_ROUTE.LAYOUT_FILE}.ts`), entryName, isMainEntry);
-  if (isPathlessLayout) {
-    delete finalRoute.path;
-  }
-  const childRoutes = finalRoute.children = (_finalRoute_children = finalRoute.children) === null || _finalRoute_children === void 0 ? void 0 : _finalRoute_children.filter((childRoute) => childRoute);
-  if (childRoutes && childRoutes.length === 0 && !finalRoute.index && !finalRoute._component) {
-    return null;
-  }
-  if (childRoutes && childRoutes.length === 1 && !finalRoute._component) {
-    const childRoute = childRoutes[0];
-    if (childRoute.path === "*") {
-      const path2 = `${finalRoute.path || ""}/${childRoute.path || ""}`;
-      finalRoute = {
-        ...childRoute,
-        path: path2
-      };
-    }
-  }
-  if (isRoot && !finalRoute._component) {
-    throw new Error("The root layout component is required, make sure the routes/layout.tsx file exists.");
-  }
-  if (isRoot && !oldVersion) {
-    const optimizedRoutes = optimizeRoute(finalRoute);
-    return optimizedRoutes;
-  }
-  return finalRoute;
-};
-export {
-  getRouteId,
-  optimizeRoute,
-  walk
-};

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

@@ -1,405 +0,0 @@
-import path from "path";
-import { fs, getEntryOptions, isSSGEntry, slash } from "@modern-js/utils";
-import { ROUTE_MODULES } from "@modern-js/utils/universal/constants";
-import { APP_CONFIG_NAME, TEMP_LOADERS_DIR } from "./constants";
-import { getServerLoadersFile } from "./utils";
-const index = ({ mountId, imports, renderFunction: renderFunction2, exportStatement }) => `
-const IS_BROWSER = typeof window !== 'undefined' && window.name !== 'nodejs';
-const IS_REACT18 = process.env.IS_REACT18 === 'true';
-const MOUNT_ID = '${mountId}';
-
-${imports}
-
-let AppWrapper = null;
-
-let root = null;
-
-function render() {
-  ${renderFunction2}
-}
-
-AppWrapper = render();
-
-${exportStatement};
-`;
-const renderFunction = ({ plugins, customBootstrap, fileSystemRoutes: fileSystemRoutes2 }) => {
-  const bootstrap = "bootstrap(AppWrapper, MOUNT_ID, root, ReactDOM)";
-  return `
-  const finalAppConfig = {
-    ...App.config,
-    ...typeof ${APP_CONFIG_NAME} === 'function' ? ${APP_CONFIG_NAME}() : {},
-  }
-
-  AppWrapper = createApp({
-    plugins: [
-     ${plugins.map(({ name, options, args }) => `${name}({...${options}, ...finalAppConfig?.${args || name}}),`).join("\n")}
-    ]
-  })(${fileSystemRoutes2 ? "" : `App`})
-
-
-  if(!AppWrapper.init && typeof appInit !== 'undefined') {
-    AppWrapper.init = appInit;
-  }
-
-
-  if (IS_BROWSER) {
-    ${customBootstrap ? `customBootstrap(AppWrapper, () => ${bootstrap});` : `${bootstrap};`}
-  }
-
-  return AppWrapper
-`;
-};
-const html = (partials) => `
-<!DOCTYPE html>
-<html>
-<head>
-
-  ${partials.top.join("\n")}
-
-  ${partials.head.join("\n")}
-
-</head>
-
-<body>
-  <div id="<%= mountId %>"><!--<?- html ?>--></div>
-  ${partials.body.join("\n")}
-  <!--<?- chunksMap.js ?>-->
-  <!--<?- SSRDataScript ?>-->
-  <!--<?- bottomTemplate ?>-->
-</body>
-
-</html>
-`;
-const routesForServer = ({ routes }) => {
-  const loaders = [];
-  const actions = [];
-  const loadersMap = {};
-  const traverseRouteTree = (route) => {
-    let 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);
-    }
-    let loader;
-    let action;
-    if (route.type === "nested") {
-      if (route.loader || route.data) {
-        loaders.push(route.loader);
-        const loaderId = loaders.length - 1;
-        loader = `loader_${loaderId}`;
-        const inline = Boolean(route.data);
-        loadersMap[loader] = {
-          loaderId,
-          routeId: route.id,
-          filePath: route.data || route.loader,
-          clientData: Boolean(route.clientData),
-          route,
-          inline
-        };
-        if (route.action) {
-          actions.push(route.action);
-          action = `action_${loaders.length - 1}`;
-        }
-      }
-    }
-    const finalRoute = {
-      ...route,
-      loader,
-      action,
-      children
-    };
-    return finalRoute;
-  };
-  let routesCode = `
-  export const routes = [
-  `;
-  for (const route of routes) {
-    if ("type" in route) {
-      const keywords = [
-        "loader",
-        "action"
-      ];
-      const regs = keywords.map(createMatchReg);
-      const newRoute = traverseRouteTree(route);
-      const routeStr = JSON.stringify(newRoute, null, 2);
-      routesCode += regs.reduce((acc, reg) => acc.replace(reg, "$1$2"), routeStr).replace(/\\"/g, '"');
-    } else {
-      routesCode += `${JSON.stringify(route, null, 2)}`;
-    }
-  }
-  routesCode += `
-];`;
-  let importLoadersCode = "";
-  for (const [key, loaderInfo] of Object.entries(loadersMap)) {
-    if (loaderInfo.inline) {
-      const { route } = loaderInfo;
-      if (route.action) {
-        importLoadersCode += `import { loader as ${key}, action as action_${loaderInfo.loaderId} } from "${slash(loaderInfo.filePath)}";
-`;
-      } else {
-        importLoadersCode += `import { loader as ${key} } from "${slash(loaderInfo.filePath)}";
-`;
-      }
-    } else {
-      importLoadersCode += `import ${key} from "${slash(loaderInfo.filePath)}";
-`;
-    }
-  }
-  return `
-    ${importLoadersCode}
-    ${routesCode}
-  `;
-};
-const createMatchReg = (keyword) => new RegExp(`("${keyword}":\\s)"([^
-]+)"`, "g");
-const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true }) => {
-  const components = [];
-  const loadings = [];
-  const errors = [];
-  const loaders = [];
-  const loadersMap = {};
-  const configs = [];
-  const configsMap = {};
-  const loadersMapFile = path.join(internalDirectory, entryName, TEMP_LOADERS_DIR, "map.json");
-  const importLazyCode = `
-    import { lazy } from "react";
-    import loadable, { lazy as loadableLazy } from "@modern-js/runtime/loadable"
-  `;
-  let rootLayoutCode = ``;
-  const getDataLoaderPath = ({ loaderId, clientData, action, inline, routeId }) => {
-    if (!ssrMode) {
-      return "";
-    }
-    const clientDataStr = clientData ? `&clientData=${clientData}` : "";
-    if (nestedRoutesEntry) {
-      return `?loaderId=${loaderId}${clientDataStr}&action=${action ? slash(action) : action}&inline=${inline}&routeId=${routeId}`;
-    }
-    return "";
-  };
-  const traverseRouteTree = (route) => {
-    let 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);
-    }
-    let loading;
-    let error;
-    let loader;
-    let action;
-    let config;
-    let component = "";
-    let lazyImport = null;
-    if (route.type === "nested") {
-      if (route.loading) {
-        loadings.push(route.loading);
-        loading = `loading_${loadings.length - 1}`;
-      }
-      if (route.error) {
-        errors.push(route.error);
-        error = `error_${errors.length - 1}`;
-      }
-      if (route.loader || route.data) {
-        loaders.push(route.loader);
-        const loaderId = loaders.length - 1;
-        loader = `loader_${loaderId}`;
-        const inline = Boolean(route.data);
-        loadersMap[loader] = {
-          loaderId,
-          routeId: route.id,
-          filePath: route.data || route.loader,
-          clientData: Boolean(route.clientData),
-          route,
-          inline
-        };
-        loader = `loader_${loaderId}`;
-        if (route.action) {
-          action = `action_${loaderId}`;
-        }
-      }
-      if (typeof route.config === "string") {
-        configs.push(route.config);
-        const configId = configs.length - 1;
-        config = `config_${configId}`;
-        configsMap[config] = route.config;
-      }
-      if (route._component) {
-        if (splitRouteChunks) {
-          if (route.isRoot) {
-            lazyImport = `() => import('${route._component}').then(routeModule => handleRouteModule(routeModule, "${route.id}")).catch(handleRouteModuleError) `;
-            rootLayoutCode = `import RootLayout from '${route._component}'`;
-            component = `RootLayout`;
-          } else if (ssrMode === "string") {
-            lazyImport = `() => import(/* webpackChunkName: "${route.id}" */  '${route._component}').then(routeModule => handleRouteModule(routeModule, "${route.id}")).catch(handleRouteModuleError) `;
-            component = `loadable(${lazyImport})`;
-          } else {
-            lazyImport = `() => import(/* webpackChunkName: "${route.id}" */  '${route._component}').then(routeModule => handleRouteModule(routeModule, "${route.id}")).catch(handleRouteModuleError) `;
-            component = `lazy(${lazyImport})`;
-          }
-        } else if (ssrMode === "string") {
-          components.push(route._component);
-          component = `component_${components.length - 1}`;
-        } else {
-          lazyImport = `() => import(/* webpackMode: "eager" */  '${route._component}').then(routeModule => handleRouteModule(routeModule, "${route.id}")).catch(handleRouteModuleError) `;
-          component = `lazy(${lazyImport})`;
-        }
-      }
-    } else if (route._component) {
-      if (splitRouteChunks) {
-        lazyImport = `() => import('${route._component}')`;
-        component = `loadable(${lazyImport})`;
-      } else {
-        components.push(route._component);
-        component = `component_${components.length - 1}`;
-      }
-    }
-    const finalRoute = {
-      ...route,
-      lazyImport,
-      loading,
-      loader,
-      action,
-      config,
-      error,
-      children
-    };
-    if (route._component) {
-      finalRoute.component = component;
-    }
-    if (route.type === "nested" && route._component && (route.loader || route.data)) {
-      finalRoute.shouldRevalidate = `createShouldRevalidate("${route.id}")`;
-    }
-    return finalRoute;
-  };
-  let routeComponentsCode = `
-    export const routes = [
-  `;
-  for (const route of routes) {
-    if ("type" in route) {
-      const newRoute = traverseRouteTree(route);
-      const routeStr = JSON.stringify(newRoute, null, 2);
-      const keywords = [
-        "component",
-        "lazyImport",
-        "shouldRevalidate",
-        "loader",
-        "action",
-        "loading",
-        "error",
-        "config"
-      ];
-      const regs = keywords.map(createMatchReg);
-      const newRouteStr = regs.reduce((acc, reg) => acc.replace(reg, "$1$2"), routeStr).replace(/"(RootLayout)"/g, "$1").replace(/\\"/g, '"');
-      routeComponentsCode += `${newRouteStr},`;
-    } else {
-      const component = `loadable(() => import('${route._component}'))`;
-      const finalRoute = {
-        ...route,
-        component
-      };
-      const keywords = [
-        "component",
-        "lazyImport"
-      ];
-      const routeStr = JSON.stringify(finalRoute, null, 2);
-      const regs = keywords.map(createMatchReg);
-      const newRouteStr = regs.reduce((acc, reg) => acc.replace(reg, "$1$2"), routeStr).replace(/\\"/g, '"');
-      routeComponentsCode += `${newRouteStr},`;
-    }
-  }
-  routeComponentsCode += `
-];`;
-  const importLoadingCode = loadings.map((loading, index2) => {
-    return `import loading_${index2} from '${loading}';
-`;
-  }).join("");
-  const importComponentsCode = components.map((component, index2) => {
-    return `import component_${index2} from '${component}';
-`;
-  }).join("");
-  const importErrorComponentsCode = errors.map((error, index2) => {
-    return `import error_${index2} from '${error}';
-`;
-  }).join("");
-  let importLoadersCode = "";
-  for (const [key, loaderInfo] of Object.entries(loadersMap)) {
-    if (loaderInfo.inline) {
-      const { route } = loaderInfo;
-      if (route.action) {
-        importLoadersCode += `import { loader as ${key}, action as action_${loaderInfo.loaderId} } from "${slash(loaderInfo.filePath)}${getDataLoaderPath({
-          loaderId: key,
-          clientData: loaderInfo.clientData,
-          action: route.action,
-          inline: loaderInfo.inline,
-          routeId: loaderInfo.routeId
-        })}";
-`;
-      } else {
-        importLoadersCode += `import { loader as ${key} } from "${slash(loaderInfo.filePath)}${getDataLoaderPath({
-          loaderId: key,
-          clientData: loaderInfo.clientData,
-          action: false,
-          inline: loaderInfo.inline,
-          routeId: route.id
-        })}";
-`;
-      }
-    } else {
-      importLoadersCode += `import ${key} from "${slash(loaderInfo.filePath)}${getDataLoaderPath({
-        loaderId: key,
-        clientData: loaderInfo.clientData,
-        action: false,
-        inline: loaderInfo.inline,
-        routeId: loaderInfo.routeId
-      })}";
-`;
-    }
-  }
-  let importConfigsCode = "";
-  for (const [key, configPath] of Object.entries(configsMap)) {
-    importConfigsCode += `import * as ${key} from "${slash(configPath)}";
-`;
-  }
-  await fs.ensureFile(loadersMapFile);
-  await fs.writeJSON(loadersMapFile, loadersMap);
-  const importRuntimeRouterCode = `
-    import { createShouldRevalidate, handleRouteModule,  handleRouteModuleError} from '@modern-js/runtime/router';
-  `;
-  const routeModulesCode = `
-    if(typeof document !== 'undefined'){
-      window.${ROUTE_MODULES} = {}
-    }
-  `;
-  return `
-    ${importLazyCode}
-    ${importComponentsCode}
-    ${importRuntimeRouterCode}
-    ${rootLayoutCode}
-    ${importLoadingCode}
-    ${importErrorComponentsCode}
-    ${importLoadersCode}
-    ${importConfigsCode}
-    ${routeModulesCode}
-    ${routeComponentsCode}
-  `;
-};
-function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
-  const { entryName, isMainEntry } = entrypoint;
-  const { packageName, internalDirectory } = appContext;
-  const ssr = getEntryOptions(entryName, isMainEntry, config.server.ssr, config.server.ssrByEntries, packageName);
-  const ssg = isSSGEntry(config, entryName, entrypoints);
-  if (entrypoint.nestedRoutesEntry && (ssr || ssg)) {
-    const serverLoaderRuntime = require.resolve("@modern-js/plugin-data-loader/runtime");
-    const serverLoadersFile = getServerLoadersFile(internalDirectory, entryName);
-    const combinedModule = `export * from "${slash(serverLoaderRuntime)}"; export * from "${slash(serverLoadersFile)}"`;
-    return combinedModule;
-  }
-  return null;
-}
-export {
-  fileSystemRoutes,
-  html,
-  index,
-  renderFunction,
-  routesForServer,
-  ssrLoaderCombinedModule
-};

package/dist/esm-node/plugins/deploy/exports.js

@@ -1,4 +0,0 @@
-import { handleDependencies } from "./dependencies";
-export {
-  handleDependencies
-};

package/dist/esm-node/utils/getServerInternalPlugins.js

@@ -1,15 +0,0 @@
-async function getServerInternalPlugins(api) {
-  const hookRunners = api.useHookRunners();
-  const { plugins: serverPlugins } = await hookRunners.collectServerPlugins({
-    plugins: []
-  });
-  const serverInternalPlugins = serverPlugins.reduce((result, plugin) => Object.assign(result, plugin), {});
-  api.setAppContext({
-    ...api.useAppContext(),
-    serverInternalPlugins
-  });
-  return serverInternalPlugins;
-}
-export {
-  getServerInternalPlugins
-};

package/dist/js/modern/analyze/constants.js

@@ -1,15 +0,0 @@
-export const JS_EXTENSIONS = ['.js', '.ts', '.jsx', '.tsx'];
-export const INDEX_FILE_NAME = 'index';
-export const APP_FILE_NAME = 'App';
-export const PAGES_DIR_NAME = 'pages';
-export const FILE_SYSTEM_ROUTES_FILE_NAME = 'routes.js';
-export const ENTRY_POINT_FILE_NAME = 'index.js';
-export const ENTRY_BOOTSTRAP_FILE_NAME = 'bootstrap.js';
-export const FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = /^\[(\S+)\]([*+?]?)$/;
-export const FILE_SYSTEM_ROUTES_LAYOUT = '_layout';
-export const FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT = '_app';
-export const FILE_SYSTEM_ROUTES_INDEX = 'index';
-export const FILE_SYSTEM_ROUTES_IGNORED_REGEX = /\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/;
-export const HTML_PARTIALS_FOLDER = 'html';
-export const HTML_PARTIALS_EXTENSIONS = ['.htm', '.html', '.ejs'];
-export const FILE_SYSTEM_ROUTES_COMPONENTS_DIR = 'internal_components';