Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/utils/compat/v1-route-convention.ts
T

498 lines
16 KiB
TypeScript

// I copied this file from:
// https://github.com/remix-run/v1-compat-utils/blob/main/packages/v1-route-convention/src/lib.ts
import fs from "node:fs";
import path from "node:path";
import { DefineRoutesFunction } from "@react-router/remix-config-routes-adapter";
import { RouteManifest } from "node_modules/@react-router/remix-config-routes-adapter/dist/manifest";
let paramPrefixChar = "$" as const;
let escapeStart = "[" as const;
let escapeEnd = "]" as const;
let optionalStart = "(" as const;
let optionalEnd = ")" as const;
let routeModuleExts = [".js", ".jsx", ".ts", ".tsx", ".md", ".mdx"];
function isRouteModuleFile(filename: string): boolean {
return routeModuleExts.includes(path.extname(filename));
}
function matchesIgnoredFilePattern(file: string, pattern: string): boolean {
const normalizedFile = file.split(path.sep).join("/");
const normalizedPattern = pattern.split(path.sep).join("/");
if (normalizedPattern === "**/.*") {
return normalizedFile.split("/").some((segment) => segment.startsWith("."));
}
if (normalizedPattern.startsWith("**/*")) {
return normalizedFile.endsWith(normalizedPattern.slice("**/*".length));
}
if (normalizedPattern.endsWith("/**")) {
const directory = normalizedPattern.slice(0, -"/**".length);
return normalizedFile === directory || normalizedFile.startsWith(`${directory}/`);
}
return normalizedFile === normalizedPattern;
}
export type CreateRoutesFromFoldersOptions = {
/**
* The directory where your app lives. Defaults to `app`.
* @default "app"
*/
appDirectory?: string;
/**
* A list of glob patterns to ignore when looking for route modules.
* Defaults to `[]`.
*/
ignoredFilePatterns?: string[];
/**
* The directory where your routes live. Defaults to `routes`.
* This is relative to `appDirectory`.
* @default "routes"
*/
routesDirectory?: string;
};
/**
* Defines routes using the filesystem convention in `apps/web/app/routes`. The rules are:
*
* - Route paths are derived from the file path. A `.` in the filename indicates
* a `/` in the URL (a "nested" URL, but no route nesting). A `$` in the
* filename indicates a dynamic URL segment.
* - Subdirectories are used for nested routes.
*
* For example, a file named `apps/web/app/routes/gists/$username.tsx` creates a route
* with a path of `gists/:username`.
*/
export function createRoutesFromFolders(defineRoutes: DefineRoutesFunction, options: CreateRoutesFromFoldersOptions = {}): RouteManifest {
let { appDirectory = "app", ignoredFilePatterns = [], routesDirectory = "routes" } = options;
let appRoutesDirectory = path.join(appDirectory, routesDirectory);
let files: { [routeId: string]: string } = {};
// First, find all route modules in apps/web/app/routes
visitFiles(appRoutesDirectory, (file) => {
if (ignoredFilePatterns.length > 0 && ignoredFilePatterns.some((pattern) => matchesIgnoredFilePattern(file, pattern))) {
return;
}
if (isRouteModuleFile(file)) {
// Route ids and manifest file paths are URL-like repo paths. Keep them
// POSIX-stable on Windows instead of leaking `path.join` backslashes into
// React Router's manifest.
let relativePath = normalizeSlashes(path.join(routesDirectory, file));
let routeId = createRouteId(relativePath);
files[routeId] = relativePath;
return;
}
throw new Error(`Invalid route module file: ${path.join(appRoutesDirectory, file)}`);
});
let routeIds = Object.keys(files).sort(byLongestFirst);
let parentRouteIds = getParentRouteIds(routeIds);
let uniqueRoutes = new Map<string, string>();
// Then, recurse through all routes using the public defineRoutes() API
function defineNestedRoutes(defineRoute: DefineRouteFunction, parentId?: string): void {
let childRouteIds = routeIds.filter((id) => {
if (!parentId && id === `${routesDirectory}/admin`) {
return false;
}
return parentRouteIds[id] === parentId;
});
for (let routeId of childRouteIds) {
let routePath: string | undefined = createRoutePath(routeId.slice((parentId || routesDirectory).length + 1));
// Index when the parent-relative path resolves to nothing and the final
// segment is the index marker. Supports the v1 `index` filename and the
// v2 flat `_index` filename. A flat `foo._index` (relative path "foo") is
// NOT an index — it is the leaf route at `/foo`.
let isIndexRoute = routePath === undefined && /(?:^|[/.])_?index$/.test(routeId);
let fullPath = createRoutePath(routeId.slice(routesDirectory.length + 1));
fullPath = promoteTenantAppRoutePath(fullPath);
routePath = promoteTenantAppRoutePath(routePath);
let uniqueRouteId = (fullPath || "") + (isIndexRoute ? "?index" : "");
let isPathlessLayoutRoute = routeId.split("/").pop()?.startsWith("__") === true;
/**
* 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/
* __public/
* login.tsx
* perks.tsx
* __private/
* orders.tsx
* profile.tsx
* __public.tsx
* __private.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
*/
if (uniqueRouteId && !isPathlessLayoutRoute) {
if (uniqueRoutes.has(uniqueRouteId)) {
throw new Error(
`Path ${JSON.stringify(fullPath || "/")} defined by route ` +
`${JSON.stringify(routeId)} conflicts with route ` +
`${JSON.stringify(uniqueRoutes.get(uniqueRouteId))}`
);
} else {
uniqueRoutes.set(uniqueRouteId, routeId);
}
}
if (isIndexRoute) {
let invalidChildRoutes = routeIds.filter((id) => parentRouteIds[id] === routeId);
if (invalidChildRoutes.length > 0) {
throw new Error(`Child routes are not allowed in index routes. Please remove child routes of ${routeId}`);
}
defineRoute(routePath, files[routeId], { index: true, id: routeId });
} else {
defineRoute(routePath, files[routeId], { id: routeId }, () => {
defineNestedRoutes(defineRoute, routeId);
});
}
}
}
function defineAdminHostRoutes(defineRoute: DefineRouteFunction): void {
const adminRouteId = `${routesDirectory}/admin`;
if (!files[adminRouteId]) {
return;
}
defineRoute(undefined, files[adminRouteId], { id: getAdminHostRouteId(adminRouteId) }, () => {
defineAdminHostChildRoutes(defineRoute, adminRouteId);
});
}
function defineAdminHostChildRoutes(defineRoute: DefineRouteFunction, parentId: string): void {
let childRouteIds = routeIds.filter((id) => {
return parentRouteIds[id] === parentId && shouldCreateAdminHostRoute(id);
});
for (let routeId of childRouteIds) {
const routePath = createAdminHostRoutePath(routeId, parentId);
// Index when the parent-relative path resolves to nothing and the final
// segment is the index marker. Supports the v1 `index` filename and the
// v2 flat `_index` filename. A flat `foo._index` (relative path "foo") is
// NOT an index — it is the leaf route at `/foo`.
let isIndexRoute = routePath === undefined && /(?:^|[/.])_?index$/.test(routeId);
if (isIndexRoute) {
defineRoute(routePath, files[routeId], { index: true, id: getAdminHostRouteId(routeId) });
} else {
defineRoute(routePath, files[routeId], { id: getAdminHostRouteId(routeId) }, () => {
defineAdminHostChildRoutes(defineRoute, routeId);
});
}
}
}
return defineRoutes((defineRoute) => {
defineAdminHostRoutes(defineRoute);
defineNestedRoutes(defineRoute);
});
}
// Mirrors Remix v1 route-id parsing; covered by v1-route-convention tests so
// route migration changes fail before runtime.
export function createRoutePath(partialRouteId: string): string | undefined {
let result = "";
let rawSegmentBuffer = "";
let inEscapeSequence = 0;
let inOptionalSegment = 0;
let optionalSegmentIndex = null;
let skipSegment = false;
for (let i = 0; i < partialRouteId.length; i++) {
let char = partialRouteId.charAt(i);
let prevChar = i > 0 ? partialRouteId.charAt(i - 1) : undefined;
let nextChar = i < partialRouteId.length - 1 ? partialRouteId.charAt(i + 1) : undefined;
function isNewEscapeSequence() {
return !inEscapeSequence && char === escapeStart && prevChar !== escapeStart;
}
function isCloseEscapeSequence() {
return inEscapeSequence && char === escapeEnd && nextChar !== escapeEnd;
}
function isStartOfLayoutSegment() {
return char === "_" && nextChar === "_" && !rawSegmentBuffer;
}
function isNewOptionalSegment() {
return (
char === optionalStart &&
prevChar !== optionalStart &&
(isSegmentSeparator(prevChar) || prevChar === undefined) &&
!inOptionalSegment &&
!inEscapeSequence
);
}
function isCloseOptionalSegment() {
return (
char === optionalEnd && nextChar !== optionalEnd && (isSegmentSeparator(nextChar) || nextChar === undefined) && inOptionalSegment && !inEscapeSequence
);
}
if (skipSegment) {
if (isSegmentSeparator(char)) {
skipSegment = false;
}
continue;
}
if (isNewEscapeSequence()) {
inEscapeSequence++;
continue;
}
if (isCloseEscapeSequence()) {
inEscapeSequence--;
continue;
}
if (isNewOptionalSegment()) {
inOptionalSegment++;
optionalSegmentIndex = result.length;
result += optionalStart;
continue;
}
if (isCloseOptionalSegment()) {
if (optionalSegmentIndex !== null) {
result = result.slice(0, optionalSegmentIndex) + result.slice(optionalSegmentIndex + 1);
}
optionalSegmentIndex = null;
inOptionalSegment--;
result += "?";
continue;
}
if (inEscapeSequence) {
result += char;
continue;
}
if (isSegmentSeparator(char)) {
if ((rawSegmentBuffer === "index" || rawSegmentBuffer === "_index") && result.endsWith("index")) {
result = result.replace(/\/?_?index$/, "");
} else {
result += "/";
}
rawSegmentBuffer = "";
inOptionalSegment = 0;
optionalSegmentIndex = null;
continue;
}
if (isStartOfLayoutSegment()) {
skipSegment = true;
continue;
}
rawSegmentBuffer += char;
if (char === paramPrefixChar) {
if (nextChar === optionalEnd) {
throw new Error(`Invalid route path: ${partialRouteId}. Splat route $ is already optional`);
}
result += typeof nextChar === "undefined" ? "*" : ":";
continue;
}
result += char;
}
if ((rawSegmentBuffer === "index" || rawSegmentBuffer === "_index") && result.endsWith("index")) {
result = result.replace(/\/?_?index$/, "");
} else {
result = result.replace(/\/$/, "");
}
if ((rawSegmentBuffer === "index" || rawSegmentBuffer === "_index") && result.endsWith("index?")) {
throw new Error(`Invalid route path: ${partialRouteId}. Make index route optional by using (index)`);
}
return result || undefined;
}
function isSegmentSeparator(checkChar: string | undefined) {
if (!checkChar) return false;
return ["/", ".", path.win32.sep].includes(checkChar);
}
function promoteTenantAppRoutePath(routePath: string | undefined): string | undefined {
if (routePath === "app/:tenant") {
return ":tenant";
}
if (routePath?.startsWith("app/:tenant/")) {
return routePath.replace(/^app\/:tenant\//, ":tenant/");
}
return routePath;
}
function getAdminHostRouteId(routeId: string): string {
return `${routeId}.__host`;
}
function shouldCreateAdminHostRoute(routeId: string): boolean {
if (!routeId.startsWith("routes/admin/")) {
return false;
}
// /select-tenant exists on both app and admin hosts. Registering the admin
// file as a second pathless-host alias creates two identical manifest paths,
// and React Router always matches the admin branch first on the app host.
// The single public route dispatches to the correct loader by request host.
if (routeId === "routes/admin/select-tenant") {
return false;
}
const canonicalPath = createRoutePath(routeId.slice("routes/admin/".length));
if (!canonicalPath) {
return true;
}
return !["404", "dashboard", "mfa-challenge"].includes(canonicalPath);
}
function createAdminHostRoutePath(routeId: string, parentId: string): string | undefined {
if (routeId === "routes/admin/settings") {
return undefined;
}
if (parentId === "routes/admin/settings") {
return createRoutePath(routeId.slice("routes/admin/".length));
}
return createRoutePath(routeId.slice(parentId.length + 1));
}
function getParentRouteIds(routeIds: string[]): Record<string, string | undefined> {
return routeIds.reduce<Record<string, string | undefined>>(
(parentRouteIds, childRouteId) => ({
...parentRouteIds,
[childRouteId]: routeIds.find((id) => childRouteId.startsWith(`${id}/`)),
}),
{}
);
}
function byLongestFirst(a: string, b: string): number {
return b.length - a.length;
}
function visitFiles(dir: string, visitor: (file: string) => void, baseDir = dir): void {
for (let filename of fs.readdirSync(dir)) {
let file = path.resolve(dir, filename);
let stat = fs.lstatSync(file);
if (stat.isDirectory()) {
visitFiles(file, visitor, baseDir);
} else if (stat.isFile()) {
visitor(path.relative(baseDir, file));
}
}
}
/*
eslint
no-loop-func: "off",
*/
function createRouteId(file: string) {
return normalizeSlashes(stripFileExtension(file));
}
function normalizeSlashes(file: string) {
return file.split(path.win32.sep).join("/");
}
function stripFileExtension(file: string) {
return file.replace(/\.[a-z0-9]+$/i, "");
}
interface DefineRouteOptions {
/**
* Should be `true` if the route `path` is case-sensitive. Defaults to
* `false`.
*/
caseSensitive?: boolean;
/**
* Should be `true` if this is an index route that does not allow child routes.
*/
index?: boolean;
/**
* An optional unique id string for this route. Use this if you need to aggregate
* two or more routes with the same route file.
*/
id?: string;
}
interface DefineRouteChildren {
(): void;
}
interface DefineRouteFunction {
(
/**
* The path this route uses to match the URL pathname.
*/
path: string | undefined,
/**
* The path to the file that exports the React component rendered by this
* route as its default export, relative to the `app` directory.
*/
file: string,
/**
* Options for defining routes, or a function for defining child routes.
*/
optionsOrChildren?: DefineRouteOptions | DefineRouteChildren,
/**
* A function for defining child routes.
*/
children?: DefineRouteChildren
): void;
}