vinext 1.2.1 → 1.3.1

package/dist/routing/hashed-route-patterns.js

@@ -0,0 +1,22 @@
+import { splitPathnameForRouteMatch } from "./utils.js";
+import { fnv1a64 } from "../utils/hash.js";
+//#region src/routing/hashed-route-patterns.ts
+/**
+* Hybrid App/Pages clients need App route handler patterns only to decide
+* route ownership, so they receive them with every static segment hashed and
+* never see the handlers' paths in plain text (issue #3624). Dynamic parts
+* stay as they are, so a hashed pattern matches a hashed URL with the usual
+* route trie. A collision can only add a false handler match, which sends the
+* navigation to the document.
+*/
+function hashRouteSegment(segment) {
+	return fnv1a64(segment).slice(0, 8);
+}
+function hashRoutePatternParts(patternParts) {
+	return patternParts.map((part) => part.startsWith(":") ? part : hashRouteSegment(part));
+}
+function hashRoutePathname(pathname) {
+	return "/" + splitPathnameForRouteMatch(pathname).map(hashRouteSegment).join("/");
+}
+//#endregion
+export { hashRoutePathname, hashRoutePatternParts };

package/dist/routing/optimistic-route-trie.d.ts

@@ -0,0 +1,28 @@
+//#region src/routing/optimistic-route-trie.d.ts
+type OptimisticTrieRoute = {
+  readonly patternParts: readonly string[];
+};
+export type OptimisticRouteTrieNode<Route extends OptimisticTrieRoute> = {
+  catchAllChild: {
+    paramName: string;
+    route: Route;
+  } | null;
+  dynamicChild: {
+    node: OptimisticRouteTrieNode<Route>;
+    paramName: string;
+  } | null;
+  optionalCatchAllChild: {
+    paramName: string;
+    route: Route;
+  } | null;
+  route: Route | null;
+  staticChildren: Map<string, OptimisticRouteTrieNode<Route>>;
+};
+export type OptimisticRouteTrieMatch<Route extends OptimisticTrieRoute> = {
+  params: Record<string, string | string[]>;
+  route: Route;
+};
+export declare function buildOptimisticRouteTrie<Route extends OptimisticTrieRoute>(routes: Iterable<Route>, onDynamicSegmentConflict?: (existingParamName: string, part: string) => void): OptimisticRouteTrieNode<Route>;
+export declare function matchOptimisticRouteTrie<Route extends OptimisticTrieRoute>(trie: OptimisticRouteTrieNode<Route>, urlParts: readonly string[]): OptimisticRouteTrieMatch<Route> | null;
+//#endregion
+export {};

package/dist/routing/optimistic-route-trie.js

@@ -0,0 +1,102 @@
+import { buildParams } from "./utils.js";
+//#region src/routing/optimistic-route-trie.ts
+function createNode() {
+	return {
+		catchAllChild: null,
+		dynamicChild: null,
+		optionalCatchAllChild: null,
+		route: null,
+		staticChildren: /* @__PURE__ */ new Map()
+	};
+}
+function buildOptimisticRouteTrie(routes, onDynamicSegmentConflict) {
+	const root = createNode();
+	for (const route of routes) {
+		let node = root;
+		const parts = route.patternParts;
+		if (parts.length === 0) {
+			node.route ??= route;
+			continue;
+		}
+		for (const [index, part] of parts.entries()) {
+			const isTerminal = index === parts.length - 1;
+			if (part.startsWith(":") && part.endsWith("+")) {
+				if (isTerminal && node.catchAllChild === null) node.catchAllChild = {
+					paramName: part.slice(1, -1),
+					route
+				};
+				break;
+			}
+			if (part.startsWith(":") && part.endsWith("*")) {
+				if (isTerminal && node.optionalCatchAllChild === null) node.optionalCatchAllChild = {
+					paramName: part.slice(1, -1),
+					route
+				};
+				break;
+			}
+			if (part.startsWith(":")) {
+				const paramName = part.slice(1);
+				if (node.dynamicChild === null) node.dynamicChild = {
+					node: createNode(),
+					paramName
+				};
+				else if (node.dynamicChild.paramName !== paramName) onDynamicSegmentConflict?.(node.dynamicChild.paramName, part);
+				node = node.dynamicChild.node;
+				if (isTerminal) node.route ??= route;
+				continue;
+			}
+			let staticChild = node.staticChildren.get(part);
+			if (staticChild === void 0) {
+				staticChild = createNode();
+				node.staticChildren.set(part, staticChild);
+			}
+			node = staticChild;
+			if (isTerminal) node.route ??= route;
+		}
+	}
+	return root;
+}
+function matchNode(node, urlParts, index, entries) {
+	if (index === urlParts.length) {
+		if (node.route !== null) return {
+			route: node.route,
+			params: buildParams(entries)
+		};
+		if (node.optionalCatchAllChild !== null) return {
+			route: node.optionalCatchAllChild.route,
+			params: buildParams(entries)
+		};
+		return null;
+	}
+	const segment = urlParts[index];
+	const staticChild = node.staticChildren.get(segment);
+	if (staticChild !== void 0) return matchNode(staticChild, urlParts, index + 1, entries);
+	if (node.dynamicChild !== null) {
+		entries.push([node.dynamicChild.paramName, segment]);
+		const match = matchNode(node.dynamicChild.node, urlParts, index + 1, entries);
+		if (match !== null) return match;
+		entries.pop();
+	}
+	if (node.catchAllChild !== null) {
+		const params = buildParams(entries);
+		params[node.catchAllChild.paramName] = urlParts.slice(index);
+		return {
+			route: node.catchAllChild.route,
+			params
+		};
+	}
+	if (node.optionalCatchAllChild !== null) {
+		const params = buildParams(entries);
+		params[node.optionalCatchAllChild.paramName] = urlParts.slice(index);
+		return {
+			route: node.optionalCatchAllChild.route,
+			params
+		};
+	}
+	return null;
+}
+function matchOptimisticRouteTrie(trie, urlParts) {
+	return matchNode(trie, urlParts, 0, []);
+}
+//#endregion
+export { buildOptimisticRouteTrie, matchOptimisticRouteTrie };

