@modern-js/app-tools 1.22.2 → 2.0.0-alpha.0

package/dist/js/modern/analyze/index.js

@@ -1,148 +1,235 @@
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-import * as path from 'path';
-import { createAsyncWaterfall } from '@modern-js/plugin';
-import { createDebugger, fs, isApiOnly } from '@modern-js/utils';
-import { cloneDeep } from '@modern-js/utils/lodash';
-import { isRouteComponentFile } from "./utils";
-const debug = createDebugger('plugin-analyze');
-export const modifyEntryImports = createAsyncWaterfall();
-export const modifyEntryExport = createAsyncWaterfall();
-export const addRuntimeExports = createAsyncWaterfall();
-export const modifyEntryRuntimePlugins = createAsyncWaterfall();
-export const modifyEntryRenderFunction = createAsyncWaterfall();
-export const modifyAsyncEntry = createAsyncWaterfall();
-export const modifyFileSystemRoutes = createAsyncWaterfall();
-export const modifyServerRoutes = createAsyncWaterfall();
-export const htmlPartials = createAsyncWaterfall();
-export const beforeGenerateRoutes = createAsyncWaterfall();
-export const addDefineTypes = createAsyncWaterfall();
-export default (() => ({
-  name: '@modern-js/plugin-analyze',
-  registerHook: {
-    modifyAsyncEntry,
-    modifyEntryImports,
-    modifyEntryExport,
-    modifyEntryRuntimePlugins,
-    modifyEntryRenderFunction,
-    modifyFileSystemRoutes,
-    modifyServerRoutes,
-    htmlPartials,
-    addRuntimeExports,
-    beforeGenerateRoutes,
-    addDefineTypes
-  },
-  setup: api => {
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import * as path from "path";
+import { createDebugger, fs, isApiOnly } from "@modern-js/utils";
+import { cloneDeep } from "@modern-js/utils/lodash";
+import { createBuilderForModern } from "../builder";
+import { printInstructions } from "../utils/printInstructions";
+import { generateRoutes } from "../utils/routes";
+import { emitResolvedConfig } from "../utils/config";
+import { getCommand } from "../utils/commands";
+import { initialNormalizedConfig } from "../config";
+import { isNestedRouteComponent, isPageComponentFile } from "./utils";
+import { loaderBuilder, serverLoaderBuilder } from "./Builder";
+const debug = createDebugger("plugin-analyze");
+var analyze_default = () => ({
+  name: "@modern-js/plugin-analyze",
+  setup: (api) => {
     let pagesDir = [];
+    let nestedRouteEntries = [];
     let originEntrypoints = [];
     return {
-      async prepare() {
-        var _resolvedConfig$sourc;
-
-        const appContext = api.useAppContext();
-        const resolvedConfig = api.useResolvedConfigContext();
-        const hookRunners = api.useHookRunners();
-
-        try {
-          fs.emptydirSync(appContext.internalDirectory);
-        } catch (_unused) {// FIXME:
-        }
-
-        const apiOnly = await isApiOnly(appContext.appDirectory, resolvedConfig === null || resolvedConfig === void 0 ? void 0 : (_resolvedConfig$sourc = resolvedConfig.source) === null || _resolvedConfig$sourc === void 0 ? void 0 : _resolvedConfig$sourc.entriesDir);
-        await hookRunners.addRuntimeExports();
-
-        if (apiOnly) {
-          const {
-            routes
-          } = await hookRunners.modifyServerRoutes({
-            routes: []
+      prepare() {
+        return __async(this, null, function* () {
+          var _a2;
+          let appContext = api.useAppContext();
+          const resolvedConfig = api.useResolvedConfigContext();
+          const hookRunners = api.useHookRunners();
+          try {
+            fs.emptydirSync(appContext.internalDirectory);
+          } catch (e) {
+          }
+          const apiOnly = yield isApiOnly(
+            appContext.appDirectory,
+            (_a2 = resolvedConfig.source) == null ? void 0 : _a2.entriesDir
+          );
+          yield hookRunners.addRuntimeExports();
+          if (apiOnly) {
+            const { routes: routes2 } = yield hookRunners.modifyServerRoutes({
+              routes: []
+            });
+            debug(`server routes: %o`, routes2);
+            appContext = __spreadProps(__spreadValues({}, appContext), {
+              apiOnly,
+              serverRoutes: routes2
+            });
+            api.setAppContext(appContext);
+            return;
+          }
+          const [
+            { getBundleEntry },
+            { getServerRoutes },
+            { generateCode },
+            { getHtmlTemplate }
+          ] = yield Promise.all([
+            import("./getBundleEntry"),
+            import("./getServerRoutes"),
+            import("./generateCode"),
+            import("./getHtmlTemplate")
+          ]);
+          const entrypoints = getBundleEntry(appContext, resolvedConfig);
+          console.log("final entries", entrypoints);
+          const defaultChecked = entrypoints.map((point) => point.entryName);
+          debug(`entrypoints: %o`, entrypoints);
+          const initialRoutes = getServerRoutes(entrypoints, {
+            appContext,
+            config: resolvedConfig
+          });
+          const { routes } = yield hookRunners.modifyServerRoutes({
+            routes: initialRoutes
           });
           debug(`server routes: %o`, routes);
-          api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
-            apiOnly,
+          appContext = __spreadProps(__spreadValues({}, appContext), {
+            entrypoints,
             serverRoutes: routes
-          }));
-          return;
-        }
-
-        const [{
-          getBundleEntry
-        }, {
-          getServerRoutes
-        }, {
-          generateCode
-        }, {
-          getHtmlTemplate
-        }] = await Promise.all([import("./getBundleEntry"), import("./getServerRoutes"), import("./generateCode"), import("./getHtmlTemplate")]);
-        const entrypoints = getBundleEntry(appContext, resolvedConfig);
-        const defaultChecked = entrypoints.map(point => point.entryName);
-        debug(`entrypoints: %o`, entrypoints);
-        const initialRoutes = getServerRoutes(entrypoints, {
-          appContext,
-          config: resolvedConfig
-        });
-        const {
-          routes
-        } = await hookRunners.modifyServerRoutes({
-          routes: initialRoutes
-        });
-        debug(`server routes: %o`, routes);
-        api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
-          entrypoints,
-          serverRoutes: routes
-        }));
-        pagesDir = entrypoints.map(point => point.entry);
-        originEntrypoints = cloneDeep(entrypoints);
-        await generateCode(appContext, resolvedConfig, entrypoints, api);
-        const htmlTemplates = await getHtmlTemplate(entrypoints, api, {
-          appContext,
-          config: resolvedConfig
+          });
+          api.setAppContext(appContext);
+          nestedRouteEntries = entrypoints.map((point) => point.nestedRoutesEntry).filter(Boolean);
+          pagesDir = entrypoints.map((point) => point.entry).filter(Boolean).concat(nestedRouteEntries);
+          originEntrypoints = cloneDeep(entrypoints);
+          yield generateCode(appContext, resolvedConfig, entrypoints, api);
+          const htmlTemplates = yield getHtmlTemplate(entrypoints, api, {
+            appContext,
+            config: resolvedConfig
+          });
+          debug(`html templates: %o`, htmlTemplates);
+          yield hookRunners.addDefineTypes();
+          debug(`add Define Types`);
+          appContext = __spreadProps(__spreadValues({}, appContext), {
+            entrypoints,
+            checkedEntries: defaultChecked,
+            apiOnly,
+            serverRoutes: routes,
+            htmlTemplates
+          });
+          api.setAppContext(appContext);
+          const command = getCommand();
+          const buildCommands = ["dev", "start", "build", "inspect", "deploy"];
+          if (buildCommands.includes(command)) {
+            let _b;
+            const normalizedConfig = api.useResolvedConfigContext();
+            const builder = yield createBuilderForModern({
+              normalizedConfig,
+              appContext,
+              compatPluginConfig: {
+                onBeforeBuild(_0) {
+                  return __async(this, arguments, function* ({ bundlerConfigs }) {
+                    const hookRunners2 = api.useHookRunners();
+                    yield generateRoutes(appContext);
+                    yield hookRunners2.beforeBuild({ bundlerConfigs });
+                  });
+                },
+                onAfterBuild(_0) {
+                  return __async(this, arguments, function* ({ stats }) {
+                    const hookRunners2 = api.useHookRunners();
+                    yield hookRunners2.afterBuild({ stats });
+                    yield emitResolvedConfig(
+                      appContext.appDirectory,
+                      normalizedConfig
+                    );
+                  });
+                },
+                onDevCompileDone(_0) {
+                  return __async(this, arguments, function* ({ isFirstCompile }) {
+                    const hookRunners2 = api.useHookRunners();
+                    if (process.stdout.isTTY || isFirstCompile) {
+                      hookRunners2.afterDev();
+                      if (isFirstCompile) {
+                        printInstructions(
+                          hookRunners2,
+                          appContext,
+                          normalizedConfig
+                        );
+                      }
+                    }
+                  });
+                },
+                onBeforeCreateCompiler(_0) {
+                  return __async(this, arguments, function* ({ bundlerConfigs }) {
+                    const hookRunners2 = api.useHookRunners();
+                    yield hookRunners2.beforeCreateCompiler({
+                      bundlerConfigs
+                    });
+                  });
+                },
+                onAfterCreateCompiler(_0) {
+                  return __async(this, arguments, function* ({ compiler }) {
+                    const hookRunners2 = api.useHookRunners();
+                    yield hookRunners2.afterCreateCompiler({ compiler });
+                  });
+                }
+              }
+            });
+            builder.addPlugins(resolvedConfig.builderPlugins);
+            appContext = __spreadProps(__spreadValues({}, appContext), {
+              builder
+            });
+            api.setAppContext(appContext);
+          }
         });
-        debug(`html templates: %o`, htmlTemplates);
-        await hookRunners.addDefineTypes();
-        debug(`add Define Types`);
-        api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
-          entrypoints,
-          checkedEntries: defaultChecked,
-          apiOnly,
-          serverRoutes: routes,
-          htmlTemplates
-        }));
       },
-
       watchFiles() {
         return pagesDir;
       },
-
-      async fileChange(e) {
+      resolvedConfig({ resolved }) {
         const appContext = api.useAppContext();
-        const {
-          appDirectory
-        } = appContext;
-        const {
-          filename,
-          eventType
-        } = e;
-
-        const isPageFile = name => pagesDir.some(pageDir => name.includes(pageDir));
-
-        const absoluteFilePath = path.resolve(appDirectory, filename);
-        const isRouteComponent = isPageFile(absoluteFilePath) && isRouteComponentFile(absoluteFilePath);
-
-        if (isRouteComponent && (eventType === 'add' || eventType === 'unlink')) {
-          const resolvedConfig = api.useResolvedConfigContext();
-          const {
-            generateCode
-          } = await import("./generateCode");
-          const entrypoints = cloneDeep(originEntrypoints);
-          generateCode(appContext, resolvedConfig, entrypoints, api);
-        }
+        const config = initialNormalizedConfig(resolved, appContext);
+        return {
+          resolved: config
+        };
+      },
+      beforeRestart() {
+        return __async(this, null, function* () {
+          serverLoaderBuilder.stop();
+          loaderBuilder.stop();
+        });
+      },
+      fileChange(e) {
+        return __async(this, null, function* () {
+          const appContext = api.useAppContext();
+          const { appDirectory } = appContext;
+          const { filename, eventType } = e;
+          const isPageFile = (name) => pagesDir.some((pageDir) => name.includes(pageDir));
+          const absoluteFilePath = path.resolve(appDirectory, filename);
+          const isRouteComponent = isPageFile(absoluteFilePath) && isPageComponentFile(absoluteFilePath);
+          if (isRouteComponent && (eventType === "add" || eventType === "unlink") || isNestedRouteComponent(nestedRouteEntries, absoluteFilePath) && eventType === "change") {
+            const resolvedConfig = api.useResolvedConfigContext();
+            const { generateCode } = yield import("./generateCode");
+            const entrypoints = cloneDeep(originEntrypoints);
+            generateCode(appContext, resolvedConfig, entrypoints, api);
+          }
+        });
       }
-
     };
   }
-}));
+});
+export {
+  analyze_default as default
+};

