react-router 8.3.1 → 8.4.0

package/dist/development/lib/router/matcher-route-pattern.js

@@ -0,0 +1,216 @@
+/**
+ * react-router v8.4.0
+ *
+ * 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
+ */
+import { invariant, parsePath, warning } from "./history.js";
+import { decodePath, explodeOptionalSegments, joinPaths, matchPath, normalizePathname, stripBasename } from "./utils.js";
+import { createMultiMatcher } from "@remix-run/route-pattern/match";
+import { descending } from "@remix-run/route-pattern/specificity";
+//#region lib/router/matcher-route-pattern.ts
+var RoutePatternDataRouteMatcher = class {
+	#state;
+	#basename;
+	constructor(basename) {
+		this.#basename = basename;
+	}
+	update(routes) {
+		let branches = flattenRoutes(routes);
+		let matcher = createMultiMatcher({ ignoreCase: true });
+		let partialMatcher = createMultiMatcher({ ignoreCase: true });
+		for (let branch of branches) {
+			let routePattern = convertReactRouterPathToRoutePattern(branch.path);
+			validateRoutePatternSplat(branch.path, routePattern);
+			routePattern = addOptionalTrailingSlash(routePattern);
+			matcher.add(routePattern, branch);
+			if (!branch.routesMeta[branch.routesMeta.length - 1].route.index) partialMatcher.add(routePattern === "/" ? `/*__rr_partial` : `${routePattern}(/*__rr_partial)`, branch);
+		}
+		this.#state = {
+			branches,
+			matcher,
+			partialMatcher
+		};
+		return branches;
+	}
+	match(locationArg, allowPartial = false) {
+		let pathname = stripBasename((typeof locationArg === "string" ? parsePath(locationArg) : locationArg).pathname || "/", this.#basename);
+		if (pathname == null) return null;
+		let decoded = decodePath(pathname);
+		let url = new URL("http://reactrouter.local");
+		url.pathname = pathname.endsWith("/") ? pathname : `${pathname}/`;
+		invariant(this.#state, "Route pattern routes must be initialized before matching.");
+		let matches = this.#state.matcher.matchAll(url);
+		if (allowPartial) matches.push(...this.#state.partialMatcher.matchAll(url));
+		for (let match of prioritizeValidatedMatches(matches)) {
+			let routeMatches = convertRoutePatternMatchToRouteMatches(match, decoded, allowPartial);
+			if (routeMatches && validateRouteMatchParams(routeMatches)) return routeMatches;
+		}
+		return null;
+	}
+};
+function validateRoutePatternSplat(routePath, routePattern) {
+	invariant(getRoutePatternSplatIndexes(routePattern).length <= 1 && isTerminalRoutePatternSplat(routePattern), `Route path "${routePath}" is not supported with \`future.unstable_routePatternMatching\` because React Router only supports a single splat at the end of a route path.`);
+}
+function getRoutePatternSplatIndexes(routePattern) {
+	let splatIndexes = [];
+	for (let i = 0; i < routePattern.length; i++) {
+		let char = routePattern[i];
+		if (char === "\\") {
+			i++;
+			continue;
+		}
+		if (char === "*") splatIndexes.push(i);
+	}
+	return splatIndexes;
+}
+function isTerminalRoutePatternSplat(routePattern) {
+	for (let i = 0; i < routePattern.length; i++) {
+		let char = routePattern[i];
+		if (char === "\\") {
+			i++;
+			continue;
+		}
+		if (char !== "*") continue;
+		let suffix = routePattern.slice(i + 1);
+		return /^[a-zA-Z_$][a-zA-Z_$0-9]*$/.test(suffix) || suffix === "";
+	}
+	return true;
+}
+function addOptionalTrailingSlash(routePattern) {
+	return routePattern === "/" ? routePattern : `${routePattern.replace(/\/+$/, "")}(/)`;
+}
+function flattenRoutes(routes, branches = [], parentsMeta = [], parentPath = "") {
+	routes.forEach((route, index) => {
+		invariant(route.caseSensitive !== true, "`caseSensitive` routes are not supported with `future.unstable_routePatternMatching`.");
+		let meta = {
+			relativePath: route.path || "",
+			caseSensitive: false,
+			childrenIndex: index,
+			route
+		};
+		let absolutePath;
+		if (meta.relativePath.startsWith("/")) {
+			absolutePath = meta.relativePath;
+			let parentPathMatch = explodeOptionalSegments(parentPath).find((path) => meta.relativePath.startsWith(path));
+			invariant(parentPathMatch != null, `Absolute route path "${meta.relativePath}" nested under path "${parentPath}" is not valid. An absolute child route path must start with the combined path of all its parent routes.`);
+			meta.relativePath = meta.relativePath.slice(parentPathMatch.length);
+		}
+		let routesMeta = parentsMeta.concat(meta);
+		let path = absolutePath ?? (meta.relativePath ? joinPaths([parentPath, meta.relativePath]) : parentPath);
+		if (route.children && route.children.length > 0) {
+			invariant(route.index !== true, `Index routes must not have child routes. Please remove all child routes from route path "${path}".`);
+			flattenRoutes(route.children, branches, routesMeta, path);
+			if (route.children?.some((child) => child.index)) return;
+		}
+		if (route.path != null || route.index) branches.push({
+			path,
+			score: 0,
+			routesMeta
+		});
+	});
+	return branches;
+}
+function convertReactRouterPathToRoutePattern(path) {
+	warning(path === "*" || !path.endsWith("*") || path.endsWith("/*"), `Route path "${path}" will be treated as if it were "${path.replace(/\*$/, "/*")}" because the \`*\` character must always follow a \`/\` in the pattern. To get rid of this warning, please change the route path to "${path.replace(/\*$/, "/*")}".`);
+	if (path.endsWith("*") && path !== "*" && !path.endsWith("/*")) path = path.replace(/\*$/, "/*");
+	path = path.replace(/^\/*/, "/");
+	if (path === "") return "/";
+	let segments = path.split("/");
+	let pattern = segments.shift() || "";
+	for (let i = 0; i < segments.length;) {
+		let optionalRun = [];
+		while (i < segments.length && isOptionalRouteSegment(segments[i])) {
+			optionalRun.push(convertRouteSegment(segments[i].slice(0, -1)));
+			i++;
+		}
+		if (optionalRun.length > 0) {
+			let nested = optionalRun.reduceRight((child, segment) => `/${segment}${child ? `(${child})` : ""}`, "");
+			pattern += `(${nested})`;
+			continue;
+		}
+		pattern += `/${convertRouteSegment(segments[i])}`;
+		i++;
+	}
+	return pattern || "/";
+}
+function isOptionalRouteSegment(segment) {
+	return segment.endsWith("?");
+}
+function convertRouteSegment(segment) {
+	if (segment === "*") return "*__rr_splat";
+	let paramMatch = segment.match(/^:([\w-]+)(\?)?(.*)$/);
+	if (paramMatch) {
+		let [, paramName, optional, suffix] = paramMatch;
+		let converted = `:${paramName}${escapeRoutePatternLiteral(suffix)}`;
+		return optional ? `(:${paramName})${escapeRoutePatternLiteral(suffix)}` : converted;
+	}
+	return escapeRoutePatternLiteral(segment);
+}
+function escapeRoutePatternLiteral(value) {
+	return value.replace(/[\\():*]/g, "\\$&");
+}
+function validateRouteMatchParams(matches) {
+	return matches.every(({ route, params }) => route.unstable_validateParams == null || Object.keys(route.unstable_validateParams).length === 0 || Object.entries(route.unstable_validateParams).every(([param, re]) => params[param] != null ? new RegExp(re.source, re.flags).test(params[param]) : true));
+}
+function prioritizeValidatedMatches(matches) {
+	return matches.sort((a, b) => {
+		let specificity = descending(a, b);
+		if (specificity !== 0) return specificity;
+		return Number(hasParamValidators(b)) - Number(hasParamValidators(a));
+	});
+}
+function hasParamValidators(match) {
+	return match.data.routesMeta.some((meta) => meta.route.unstable_validateParams != null && Object.keys(meta.route.unstable_validateParams).length > 0);
+}
+function convertRoutePatternMatchToRouteMatches(match, pathname, allowPartial) {
+	let result = matchRoutePatternBranch(match.data, pathname, allowPartial, 0, "/", {});
+	if (result == null) return null;
+	for (let routeMatch of result.matches) routeMatch.params = result.params;
+	return result.matches;
+}
+function matchRoutePatternBranch(branch, pathname, allowPartial, metaIndex, matchedPathname, matchedParams) {
+	let meta = branch.routesMeta[metaIndex];
+	let end = metaIndex === branch.routesMeta.length - 1;
+	let remainingPathname = matchedPathname === "/" ? pathname : pathname.slice(matchedPathname.length) || "/";
+	for (let relativePath of explodeOptionalSegments(meta.relativePath)) {
+		let pattern = {
+			path: relativePath,
+			caseSensitive: false,
+			end
+		};
+		let pathMatch = matchPath(pattern, remainingPathname);
+		if (!pathMatch && end && allowPartial && !meta.route.index) pathMatch = matchPath({
+			...pattern,
+			end: false
+		}, remainingPathname);
+		if (!pathMatch) continue;
+		let params = {
+			...matchedParams,
+			...pathMatch.params
+		};
+		let routeMatch = {
+			params,
+			pathname: joinPaths([matchedPathname, pathMatch.pathname]),
+			pathnameBase: normalizePathname(joinPaths([matchedPathname, pathMatch.pathnameBase])),
+			route: meta.route
+		};
+		let nextMatchedPathname = pathMatch.pathnameBase === "/" ? matchedPathname : joinPaths([matchedPathname, pathMatch.pathnameBase]);
+		if (end) return {
+			matches: [routeMatch],
+			params
+		};
+		let childResult = matchRoutePatternBranch(branch, pathname, allowPartial, metaIndex + 1, nextMatchedPathname, params);
+		if (childResult) return {
+			matches: [routeMatch, ...childResult.matches],
+			params: childResult.params
+		};
+	}
+	return null;
+}
+//#endregion
+export { RoutePatternDataRouteMatcher };

package/dist/development/lib/router/matcher-route-pattern.preload.d.ts

@@ -0,0 +1,20 @@
+
+//#region lib/router/matcher-route-pattern.preload.d.ts
+/**
+ * Initialize the route-pattern matcher before creating a Data Router or static
+ * handler with `future.unstable_routePatternMatching` enabled. Import from
+ * `react-router/route-pattern` and call this once during application startup.
+ * Server and browser applications must each preload their own matcher.
+ *
+ * The matcher is statically imported by this module. Tree-shaking bundlers can
+ * remove it from applications that do not use this function. Initialization is
+ * synchronous, and repeated calls are safe.
+ *
+ * @public
+ * @category Data Routers
+ * @mode data
+ * @returns {void}
+ */
+declare function unstable_preloadRoutePattern(): void;
+//#endregion
+export { unstable_preloadRoutePattern };

package/dist/development/lib/router/matcher-route-pattern.preload.js

@@ -0,0 +1,36 @@
+/**
+ * react-router v8.4.0
+ *
+ * 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
+ */
+import { RoutePatternDataRouteMatcher } from "./matcher-route-pattern.js";
+//#region lib/router/matcher-route-pattern.preload.ts
+let RoutePatternMatcher;
+function getRoutePatternMatcher() {
+	return RoutePatternMatcher;
+}
+/**
+* Initialize the route-pattern matcher before creating a Data Router or static
+* handler with `future.unstable_routePatternMatching` enabled. Import from
+* `react-router/route-pattern` and call this once during application startup.
+* Server and browser applications must each preload their own matcher.
+*
+* The matcher is statically imported by this module. Tree-shaking bundlers can
+* remove it from applications that do not use this function. Initialization is
+* synchronous, and repeated calls are safe.
+*
+* @public
+* @category Data Routers
+* @mode data
+* @returns {void}
+*/
+function unstable_preloadRoutePattern() {
+	RoutePatternMatcher = RoutePatternDataRouteMatcher;
+}
+//#endregion
+export { getRoutePatternMatcher, unstable_preloadRoutePattern };

package/dist/development/lib/router/matcher.d.ts

@@ -0,0 +1,2 @@
+
+export { };

package/dist/development/lib/router/matcher.js

@@ -0,0 +1,29 @@
+/**
+ * react-router v8.4.0
+ *
+ * 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
+ */
+import { flattenAndRankRoutes, matchRoutesImpl } from "./utils.js";
+//#region lib/router/matcher.ts
+var V6RegExMatcher = class {
+	#routes = [];
+	#branches = [];
+	#basename;
+	constructor(basename) {
+		this.#basename = basename;
+	}
+	update(routes) {
+		this.#routes = routes;
+		this.#branches = flattenAndRankRoutes(routes);
+	}
+	match(locationArg, allowPartial = false) {
+		return matchRoutesImpl(this.#routes, locationArg, this.#basename, allowPartial, this.#branches);
+	}
+};
+//#endregion
+export { V6RegExMatcher };

package/dist/development/lib/router/navigation.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.3.1
+ * react-router v8.4.0
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/development/lib/router/router.d.ts

@@ -1,6 +1,6 @@
 
 import { Action, History, Location, Path, To } from "./history.js";
-import { DataRouteMatch, DataRouteObject, DataStrategyFunction, FormEncType, HTMLFormMethod, MapRoutePropertiesFunction, MaybePromise, PatchRoutesOnNavigationFunction, RouteBranch, RouteData, RouteManifest, RouteObject, RouterContextProvider, Submission, UIMatch } from "./utils.js";
+import { DataRouteMatch, DataRouteObject, DataStrategyFunction, FormEncType, HTMLFormMethod, MapRoutePropertiesFunction, MaybePromise, PatchRoutesOnNavigationFunction, RouteData, RouteManifest, RouteObject, RouterContextProvider, Submission, UIMatch } from "./utils.js";
 import { ClientInstrumentation, ServerInstrumentation } from "./instrumentation.js";
 
 //#region lib/router/router.d.ts
@@ -40,9 +40,10 @@ interface Router {
    * @private
    * PRIVATE - DO NOT USE
    *
-   * Return the route branches for this router instance
+   * Match routes against a location using the router's configured route
+   * matching implementation.
    */
-  get branches(): RouteBranch<DataRouteObject>[] | undefined;
+  match(locationArg: Partial<Location> | string): DataRouteMatch[] | null;
   /**
    * @private
    * PRIVATE - DO NOT USE
@@ -304,7 +305,10 @@ type HydrationState = Partial<Pick<RouterState, "loaderData" | "actionData" | "e
 /**
  * Future flags to toggle new feature behavior
  */
-interface FutureConfig {}
+interface FutureConfig {
+  /** Enables route-pattern matching after calling `unstable_preloadRoutePattern()`. */
+  unstable_routePatternMatching?: boolean;
+}
 /**
  * Initialization options for createRouter
  */
@@ -336,6 +340,8 @@ interface StaticHandlerContext {
   loaderHeaders: Record<string, Headers>;
   actionHeaders: Record<string, Headers>;
   _deepestRenderedBoundaryId?: string | null;
+  /** @private */
+  _match: StaticHandler["match"];
 }
 /**
  * A StaticHandler instance manages a singular SSR navigation/fetch event
@@ -349,10 +355,10 @@ interface StaticHandler {
    * @private
    * PRIVATE - DO NOT USE
    *
-   * The route branches derived from the data routes, used for internal route
-   * matching in Framework Mode
+   * Match routes against a location using the handler's configured route
+   * matching implementation.
    */
-  _internalRouteBranches: RouteBranch<DataRouteObject>[];
+  match(locationArg: Partial<Location> | string): DataRouteMatch[] | null;
   /**
    * Perform a query for a given request - executing all matched route
    * loaders/actions.  Used for document requests.