@react-router/fs-routes 7.0.0-pre.2 → 7.0.0-pre.3

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @react-router/fs-routes
 
+## 7.0.0-pre.3
+
+### Patch Changes
+
+- Updated dependencies:
+  - `@react-router/dev@7.0.0-pre.3`
+
 ## 7.0.0-pre.2
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,6 @@
 # @react-router/fs-routes
 
-File system routing conventions for [React Router.](https://github.com/remix-run/react-router)
+File system routing conventions for [React Router](https://github.com/remix-run/react-router), for use within `routes.ts`.
 
 ```sh
 npm install @react-router/fs-routes

package/dist/index.d.ts

@@ -1,11 +1,12 @@
-import { type RouteConfigEntry } from "@react-router/dev/routes";
+import { RouteConfigEntry } from '@react-router/dev/routes';
+
 /**
  * Creates route config from the file system using a convention that matches
  * [Remix v2's route file
  * naming](https://remix.run/docs/en/v2/file-conventions/routes-files), for use
  * within `routes.ts`.
  */
-export declare function flatRoutes(options?: {
+declare function flatRoutes(options?: {
     /**
      * An array of [minimatch](https://www.npmjs.com/package/minimatch) globs that match files to ignore.
      * Defaults to `[]`.
@@ -17,3 +18,5 @@ export declare function flatRoutes(options?: {
      */
     rootDirectory?: string;
 }): Promise<RouteConfigEntry[]>;
+
+export { flatRoutes };

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/fs-routes v7.0.0-pre.2
+ * @react-router/fs-routes v7.0.0-pre.3
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -8,39 +8,467 @@
  *
  * @license MIT
  */
-'use strict';
+"use strict";
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-Object.defineProperty(exports, '__esModule', { value: true });
+// index.ts
+var react_router_fs_routes_exports = {};
+__export(react_router_fs_routes_exports, {
+  flatRoutes: () => flatRoutes2
+});
+module.exports = __toCommonJS(react_router_fs_routes_exports);
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path3 = __toESM(require("path"));
+var import_routes = require("@react-router/dev/routes");
 
-var fs = require('node:fs');
-var path = require('node:path');
-var routes = require('@react-router/dev/routes');
-var manifest = require('./manifest.js');
-var flatRoutes$1 = require('./flatRoutes.js');
-var normalizeSlashes = require('./normalizeSlashes.js');
+// manifest.ts
+function routeManifestToRouteConfig(routeManifest, rootId = "root") {
+  let routeConfigById = {};
+  for (let id in routeManifest) {
+    let route = routeManifest[id];
+    routeConfigById[id] = {
+      id: route.id,
+      file: route.file,
+      path: route.path,
+      index: route.index,
+      caseSensitive: route.caseSensitive
+    };
+  }
+  let routeConfig = [];
+  for (let id in routeConfigById) {
+    let route = routeConfigById[id];
+    let parentId = routeManifest[route.id].parentId;
+    if (parentId === rootId) {
+      routeConfig.push(route);
+    } else {
+      let parentRoute = parentId && routeConfigById[parentId];
+      if (parentRoute) {
+        parentRoute.children = parentRoute.children || [];
+        parentRoute.children.push(route);
+      }
+    }
+  }
+  return routeConfig;
+}
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+// flatRoutes.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+var import_minimatch = require("minimatch");
 
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+// normalizeSlashes.ts
+var import_node_path = __toESM(require("path"));
+function normalizeSlashes(file) {
+  return file.split(import_node_path.default.win32.sep).join("/");
+}
 
-/**
- * Creates route config from the file system using a convention that matches
- * [Remix v2's route file
- * naming](https://remix.run/docs/en/v2/file-conventions/routes-files), for use
- * within `routes.ts`.
- */
-async function flatRoutes(options = {}) {
-  let {
-    ignoredRouteFiles = [],
-    rootDirectory: userRootDirectory = "routes"
-  } = options;
-  let appDirectory = routes.getAppDirectory();
-  let rootDirectory = path__default["default"].resolve(appDirectory, userRootDirectory);
-  let relativeRootDirectory = path__default["default"].relative(appDirectory, rootDirectory);
-  let prefix = normalizeSlashes.normalizeSlashes(relativeRootDirectory);
-  let routes$1 = fs__default["default"].existsSync(rootDirectory) ? flatRoutes$1.flatRoutes(appDirectory, ignoredRouteFiles, prefix) : {};
-  return manifest.routeManifestToRouteConfig(routes$1);
-}
-
-exports.flatRoutes = flatRoutes;
+// flatRoutes.ts
+var routeModuleExts = [".js", ".jsx", ".ts", ".tsx", ".md", ".mdx"];
+var paramPrefixChar = "$";
+var escapeStart = "[";
+var escapeEnd = "]";
+var optionalStart = "(";
+var optionalEnd = ")";
+var PrefixLookupTrieEndSymbol = Symbol("PrefixLookupTrieEndSymbol");
+var PrefixLookupTrie = class {
+  root = {
+    [PrefixLookupTrieEndSymbol]: false
+  };
+  add(value) {
+    if (!value) throw new Error("Cannot add empty string to PrefixLookupTrie");
+    let node = this.root;
+    for (let char of value) {
+      if (!node[char]) {
+        node[char] = {
+          [PrefixLookupTrieEndSymbol]: false
+        };
+      }
+      node = node[char];
+    }
+    node[PrefixLookupTrieEndSymbol] = true;
+  }
+  findAndRemove(prefix, filter) {
+    let node = this.root;
+    for (let char of prefix) {
+      if (!node[char]) return [];
+      node = node[char];
+    }
+    return this.#findAndRemoveRecursive([], node, prefix, filter);
+  }
+  #findAndRemoveRecursive(values, node, prefix, filter) {
+    for (let char of Object.keys(node)) {
+      this.#findAndRemoveRecursive(values, node[char], prefix + char, filter);
+    }
+    if (node[PrefixLookupTrieEndSymbol] && filter(prefix)) {
+      node[PrefixLookupTrieEndSymbol] = false;
+      values.push(prefix);
+    }
+    return values;
+  }
+};
+function flatRoutes(appDirectory, ignoredFilePatterns = [], prefix = "routes") {
+  let ignoredFileRegex = Array.from(/* @__PURE__ */ new Set(["**/.*", ...ignoredFilePatterns])).map((re) => (0, import_minimatch.makeRe)(re)).filter((re) => !!re);
+  let routesDir = import_node_path2.default.join(appDirectory, prefix);
+  let rootRoute = findFile(appDirectory, "root", routeModuleExts);
+  if (!rootRoute) {
+    throw new Error(
+      `Could not find a root route module in the app directory: ${appDirectory}`
+    );
+  }
+  if (!import_node_fs.default.existsSync(rootRoute)) {
+    throw new Error(
+      `Could not find the routes directory: ${routesDir}. Did you forget to create it?`
+    );
+  }
+  let entries = import_node_fs.default.readdirSync(routesDir, {
+    withFileTypes: true,
+    encoding: "utf-8"
+  });
+  let routes = [];
+  for (let entry of entries) {
+    let filepath = normalizeSlashes(import_node_path2.default.join(routesDir, entry.name));
+    let route = null;
+    if (entry.isDirectory()) {
+      route = findRouteModuleForFolder(
+        appDirectory,
+        filepath,
+        ignoredFileRegex
+      );
+    } else if (entry.isFile()) {
+      route = findRouteModuleForFile(appDirectory, filepath, ignoredFileRegex);
+    }
+    if (route) routes.push(route);
+  }
+  let routeManifest = flatRoutesUniversal(appDirectory, routes, prefix);
+  return routeManifest;
+}
+function flatRoutesUniversal(appDirectory, routes, prefix = "routes") {
+  let urlConflicts = /* @__PURE__ */ new Map();
+  let routeManifest = {};
+  let prefixLookup = new PrefixLookupTrie();
+  let uniqueRoutes = /* @__PURE__ */ new Map();
+  let routeIdConflicts = /* @__PURE__ */ new Map();
+  let routeIds = /* @__PURE__ */ new Map();
+  for (let file of routes) {
+    let normalizedFile = normalizeSlashes(file);
+    let routeExt = import_node_path2.default.extname(normalizedFile);
+    let routeDir = import_node_path2.default.dirname(normalizedFile);
+    let normalizedApp = normalizeSlashes(appDirectory);
+    let routeId = routeDir === import_node_path2.default.posix.join(normalizedApp, prefix) ? import_node_path2.default.posix.relative(normalizedApp, normalizedFile).slice(0, -routeExt.length) : import_node_path2.default.posix.relative(normalizedApp, routeDir);
+    let conflict = routeIds.get(routeId);
+    if (conflict) {
+      let currentConflicts = routeIdConflicts.get(routeId);
+      if (!currentConflicts) {
+        currentConflicts = [import_node_path2.default.posix.relative(normalizedApp, conflict)];
+      }
+      currentConflicts.push(import_node_path2.default.posix.relative(normalizedApp, normalizedFile));
+      routeIdConflicts.set(routeId, currentConflicts);
+      continue;
+    }
+    routeIds.set(routeId, normalizedFile);
+  }
+  let sortedRouteIds = Array.from(routeIds).sort(
+    ([a], [b]) => b.length - a.length
+  );
+  for (let [routeId, file] of sortedRouteIds) {
+    let index = routeId.endsWith("_index");
+    let [segments, raw] = getRouteSegments(routeId.slice(prefix.length + 1));
+    let pathname = createRoutePath(segments, raw, index);
+    routeManifest[routeId] = {
+      file: file.slice(appDirectory.length + 1),
+      id: routeId,
+      path: pathname
+    };
+    if (index) routeManifest[routeId].index = true;
+    let childRouteIds = prefixLookup.findAndRemove(routeId, (value) => {
+      return [".", "/"].includes(value.slice(routeId.length).charAt(0));
+    });
+    prefixLookup.add(routeId);
+    if (childRouteIds.length > 0) {
+      for (let childRouteId of childRouteIds) {
+        routeManifest[childRouteId].parentId = routeId;
+      }
+    }
+  }
+  let parentChildrenMap = /* @__PURE__ */ new Map();
+  for (let [routeId] of sortedRouteIds) {
+    let config = routeManifest[routeId];
+    if (!config.parentId) continue;
+    let existingChildren = parentChildrenMap.get(config.parentId) || [];
+    existingChildren.push(config);
+    parentChildrenMap.set(config.parentId, existingChildren);
+  }
+  for (let [routeId] of sortedRouteIds) {
+    let config = routeManifest[routeId];
+    let originalPathname = config.path || "";
+    let pathname = config.path;
+    let parentConfig = config.parentId ? routeManifest[config.parentId] : null;
+    if (parentConfig?.path && pathname) {
+      pathname = pathname.slice(parentConfig.path.length).replace(/^\//, "").replace(/\/$/, "");
+    }
+    if (!config.parentId) config.parentId = "root";
+    config.path = pathname || void 0;
+    let lastRouteSegment = config.id.replace(new RegExp(`^${prefix}/`), "").split(".").pop();
+    let isPathlessLayoutRoute = lastRouteSegment && lastRouteSegment.startsWith("_") && lastRouteSegment !== "_index";
+    if (isPathlessLayoutRoute) {
+      continue;
+    }
+    let conflictRouteId = originalPathname + (config.index ? "?index" : "");
+    let conflict = uniqueRoutes.get(conflictRouteId);
+    uniqueRoutes.set(conflictRouteId, config);
+    if (conflict && (originalPathname || config.index)) {
+      let currentConflicts = urlConflicts.get(originalPathname);
+      if (!currentConflicts) currentConflicts = [conflict];
+      currentConflicts.push(config);
+      urlConflicts.set(originalPathname, currentConflicts);
+      continue;
+    }
+  }
+  if (routeIdConflicts.size > 0) {
+    for (let [routeId, files] of routeIdConflicts.entries()) {
+      console.error(getRouteIdConflictErrorMessage(routeId, files));
+    }
+  }
+  if (urlConflicts.size > 0) {
+    for (let [path4, routes2] of urlConflicts.entries()) {
+      for (let i = 1; i < routes2.length; i++) {
+        delete routeManifest[routes2[i].id];
+      }
+      let files = routes2.map((r) => r.file);
+      console.error(getRoutePathConflictErrorMessage(path4, files));
+    }
+  }
+  return routeManifest;
+}
+function findRouteModuleForFile(appDirectory, filepath, ignoredFileRegex) {
+  let relativePath = normalizeSlashes(import_node_path2.default.relative(appDirectory, filepath));
+  let isIgnored = ignoredFileRegex.some((regex) => regex.test(relativePath));
+  if (isIgnored) return null;
+  return filepath;
+}
+function findRouteModuleForFolder(appDirectory, filepath, ignoredFileRegex) {
+  let relativePath = import_node_path2.default.relative(appDirectory, filepath);
+  let isIgnored = ignoredFileRegex.some((regex) => regex.test(relativePath));
+  if (isIgnored) return null;
+  let routeRouteModule = findFile(filepath, "route", routeModuleExts);
+  let routeIndexModule = findFile(filepath, "index", routeModuleExts);
+  if (routeRouteModule && routeIndexModule) {
+    let [segments, raw] = getRouteSegments(
+      import_node_path2.default.relative(appDirectory, filepath)
+    );
+    let routePath = createRoutePath(segments, raw, false);
+    console.error(
+      getRoutePathConflictErrorMessage(routePath || "/", [
+        routeRouteModule,
+        routeIndexModule
+      ])
+    );
+  }
+  return routeRouteModule || routeIndexModule || null;
+}
+function getRouteSegments(routeId) {
+  let routeSegments = [];
+  let rawRouteSegments = [];
+  let index = 0;
+  let routeSegment = "";
+  let rawRouteSegment = "";
+  let state = "NORMAL";
+  let pushRouteSegment = (segment, rawSegment) => {
+    if (!segment) return;
+    let notSupportedInRR = (segment2, char) => {
+      throw new Error(
+        `Route segment "${segment2}" for "${routeId}" cannot contain "${char}".
+If this is something you need, upvote this proposal for React Router https://github.com/remix-run/react-router/discussions/9822.`
+      );
+    };
+    if (rawSegment.includes("*")) {
+      return notSupportedInRR(rawSegment, "*");
+    }
+    if (rawSegment.includes(":")) {
+      return notSupportedInRR(rawSegment, ":");
+    }
+    if (rawSegment.includes("/")) {
+      return notSupportedInRR(segment, "/");
+    }
+    routeSegments.push(segment);
+    rawRouteSegments.push(rawSegment);
+  };
+  while (index < routeId.length) {
+    let char = routeId[index];
+    index++;
+    switch (state) {
+      case "NORMAL": {
+        if (isSegmentSeparator(char)) {
+          pushRouteSegment(routeSegment, rawRouteSegment);
+          routeSegment = "";
+          rawRouteSegment = "";
+          state = "NORMAL";
+          break;
+        }
+        if (char === escapeStart) {
+          state = "ESCAPE";
+          rawRouteSegment += char;
+          break;
+        }
+        if (char === optionalStart) {
+          state = "OPTIONAL";
+          rawRouteSegment += char;
+          break;
+        }
+        if (!routeSegment && char === paramPrefixChar) {
+          if (index === routeId.length) {
+            routeSegment += "*";
+            rawRouteSegment += char;
+          } else {
+            routeSegment += ":";
+            rawRouteSegment += char;
+          }
+          break;
+        }
+        routeSegment += char;
+        rawRouteSegment += char;
+        break;
+      }
+      case "ESCAPE": {
+        if (char === escapeEnd) {
+          state = "NORMAL";
+          rawRouteSegment += char;
+          break;
+        }
+        routeSegment += char;
+        rawRouteSegment += char;
+        break;
+      }
+      case "OPTIONAL": {
+        if (char === optionalEnd) {
+          routeSegment += "?";
+          rawRouteSegment += char;
+          state = "NORMAL";
+          break;
+        }
+        if (char === escapeStart) {
+          state = "OPTIONAL_ESCAPE";
+          rawRouteSegment += char;
+          break;
+        }
+        if (!routeSegment && char === paramPrefixChar) {
+          if (index === routeId.length) {
+            routeSegment += "*";
+            rawRouteSegment += char;
+          } else {
+            routeSegment += ":";
+            rawRouteSegment += char;
+          }
+          break;
+        }
+        routeSegment += char;
+        rawRouteSegment += char;
+        break;
+      }
+      case "OPTIONAL_ESCAPE": {
+        if (char === escapeEnd) {
+          state = "OPTIONAL";
+          rawRouteSegment += char;
+          break;
+        }
+        routeSegment += char;
+        rawRouteSegment += char;
+        break;
+      }
+    }
+  }
+  pushRouteSegment(routeSegment, rawRouteSegment);
+  return [routeSegments, rawRouteSegments];
+}
+function createRoutePath(routeSegments, rawRouteSegments, isIndex) {
+  let result = [];
+  if (isIndex) {
+    routeSegments = routeSegments.slice(0, -1);
+  }
+  for (let index = 0; index < routeSegments.length; index++) {
+    let segment = routeSegments[index];
+    let rawSegment = rawRouteSegments[index];
+    if (segment.startsWith("_") && rawSegment.startsWith("_")) {
+      continue;
+    }
+    if (segment.endsWith("_") && rawSegment.endsWith("_")) {
+      segment = segment.slice(0, -1);
+    }
+    result.push(segment);
+  }
+  return result.length ? result.join("/") : void 0;
+}
+function getRoutePathConflictErrorMessage(pathname, routes) {
+  let [taken, ...others] = routes;
+  if (!pathname.startsWith("/")) {
+    pathname = "/" + pathname;
+  }
+  return `\u26A0\uFE0F Route Path Collision: "${pathname}"
+
+The following routes all define the same URL, only the first one will be used
+
+\u{1F7E2} ${taken}
+` + others.map((route) => `\u2B55\uFE0F\uFE0F ${route}`).join("\n") + "\n";
+}
+function getRouteIdConflictErrorMessage(routeId, files) {
+  let [taken, ...others] = files;
+  return `\u26A0\uFE0F Route ID Collision: "${routeId}"
+
+The following routes all define the same Route ID, only the first one will be used
+
+\u{1F7E2} ${taken}
+` + others.map((route) => `\u2B55\uFE0F\uFE0F ${route}`).join("\n") + "\n";
+}
+function isSegmentSeparator(checkChar) {
+  if (!checkChar) return false;
+  return ["/", ".", import_node_path2.default.win32.sep].includes(checkChar);
+}
+function findFile(dir, basename, extensions) {
+  for (let ext of extensions) {
+    let name = basename + ext;
+    let file = import_node_path2.default.join(dir, name);
+    if (import_node_fs.default.existsSync(file)) return file;
+  }
+  return void 0;
+}
+
+// index.ts
+async function flatRoutes2(options = {}) {
+  let { ignoredRouteFiles = [], rootDirectory: userRootDirectory = "routes" } = options;
+  let appDirectory = (0, import_routes.getAppDirectory)();
+  let rootDirectory = import_node_path3.default.resolve(appDirectory, userRootDirectory);
+  let relativeRootDirectory = import_node_path3.default.relative(appDirectory, rootDirectory);
+  let prefix = normalizeSlashes(relativeRootDirectory);
+  let routes = import_node_fs2.default.existsSync(rootDirectory) ? flatRoutes(appDirectory, ignoredRouteFiles, prefix) : {};
+  return routeManifestToRouteConfig(routes);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  flatRoutes
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@react-router/fs-routes",
-  "version": "7.0.0-pre.2",
-  "description": "File system routing conventions for React Router",
+  "version": "7.0.0-pre.3",
+  "description": "File system routing conventions for React Router, for use within routes.ts",
   "bugs": {
     "url": "https://github.com/remix-run/react-router/issues"
   },
@@ -20,16 +20,31 @@
     },
     "./package.json": "./package.json"
   },
