vinext 0.0.50 → 0.0.52

package/dist/routing/app-route-graph.js

@@ -32,6 +32,9 @@ function createAppRouteGraphSlotId(slotName, ownerTreePath) {
 function createAppRouteGraphDefaultId(slotId) {
 	return `default:${slotId}`;
 }
+function createAppRouteGraphInterceptionId(slotId, sourcePattern, targetPattern) {
+	return `interception:${slotId}:${sourcePattern}->${targetPattern}`;
+}
 function createAppRouteGraphRootBoundaryId(treePath) {
 	return `root-boundary:${treePath}`;
 }
@@ -59,8 +62,10 @@ function createStaticSegmentGraph(routes) {
 	const slots = /* @__PURE__ */ new Map();
 	const defaults = /* @__PURE__ */ new Map();
 	const slotBindings = /* @__PURE__ */ new Map();
+	const interceptions = /* @__PURE__ */ new Map();
 	const boundaries = /* @__PURE__ */ new Map();
 	const rootBoundaries = /* @__PURE__ */ new Map();
+	const routeIdByPattern = createRouteManifestRouteIdByPattern(routes);
 	for (const route of routes) {
 		routeEntries.set(route.ids.route, {
 			id: route.ids.route,
@@ -92,9 +97,12 @@ function createStaticSegmentGraph(routes) {
 			const treePath = createAppRouteGraphTreePath(route.routeSegments, treePosition);
 			const existingLayout = layouts.get(layoutId);
 			if (existingLayout) assertRouteManifestRootBoundary("layout", route, layoutId, existingLayout.rootBoundaryId);
+			const layoutRouteParts = convertTreePathToRouteParts(treePath);
 			const layout = {
 				id: layoutId,
 				treePath,
+				patternParts: layoutRouteParts.urlSegments,
+				paramNames: layoutRouteParts.params,
 				rootBoundaryId: route.ids.rootBoundary
 			};
 			layouts.set(layoutId, layout);
@@ -135,6 +143,20 @@ function createStaticSegmentGraph(routes) {
 		for (const slot of route.parallelSlots) {
 			const ownerLayoutId = findSlotOwnerLayoutId(route, slot);
 			const defaultId = slot.defaultPath ? createAppRouteGraphDefaultId(slot.id) : null;
+			if (slot.layoutPath) {
+				const slotLayoutTreePath = createSlotLayoutTreePath(slot);
+				const slotLayoutId = createAppRouteGraphLayoutId(slotLayoutTreePath);
+				const existingLayout = layouts.get(slotLayoutId);
+				if (existingLayout) assertRouteManifestRootBoundary("layout", route, slotLayoutId, existingLayout.rootBoundaryId);
+				const slotLayoutRouteParts = convertTreePathToRouteParts(slotLayoutTreePath);
+				layouts.set(slotLayoutId, {
+					id: slotLayoutId,
+					treePath: slotLayoutTreePath,
+					patternParts: slotLayoutRouteParts.urlSegments,
+					paramNames: slotLayoutRouteParts.params,
+					rootBoundaryId: route.ids.rootBoundary
+				});
+			}
 			slots.set(slot.id, {
 				id: slot.id,
 				key: slot.key,
@@ -155,6 +177,13 @@ function createStaticSegmentGraph(routes) {
 			});
 			const binding = createRouteManifestSlotBinding(route, slot, ownerLayoutId, defaultId);
 			slotBindings.set(binding.id, binding);
+			addRouteManifestInterceptionFacts({
+				interceptions,
+				ownerLayoutId,
+				route,
+				routeIdByPattern,
+				slot
+			});
 		}
 	}
 	return {
@@ -166,10 +195,15 @@ function createStaticSegmentGraph(routes) {
 		slots,
 		defaults,
 		slotBindings,
+		interceptions,
+		interceptionsBySlotId: createRouteManifestInterceptionsBySlotId(interceptions),
 		boundaries,
 		rootBoundaries
 	};
 }
+function createRouteManifestRouteIdByPattern(routes) {
+	return new Map(routes.map((route) => [route.pattern, route.ids.route]));
+}
 function findRouteManifestOwnerLayoutId(route, treePosition) {
 	const layoutIndex = route.layoutTreePositions.indexOf(treePosition);
 	return route.ids.layouts[layoutIndex] ?? null;
@@ -178,6 +212,11 @@ function findSlotOwnerLayoutId(route, slot) {
 	if (slot.layoutIndex < 0) return null;
 	return route.ids.layouts[slot.layoutIndex] ?? null;
 }
+function createSlotLayoutTreePath(slot) {
+	const slotSegment = `@${slot.name}`;
+	if (slot.ownerTreePath === "/") return `/${slotSegment}`;
+	return `${slot.ownerTreePath}/${slotSegment}`;
+}
 function createRouteManifestSlotBinding(route, slot, ownerLayoutId, defaultId) {
 	const state = getRouteManifestSlotBindingState(slot);
 	const binding = {
@@ -193,6 +232,35 @@ function createRouteManifestSlotBinding(route, slot, ownerLayoutId, defaultId) {
 	if (slot.slotParamNames) binding.slotParamNames = [...slot.slotParamNames];
 	return binding;
 }
+function addRouteManifestInterceptionFacts(input) {
+	for (const interception of input.slot.interceptingRoutes) {
+		const id = createAppRouteGraphInterceptionId(input.slot.id, interception.sourceMatchPattern, interception.targetPattern);
+		input.interceptions.set(id, {
+			id,
+			sourcePattern: interception.sourceMatchPattern,
+			sourcePatternParts: splitRouteManifestPatternParts(interception.sourceMatchPattern),
+			targetPattern: interception.targetPattern,
+			targetPatternParts: splitRouteManifestPatternParts(interception.targetPattern),
+			slotId: input.slot.id,
+			ownerLayoutId: input.ownerLayoutId,
+			interceptingRouteId: input.routeIdByPattern.get(interception.sourceMatchPattern) ?? null,
+			targetRouteId: input.routeIdByPattern.get(interception.targetPattern) ?? null
+		});
+	}
+}
+function createRouteManifestInterceptionsBySlotId(interceptions) {
+	const interceptionsBySlotId = /* @__PURE__ */ new Map();
+	for (const interception of interceptions.values()) {
+		const existing = interceptionsBySlotId.get(interception.slotId);
+		if (existing) existing.push(interception);
+		else interceptionsBySlotId.set(interception.slotId, [interception]);
+	}
+	for (const slotInterceptions of interceptionsBySlotId.values()) slotInterceptions.sort((left, right) => compareStableStrings(left.id, right.id));
+	return new Map(Array.from(interceptionsBySlotId.entries()).sort(([left], [right]) => compareStableStrings(left, right)));
+}
+function splitRouteManifestPatternParts(pattern) {
+	return pattern.split("/").filter((part) => part.length > 0);
+}
 function getRouteManifestSlotBindingState(slot) {
 	if (slot.pagePath) return "active";
 	if (slot.defaultPath) return "default";
@@ -252,6 +320,8 @@ function createRouteManifestGraphVersion(segmentGraph) {
 		slots: sortedMapValues(segmentGraph.slots),
 		defaults: sortedMapValues(segmentGraph.defaults),
 		slotBindings: sortedMapValues(segmentGraph.slotBindings),
+		interceptions: sortedMapValues(segmentGraph.interceptions),
+		interceptionsBySlotId: sortedMapValues(segmentGraph.interceptionsBySlotId),
 		boundaries: sortedMapValues(segmentGraph.boundaries),
 		rootBoundaries: sortedMapValues(segmentGraph.rootBoundaries)
 	};
@@ -259,7 +329,7 @@ function createRouteManifestGraphVersion(segmentGraph) {
 }
 async function buildAppRouteGraph(appDir, matcher) {
 	const routes = [];
-	const excludeDir = (name) => name.startsWith("@") || name.startsWith("_");
+	const excludeDir = (name) => name.startsWith("@") || name.startsWith("_") || isInterceptionMarkerDir(name);
 	for await (const file of scanWithExtensions("**/page", appDir, matcher.extensions, excludeDir)) {
 		const route = fileToAppRoute(file, appDir, "page", matcher);
 		if (route) routes.push(route);
@@ -269,17 +339,22 @@ async function buildAppRouteGraph(appDir, matcher) {
 		if (route) routes.push(route);
 	}
 	const routePatterns = new Set(routes.map((route) => route.pattern));
+	const ghostParentRoutes = [];
 	for await (const file of scanWithExtensions("**/layout", appDir, matcher.extensions, excludeDir)) {
 		const dir = path.dirname(file);
 		const routeDir = dir === "." ? appDir : path.join(appDir, dir);
 		if (!hasParallelSlotDirectory(routeDir)) continue;
 		if (discoverParallelSlots(routeDir, appDir, matcher).length === 0) continue;
 		const route = directoryToAppRoute(dir, appDir, matcher, null, null);
-		if (!route || routePatterns.has(route.pattern)) continue;
+		if (!route) continue;
+		if (routePatterns.has(route.pattern)) {
+			ghostParentRoutes.push(route);
+			continue;
+		}
 		routes.push(route);
 		routePatterns.add(route.pattern);
 	}
-	const slotSubRoutes = discoverSlotSubRoutes(routes, matcher);
+	const slotSubRoutes = discoverSlotSubRoutes(routes, matcher, ghostParentRoutes);
 	routes.push(...slotSubRoutes);
 	validatePageRouteConflicts(routes, appDir);
 	validateRoutePatterns(routes.map((route) => route.pattern));
@@ -333,7 +408,7 @@ function formatAppFilePath(filePath, appDir) {
 * - @audience slot → @audience/demographics/page.tsx (matched)
 * - other slots → their default.tsx (fallback)
 */
-function discoverSlotSubRoutes(routes, matcher) {
+function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 	const syntheticRoutes = [];
 	const routesByPattern = new Map(routes.map((r) => [r.pattern, r]));
 	const applySlotSubPages = (route, slotPages, rawSegments) => {
@@ -347,7 +422,8 @@ function discoverSlotSubRoutes(routes, matcher) {
 			return slot;
 		});
 	};
-	for (const parentRoute of routes) {
+	const allParents = [...routes, ...ghostParents];
+	for (const parentRoute of allParents) {
 		if (parentRoute.parallelSlots.length === 0) continue;
 		const isLayoutOnlyUiRoute = !parentRoute.pagePath && !parentRoute.routePath && parentRoute.layouts.length > 0;
 		if (!parentRoute.pagePath && !isLayoutOnlyUiRoute) continue;
@@ -584,6 +660,18 @@ function createAppRouteGraphTreePath(routeSegments, treePosition) {
 	if (treePathSegments.length === 0) return "/";
 	return `/${treePathSegments.join("/")}`;
 }
+function convertTreePathToRouteParts(treePath) {
+	if (treePath === "/") return {
+		urlSegments: [],
+		params: []
+	};
+	const routeParts = convertSegmentsToRouteParts(treePath.split("/").filter(Boolean));
+	if (!routeParts) throw new Error(`Invalid App Router layout tree path "${treePath}".`);
+	return {
+		urlSegments: routeParts.urlSegments,
+		params: routeParts.params
+	};
+}
 /**
 * Compute the tree position (directory depth from app root) for each layout.
 * Root layout = 0, a layout at app/blog/ = 1, app/blog/(group)/ = 2.
@@ -943,6 +1031,18 @@ const INTERCEPT_PATTERNS = [
 	}
 ];
 /**
+* Check whether a directory name begins with an interception route marker.
+*
+* Matches the prefixes listed in {@link INTERCEPT_PATTERNS}: `(.)`, `(..)`,
+* `(...)`, `(..)(..)`. The marker is not a real URL segment, so the global
+* page/route scanner must skip these directories to avoid materialising
+* literal patterns like `/templates/(..)showcase`. Interception target
+* registration happens separately via {@link discoverInterceptingRoutes}.
+*/
+function isInterceptionMarkerDir(name) {
+	return matchInterceptConvention(name) !== null;
+}
+/**
 * Discover intercepting routes inside a parallel slot directory.
 *
 * Intercepting routes use conventions like (.)photo, (..)feed, (...), etc.
@@ -972,7 +1072,7 @@ function scanForInterceptingPages(currentDir, routeDir, appDir, results, matcher
 		if (interceptMatch) {
 			const restOfName = entry.name.slice(interceptMatch.prefix.length);
 			const interceptDir = path.join(currentDir, entry.name);
-			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, results, matcher);
+			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, results, matcher);
 		} else scanForInterceptingPages(path.join(currentDir, entry.name), routeDir, appDir, results, matcher);
 	}
 }
@@ -987,29 +1087,53 @@ function matchInterceptConvention(name) {
 * Collect page.tsx files inside an intercepting route directory tree
 * and compute their target URL patterns.
 */
-function collectInterceptingPages(currentDir, interceptRoot, convention, interceptSegment, routeDir, appDir, results, matcher, parentLayoutPaths = []) {
+function collectInterceptingPages(currentDir, interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, results, matcher, parentLayoutPaths = []) {
 	const currentLayoutPath = findFile(currentDir, "layout", matcher);
 	const layoutPaths = currentLayoutPath ? [...parentLayoutPaths, currentLayoutPath] : parentLayoutPaths;
 	const page = findFile(currentDir, "page", matcher);
 	if (page) {
 		const targetPattern = computeInterceptTarget(convention, interceptSegment, currentDir, interceptRoot, routeDir, appDir);
-		if (targetPattern) results.push({
-			convention,
-			layoutPaths: [...layoutPaths],
-			targetPattern: targetPattern.pattern,
-			pagePath: page,
-			params: targetPattern.params
-		});
+		if (targetPattern) {
+			const sourceMatchPattern = computeInterceptSourceMatchPattern(interceptParentDir, appDir);
+			results.push({
+				convention,
+				layoutPaths: [...layoutPaths],
+				targetPattern: targetPattern.pattern,
+				sourceMatchPattern,
+				pagePath: page,
+				params: targetPattern.params
+			});
+		}
 	}
 	if (!fs.existsSync(currentDir)) return;
 	const entries = fs.readdirSync(currentDir, { withFileTypes: true });
 	for (const entry of entries) {
 		if (!entry.isDirectory()) continue;
 		if (entry.name.startsWith("_")) continue;
-		collectInterceptingPages(path.join(currentDir, entry.name), interceptRoot, convention, interceptSegment, routeDir, appDir, results, matcher, layoutPaths);
+		collectInterceptingPages(path.join(currentDir, entry.name), interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, results, matcher, layoutPaths);
 	}
 }
 /**
+* Compute the URL pattern for the *intercepting route* — the path that
+* owns the slot containing the interception marker. Route groups (`(name)`)
+* and parallel slots (`@slot`) are stripped because Next.js'
+* `normalizeAppPath` treats them as invisible in the URL.
+*
+* Mirrors Next.js' computation in `extractInterceptionRouteInformation`:
+* `interceptingRoute = normalizeAppPath(path.split(marker, 2)[0])`.
+*
+* Returns `/` for the app root.
+*
+* @see https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/interception-routes.ts
+*/
+function computeInterceptSourceMatchPattern(interceptParentDir, appDir) {
+	const segments = path.relative(appDir, interceptParentDir).split(path.sep).filter(Boolean);
+	const converted = convertSegmentsToRouteParts(segments);
+	const urlSegments = converted ? converted.urlSegments : segments.filter((segment) => !isInvisibleSegment(segment));
+	if (urlSegments.length === 0) return "/";
+	return "/" + urlSegments.join("/");
+}
+/**
 * Check whether a path segment is invisible in the URL (route groups, parallel slots, ".").
 *
 * Used by computeInterceptTarget, convertSegmentsToRouteParts, and
@@ -1161,6 +1285,6 @@ function joinRoutePattern(basePattern, subPath) {
 	return basePattern === "/" ? `/${subPath}` : `${basePattern}/${subPath}`;
 }
 //#endregion
-export { buildAppRouteGraph, computeRootParamNames };
+export { buildAppRouteGraph, computeRootParamNames, convertSegmentsToRouteParts, isInvisibleSegment };
 
 //# sourceMappingURL=app-route-graph.js.map