@modern-js/runtime 2.52.0 → 2.54.0

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

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

@@ -0,0 +1,335 @@
+import path from "path";
+import { fs, getEntryOptions, isSSGEntry, slash } from "@modern-js/utils";
+import { ROUTE_MODULES } from "@modern-js/utils/universal/constants";
+import { TEMP_LOADERS_DIR } from "../constants";
+import { getServerLoadersFile } from "./utils";
+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, 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
+        })}";
+`;
+      } 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,
+  routesForServer,
+  ssrLoaderCombinedModule
+};

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

@@ -0,0 +1,101 @@
+import fs from "fs";
+import path from "path";
+import { normalizeToPosixPath, fs as fse, JS_EXTENSIONS } from "@modern-js/utils";
+import { transform } from "esbuild";
+import { parse } from "es-module-lexer";
+import { ACTION_EXPORT_NAME, LOADER_EXPORT_NAME } from "../constants";
+const walkDirectory = (dir) => fs.readdirSync(dir).reduce((previous, filename) => {
+  const filePath = path.join(dir, filename);
+  if (fs.statSync(filePath).isDirectory()) {
+    return [
+      ...previous,
+      ...walkDirectory(filePath)
+    ];
+  } else {
+    return [
+      ...previous,
+      filePath
+    ];
+  }
+}, []);
+const isPageComponentFile = (filePath) => {
+  if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) {
+    return false;
+  }
+  if ([
+    ".js",
+    ".jsx",
+    ".ts",
+    ".tsx"
+  ].includes(path.extname(filePath))) {
+    return true;
+  }
+  return false;
+};
+const replaceWithAlias = (base, filePath, alias) => {
+  if (filePath.includes(base)) {
+    return normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
+  } else {
+    return filePath;
+  }
+};
+const parseModule = async ({ source, filename }) => {
+  let content = source;
+  if (JS_EXTENSIONS.some((ext) => filename.endsWith(ext))) {
+    const result = await transform(content, {
+      loader: path.extname(filename).slice(1),
+      format: "esm"
+    });
+    content = result.code;
+  }
+  return parse(content);
+};
+const hasLoader = async (filename, source) => {
+  let content = source;
+  if (!source) {
+    content = (await fse.readFile(filename, "utf-8")).toString();
+  }
+  if (content) {
+    const [, moduleExports] = await parseModule({
+      source: content.toString(),
+      filename
+    });
+    return moduleExports.some((e) => e.n === LOADER_EXPORT_NAME);
+  }
+  return false;
+};
+const hasAction = async (filename, source) => {
+  let content = source;
+  if (!source) {
+    content = (await fse.readFile(filename, "utf-8")).toString();
+  }
+  if (content) {
+    const [, moduleExports] = await parseModule({
+      source: content.toString(),
+      filename
+    });
+    return moduleExports.some((e) => e.n === ACTION_EXPORT_NAME);
+  }
+  return false;
+};
+const getServerLoadersFile = (internalDirectory, entryName) => {
+  return path.join(internalDirectory, entryName, "route-server-loaders.js");
+};
+const getServerCombinedModueFile = (internalDirectory, entryName) => {
+  return path.join(internalDirectory, entryName, "server-loader-combined.js");
+};
+const getPathWithoutExt = (filename) => {
+  const extname = path.extname(filename);
+  return filename.slice(0, -extname.length);
+};
+export {
+  getPathWithoutExt,
+  getServerCombinedModueFile,
+  getServerLoadersFile,
+  hasAction,
+  hasLoader,
+  isPageComponentFile,
+  parseModule,
+  replaceWithAlias,
+  walkDirectory
+};