package/dist/routing/route-matching.d.ts

@@ -35,4 +35,5 @@ export declare function matchRouteWithTrieRawPathname<R extends {
   route: R;
   params: Record<string, string | string[]>;
 } | null;
-//#endregion
+//#endregion
+export {};

package/dist/routing/route-pattern.d.ts

@@ -68,4 +68,5 @@ export declare function normalizeStaticPathname(pathname: string): string;
  * locale handling should be added here, not duplicated at call sites.
  */
 export declare function normalizeStaticPathsEntry(entry: StaticPathsEntry, routePattern: string): NormalizedStaticPathsEntry;
-//#endregion
+//#endregion
+export {};

package/dist/routing/route-validation.d.ts

@@ -1,9 +1,14 @@
 //#region src/routing/route-validation.d.ts
 /**
- * Dynamic route validation adapted from Next.js' sorted-routes implementation.
+ * Dynamic route validation and sorting adapted from Next.js' sorted-routes implementation.
  * Source:
  * https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/sorted-routes.ts
  */
+/**
+ * Sort Next.js-format page paths (e.g. "/posts/[id]") into route-priority
+ * order, matching Next.js' `getSortedRoutes`.
+ */
+export declare function getSortedRoutes(pages: readonly string[]): string[];
 export declare function patternToNextFormat(pattern: string): string;
 export declare function validateRoutePatterns(patterns: readonly string[]): void;
 //#endregion

package/dist/routing/route-validation.js

@@ -1,7 +1,7 @@
 import { removeTrailingSlash } from "../utils/base-path.js";
 //#region src/routing/route-validation.ts
 /**
-* Dynamic route validation adapted from Next.js' sorted-routes implementation.
+* Dynamic route validation and sorting adapted from Next.js' sorted-routes implementation.
 * Source:
 * https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/sorted-routes.ts
 */
@@ -69,17 +69,33 @@ var UrlNode = class UrlNode {
 		}
 		child.insertSegments(urlPaths.slice(1), slugNames, isCatchAll);
 	}
