@modern-js/runtime 2.69.5 → 3.0.0-alpha.0

package/dist/esm-node/router/cli/code/nestedRoutes.js

@@ -1,258 +0,0 @@
-import * as path from "path";
-import { fs, JS_EXTENSIONS, normalizeToPosixPath } from "@modern-js/utils";
-import { NESTED_ROUTE } from "../constants";
-import { getPathWithoutExt, 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}` : ""}` : 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.unshift(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/router/cli/code/templates.js

@@ -1,452 +0,0 @@
-import path from "path";
-import { fs, findExists, formatImportPath, getEntryOptions, isSSGEntry, slash } from "@modern-js/utils";
-import { ROUTE_MODULES } from "@modern-js/utils/universal/constants";
-import { APP_CONFIG_NAME, APP_INIT_EXPORTED, TEMP_LOADERS_DIR } from "../constants";
-import { getPathWithoutExt, getServerLoadersFile, parseModule, replaceWithAlias } from "./utils";
-const routesForServer = ({ routesForServerLoaderMatches }) => {
-  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 routesForServerLoaderMatches) {
-    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 ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true, isRscClient = false }) => {
-  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 "@${metaName}/runtime/loadable"
-  `;
-  let rootLayoutCode = ``;
-  const getDataLoaderPath = ({ loaderId, clientData, action, inline, routeId, inValidSSRRoute }) => {
-    if (!ssrMode) {
-      return "";
-    }
-    const clientDataStr = clientData ? `&clientData=${clientData}` : "";
-    const retain = inValidSSRRoute !== null && inValidSSRRoute !== void 0 ? inValidSSRRoute : false;
-    if (nestedRoutesEntry) {
-      return `?loaderId=${loaderId}${clientDataStr}&action=${action ? slash(action) : action}&inline=${inline}&routeId=${routeId}&retain=${retain}`;
-    }
-    return "";
-  };
-  const createLazyImport = ({ componentPath, routeId, webpackChunkName, eager }) => {
-    const importOptions = webpackChunkName ? `/* webpackChunkName: "${routeId}" */  ` : eager ? `/* webpackMode: "eager" */  ` : "";
-    return `() => import(${importOptions}'${componentPath}').then(routeModule => handleRouteModule(routeModule, "${routeId}")).catch(handleRouteModuleError)`;
-  };
-  const traverseRouteTree = (route, isRscClient2) => {
-    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((child) => traverseRouteTree(child, isRscClient2));
-    }
-    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,
-          inValidSSRRoute: route.inValidSSRRoute,
-          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 (route.isRoot) {
-          lazyImport = createLazyImport({
-            componentPath: route._component,
-            routeId: route.id
-          });
-          rootLayoutCode = `import RootLayout from '${route._component}'`;
-          component = "RootLayout";
-        } else if (splitRouteChunks) {
-          lazyImport = createLazyImport({
-            componentPath: route._component,
-            routeId: route.id,
-            webpackChunkName: true
-          });
-          component = ssrMode === "string" ? `loadable(${lazyImport})` : `lazy(${lazyImport})`;
-        } else {
-          if (ssrMode === "string") {
-            components.push(route._component);
-            component = `component_${components.length - 1}`;
-          } else {
-            lazyImport = createLazyImport({
-              componentPath: route._component,
-              routeId: route.id,
-              eager: true
-            });
-            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,
-      loading,
-      loader,
-      action,
-      config,
-      error,
-      children
-    };
-    if (!isRscClient2) {
-      finalRoute.lazyImport = lazyImport;
-    }
-    if (route._component && !isRscClient2) {
-      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, isRscClient);
-      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, index) => {
-    return `import loading_${index} from '${loading}';
-`;
-  }).join("");
-  const importComponentsCode = components.map((component, index) => {
-    return `import component_${index} from '${component}';
-`;
-  }).join("");
-  const importErrorComponentsCode = errors.map((error, index) => {
-    return `import error_${index} 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,
-          inValidSSRRoute: loaderInfo.inValidSSRRoute
-        })}";
-`;
-      } else {
-        importLoadersCode += `import { loader as ${key} } from "${slash(loaderInfo.filePath)}${getDataLoaderPath({
-          loaderId: key,
-          clientData: loaderInfo.clientData,
-          action: false,
-          inline: loaderInfo.inline,
-          routeId: route.id,
-          inValidSSRRoute: loaderInfo.inValidSSRRoute
-        })}";
-`;
-      }
-    } else {
-      importLoadersCode += `import ${key} from "${slash(loaderInfo.filePath)}${getDataLoaderPath({
-        loaderId: key,
-        clientData: loaderInfo.clientData,
-        action: false,
-        inline: loaderInfo.inline,
-        routeId: loaderInfo.routeId,
-        inValidSSRRoute: loaderInfo.inValidSSRRoute
-      })}";
-`;
-    }
-  }
-  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 '@${metaName}/runtime/router';
-  `;
-  const routeModulesCode = `
-    if(typeof document !== 'undefined'){
-      window.${ROUTE_MODULES} = {}
-    }
-  `;
-  return `
-    ${importLazyCode}
-    ${!isRscClient ? importComponentsCode : ""}
-    ${importRuntimeRouterCode}
-    ${!isRscClient ? 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)}"`;
-    if (!config.source.enableAsyncEntry) {
-      return combinedModule;
-    }
-    return `
-    async function loadModules() {
-      const [moduleA, moduleB] = await Promise.all([
-        import("${slash(serverLoaderRuntime)}"),
-        import("${slash(serverLoadersFile)}")
-      ]);
-
-      return {
-        ...moduleA,
-        ...moduleB
-      };
-    }
-
-    export { loadModules };
-    `;
-  }
-  return null;
-}
-const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, rscType = false }) => {
-  const imports = [
-    `import { setGlobalContext } from '@${metaName}/runtime/context';`
-  ];
-  if (nestedRoutesEntry) {
-    const rootLayoutPath = path.join(nestedRoutesEntry, "layout");
-    const rootLayoutFile = findExists([
-      ".js",
-      ".ts",
-      ".jsx",
-      ".tsx"
-    ].map((ext) => `${rootLayoutPath}${ext}`));
-    if (rootLayoutFile) {
-      const rootLayoutBuffer = await fs.readFile(rootLayoutFile);
-      const rootLayout = rootLayoutBuffer.toString();
-      const [, moduleExports] = await parseModule({
-        source: rootLayout.toString(),
-        filename: rootLayoutFile
-      });
-      const hasAppConfig = moduleExports.some((e) => e.n === APP_CONFIG_NAME);
-      const hasAppInit = moduleExports.some((e) => e.n === APP_INIT_EXPORTED);
-      const layoutPath = formatImportPath(getPathWithoutExt(replaceWithAlias(srcDirectory, rootLayoutFile, internalSrcAlias)));
-      if (hasAppConfig) {
-        imports.push(`import { config as appConfig } from '${layoutPath}';`);
-      } else {
-        imports.push(`let appConfig;`);
-      }
-      if (hasAppInit) {
-        imports.push(`import { init as appInit } from '${layoutPath}';`);
-      } else {
-        imports.push(`let appInit;`);
-      }
-    } else {
-      imports.push(`let appConfig;`);
-      imports.push(`let appInit;`);
-    }
-  } else {
-    imports.push(`let appConfig;`);
-    imports.push(`let appInit;`);
-  }
-  if (globalApp) {
-    imports.push(`import layoutApp from '${formatImportPath(globalApp.replace(srcDirectory, internalSrcAlias))}';`);
-  } else {
-    imports.push(`let layoutApp;`);
-  }
-  const isClient = rscType === "client";
-  const enableRsc = Boolean(rscType);
-  if (isClient) {
-    return `${imports.join("\n")}
-
-    import { routes } from './routes';
-
-    const entryName = '${entryName}';
-      setGlobalContext({
-        entryName,
-        layoutApp,
-        routes,
-        appInit,
-        appConfig,
-        isRscClient: true,
-        enableRsc: true,
-      });
-    `;
-  } else {
-    return `${imports.join("\n")}
-
-    import { routes } from './routes';
-
-    const entryName = '${entryName}';
-      setGlobalContext({
-        entryName,
-        layoutApp,
-        routes,
-        appInit,
-        appConfig,
-        enableRsc: ${enableRsc},
-      });
-    `;
-  }
-};
-export {
-  fileSystemRoutes,
-  routesForServer,
-  runtimeGlobalContext,
-  ssrLoaderCombinedModule
-};