+  "wireit": {
+    "build": {
+      "command": "tsup",
+      "files": [
+        "*.ts",
+        "tsconfig.json",
+        "package.json"
+      ],
+      "output": [
+        "dist/**"
+      ]
+    }
+  },
   "dependencies": {
     "minimatch": "^9.0.0"
   },
   "devDependencies": {
+    "tsup": "^8.3.0",
     "typescript": "^5.1.6",
-    "@react-router/dev": "7.0.0-pre.2"
+    "wireit": "0.14.9",
+    "@react-router/dev": "7.0.0-pre.3"
   },
   "peerDependencies": {
     "typescript": "^5.1.0",
-    "@react-router/dev": "^7.0.0-pre.2"
+    "@react-router/dev": "^7.0.0-pre.3"
   },
   "peerDependenciesMeta": {
     "typescript": {
@@ -46,6 +61,6 @@
     "README.md"
   ],
   "scripts": {
-    "tsc": "tsc"
+    "build": "wireit"
   }
 }

package/dist/flatRoutes.d.ts

@@ -1,14 +0,0 @@
-import type { RouteManifest } from "./manifest";
-export declare const routeModuleExts: string[];
-export declare let paramPrefixChar: "$";
-export declare let escapeStart: "[";
-export declare let escapeEnd: "]";
-export declare let optionalStart: "(";
-export declare let optionalEnd: ")";
-export declare function flatRoutes(appDirectory: string, ignoredFilePatterns?: string[], prefix?: string): RouteManifest;
-export declare function flatRoutesUniversal(appDirectory: string, routes: string[], prefix?: string): RouteManifest;
-export declare function getRouteSegments(routeId: string): [string[], string[]];
-export declare function createRoutePath(routeSegments: string[], rawRouteSegments: string[], isIndex?: boolean): string | undefined;
-export declare function getRoutePathConflictErrorMessage(pathname: string, routes: string[]): string;
-export declare function getRouteIdConflictErrorMessage(routeId: string, files: string[]): string;
-export declare function isSegmentSeparator(checkChar: string | undefined): boolean;