-	assertOptionalCatchAllSpecificity(prefix = "/") {
-		if (!this.placeholder && this.optionalRestSlugName !== null) {
+	/**
+	* Flatten the tree into route-priority order: static children
+	* alphabetically, then the dynamic, catch-all and optional catch-all
+	* children. Throws when a route shares a level with an optional catch-all.
+	*/
+	smoosh(prefix = "/") {
+		const routes = [...this.children.keys()].filter((segment) => segment !== "[]" && segment !== "[...]" && segment !== "[[...]]").sort().flatMap((segment) => this.children.get(segment).smoosh(`${prefix}${segment}/`));
+		if (this.slugName !== null) routes.push(...this.children.get("[]").smoosh(`${prefix}[${this.slugName}]/`));
+		if (!this.placeholder) {
 			const route = prefix === "/" ? "/" : prefix.slice(0, -1);
-			throw new Error(`You cannot define a route with the same specificity as a optional catch-all route ("${route}" and "${route}[[...${this.optionalRestSlugName}]]").`);
-		}
-		for (const [segment, child] of this.children) {
-			const nextPrefixSegment = segment === "[]" ? `[${this.slugName}]` : segment === "[...]" ? `[...${this.restSlugName}]` : segment === "[[...]]" ? `[[...${this.optionalRestSlugName}]]` : segment;
-			child.assertOptionalCatchAllSpecificity(`${prefix}${nextPrefixSegment}/`);
+			if (this.optionalRestSlugName !== null) throw new Error(`You cannot define a route with the same specificity as a optional catch-all route ("${route}" and "${route}[[...${this.optionalRestSlugName}]]").`);
+			routes.unshift(route);
 		}
+		if (this.restSlugName !== null) routes.push(...this.children.get("[...]").smoosh(`${prefix}[...${this.restSlugName}]/`));
+		if (this.optionalRestSlugName !== null) routes.push(...this.children.get("[[...]]").smoosh(`${prefix}[[...${this.optionalRestSlugName}]]/`));
+		return routes;
 	}
 };
+/**
+* Sort Next.js-format page paths (e.g. "/posts/[id]") into route-priority
+* order, matching Next.js' `getSortedRoutes`.
+*/
+function getSortedRoutes(pages) {
+	const root = new UrlNode();
+	for (const page of pages) root.insert(page);
+	return root.smoosh();
+}
 function patternToNextFormat(pattern) {
 	if (pattern === "/") return "/";
 	return pattern.split("/").map((segment) => {
@@ -102,7 +118,7 @@ function validateRoutePatterns(patterns) {
 		seenPatterns.add(normalizedPattern);
 		root.insert(patternToNextFormat(normalizedPattern));
 	}
-	root.assertOptionalCatchAllSpecificity();
+	root.smoosh();
 }
 //#endregion
-export { patternToNextFormat, validateRoutePatterns };
+export { getSortedRoutes, patternToNextFormat, validateRoutePatterns };

package/dist/server/accept-encoding.d.ts

@@ -23,4 +23,5 @@ export declare function selectContentEncoding<T extends ContentEncoding>(parsed:
 export declare const HAS_ZSTD: boolean;
 /** Select by client q-value first, then zstd > br > gzip > deflate > identity. */
 export declare function negotiateEncoding(req: IncomingMessage): NegotiatedEncoding;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-action-forwarding.d.ts

@@ -1,3 +1,4 @@
+import { ExecutionContextLike } from "../shims/request-context.js";
 import { AppMiddlewareContext } from "./app-middleware.js";
 //#region src/server/app-action-forwarding.d.ts
 type ActionOwnerManifest = Readonly<Record<string, readonly string[]>>;
@@ -13,5 +14,13 @@ type ForwardServerActionOptions = {
   request: Request;
 };
 export declare function areServerActionsOwnedByRoute(actionOwners: ActionOwnerManifest | null, actionIds: readonly string[], currentRoutePattern: string | null): boolean;
+/**
+ * The execution context a forwarded action re-enters the app handler with.
+ * Middleware runs again there, so it keeps the server-owned middleware origin.
+ */
+export declare function createForwardedActionContext(executionContext: ExecutionContextLike | null | undefined): {
+  actionForwarded: true;
+} & Partial<ExecutionContextLike>;
 export declare function forwardServerActionIfNeeded(options: ForwardServerActionOptions): Promise<Response | null>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-action-forwarding.js

@@ -98,6 +98,20 @@ function areServerActionsOwnedByRoute(actionOwners, actionIds, currentRoutePatte
 		return ownerPatterns?.includes("*") === true || currentRoutePattern !== null && ownerPatterns?.includes(currentRoutePattern) === true;
 	});
 }
+/**
+* The execution context a forwarded action re-enters the app handler with.
+* Middleware runs again there, so it keeps the server-owned middleware origin.
+*/
+function createForwardedActionContext(executionContext) {
+	if (!executionContext) return { actionForwarded: true };
+	return {
+		actionForwarded: true,
+		cache: executionContext.cache,
+		middlewareOrigin: executionContext.middlewareOrigin,
+		passThroughOnException: executionContext.passThroughOnException?.bind(executionContext),
+		waitUntil: executionContext.waitUntil.bind(executionContext)
+	};
+}
 async function forwardServerActionIfNeeded(options) {
 	if (!options.actionOwners) return null;
 	const csrfResponse = validateCsrfOrigin(options.request, options.allowedOrigins);
@@ -137,4 +151,4 @@ async function forwardServerActionIfNeeded(options) {
 	return emptyActionForwardResponse(options.middlewareContext);
 }
 //#endregion
-export { areServerActionsOwnedByRoute, forwardServerActionIfNeeded };
+export { areServerActionsOwnedByRoute, createForwardedActionContext, forwardServerActionIfNeeded };

package/dist/server/app-bfcache-identity.d.ts

@@ -31,4 +31,5 @@ export declare function preserveBfcacheIdsForMergedElements(options: {
   preservedElementIds?: readonly string[];
   preservePreviousIds?: readonly string[];
 }): BfcacheIdMap;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-browser-action-result.d.ts

@@ -62,4 +62,5 @@ type DiscardedServerActionRefreshSchedulerOptions = {
   runRefresh: () => void;
 };
 export declare function createDiscardedServerActionRefreshScheduler(options: DiscardedServerActionRefreshSchedulerOptions): DiscardedServerActionRefreshScheduler;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-browser-client-reuse-manifest.d.ts

@@ -7,4 +7,5 @@ type CreateClientReuseManifestHeaderOptions = Readonly<{
   limits?: ClientReuseManifestLimits;
 }>;
 export declare function createClientReuseManifestHeaderFromVisibleAppState(state: VisibleAppState, options?: CreateClientReuseManifestHeaderOptions): string | null;
-//#endregion
+//#endregion
+export {};