@modern-js/app-tools 2.4.0 → 2.5.0-alpha.1

package/dist/cjs/analyze/makeLegalIdentifier.js

@@ -0,0 +1,36 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var makeLegalIdentifier_exports = {};
+__export(makeLegalIdentifier_exports, {
+  makeLegalIdentifier: () => makeLegalIdentifier
+});
+module.exports = __toCommonJS(makeLegalIdentifier_exports);
+const reservedWords = "break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public";
+const builtins = "arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl";
+const forbidList = new Set(`${reservedWords} ${builtins}`.split(" "));
+function makeLegalIdentifier(str) {
+  const identifier = str.replace(/-(\w)/g, (_, letter) => letter.toUpperCase()).replace(/[^$_a-zA-Z0-9]/g, "_");
+  if (/\d/.test(identifier[0]) || forbidList.has(identifier)) {
+    return `_${identifier}`;
+  }
+  return identifier || "_";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  makeLegalIdentifier
+});

package/dist/cjs/analyze/nestedRoutes.js

@@ -0,0 +1,179 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var nestedRoutes_exports = {};
+__export(nestedRoutes_exports, {
+  walk: () => walk
+});
+module.exports = __toCommonJS(nestedRoutes_exports);
+var path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_constants = require("./constants");
+var import_utils2 = require("./utils");
+const conventionNames = Object.values(import_constants.NESTED_ROUTE);
+const replaceDynamicPath = (routePath) => {
+  return routePath.replace(/\[(.*?)\]/g, ":$1");
+};
+const createIndexRoute = (routeInfo, rootDir, filename, entryName) => {
+  return createRoute(
+    {
+      ...routeInfo,
+      index: true,
+      children: void 0
+    },
+    rootDir,
+    filename,
+    entryName
+  );
+};
+const createRoute = (routeInfo, rootDir, filename, entryName) => {
+  const id = (0, import_utils.getRouteId)(filename, rootDir, entryName);
+  return {
+    ...routeInfo,
+    id,
+    type: "nested"
+  };
+};
+const walk = async (dirname, rootDir, alias, entryName) => {
+  var _a, _b, _c, _d;
+  if (!await import_utils.fs.pathExists(dirname)) {
+    return null;
+  }
+  const isDirectory = (await import_utils.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,
+    children: [],
+    isRoot
+  };
+  let pageLoaderFile = "";
+  let pageRoute = null;
+  let splatLoaderFile = "";
+  let splatRoute = null;
+  const items = await import_utils.fs.readdir(dirname);
+  for (const item of items) {
+    const itemPath = path.join(dirname, item);
+    const extname = path.extname(item);
+    const itemWithoutExt = item.slice(0, -extname.length);
+    const isDirectory2 = (await import_utils.fs.stat(itemPath)).isDirectory();
+    if (isDirectory2) {
+      const childRoute = await walk(itemPath, rootDir, alias, entryName);
+      if (childRoute) {
+        (_a = route.children) == null ? void 0 : _a.push(childRoute);
+      }
+    }
+    if (extname && (!import_constants.JS_EXTENSIONS.includes(extname) || !conventionNames.includes(itemWithoutExt))) {
+      continue;
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.LAYOUT_LOADER_FILE) {
+      if (!route.loader) {
+        route.loader = itemPath;
+      }
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.LAYOUT_FILE) {
+      route._component = (0, import_utils2.replaceWithAlias)(alias.basename, itemPath, alias.name);
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.PAGE_LOADER_FILE) {
+      pageLoaderFile = itemPath;
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.PAGE_FILE) {
+      pageRoute = createIndexRoute(
+        {
+          _component: (0, import_utils2.replaceWithAlias)(alias.basename, itemPath, alias.name)
+        },
+        rootDir,
+        itemPath,
+        entryName
+      );
+      if (pageLoaderFile) {
+        pageRoute.loader = pageLoaderFile;
+      }
+      (_b = route.children) == null ? void 0 : _b.push(pageRoute);
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.SPLATE_LOADER_FILE) {
+      splatLoaderFile = itemPath;
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.SPLATE_FILE) {
+      splatRoute = createRoute(
+        {
+          _component: (0, import_utils2.replaceWithAlias)(alias.basename, itemPath, alias.name),
+          path: "*"
+        },
+        rootDir,
+        itemPath,
+        entryName
+      );
+      if (splatLoaderFile) {
+        splatRoute.loader = splatLoaderFile;
+      }
+      (_c = route.children) == null ? void 0 : _c.push(splatRoute);
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.LOADING_FILE) {
+      route.loading = (0, import_utils2.replaceWithAlias)(alias.basename, itemPath, alias.name);
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.ERROR_FILE) {
+      route.error = (0, import_utils2.replaceWithAlias)(alias.basename, itemPath, alias.name);
+    }
+  }
+  let finalRoute = createRoute(
+    route,
+    rootDir,
+    path.join(dirname, `${import_constants.NESTED_ROUTE.LAYOUT_FILE}.ts`),
+    entryName
+  );
+  if (isPathlessLayout) {
+    delete finalRoute.path;
+  }
+  route.children = (_d = route.children) == null ? void 0 : _d.filter((childRoute) => childRoute);
+  if (route.children && route.children.length === 0 && !route.index) {
+    return null;
+  }
+  if (finalRoute.children && finalRoute.children.length === 1 && !finalRoute._component) {
+    const childRoute = finalRoute.children[0];
+    if (childRoute.path === "*") {
+      const path2 = `${finalRoute.path || ""}/${childRoute.path || ""}`;
+      finalRoute = {
+        ...childRoute,
+        path: path2
+      };
+    }
+  }
+  return finalRoute;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  walk
+});