package/dist/flatRoutes.js

@@ -1,435 +0,0 @@
-/**
- * @react-router/fs-routes v7.0.0-pre.2
- *
- * Copyright (c) Remix Software Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE.md file in the root directory of this source tree.
- *
- * @license MIT
- */
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var fs = require('node:fs');
-var path = require('node:path');
-var minimatch = require('minimatch');
-var normalizeSlashes = require('./normalizeSlashes.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-
-const routeModuleExts = [".js", ".jsx", ".ts", ".tsx", ".md", ".mdx"];
-let paramPrefixChar = "$";
-let escapeStart = "[";
-let escapeEnd = "]";
-let optionalStart = "(";
-let optionalEnd = ")";
-const PrefixLookupTrieEndSymbol = Symbol("PrefixLookupTrieEndSymbol");
-class PrefixLookupTrie {
-  root = {
-    [PrefixLookupTrieEndSymbol]: false
-  };
-  add(value) {
-    if (!value) throw new Error("Cannot add empty string to PrefixLookupTrie");
-    let node = this.root;
-    for (let char of value) {
-      if (!node[char]) {
-        node[char] = {
-          [PrefixLookupTrieEndSymbol]: false
-        };
-      }
-      node = node[char];
-    }
-    node[PrefixLookupTrieEndSymbol] = true;
-  }
-  findAndRemove(prefix, filter) {
-    let node = this.root;
-    for (let char of prefix) {
-      if (!node[char]) return [];
-      node = node[char];
-    }
-    return this.#findAndRemoveRecursive([], node, prefix, filter);
-  }
-  #findAndRemoveRecursive(values, node, prefix, filter) {
-    for (let char of Object.keys(node)) {
-      this.#findAndRemoveRecursive(values, node[char], prefix + char, filter);
-    }
-    if (node[PrefixLookupTrieEndSymbol] && filter(prefix)) {
-      node[PrefixLookupTrieEndSymbol] = false;
-      values.push(prefix);
-    }
-    return values;
-  }
-}
-function flatRoutes(appDirectory, ignoredFilePatterns = [], prefix = "routes") {
-  let ignoredFileRegex = Array.from(new Set(["**/.*", ...ignoredFilePatterns])).map(re => minimatch.makeRe(re)).filter(re => !!re);
-  let routesDir = path__default["default"].join(appDirectory, prefix);
-  let rootRoute = findFile(appDirectory, "root", routeModuleExts);
-  if (!rootRoute) {
-    throw new Error(`Could not find a root route module in the app directory: ${appDirectory}`);
-  }
-  if (!fs__default["default"].existsSync(rootRoute)) {
-    throw new Error(`Could not find the routes directory: ${routesDir}. Did you forget to create it?`);
-  }
-
-  // Only read the routes directory
-  let entries = fs__default["default"].readdirSync(routesDir, {
-    withFileTypes: true,
-    encoding: "utf-8"
-  });
-  let routes = [];
-  for (let entry of entries) {
-    let filepath = normalizeSlashes.normalizeSlashes(path__default["default"].join(routesDir, entry.name));
-    let route = null;
-    // If it's a directory, don't recurse into it, instead just look for a route module
-    if (entry.isDirectory()) {
-      route = findRouteModuleForFolder(appDirectory, filepath, ignoredFileRegex);
-    } else if (entry.isFile()) {
-      route = findRouteModuleForFile(appDirectory, filepath, ignoredFileRegex);
-    }
-    if (route) routes.push(route);
-  }
-  let routeManifest = flatRoutesUniversal(appDirectory, routes, prefix);
-  return routeManifest;
-}
-function flatRoutesUniversal(appDirectory, routes, prefix = "routes") {
-  let urlConflicts = new Map();
-  let routeManifest = {};
-  let prefixLookup = new PrefixLookupTrie();
-  let uniqueRoutes = new Map();
-  let routeIdConflicts = new Map();
-
-  // id -> file
-  let routeIds = new Map();
-  for (let file of routes) {
-    let normalizedFile = normalizeSlashes.normalizeSlashes(file);
-    let routeExt = path__default["default"].extname(normalizedFile);
-    let routeDir = path__default["default"].dirname(normalizedFile);
-    let normalizedApp = normalizeSlashes.normalizeSlashes(appDirectory);
-    let routeId = routeDir === path__default["default"].posix.join(normalizedApp, prefix) ? path__default["default"].posix.relative(normalizedApp, normalizedFile).slice(0, -routeExt.length) : path__default["default"].posix.relative(normalizedApp, routeDir);
-    let conflict = routeIds.get(routeId);
-    if (conflict) {
-      let currentConflicts = routeIdConflicts.get(routeId);
-      if (!currentConflicts) {
-        currentConflicts = [path__default["default"].posix.relative(normalizedApp, conflict)];
-      }
-      currentConflicts.push(path__default["default"].posix.relative(normalizedApp, normalizedFile));
-      routeIdConflicts.set(routeId, currentConflicts);
-      continue;
-    }
-    routeIds.set(routeId, normalizedFile);
-  }
-  let sortedRouteIds = Array.from(routeIds).sort(([a], [b]) => b.length - a.length);
-  for (let [routeId, file] of sortedRouteIds) {
-    let index = routeId.endsWith("_index");
-    let [segments, raw] = getRouteSegments(routeId.slice(prefix.length + 1));
-    let pathname = createRoutePath(segments, raw, index);
-    routeManifest[routeId] = {
-      file: file.slice(appDirectory.length + 1),
-      id: routeId,
-      path: pathname
-    };
-    if (index) routeManifest[routeId].index = true;
-    let childRouteIds = prefixLookup.findAndRemove(routeId, value => {
-      return [".", "/"].includes(value.slice(routeId.length).charAt(0));
-    });
-    prefixLookup.add(routeId);
-    if (childRouteIds.length > 0) {
-      for (let childRouteId of childRouteIds) {
-        routeManifest[childRouteId].parentId = routeId;
-      }
-    }
-  }
-
-  // path creation
-  let parentChildrenMap = new Map();
-  for (let [routeId] of sortedRouteIds) {
-    let config = routeManifest[routeId];
-    if (!config.parentId) continue;
-    let existingChildren = parentChildrenMap.get(config.parentId) || [];
-    existingChildren.push(config);
-    parentChildrenMap.set(config.parentId, existingChildren);
-  }
-  for (let [routeId] of sortedRouteIds) {
-    let config = routeManifest[routeId];
-    let originalPathname = config.path || "";
-    let pathname = config.path;
-    let parentConfig = config.parentId ? routeManifest[config.parentId] : null;
-    if (parentConfig !== null && parentConfig !== void 0 && parentConfig.path && pathname) {
-      pathname = pathname.slice(parentConfig.path.length).replace(/^\//, "").replace(/\/$/, "");
-    }
-    if (!config.parentId) config.parentId = "root";
-    config.path = pathname || undefined;
-
-    /**
-     * We do not try to detect path collisions for pathless layout route
-     * files because, by definition, they create the potential for route
-     * collisions _at that level in the tree_.
-     *
-     * Consider example where a user may want multiple pathless layout routes
-     * for different subfolders
-     *
-     *   routes/
-     *     account.tsx
-     *     account._private.tsx
-     *     account._private.orders.tsx
-     *     account._private.profile.tsx
-     *     account._public.tsx
-     *     account._public.login.tsx
-     *     account._public.perks.tsx
-     *
-     * In order to support both a public and private layout for `/account/*`
-     * URLs, we are creating a mutually exclusive set of URLs beneath 2
-     * separate pathless layout routes.  In this case, the route paths for
-     * both account._public.tsx and account._private.tsx is the same
-     * (/account), but we're again not expecting to match at that level.
-     *
-     * By only ignoring this check when the final portion of the filename is
-     * pathless, we will still detect path collisions such as:
-     *
-     *   routes/parent._pathless.foo.tsx
-     *   routes/parent._pathless2.foo.tsx
-     *
-     * and
-     *
-     *   routes/parent._pathless/index.tsx
-     *   routes/parent._pathless2/index.tsx
-     */
-    let lastRouteSegment = config.id.replace(new RegExp(`^${prefix}/`), "").split(".").pop();
-    let isPathlessLayoutRoute = lastRouteSegment && lastRouteSegment.startsWith("_") && lastRouteSegment !== "_index";
-    if (isPathlessLayoutRoute) {
-      continue;
-    }
-    let conflictRouteId = originalPathname + (config.index ? "?index" : "");
-    let conflict = uniqueRoutes.get(conflictRouteId);
-    uniqueRoutes.set(conflictRouteId, config);
-    if (conflict && (originalPathname || config.index)) {
-      let currentConflicts = urlConflicts.get(originalPathname);
-      if (!currentConflicts) currentConflicts = [conflict];
-      currentConflicts.push(config);
-      urlConflicts.set(originalPathname, currentConflicts);
-      continue;
-    }
-  }
-  if (routeIdConflicts.size > 0) {
-    for (let [routeId, files] of routeIdConflicts.entries()) {
-      console.error(getRouteIdConflictErrorMessage(routeId, files));
-    }
-  }
-
-  // report conflicts
-  if (urlConflicts.size > 0) {
-    for (let [path, routes] of urlConflicts.entries()) {
-      // delete all but the first route from the manifest
-      for (let i = 1; i < routes.length; i++) {
-        delete routeManifest[routes[i].id];
-      }
-      let files = routes.map(r => r.file);
-      console.error(getRoutePathConflictErrorMessage(path, files));
-    }
-  }
-  return routeManifest;
-}
-function findRouteModuleForFile(appDirectory, filepath, ignoredFileRegex) {
-  let relativePath = normalizeSlashes.normalizeSlashes(path__default["default"].relative(appDirectory, filepath));
-  let isIgnored = ignoredFileRegex.some(regex => regex.test(relativePath));
-  if (isIgnored) return null;
-  return filepath;
-}
-function findRouteModuleForFolder(appDirectory, filepath, ignoredFileRegex) {
-  let relativePath = path__default["default"].relative(appDirectory, filepath);
-  let isIgnored = ignoredFileRegex.some(regex => regex.test(relativePath));
-  if (isIgnored) return null;
-  let routeRouteModule = findFile(filepath, "route", routeModuleExts);
-  let routeIndexModule = findFile(filepath, "index", routeModuleExts);
-
-  // if both a route and index module exist, throw a conflict error
-  // preferring the route module over the index module
-  if (routeRouteModule && routeIndexModule) {
-    let [segments, raw] = getRouteSegments(path__default["default"].relative(appDirectory, filepath));
-    let routePath = createRoutePath(segments, raw, false);
-    console.error(getRoutePathConflictErrorMessage(routePath || "/", [routeRouteModule, routeIndexModule]));
-  }
-  return routeRouteModule || routeIndexModule || null;
-}
-function getRouteSegments(routeId) {
-  let routeSegments = [];
-  let rawRouteSegments = [];
-  let index = 0;
-  let routeSegment = "";
-  let rawRouteSegment = "";
-  let state = "NORMAL";
-  let pushRouteSegment = (segment, rawSegment) => {
-    if (!segment) return;
-    let notSupportedInRR = (segment, char) => {
-      throw new Error(`Route segment "${segment}" for "${routeId}" cannot contain "${char}".\n` + `If this is something you need, upvote this proposal for React Router https://github.com/remix-run/react-router/discussions/9822.`);
-    };
-    if (rawSegment.includes("*")) {
-      return notSupportedInRR(rawSegment, "*");
-    }
-    if (rawSegment.includes(":")) {
-      return notSupportedInRR(rawSegment, ":");
-    }
-    if (rawSegment.includes("/")) {
-      return notSupportedInRR(segment, "/");
-    }
-    routeSegments.push(segment);
-    rawRouteSegments.push(rawSegment);
-  };
-  while (index < routeId.length) {
-    let char = routeId[index];
-    index++; //advance to next char
-
-    switch (state) {
-      case "NORMAL":
-        {
-          if (isSegmentSeparator(char)) {
-            pushRouteSegment(routeSegment, rawRouteSegment);
-            routeSegment = "";
-            rawRouteSegment = "";
-            state = "NORMAL";
-            break;
-          }
-          if (char === escapeStart) {
-            state = "ESCAPE";
-            rawRouteSegment += char;
-            break;
-          }
-          if (char === optionalStart) {
-            state = "OPTIONAL";
-            rawRouteSegment += char;
-            break;
-          }
-          if (!routeSegment && char === paramPrefixChar) {
-            if (index === routeId.length) {
-              routeSegment += "*";
-              rawRouteSegment += char;
-            } else {
-              routeSegment += ":";
-              rawRouteSegment += char;
-            }
-            break;
-          }
-          routeSegment += char;
-          rawRouteSegment += char;
-          break;
-        }
-      case "ESCAPE":
-        {
-          if (char === escapeEnd) {
-            state = "NORMAL";
-            rawRouteSegment += char;
-            break;
-          }
-          routeSegment += char;
-          rawRouteSegment += char;
-          break;
-        }
-      case "OPTIONAL":
-        {
-          if (char === optionalEnd) {
-            routeSegment += "?";
-            rawRouteSegment += char;
-            state = "NORMAL";
-            break;
-          }
-          if (char === escapeStart) {
-            state = "OPTIONAL_ESCAPE";
-            rawRouteSegment += char;
-            break;
-          }
-          if (!routeSegment && char === paramPrefixChar) {
-            if (index === routeId.length) {
-              routeSegment += "*";
-              rawRouteSegment += char;
-            } else {
-              routeSegment += ":";
-              rawRouteSegment += char;
-            }
-            break;
-          }
-          routeSegment += char;
-          rawRouteSegment += char;
-          break;
-        }
-      case "OPTIONAL_ESCAPE":
-        {
-          if (char === escapeEnd) {
-            state = "OPTIONAL";
-            rawRouteSegment += char;
-            break;
-          }
-          routeSegment += char;
-          rawRouteSegment += char;
-          break;
-        }
-    }
-  }
-
-  // process remaining segment
-  pushRouteSegment(routeSegment, rawRouteSegment);
-  return [routeSegments, rawRouteSegments];
-}
-function createRoutePath(routeSegments, rawRouteSegments, isIndex) {
-  let result = [];
-  if (isIndex) {
-    routeSegments = routeSegments.slice(0, -1);
-  }
-  for (let index = 0; index < routeSegments.length; index++) {
-    let segment = routeSegments[index];
-    let rawSegment = rawRouteSegments[index];
-
-    // skip pathless layout segments
-    if (segment.startsWith("_") && rawSegment.startsWith("_")) {
-      continue;
-    }
-
-    // remove trailing slash
-    if (segment.endsWith("_") && rawSegment.endsWith("_")) {
-      segment = segment.slice(0, -1);
-    }
-    result.push(segment);
-  }
-  return result.length ? result.join("/") : undefined;
-}
-function getRoutePathConflictErrorMessage(pathname, routes) {
-  let [taken, ...others] = routes;
-  if (!pathname.startsWith("/")) {
-    pathname = "/" + pathname;
-  }
-  return `⚠️ Route Path Collision: "${pathname}"\n\n` + `The following routes all define the same URL, only the first one will be used\n\n` + `🟢 ${taken}\n` + others.map(route => `⭕️️ ${route}`).join("\n") + "\n";
-}
-function getRouteIdConflictErrorMessage(routeId, files) {
-  let [taken, ...others] = files;
-  return `⚠️ Route ID Collision: "${routeId}"\n\n` + `The following routes all define the same Route ID, only the first one will be used\n\n` + `🟢 ${taken}\n` + others.map(route => `⭕️️ ${route}`).join("\n") + "\n";
-}
-function isSegmentSeparator(checkChar) {
-  if (!checkChar) return false;
-  return ["/", ".", path__default["default"].win32.sep].includes(checkChar);
-}
-function findFile(dir, basename, extensions) {
-  for (let ext of extensions) {
-    let name = basename + ext;
-    let file = path__default["default"].join(dir, name);
-    if (fs__default["default"].existsSync(file)) return file;
-  }
-  return undefined;
-}
-
-exports.createRoutePath = createRoutePath;
-exports.escapeEnd = escapeEnd;
-exports.escapeStart = escapeStart;
-exports.flatRoutes = flatRoutes;
-exports.flatRoutesUniversal = flatRoutesUniversal;
-exports.getRouteIdConflictErrorMessage = getRouteIdConflictErrorMessage;
-exports.getRoutePathConflictErrorMessage = getRoutePathConflictErrorMessage;
-exports.getRouteSegments = getRouteSegments;
-exports.isSegmentSeparator = isSegmentSeparator;
-exports.optionalEnd = optionalEnd;
-exports.optionalStart = optionalStart;
-exports.paramPrefixChar = paramPrefixChar;
-exports.routeModuleExts = routeModuleExts;

package/dist/manifest.d.ts

@@ -1,13 +0,0 @@
-import type { RouteConfigEntry } from "@react-router/dev/routes";
-export interface RouteManifestEntry {
-    path?: string;
-    index?: boolean;
-    caseSensitive?: boolean;
-    id: string;
-    parentId?: string;
-    file: string;
-}
-export interface RouteManifest {
-    [routeId: string]: RouteManifestEntry;
-}
-export declare function routeManifestToRouteConfig(routeManifest: RouteManifest, rootId?: string): RouteConfigEntry[];

package/dist/manifest.js

@@ -1,44 +0,0 @@
-/**
- * @react-router/fs-routes v7.0.0-pre.2
- *
- * Copyright (c) Remix Software Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE.md file in the root directory of this source tree.
- *
- * @license MIT
- */
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function routeManifestToRouteConfig(routeManifest, rootId = "root") {
-  let routeConfigById = {};
-  for (let id in routeManifest) {
-    let route = routeManifest[id];
-    routeConfigById[id] = {
-      id: route.id,
-      file: route.file,
-      path: route.path,
-      index: route.index,
-      caseSensitive: route.caseSensitive
-    };
-  }
-  let routeConfig = [];
-  for (let id in routeConfigById) {
-    let route = routeConfigById[id];
-    let parentId = routeManifest[route.id].parentId;
-    if (parentId === rootId) {
-      routeConfig.push(route);
-    } else {
-      let parentRoute = parentId && routeConfigById[parentId];
-      if (parentRoute) {
-        parentRoute.children = parentRoute.children || [];
-        parentRoute.children.push(route);
-      }
-    }
-  }
-  return routeConfig;
-}
-
-exports.routeManifestToRouteConfig = routeManifestToRouteConfig;

package/dist/normalizeSlashes.d.ts

@@ -1 +0,0 @@
-export declare function normalizeSlashes(file: string): string;

package/dist/normalizeSlashes.js

@@ -1,25 +0,0 @@
-/**
- * @react-router/fs-routes v7.0.0-pre.2
- *
- * Copyright (c) Remix Software Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE.md file in the root directory of this source tree.
- *
- * @license MIT
- */
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var path = require('node:path');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-
-function normalizeSlashes(file) {
-  return file.split(path__default["default"].win32.sep).join("/");
-}
-
-exports.normalizeSlashes = normalizeSlashes;