@modern-js/app-tools 2.0.0-canary.0 → 2.0.1

package/bin/modern.js

@@ -2,11 +2,14 @@
 const {
   INTERNAL_APP_TOOLS_PLUGINS,
   INTERNAL_SERVER_PLUGINS,
+  INTERNAL_APP_TOOLS_RUNTIME_PLUGINS,
 } = require('@modern-js/utils');
 
 require('@modern-js/core/runBin').run({
   internalPlugins: {
     cli: INTERNAL_APP_TOOLS_PLUGINS,
     server: INTERNAL_SERVER_PLUGINS,
+    autoLoad: INTERNAL_APP_TOOLS_RUNTIME_PLUGINS,
   },
+  toolsType: 'app-tools',
 });

package/dist/js/modern/analyze/Builder.js

@@ -0,0 +1,39 @@
+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 { build } from "esbuild";
+class Builder {
+  build(options) {
+    return __async(this, null, function* () {
+      this.buildRes = yield build(options);
+    });
+  }
+  stop() {
+    var _a, _b;
+    ((_a = this.buildRes) == null ? void 0 : _a.stop) && ((_b = this.buildRes) == null ? void 0 : _b.stop());
+  }
+}
+const loaderBuilder = new Builder();
+const serverLoaderBuilder = new Builder();
+export {
+  Builder,
+  loaderBuilder,
+  serverLoaderBuilder
+};

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

@@ -16,8 +16,23 @@ const FILE_SYSTEM_ROUTES_IGNORED_REGEX = /\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/
 const HTML_PARTIALS_FOLDER = "html";
 const HTML_PARTIALS_EXTENSIONS = [".htm", ".html", ".ejs"];
 const FILE_SYSTEM_ROUTES_COMPONENTS_DIR = "internal_components";