package/dist/cjs/analyze/templates.js

@@ -0,0 +1,330 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var templates_exports = {};
+__export(templates_exports, {
+  fileSystemRoutes: () => fileSystemRoutes,
+  html: () => html,
+  index: () => index,
+  renderFunction: () => renderFunction,
+  routesForServer: () => routesForServer
+});
+module.exports = __toCommonJS(templates_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_constants = require("./constants");
+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 ${import_constants.APP_CONFIG_NAME} === 'function' ? ${import_constants.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>
+  <%= meta %>
+  <title><%= title %></title>
+
+  ${partials.top.join("\n")}
+
+  <script>
+    window.__assetPrefix__ = '<%= assetPrefix %>';
+  <\/script>
+  ${partials.head.join("\n")}
+
+  <!--<?- chunksMap.css ?>-->
+</head>
+
+<body>
+  <noscript>
+    We're sorry but react app doesn't work properly without JavaScript enabled. Please enable it to continue.
+  </noscript>
+  <div id="<%= mountId %>"><!--<?- html ?>--></div>
+  ${partials.body.join("\n")}
+  <!--<?- chunksMap.js ?>-->
+  <!--<?- SSRDataScript ?>-->
+  <!--<?- bottomTemplate ?>-->
+</body>
+
+</html>
+`;
+const routesForServer = ({
+  routes,
+  metaName
+}) => {
+  const loaders = [];
+  const traverseRouteTree = (route) => {
+    var _a;
+    let children;
+    if ("children" in route && route.children) {
+      children = (_a = route == null ? void 0 : route.children) == null ? void 0 : _a.map(traverseRouteTree);
+    }
+    let loader;
+    if (route.type === "nested") {
+      if (route.loader) {
+        loaders.push(route.loader);
+        loader = `loader_${loaders.length - 1}`;
+      }
+    }
+    const finalRoute = {
+      ...route,
+      loader,
+      children
+    };
+    return finalRoute;
+  };
+  let routesCode = `
+  export const routes = [
+  `;
+  for (const route of routes) {
+    if ("type" in route) {
+      const newRoute = traverseRouteTree(route);
+      routesCode += `${JSON.stringify(newRoute, null, 2).replace(
+        /"(loader_[^"])"/g,
+        "$1"
+      )},`;
+    } else {
+      routesCode += `${JSON.stringify(route, null, 2)}`;
+    }
+  }
+  routesCode += `
+];`;
+  let importLoadersCode = "";
+  if (loaders.length > 0) {
+    importLoadersCode = loaders.map((loader, index2) => {
+      return `import loader_${index2} from "${(0, import_utils.slash)(loader)}"`;
+    }).join("\n");
+  }
+  const exportCode = `
+    export { handleRequest } from '@modern-js/plugin-data-loader/runtime';
+  `;
+  return `
+    ${importLoadersCode}
+    ${routesCode}
+    ${exportCode}
+  `;
+};
+const fileSystemRoutes = async ({
+  routes,
+  ssrMode,
+  nestedRoutesEntry,
+  entryName,
+  internalDirectory
+}) => {
+  const loadings = [];
+  const errors = [];
+  const loaders = [];
+  const loadersMap = {};
+  const loadersMapFile = import_path.default.join(
+    internalDirectory,
+    entryName,
+    import_constants.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) => {
+    if (!ssrMode) {
+      return "";
+    }
+    let dataLoaderPath = require.resolve("@modern-js/plugin-data-loader/loader");
+    if (nestedRoutesEntry) {
+      dataLoaderPath = `${(0, import_utils.slash)(dataLoaderPath)}?mapFile=${(0, import_utils.slash)(
+        loadersMapFile
+      )}&loaderId=${loaderId}!`;
+    }
+    return dataLoaderPath;
+  };
+  const traverseRouteTree = (route) => {
+    var _a;
+    let children;
+    if ("children" in route && route.children) {
+      children = (_a = route == null ? void 0 : route.children) == null ? void 0 : _a.map(traverseRouteTree);
+    }
+    let loading;
+    let error;
+    let loader;
+    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) {
+        loaders.push(route.loader);
+        const loaderId = loaders.length - 1;
+        loader = `loader_${loaderId}`;
+        loadersMap[loader] = {
+          routeId: route.id,
+          filePath: route.loader,
+          inline: false
+        };
+      }
+      if (route._component) {
+        if (route.isRoot) {
+          rootLayoutCode = `import RootLayout from '${route._component}'`;
+          component = `RootLayout`;
+        } else if (ssrMode === "string") {
+          lazyImport = `() => import(/* webpackChunkName: "${route.id}" */  '${route._component}')`;
+          component = `loadable(${lazyImport})`;
+        } else {
+          lazyImport = `() => import(/* webpackChunkName: "${route.id}" */  '${route._component}')`;
+          component = `lazy(${lazyImport})`;
+        }
+      }
+    } else if (route._component) {
+      lazyImport = `() => import('${route._component}')`;
+      component = `loadable(${lazyImport})`;
+    }
+    const finalRoute = {
+      ...route,
+      lazyImport,
+      loading,
+      loader,
+      error,
+      children
+    };
+    if (route._component) {
+      finalRoute.component = component;
+    }
+    return finalRoute;
+  };
+  let routeComponentsCode = `
+    export const routes = [
+  `;
+  for (const route of routes) {
+    if ("type" in route) {
+      const newRoute = traverseRouteTree(route);
+      routeComponentsCode += `${JSON.stringify(newRoute, null, 2).replace(/"(loadable.*\))"/g, "$1").replace(/"(loadableLazy.*\))"/g, "$1").replace(/"(\(\)[^,]+)",/g, "$1,").replace(/"(lazy\(.*\))"/g, "$1").replace(/"(loading_[^"])"/g, "$1").replace(/"(loader_[^"])"/g, "$1").replace(/"(RootLayout)"/g, "$1").replace(/"(error_[^"])"/g, "$1").replace(/\\"/g, '"')},`;
+    } else {
+      const component = `loadable(() => import('${route._component}'))`;
+      const finalRoute = {
+        ...route,
+        component
+      };
+      routeComponentsCode += `${JSON.stringify(finalRoute, null, 2).replace(/"(loadable[^"]*)"/g, "$1").replace(/"(lazy[^"]*)"/g, "$1")},`;
+    }
+  }
+  routeComponentsCode += `
+];`;
+  const importLoadingCode = loadings.map((loading, index2) => {
+    return `import loading_${index2} from '${loading}';
+`;
+  }).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) {
+      importLoadersCode += `import { loader as ${key} } from "${getDataLoaderPath(
+        key
+      )}${(0, import_utils.slash)(loaderInfo.filePath)}";
+`;
+    } else {
+      importLoadersCode += `import ${key} from "${getDataLoaderPath(
+        key
+      )}${(0, import_utils.slash)(loaderInfo.filePath)}";
+`;
+    }
+  }
+  await import_utils.fs.ensureFile(loadersMapFile);
+  await import_utils.fs.writeJSON(loadersMapFile, loadersMap);
+  return `
+    ${importLazyCode}
+    ${rootLayoutCode}
+    ${importLoadingCode}
+    ${importErrorComponentsCode}
+    ${importLoadersCode}
+    ${routeComponentsCode}
+  `;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fileSystemRoutes,
+  html,
+  index,
+  renderFunction,
+  routesForServer
+});

package/dist/cjs/analyze/utils.js

@@ -0,0 +1,152 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  getDefaultImports: () => getDefaultImports,
+  getServerLoadersFile: () => getServerLoadersFile,
+  hasLoader: () => hasLoader,
+  isPageComponentFile: () => isPageComponentFile,
+  parseModule: () => parseModule,
+  replaceWithAlias: () => replaceWithAlias,
+  walkDirectory: () => walkDirectory
+});
+module.exports = __toCommonJS(utils_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_esbuild = require("esbuild");
+var import_es_module_lexer = require("es-module-lexer");
+var import_constants = require("./constants");
+const walkDirectory = (dir) => import_fs.default.readdirSync(dir).reduce((previous, filename) => {
+  const filePath = import_path.default.join(dir, filename);
+  if (import_fs.default.statSync(filePath).isDirectory()) {
+    return [...previous, ...walkDirectory(filePath)];
+  } else {
+    return [...previous, filePath];
+  }
+}, []);
+const getDefaultImports = ({
+  entrypoint,
+  srcDirectory,
+  internalSrcAlias,
+  internalDirAlias,
+  internalDirectory
+}) => {
+  const { entryName, fileSystemRoutes, customBootstrap, entry } = entrypoint;
+  const imports = [
+    {
+      specifiers: [{ local: "React" }],
+      value: "react"
+    },
+    {
+      specifiers: [{ local: "ReactDOM" }],
+      value: (0, import_utils.isReact18)(import_path.default.join(internalDirectory, "../../")) ? "react-dom/client" : "react-dom"
+    },
+    {
+      specifiers: [{ imported: "createApp" }, { imported: "bootstrap" }],
+      value: "@modern-js/runtime"
+    },
+    customBootstrap && {
+      specifiers: [{ local: "customBootstrap" }],
+      value: (0, import_utils.normalizeToPosixPath)(
+        customBootstrap.replace(srcDirectory, internalSrcAlias)
+      )
+    }
+  ].filter(Boolean);
+  if (fileSystemRoutes) {
+    const route = {
+      specifiers: [{ imported: "routes" }],
+      value: (0, import_utils.normalizeToPosixPath)(
+        `${internalDirAlias}/${entryName}/${import_constants.FILE_SYSTEM_ROUTES_FILE_NAME.replace(
+          ".js",
+          ""
+        )}`
+      )
+    };
+    if (fileSystemRoutes.globalApp) {
+      imports.push({
+        specifiers: [{ local: "App" }],
+        value: (0, import_utils.normalizeToPosixPath)(
+          fileSystemRoutes.globalApp.replace(srcDirectory, internalSrcAlias)
+        )
+      });
+    } else {
+      route.initialize = "const App = false;";
+    }
+    imports.push(route);
+  } else {
+    imports.push({
+      specifiers: [{ local: "App" }],
+      value: (0, import_utils.normalizeToPosixPath)(
+        entry.replace(srcDirectory, internalSrcAlias)
+      )
+    });
+  }
+  return imports;
+};
+const isPageComponentFile = (filePath) => {
+  if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) {
+    return false;
+  }
+  if ([".js", ".jsx", ".ts", ".tsx"].includes(import_path.default.extname(filePath))) {
+    return true;
+  }
+  return false;
+};
+const replaceWithAlias = (base, filePath, alias) => (0, import_utils.normalizeToPosixPath)(import_path.default.join(alias, import_path.default.relative(base, filePath)));
+const parseModule = async ({
+  source,
+  filename
+}) => {
+  let content = source;
+  if (import_constants.JS_EXTENSIONS.some((ext) => filename.endsWith(ext))) {
+    const result = await (0, import_esbuild.transform)(content, {
+      loader: import_path.default.extname(filename).slice(1),
+      format: "esm"
+    });
+    content = result.code;
+  }
+  return await (0, import_es_module_lexer.parse)(content);
+};
+const hasLoader = async (filename) => {
+  const source = await import_utils.fs.readFile(filename);
+  const [, moduleExports] = await parseModule({
+    source: source.toString(),
+    filename
+  });
+  return moduleExports.some((e) => e.n === import_constants.LOADER_EXPORT_NAME);
+};
+const getServerLoadersFile = (internalDirectory, entryName) => {
+  return import_path.default.join(internalDirectory, entryName, "route-server-loaders.js");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDefaultImports,
+  getServerLoadersFile,
+  hasLoader,
+  isPageComponentFile,
+  parseModule,
+  replaceWithAlias,
+  walkDirectory
+});