vinext 0.1.0 → 0.1.2

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

@@ -1,3 +1,4 @@
+import { normalizePathSeparators } from "../utils/path.js";
 import { compareRoutes, decodeRouteSegment, isInvisibleSegment } from "./utils.js";
 import { findFileWithExts, scanWithExtensions } from "./file-matcher.js";
 import { validateRoutePatterns } from "./route-validation.js";
@@ -33,6 +34,10 @@ function createAppRouteGraphSlotId(slotName, ownerTreePath) {
 function createAppRouteGraphDefaultId(slotId) {
 	return `default:${slotId}`;
 }
+const SIBLING_INTERCEPT_SLOT_NAME = "__vinext_sibling_intercept";
+function createAppRouteGraphSiblingInterceptSlotId(sourcePattern) {
+	return createAppRouteGraphSlotId(SIBLING_INTERCEPT_SLOT_NAME, sourcePattern);
+}
 function createAppRouteGraphInterceptionId(slotId, sourcePattern, targetPattern) {
 	return `interception:${slotId}:${sourcePattern}->${targetPattern}`;
 }
@@ -182,6 +187,21 @@ function createStaticSegmentGraph(routes) {
 				slot
 			});
 		}
+		for (const ir of route.siblingIntercepts) {
+			if (!ir.slotId) continue;
+			const id = createAppRouteGraphInterceptionId(ir.slotId, ir.sourceMatchPattern, ir.targetPattern);
+			interceptions.set(id, {
+				id,
+				sourcePattern: ir.sourceMatchPattern,
+				sourcePatternParts: splitRouteManifestPatternParts(ir.sourceMatchPattern),
+				targetPattern: ir.targetPattern,
+				targetPatternParts: splitRouteManifestPatternParts(ir.targetPattern),
+				slotId: ir.slotId,
+				ownerLayoutId: null,
+				interceptingRouteId: routeIdByPattern.get(ir.sourceMatchPattern) ?? null,
+				targetRouteId: routeIdByPattern.get(ir.targetPattern) ?? null
+			});
+		}
 	}
 	return {
 		routes: routeEntries,
@@ -353,9 +373,10 @@ async function buildAppRouteGraph(appDir, matcher) {
 	}
 	const slotSubRoutes = discoverSlotSubRoutes(routes, matcher, ghostParentRoutes);
 	routes.push(...slotSubRoutes);
+	discoverSiblingInterceptingRoutes(routes, appDir, matcher);
 	validatePageRouteConflicts(routes, appDir);
 	validateRoutePatterns(routes.map((route) => route.pattern));
-	validateRoutePatterns([...new Set(routes.flatMap((route) => route.parallelSlots.flatMap((slot) => slot.interceptingRoutes.map((intercept) => intercept.targetPattern))))]);
+	validateRoutePatterns([...new Set(routes.flatMap((route) => [...route.parallelSlots.flatMap((slot) => slot.interceptingRoutes.map((intercept) => intercept.targetPattern)), ...route.siblingIntercepts.map((intercept) => intercept.targetPattern)]))]);
 	routes.sort(compareRoutes);
 	return {
 		routes,
@@ -456,6 +477,8 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 		if (subPathMap.size === 0) continue;
 		const childrenDefault = findFile(parentPageDir, "default", matcher);
 		if (parentRoute.pagePath && !childrenDefault) continue;
+		const childrenCatchAll = childrenDefault ? null : findCatchAllPage(parentPageDir, matcher);
+		const childrenFallback = childrenDefault ?? childrenCatchAll;
 		for (const { rawSegments, converted: convertedSubRoute, slotPages } of subPathMap.values()) {
 			const { urlSegments: urlParts, params: subParams, isDynamic: subIsDynamic } = convertedSubRoute;
 			const subUrlPath = urlParts.join("/");
@@ -463,7 +486,7 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			const existingRoute = routesByPattern.get(pattern);
 			if (existingRoute) {
 				if (existingRoute.routePath && !existingRoute.pagePath) throw new Error(`You cannot have two routes that resolve to the same path ("${pattern}").`);
-				applySlotSubPages(existingRoute, slotPages, rawSegments);
+				if (urlParts.length > 0) applySlotSubPages(existingRoute, slotPages, rawSegments);
 				continue;
 			}
 			const syntheticParts = [...parentRoute.patternParts, ...urlParts];
@@ -479,7 +502,7 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			const newRoute = {
 				ids: createAppRouteSemanticIds({
 					pattern,
-					pagePath: childrenDefault,
+					pagePath: childrenFallback,
 					routePath: null,
 					routeSegments: [...parentRoute.routeSegments, ...rawSegments],
 					layoutTreePositions: parentRoute.layoutTreePositions,
@@ -487,7 +510,7 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 					slots: subSlots
 				}),
 				pattern,
-				pagePath: childrenDefault,
+				pagePath: childrenFallback,
 				routePath: null,
 				layouts: parentRoute.layouts,
 				templates: parentRoute.templates,
@@ -507,7 +530,8 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 				isDynamic: parentRoute.isDynamic || subIsDynamic,
 				params: [...parentRoute.params, ...subParams],
 				rootParamNames: parentRoute.rootParamNames,
-				patternParts: [...parentRoute.patternParts, ...urlParts]
+				patternParts: [...parentRoute.patternParts, ...urlParts],
+				siblingIntercepts: []
 			};
 			syntheticRoutes.push(newRoute);
 			routesByPattern.set(pattern, newRoute);
@@ -549,6 +573,34 @@ function findSlotSubPages(slotDir, matcher) {
 	return results;
 }
 /**
+* Find a sibling catch-all page directly under `dir`, i.e. a `[...slug]` or
+* `[[...slug]]` directory that contains a `page` file. Returns the absolute
+* page path, or null when no catch-all sibling exists.
+*
+* Used as the children fallback for slot-only sub-routes (an explicit `@slot`
+* sub-page with no corresponding children page or `default.tsx`): Next.js
+* serves the children prop from the nearest catch-all, so `/baz` renders
+* `[...catchAll]/page.tsx` for children while `@slot/baz/page.tsx` fills the
+* slot. Optional catch-alls (`[[...slug]]`) qualify because they also match a
+* single extra segment.
+*/
+function findCatchAllPage(dir, matcher) {
+	let entries;
+	try {
+		entries = fs.readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return null;
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const name = entry.name;
+		if (!(name.startsWith("[...") && name.endsWith("]") || name.startsWith("[[...") && name.endsWith("]]"))) continue;
+		const page = findFile(path.join(dir, name), "page", matcher);
+		if (page) return page;
+	}
+	return null;
+}
+/**
 * Convert a file path relative to app/ into an AppRoute.
 */
 function fileToAppRoute(file, appDir, type, matcher) {
@@ -620,7 +672,8 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 		isDynamic,
 		params,
 		rootParamNames: computeRootParamNames(segments, layoutTreePositions),
-		patternParts: urlSegments
+		patternParts: urlSegments,
+		siblingIntercepts: []
 	};
 }
 function dynamicParamNameFromSegment(segment) {
@@ -974,6 +1027,34 @@ function patternsStructurallyEquivalent(a, b) {
 	return true;
 }
 /**
+* Find a page file at the root URL level of a parallel slot directory, including
+* through transparent route-group subdirectories (e.g. `@slot/(group)/page.tsx`
+* is equivalent to `@slot/page.tsx` since `(group)` is invisible in the URL).
+*
+* Returns the absolute page path, or null if no root-level page is found.
+*
+* Only descends into route-group directories (those whose name starts with `(`
+* and ends with `)`). Dynamic segments, regular named dirs, and `@slot` dirs
+* are not transparent and are therefore not searched.
+*/
+function findSlotRootPage(slotDir, matcher) {
+	const directPage = findFile(slotDir, "page", matcher);
+	if (directPage) return directPage;
+	let entries;
+	try {
+		entries = fs.readdirSync(slotDir, { withFileTypes: true });
+	} catch {
+		return null;
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		if (!entry.name.startsWith("(") || !entry.name.endsWith(")")) continue;
+		const found = findSlotRootPage(path.join(slotDir, entry.name), matcher);
+		if (found) return found;
+	}
+	return null;
+}
+/**
 * Discover parallel route slots (@team, @analytics, etc.) in a directory.
 * Returns a ParallelSlot for each @-prefixed subdirectory that has a page or default component.
 */
@@ -986,7 +1067,7 @@ function discoverParallelSlots(dir, appDir, matcher) {
 		if (entry.name === "@children") continue;
 		const slotName = entry.name.slice(1);
 		const slotDir = path.join(dir, entry.name);
-		const pagePath = findFile(slotDir, "page", matcher);
+		const pagePath = findSlotRootPage(slotDir, matcher);
 		const defaultPath = findFile(slotDir, "default", matcher);
 		const interceptingRoutes = discoverInterceptingRoutes(slotDir, dir, appDir, matcher);
 		if (!pagePath && !defaultPath && interceptingRoutes.length === 0) continue;
@@ -1062,6 +1143,96 @@ function discoverInterceptingRoutes(slotDir, routeDir, appDir, matcher) {
 	return results;
 }
 /**
+* Discover sibling-style interception markers — interception marker directories
+* (e.g. `(..)showcase`, `(..)(..)hoge`) that are NOT wrapped inside an `@slot`
+* directory. Mutates each matching route's `siblingIntercepts` array.
+*
+* Sibling intercepts use the same conventions and target-computation logic as
+* slot intercepts, but their intercepting page replaces the full page response
+* (not a slot) during soft navigation.
+*/
+function discoverSiblingInterceptingRoutes(routes, appDir, matcher) {
+	const routesByDir = /* @__PURE__ */ new Map();
+	for (const route of routes) {
+		const filePath = route.pagePath ?? route.routePath;
+		if (!filePath) continue;
+		const routeDir = normalizePathSeparators(path.dirname(filePath));
+		if (!routesByDir.has(routeDir)) routesByDir.set(routeDir, route);
+	}
+	function walk(dir) {
+		let entries;
+		try {
+			entries = fs.readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			if (entry.name.startsWith("_")) continue;
+			if (entry.name.startsWith("@")) continue;
+			const childDir = path.join(dir, entry.name);
+			const marker = matchInterceptConvention(entry.name);
+			if (marker) {
+				const restOfName = entry.name.slice(marker.prefix.length);
+				const parentDir = dir;
+				const results = [];
+				collectInterceptingPages(childDir, childDir, marker.convention, restOfName, parentDir, appDir, parentDir, results, matcher);
+				for (const ir of results) {
+					ir.slotId = createAppRouteGraphSiblingInterceptSlotId(ir.sourceMatchPattern);
+					const owner = findOwnerRouteForDir(parentDir, appDir, routes, routesByDir);
+					if (owner) owner.siblingIntercepts.push(ir);
+				}
+				continue;
+			}
+			walk(childDir);
+		}
+	}
+	walk(appDir);
+}
+/**
+* Find the best route to attach a sibling intercept to, given the directory
+* that contains the interception marker.
+*
+* 1. Exact hit: a route whose page/handler lives directly in `dir`.
+* 2. Subtree hit: shallowest route whose page lives anywhere under `dir`
+*    (handles catch-all routes like `/templates/:catchAll+`).
+* 3. Ancestor walk: walk up the directory tree toward `appDir` looking for
+*    any of the above. This handles the case where the marker directory has
+*    no sibling pages at all (e.g. `deep/path/(...)target` with no
+*    `deep/path/page.tsx`).
+*
+* All comparisons happen in forward-slash space: `appDir` is forward-slash
+* (normalized once in the config hook), but `dir` and route file paths
+* descend through native `path.join`/`path.dirname`, which reintroduce
+* backslashes on Windows. Without normalizing, the `current === appDir`
+* termination never fires there and the walk overshoots the app root.
+* `routesByDir` keys must be forward-slash dirnames of the route file paths.
+*
+* Exported for tests.
+*/
+function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
+	const appRoot = normalizePathSeparators(appDir);
+	let current = normalizePathSeparators(dir);
+	while (true) {
+		const exact = routesByDir.get(current);
+		if (exact) return exact;
+		const currentWithSep = current + "/";
+		let best = null;
+		for (const route of routes) {
+			const filePath = route.pagePath ?? route.routePath;
+			if (!filePath) continue;
+			if (!normalizePathSeparators(filePath).startsWith(currentWithSep)) continue;
+			if (!best || route.patternParts.length < best.patternParts.length) best = route;
+		}
+		if (best) return best;
+		if (current === appRoot) break;
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return null;
+}
+/**
 * Recursively scan a directory tree for page.tsx files that are inside
 * intercepting route directories.
 */
@@ -1314,4 +1485,4 @@ function computeAppRouteStaticSiblings(allRoutes, matchedRoute) {
 	return Array.from(siblings);
 }
 //#endregion
-export { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, isInvisibleSegment };
+export { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, findOwnerRouteForDir, isInvisibleSegment };

package/dist/routing/file-matcher.js

@@ -69,7 +69,7 @@ function findFileWithExtensions(basePath, matcher) {
 */
 function findFileWithExts(dir, name, matcher) {
 	for (const ext of matcher.dottedExtensions) {
-		const filePath = path.join(dir, name + ext);
+		const filePath = path.posix.join(dir, name + ext);
 		if (existsSync(filePath)) return filePath;
 	}
 	return null;

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

@@ -5,6 +5,7 @@ declare function routePattern(pathname: string): string;
 declare function fillRoutePatternSegments(pathname: string, params: RoutePatternParams): string | null;
 declare function matchRoutePattern(urlParts: readonly string[], patternParts: readonly string[]): RoutePatternParams | null;
 declare function matchRoutePatternPrefix(pathParts: readonly string[], patternParts: readonly string[]): boolean;
+declare function matchRoutePatternWithOptionalDynamicSegments(pathParts: readonly string[], patternParts: readonly string[]): boolean;
 /**
  * A single entry from `getStaticPaths().paths`.
  *
@@ -60,4 +61,4 @@ declare function normalizeStaticPathname(pathname: string): string;
  */
 declare function normalizeStaticPathsEntry(entry: StaticPathsEntry, routePattern: string): NormalizedStaticPathsEntry;
 //#endregion
-export { RoutePatternParams, StaticPathsEntry, fillRoutePatternSegments, matchRoutePattern, matchRoutePatternPrefix, normalizeStaticPathname, normalizeStaticPathsEntry, routePattern, routePatternParts };
+export { RoutePatternParams, StaticPathsEntry, fillRoutePatternSegments, matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternWithOptionalDynamicSegments, normalizeStaticPathname, normalizeStaticPathsEntry, routePattern, routePatternParts };

package/dist/routing/route-pattern.js

@@ -104,6 +104,21 @@ function matchRoutePatternPrefix(pathParts, patternParts) {
 	}
 	return true;
 }
+function matchRoutePatternWithOptionalDynamicSegments(pathParts, patternParts) {
+	function matchFrom(pathIndex, patternIndex) {
+		if (patternIndex === patternParts.length) return pathIndex === pathParts.length;
+		const patternPart = patternParts[patternIndex];
+		if (patternPart.startsWith(":") && (patternPart.endsWith("+") || patternPart.endsWith("*"))) {
+			const minLength = patternPart.endsWith("+") ? 1 : 0;
+			for (let endIndex = pathIndex + minLength; endIndex <= pathParts.length; endIndex++) if (matchFrom(endIndex, patternIndex + 1)) return true;
+			return false;
+		}
+		if (patternPart.startsWith(":")) return matchFrom(pathIndex, patternIndex + 1) || pathIndex < pathParts.length && matchFrom(pathIndex + 1, patternIndex + 1);
+		if (pathIndex >= pathParts.length || pathParts[pathIndex] !== patternPart) return false;
+		return matchFrom(pathIndex + 1, patternIndex + 1);
+	}
+	return matchFrom(0, 0);
+}
 /**
 * Strip query string and a single trailing slash from a pathname.
 *
@@ -147,4 +162,4 @@ function normalizeStaticPathsEntry(entry, routePattern) {
 	return { params };
 }
 //#endregion
-export { fillRoutePatternSegments, matchRoutePattern, matchRoutePatternPrefix, normalizeStaticPathname, normalizeStaticPathsEntry, routePattern, routePatternParts };
+export { fillRoutePatternSegments, matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternWithOptionalDynamicSegments, normalizeStaticPathname, normalizeStaticPathsEntry, routePattern, routePatternParts };

package/dist/server/api-handler.js

@@ -7,6 +7,7 @@ import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-medi
 import { isEdgeApiRuntime } from "./edge-api-runtime.js";
 import { DEFAULT_PAGES_API_BODY_SIZE_LIMIT, resolveBodyParserConfig } from "./pages-body-parser-config.js";
 import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
+import { performOnDemandRevalidate } from "./pages-revalidate.js";
 import { decode } from "node:querystring";
 import { Buffer } from "node:buffer";
 //#region src/server/api-handler.ts
@@ -198,6 +199,9 @@ function enhanceApiObjects(req, res, query, body) {
 				if (typeof statusOrUrl === "string") this.writeHead(307, { Location: statusOrUrl });
 				else this.writeHead(statusOrUrl, { Location: url ?? "" });
 				this.end();
+			},
+			async revalidate(urlPath, opts) {
+				await performOnDemandRevalidate(req, urlPath, opts);
 			}
 		})
 	};