+const NESTED_ROUTE = {
+  LAYOUT_FILE: "layout",
+  LAYOUT_LOADER_FILE: "layout.loader",
+  PAGE_FILE: "page",
+  PAGE_LOADER_FILE: "page.loader",
+  LOADING_FILE: "loading",
+  ERROR_FILE: "error",
+  LOADER_FILE: "loader"
+};
+const APP_CONFIG_NAME = "appConfig";
+const APP_INIT_EXPORTED = "init";
+const APP_INIT_IMPORTED = "appInit";
 export {
+  APP_CONFIG_NAME,
   APP_FILE_NAME,
+  APP_INIT_EXPORTED,
+  APP_INIT_IMPORTED,
   ENTRY_BOOTSTRAP_FILE_NAME,
   ENTRY_POINT_FILE_NAME,
   FILE_SYSTEM_ROUTES_COMPONENTS_DIR,
@@ -32,6 +47,7 @@ export {
   INDEX_FILE_NAME,
   JS_EXTENSIONS,
   LOADER_EXPORT_NAME,
+  NESTED_ROUTE,
   NESTED_ROUTES_DIR,
   PAGES_DIR_NAME,
   TEMP_LOADERS_DIR

package/dist/js/modern/analyze/generateCode.js

@@ -28,8 +28,7 @@ import {
 import {
   useResolvedConfigContext
 } from "@modern-js/core";
-import { build } from "esbuild";
-import { getCommand } from "../utils/commands";
+import { isDevCommand } from "../utils/commands";
 import * as templates from "./templates";
 import { getClientRoutes, getClientRoutesLegacy } from "./getClientRoutes";
 import {
@@ -40,6 +39,7 @@ import {
 } from "./constants";
 import { getDefaultImports } from "./utils";
 import { walk } from "./nestedRoutes";
+import { loaderBuilder, serverLoaderBuilder } from "./Builder";
 const loader = {
   ".js": "jsx",
   ".ts": "tsx"
@@ -93,13 +93,12 @@ ${initialize || ""}`
   ).join("\n");
 };
 const buildLoader = (entry, outfile) => __async(void 0, null, function* () {
-  const command = getCommand();
-  yield build({
+  yield loaderBuilder.build({
     format: "esm",
     platform: "browser",
     target: "esnext",
     loader,
-    watch: command === "dev" && {},
+    watch: isDevCommand() && {},
     bundle: true,
     logLevel: "error",
     entryPoints: [entry],
@@ -107,8 +106,8 @@ const buildLoader = (entry, outfile) => __async(void 0, null, function* () {
     plugins: [
       {
         name: "make-all-packages-external",
-        setup(build2) {
-          build2.onResolve({ filter: EXTERNAL_REGEXP }, (args) => {
+        setup(build) {
+          build.onResolve({ filter: EXTERNAL_REGEXP }, (args) => {
             let external = true;
             if (args.kind === "entry-point") {
               external = false;
@@ -124,13 +123,12 @@ const buildLoader = (entry, outfile) => __async(void 0, null, function* () {
   });
 });
 const buildServerLoader = (entry, outfile) => __async(void 0, null, function* () {
-  const command = getCommand();
-  yield build({
+  yield serverLoaderBuilder.build({
     format: "cjs",
     platform: "node",
     target: "esnext",
     loader,
-    watch: command === "dev" && {},
+    watch: isDevCommand() && {},
     bundle: true,
     logLevel: "error",
     entryPoints: [entry],
@@ -138,7 +136,7 @@ const buildServerLoader = (entry, outfile) => __async(void 0, null, function* ()
   });
 });
 const generateCode = (appContext, config, entrypoints, api) => __async(void 0, null, function* () {
-  var _a, _b;
+  var _a, _b, _c;
   const {
     internalDirectory,
     distDirectory,
@@ -148,9 +146,9 @@ const generateCode = (appContext, config, entrypoints, api) => __async(void 0, n
     packageName
   } = appContext;
   const hookRunners = api.useHookRunners();
-  const islegacy = Boolean((_b = (_a = config == null ? void 0 : config.runtime) == null ? void 0 : _a.router) == null ? void 0 : _b.legacy);
+  const isV5 = typeof ((_a = config.runtime) == null ? void 0 : _a.router) !== "boolean" && ((_c = (_b = config == null ? void 0 : config.runtime) == null ? void 0 : _b.router) == null ? void 0 : _c.mode) === "react-router-5";
   const { mountId } = config.html;
-  const getRoutes = islegacy ? getClientRoutesLegacy : getClientRoutes;
+  const getRoutes = isV5 ? getClientRoutesLegacy : getClientRoutes;
   yield Promise.all(entrypoints.map(generateEntryCode));
   function generateEntryCode(entrypoint) {
     return __async(this, null, function* () {
@@ -169,7 +167,7 @@ const generateCode = (appContext, config, entrypoints, api) => __async(void 0, n
             });
           }
           if (entrypoint.nestedRoutesEntry) {
-            if (!islegacy) {
+            if (!isV5) {
               nestedRoute = yield walk(
                 entrypoint.nestedRoutesEntry,
                 entrypoint.nestedRoutesEntry,
@@ -222,7 +220,8 @@ const generateCode = (appContext, config, entrypoints, api) => __async(void 0, n
               ssrMode: mode,
               nestedRoutesEntry: entrypoint.nestedRoutesEntry,
               entryName: entrypoint.entryName,
-              internalDirectory
+              internalDirectory,
+              internalDirAlias
             })
           });
           if (entrypoint.nestedRoutesEntry) {

package/dist/js/modern/analyze/getBundleEntry.js

@@ -46,8 +46,12 @@ const getBundleEntry = (appContext, config) => {
         entryName: name,
         entry: ensureAbsolutePath(appDirectory, value.entry),
         isAutoMount: !value.disableMount,
-        fileSystemRoutes: value.enableFileSystemRoutes ? {} : void 0
+        customBootstrap: value.customBootstrap && ensureAbsolutePath(appDirectory, value.customBootstrap),
+        fileSystemRoutes: fs.statSync(ensureAbsolutePath(appDirectory, value.entry)).isDirectory() ? {} : void 0
       };
+      if (entrypoint.fileSystemRoutes) {
+        entrypoint.nestedRoutesEntry = entrypoint.entry;
+      }
       if (!ifAlreadyExists(defaults, entrypoint)) {
         defaults.push(entrypoint);
       }

package/dist/js/modern/analyze/getClientRoutes/getRoutes.js

@@ -171,20 +171,23 @@ const getClientRoutes = ({
   internalDirectory,
   internalDirAlias
 }) => {
-  const { entry, entryName } = entrypoint;
-  if (!fs.existsSync(entry)) {
+  const { entryName, pageRoutesEntry } = entrypoint;
+  if (!pageRoutesEntry) {
+    return [];
+  }
+  if (!fs.existsSync(pageRoutesEntry)) {
     throw new Error(
-      `generate file system routes error, ${entry} directory not found.`
+      `generate file system routes error, ${pageRoutesEntry} directory not found.`
     );
   }
-  if (!(fs.existsSync(entry) && fs.statSync(entry).isDirectory())) {
+  if (!(fs.existsSync(pageRoutesEntry) && fs.statSync(pageRoutesEntry).isDirectory())) {
     throw new Error(
-      `generate file system routes error, ${entry} should be directory.`
+      `generate file system routes error, ${pageRoutesEntry} should be directory.`
     );
   }
   let routes = [];
   recursiveReadDir({
-    dir: entry,
+    dir: pageRoutesEntry,
     routes,
     basePath: "/",
     srcDirectory,

package/dist/js/modern/analyze/getFileSystemEntry.js

@@ -63,9 +63,11 @@ const scanDir = (dirs) => dirs.map((dir) => {
     };
     if (isHasPages) {
       entrypoint.entry = path.join(dir, PAGES_DIR_NAME);
+      entrypoint.pageRoutesEntry = entrypoint.entry;
     }
     if (isHasNestedRoutes) {
-      entrypoint.nestedRoutesEntry = path.join(dir, NESTED_ROUTES_DIR);
+      entrypoint.entry = path.join(dir, NESTED_ROUTES_DIR);
+      entrypoint.nestedRoutesEntry = entrypoint.entry;
     }
     return entrypoint;
   }
@@ -79,14 +81,20 @@ const scanDir = (dirs) => dirs.map((dir) => {
 const getFileSystemEntry = (appContext, config) => {
   const { appDirectory } = appContext;
   const {
-    source: { entriesDir }
+    source: { entriesDir, disableEntryDirs }
   } = config;
+  let disabledDirs = [];
+  if (disableEntryDirs && Array.isArray(disableEntryDirs)) {
+    disabledDirs = disableEntryDirs == null ? void 0 : disableEntryDirs.map(
+      (dir) => ensureAbsolutePath(appDirectory, dir)
+    );
+  }
   const src = ensureAbsolutePath(appDirectory, entriesDir || "");
   if (fs.existsSync(src)) {
     if (fs.statSync(src).isDirectory()) {
       return scanDir(
         isBundleEntry(src) ? [src] : fs.readdirSync(src).map((file) => path.join(src, file)).filter(
-          (file) => fs.statSync(file).isDirectory() && isBundleEntry(file)
+          (file) => fs.statSync(file).isDirectory() && isBundleEntry(file) && !disabledDirs.includes(file)
         )
       );
     } else {

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

@@ -38,20 +38,32 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 import * as path from "path";
-import { createDebugger, fs, isApiOnly } from "@modern-js/utils";
+import { createDebugger, findExists, fs, isApiOnly } from "@modern-js/utils";
 import { cloneDeep } from "@modern-js/utils/lodash";
-import { createBuilderForEdenX } from "../builder";
+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 { isRouteComponentFile } from "./utils";
+import {
+  isNestedRouteComponent,
+  isPageComponentFile,
+  parseModule,
+  replaceWithAlias
+} from "./utils";
+import { loaderBuilder, serverLoaderBuilder } from "./Builder";
+import {
+  APP_CONFIG_NAME,
+  APP_INIT_EXPORTED,
+  APP_INIT_IMPORTED
+} from "./constants";
 const debug = createDebugger("plugin-analyze");
 var analyze_default = () => ({
   name: "@modern-js/plugin-analyze",
   setup: (api) => {
     let pagesDir = [];
+    let nestedRouteEntries = [];
     let originEntrypoints = [];
     return {
       prepare() {
@@ -108,7 +120,7 @@ var analyze_default = () => ({
             serverRoutes: routes
           });
           api.setAppContext(appContext);
-          const nestedRouteEntries = entrypoints.map((point) => point.nestedRoutesEntry).filter(Boolean);
+          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);
@@ -128,11 +140,11 @@ var analyze_default = () => ({
           });
           api.setAppContext(appContext);
           const command = getCommand();
-          const buildCommands = ["dev", "build", "inspect", "deploy"];
+          const buildCommands = ["dev", "start", "build", "inspect", "deploy"];
           if (buildCommands.includes(command)) {
             let _b;
             const normalizedConfig = api.useResolvedConfigContext();
-            const builder = yield createBuilderForEdenX({
+            const builder = yield createBuilderForModern({
               normalizedConfig,
               appContext,
               compatPluginConfig: {
@@ -184,6 +196,7 @@ var analyze_default = () => ({
                 }
               }
             });
+            builder.addPlugins(resolvedConfig.builderPlugins);
             appContext = __spreadProps(__spreadValues({}, appContext), {
               builder
             });
@@ -201,6 +214,64 @@ var analyze_default = () => ({
           resolved: config
         };
       },
+      modifyEntryImports(_0) {
+        return __async(this, arguments, function* ({ entrypoint, imports }) {
+          const appContext = api.useAppContext();
+          const { srcDirectory } = appContext;
+          const { fileSystemRoutes, nestedRoutesEntry } = entrypoint;
+          if (fileSystemRoutes && nestedRoutesEntry) {
+            const rootLayoutPath = path.join(nestedRoutesEntry, "layout");
+            const rootLayoutFile = findExists(
+              [".js", ".ts", ".jsx", ".tsx"].map(
+                (ext) => `${rootLayoutPath}${ext}`
+              )
+            );
+            if (rootLayoutFile) {
+              const rootLayoutBuffer = yield fs.readFile(rootLayoutFile);
+              const rootLayout = rootLayoutBuffer.toString();
+              const [, moduleExports] = yield parseModule({
+                source: rootLayout.toString(),
+                filename: rootLayoutFile
+              });
+              const hasAppConfig = moduleExports.some(
+                (e) => e.n === APP_CONFIG_NAME
+              );
+              const generateLayoutPath = replaceWithAlias(
+                srcDirectory,
+                rootLayoutFile,
+                "@_modern_js_src"
+              );
+              if (hasAppConfig) {
+                imports.push({
+                  value: generateLayoutPath,
+                  specifiers: [{ imported: APP_CONFIG_NAME }]
+                });
+              }
+              const hasAppInit = moduleExports.some(
+                (e) => e.n === APP_INIT_EXPORTED
+              );
+              if (hasAppInit) {
+                imports.push({
+                  value: generateLayoutPath,
+                  specifiers: [
+                    { imported: APP_INIT_EXPORTED, local: APP_INIT_IMPORTED }
+                  ]
+                });
+              }
+            }
+          }
+          return {
+            entrypoint,
+            imports
+          };
+        });
+      },
+      beforeRestart() {
+        return __async(this, null, function* () {
+          serverLoaderBuilder.stop();
+          loaderBuilder.stop();
+        });
+      },
       fileChange(e) {
         return __async(this, null, function* () {
           const appContext = api.useAppContext();
@@ -208,8 +279,8 @@ var analyze_default = () => ({
           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 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);

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

@@ -39,20 +39,9 @@ var __async = (__this, __arguments, generator) => {
 };
 import * as path from "path";
 import { fs, getRouteId } from "@modern-js/utils";
-import { JS_EXTENSIONS } from "./constants";
+import { JS_EXTENSIONS, NESTED_ROUTE } from "./constants";
 import { hasLoader, replaceWithAlias } from "./utils";
-const LAYOUT_FILE = "layout";
-const PAGE_FILE = "page";
-const LOADING_FILE = "loading";
-const ERROR_FILE = "error";
-const LOADER_FILE = "loader";
-const conventionNames = [
-  LAYOUT_FILE,
-  PAGE_FILE,
-  LOADING_FILE,
-  ERROR_FILE,
-  LOADER_FILE
-];
+const conventionNames = Object.values(NESTED_ROUTE);
 const getLoaderPath = (filename) => __async(void 0, null, function* () {
   if (yield hasLoader(filename)) {
     return filename;
@@ -105,6 +94,8 @@ const walk = (dirname, rootDir, alias, entryName) => __async(void 0, null, funct
     children: [],
     isRoot
   };
+  let pageLoaderFile = "";
+  let pageRoute = null;
   const items = yield fs.readdir(dirname);
   for (const item of items) {
     const itemPath = path.join(dirname, item);
@@ -120,12 +111,23 @@ const walk = (dirname, rootDir, alias, entryName) => __async(void 0, null, funct
     if (extname && (!JS_EXTENSIONS.includes(extname) || !conventionNames.includes(itemWithoutExt))) {
       continue;
     }
-    if (itemWithoutExt === LAYOUT_FILE) {
+    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);
-      route.loader = yield getLoaderPath(itemPath);
+      const loaderPath = yield getLoaderPath(itemPath);
+      if (loaderPath) {
+        route.loader = loaderPath;
+      }
     }
-    if (itemWithoutExt === PAGE_FILE) {
-      const childRoute = createIndexRoute(
+    if (itemWithoutExt === NESTED_ROUTE.PAGE_LOADER_FILE) {
+      pageLoaderFile = itemPath;
+    }
+    if (itemWithoutExt === NESTED_ROUTE.PAGE_FILE) {
+      pageRoute = createIndexRoute(
         {
           _component: replaceWithAlias(alias.basename, itemPath, alias.name)
         },
@@ -133,20 +135,25 @@ const walk = (dirname, rootDir, alias, entryName) => __async(void 0, null, funct
         itemPath,
         entryName
       );
-      childRoute.loader = yield getLoaderPath(itemPath);
-      (_b = route.children) == null ? void 0 : _b.push(childRoute);
+      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 === LOADING_FILE) {
+    if (itemWithoutExt === NESTED_ROUTE.LOADING_FILE) {
       route.loading = replaceWithAlias(alias.basename, itemPath, alias.name);
     }
-    if (itemWithoutExt === ERROR_FILE) {
+    if (itemWithoutExt === NESTED_ROUTE.ERROR_FILE) {
       route.error = replaceWithAlias(alias.basename, itemPath, alias.name);
     }
   }
   const finalRoute = createRoute(
     route,
     rootDir,
-    path.join(dirname, `${LAYOUT_FILE}.ts`),
+    path.join(dirname, `${NESTED_ROUTE.LAYOUT_FILE}.ts`),
     entryName
   );
   if (isPathlessLayout) {

package/dist/js/modern/analyze/templates.js

@@ -39,7 +39,7 @@ var __async = (__this, __arguments, generator) => {
 };
 import path from "path";
 import { fs, slash } from "@modern-js/utils";
-import { TEMP_LOADERS_DIR } from "./constants";
+import { APP_CONFIG_NAME, TEMP_LOADERS_DIR } from "./constants";
 const index = ({
   mountId,
   imports,
@@ -68,21 +68,34 @@ const renderFunction = ({
   plugins,
   customBootstrap,
   fileSystemRoutes: fileSystemRoutes2
-}) => `
+}) => {
+  return `
+  const finalAppConfig = {
+    ...App.config,
+    ...typeof ${APP_CONFIG_NAME} === 'object' ? ${APP_CONFIG_NAME} : {},
+  }
+
   AppWrapper = createApp({
     plugins: [
      ${plugins.map(
-  ({ name, options, args }) => `${name}({...${options}, ...App?.config?.${args || name}}),`
-).join("\n")}
+    ({ 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(AppWrapper, MOUNT_ID, root, ReactDOM);`}
   }
 
   return AppWrapper
 `;
+};
 const html = (partials) => `
 <!DOCTYPE html>
 <html>
@@ -177,14 +190,15 @@ const fileSystemRoutes = (_0) => __async(void 0, [_0], function* ({
   ssrMode,
   nestedRoutesEntry,
   entryName,
-  internalDirectory
+  internalDirectory,
+  internalDirAlias
 }) {
   const loadings = [];
   const errors = [];
   const loaders = [];
   const loadersMap = {};
   const loadersIndexFile = path.join(
-    "@_modern_js_internal",
+    internalDirAlias,
     entryName,
     TEMP_LOADERS_DIR,
     "index.js"
@@ -314,9 +328,16 @@ const fileSystemRoutes = (_0) => __async(void 0, [_0], function* ({
           TEMP_LOADERS_DIR,
           `${name}.js`
         );
-        const code = `
+        let code = "";
+        if (loader.includes(".loader.")) {
+          code = `
+          export { default as ${name} } from '${slash(loader)}'
+        `;
+        } else {
+          code = `
           export { loader as ${name} } from '${slash(loader)}'
         `;
+        }
         yield fs.ensureFile(filename);
         yield fs.writeFile(filename, code);
       }))

package/dist/js/modern/analyze/utils.js

@@ -23,7 +23,12 @@ import path from "path";
 import { isReact18, normalizeToPosixPath, fs as fse } from "@modern-js/utils";
 import { transform } from "esbuild";
 import { parse } from "es-module-lexer";
-import { FILE_SYSTEM_ROUTES_FILE_NAME, LOADER_EXPORT_NAME } from "./constants";
+import {
+  FILE_SYSTEM_ROUTES_FILE_NAME,
+  JS_EXTENSIONS,
+  LOADER_EXPORT_NAME,
+  NESTED_ROUTE
+} from "./constants";
 const walkDirectory = (dir) => fs.readdirSync(dir).reduce((previous, filename) => {
   const filePath = path.join(dir, filename);
   if (fs.statSync(filePath).isDirectory()) {
@@ -91,7 +96,7 @@ const getDefaultImports = ({
   }
   return imports;
 };
-const isRouteComponentFile = (filePath) => {
+const isPageComponentFile = (filePath) => {
   if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) {
     return false;
   }
@@ -100,13 +105,24 @@ const isRouteComponentFile = (filePath) => {
   }
   return false;
 };
+const isNestedRouteComponent = (nestedRouteEntries, absoluteFilePath) => {
+  const reg = new RegExp(
+    `(${NESTED_ROUTE.LAYOUT_FILE}|${NESTED_ROUTE.PAGE_FILE}})\\.tsx?$`
+  );
+  return nestedRouteEntries.some((nestedRoutesEntry) => {
+    if (absoluteFilePath.includes(nestedRoutesEntry) && reg.test(absoluteFilePath)) {
+      return true;
+    }
+    return false;
+  });
+};
 const replaceWithAlias = (base, filePath, alias) => normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
 const parseModule = (_0) => __async(void 0, [_0], function* ({
   source,
   filename
 }) {
   let content = source;
-  if (filename.endsWith(".tsx") || filename.endsWith(".jsx")) {
+  if (JS_EXTENSIONS.some((ext) => filename.endsWith(ext))) {
     const result = yield transform(content, {
       loader: path.extname(filename).slice(1),
       format: "esm"
@@ -126,7 +142,8 @@ const hasLoader = (filename) => __async(void 0, null, function* () {
 export {
   getDefaultImports,
   hasLoader,
-  isRouteComponentFile,
+  isNestedRouteComponent,
+  isPageComponentFile,
   parseModule,
   replaceWithAlias,
   walkDirectory