package/dist/js/modern/analyze/isDefaultExportFunction.js

@@ -1,32 +1,42 @@
-import fs from 'fs';
-import { parse } from '@babel/parser';
-import traverse from '@babel/traverse';
-import * as t from '@babel/types';
-
-const isFunction = node => t.isFunctionDeclaration(node) || t.isFunctionExpression(node) || t.isArrowFunctionExpression(node);
-
-export const isDefaultExportFunction = file => {
+import fs from "fs";
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+import * as t from "@babel/types";
+const isFunction = (node) => t.isFunctionDeclaration(node) || t.isFunctionExpression(node) || t.isArrowFunctionExpression(node);
+const isDefaultExportFunction = (file) => {
   if (!file || !fs.existsSync(file)) {
     return false;
   }
-
-  const ast = parse(fs.readFileSync(file, 'utf8'), {
-    sourceType: 'unambiguous',
-    plugins: ['jsx', 'typescript', 'classProperties', 'dynamicImport', 'exportDefaultFrom', 'exportNamespaceFrom', 'decorators-legacy', 'functionBind', 'classPrivateMethods', ['pipelineOperator', {
-      proposal: 'minimal'
-    }], 'optionalChaining', 'optionalCatchBinding', 'objectRestSpread', 'numericSeparator']
+  const ast = parse(fs.readFileSync(file, "utf8"), {
+    sourceType: "unambiguous",
+    plugins: [
+      "jsx",
+      "typescript",
+      "classProperties",
+      "dynamicImport",
+      "exportDefaultFrom",
+      "exportNamespaceFrom",
+      "decorators-legacy",
+      "functionBind",
+      "classPrivateMethods",
+      ["pipelineOperator", { proposal: "minimal" }],
+      "optionalChaining",
+      "optionalCatchBinding",
+      "objectRestSpread",
+      "numericSeparator"
+    ]
   });
   let isExportFunction = false;
   traverse(ast, {
-    ExportDefaultDeclaration: path => {
-      const {
-        declaration
-      } = path.node;
-
+    ExportDefaultDeclaration: (path) => {
+      const { declaration } = path.node;
       if (isFunction(declaration)) {
         isExportFunction = true;
       }
     }
   });
   return isExportFunction;
-};
+};
+export {
+  isDefaultExportFunction
+};

package/dist/js/modern/analyze/makeLegalIdentifier.js

@@ -1,16 +1,13 @@
-/**
- * modified from https://github.com/rollup/plugins/blob/master/packages/pluginutils
- * license at https://github.com/rollup/plugins/blob/master/LICENSE
- */
-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(' '));
-export function makeLegalIdentifier(str) {
-  const identifier = str.replace(/-(\w)/g, (_, letter) => letter.toUpperCase()).replace(/[^$_a-zA-Z0-9]/g, '_');
-
+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 || '_';
-}
+  return identifier || "_";
+}
+export {
+  makeLegalIdentifier
+};

package/dist/js/modern/analyze/nestedRoutes.js

@@ -0,0 +1,166 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import * as path from "path";
+import { fs, getRouteId } from "@modern-js/utils";
+import { JS_EXTENSIONS, NESTED_ROUTE } from "./constants";
+import { hasLoader, replaceWithAlias } from "./utils";
+const conventionNames = Object.values(NESTED_ROUTE);
+const getLoaderPath = (filename) => __async(void 0, null, function* () {
+  if (yield hasLoader(filename)) {
+    return filename;
+  }
+  return void 0;
+});
+const replaceDynamicPath = (routePath) => {
+  return routePath.replace(/\[(.*?)\]/g, ":$1");
+};
+const createIndexRoute = (routeInfo, rootDir, filename, entryName) => {
+  return createRoute(
+    __spreadProps(__spreadValues({}, routeInfo), {
+      index: true,
+      children: void 0
+    }),
+    rootDir,
+    filename,
+    entryName
+  );
+};
+const createRoute = (routeInfo, rootDir, filename, entryName) => {
+  const id = getRouteId(filename, rootDir, entryName);
+  return __spreadProps(__spreadValues({}, routeInfo), {
+    id,
+    type: "nested"
+  });
+};
+const walk = (dirname, rootDir, alias, entryName) => __async(void 0, null, function* () {
+  var _a, _b;
+  if (!(yield fs.pathExists(dirname))) {
+    return null;
+  }
+  const isDirectory = (yield 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;
+  const items = yield 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 = (yield fs.stat(itemPath)).isDirectory();
+    if (isDirectory2) {
+      const childRoute = yield walk(itemPath, rootDir, alias, entryName);
+      if (childRoute) {
+        (_a = route.children) == null ? void 0 : _a.push(childRoute);
+      }
+    }
+    if (extname && (!JS_EXTENSIONS.includes(extname) || !conventionNames.includes(itemWithoutExt))) {
+      continue;
+    }
+    if (itemWithoutExt === NESTED_ROUTE.LAYOUT_LOADER_FILE) {
+      if (!route.loader) {
+        route.loader = itemPath;
+      }
+    }
+    if (itemWithoutExt === NESTED_ROUTE.LAYOUT_FILE) {
+      route._component = replaceWithAlias(alias.basename, itemPath, alias.name);
+      const loaderPath = yield getLoaderPath(itemPath);
+      if (loaderPath) {
+        route.loader = loaderPath;
+      }
+    }
+    if (itemWithoutExt === NESTED_ROUTE.PAGE_LOADER_FILE) {
+      pageLoaderFile = itemPath;
+    }
+    if (itemWithoutExt === NESTED_ROUTE.PAGE_FILE) {
+      pageRoute = createIndexRoute(
+        {
+          _component: replaceWithAlias(alias.basename, itemPath, alias.name)
+        },
+        rootDir,
+        itemPath,
+        entryName
+      );
+      const loaderPath = yield getLoaderPath(itemPath);
+      if (loaderPath) {
+        pageRoute.loader = loaderPath;
+      } else if (pageLoaderFile) {
+        pageRoute.loader = pageLoaderFile;
+      }
+      (_b = route.children) == null ? void 0 : _b.push(pageRoute);
+    }
+    if (itemWithoutExt === NESTED_ROUTE.LOADING_FILE) {
+      route.loading = replaceWithAlias(alias.basename, itemPath, alias.name);
+    }
+    if (itemWithoutExt === NESTED_ROUTE.ERROR_FILE) {
+      route.error = replaceWithAlias(alias.basename, itemPath, alias.name);
+    }
+  }
+  const finalRoute = createRoute(
+    route,
+    rootDir,
+    path.join(dirname, `${NESTED_ROUTE.LAYOUT_FILE}.ts`),
+    entryName
+  );
+  if (isPathlessLayout) {
+    delete finalRoute.path;
+  }
+  return finalRoute;
+});
+export {
+  walk
+};