vinext 0.1.0 → 0.1.1

package/dist/plugins/require-context.js

@@ -0,0 +1,184 @@
+import { forEachAstChild, hasRange, isAstRecord, nodeArray } from "./ast-utils.js";
+import { parseAst } from "vite";
+import MagicString from "magic-string";
+//#region src/plugins/require-context.ts
+const TRANSFORMABLE_EXTENSIONS = new Set([
+	".js",
+	".jsx",
+	".ts",
+	".tsx",
+	".mjs",
+	".cjs",
+	".mts",
+	".cts"
+]);
+function createRequireContextPlugin() {
+	return {
+		name: "vinext:require-context",
+		enforce: "pre",
+		transform(code, id) {
+			if (!mayContainRequireContext(code)) return null;
+			const lang = langForId(id);
+			if (!lang) return null;
+			let ast;
+			try {
+				ast = parseAst(code, { lang });
+			} catch {
+				return null;
+			}
+			const calls = collectRequireContextCalls(ast);
+			if (calls.length === 0) return null;
+			const output = new MagicString(code);
+			for (const call of calls) output.overwrite(call.range.start, call.range.end, buildReplacement(call));
+			return {
+				code: output.toString(),
+				map: output.generateMap({ hires: "boundary" })
+			};
+		}
+	};
+}
+function mayContainRequireContext(code) {
+	return code.includes("require") && code.includes(".context");
+}
+function langForId(id) {
+	const clean = id.split("?", 1)[0];
+	const dot = clean.lastIndexOf(".");
+	if (dot < 0) return null;
+	const ext = clean.slice(dot).toLowerCase();
+	if (!TRANSFORMABLE_EXTENSIONS.has(ext)) return null;
+	switch (ext) {
+		case ".ts":
+		case ".cts":
+		case ".mts": return "ts";
+		case ".tsx": return "tsx";
+		case ".jsx": return "jsx";
+		default: return "jsx";
+	}
+}
+function collectRequireContextCalls(ast) {
+	const calls = [];
+	function visit(value) {
+		if (!isAstRecord(value)) return;
+		const parsed = parseRequireContextCall(value);
+		if (parsed) {
+			calls.push(parsed);
+			return;
+		}
+		forEachAstChild(value, visit);
+	}
+	visit(ast);
+	return calls;
+}
+function parseRequireContextCall(node) {
+	if (node.type !== "CallExpression" || !hasRange(node)) return null;
+	const callee = node.callee;
+	if (!isAstRecord(callee) || callee.type !== "MemberExpression" || callee.computed === true || callee.optional === true) return null;
+	if (!isPropertyNamed(callee.property, "context")) return null;
+	if (!isRequireExpression(callee.object)) return null;
+	const args = nodeArray(node.arguments);
+	const dir = stringLiteralValue(args[0]);
+	if (dir == null || !(dir.startsWith("./") || dir.startsWith("../"))) return null;
+	let recursive = true;
+	if (args.length >= 2) {
+		const value = booleanLiteralValue(args[1]);
+		if (value == null) return null;
+		recursive = value;
+	}
+	let pattern = "";
+	let flags = "";
+	if (args.length >= 3) {
+		const regex = regexLiteralValue(args[2]);
+		if (regex == null) return null;
+		pattern = regex.pattern;
+		flags = regex.flags;
+	} else if (args.length > 3) return null;
+	return {
+		range: node,
+		dir,
+		recursive,
+		pattern,
+		flags
+	};
+}
+function isRequireExpression(value) {
+	let node = value;
+	while (isAstRecord(node)) {
+		if (node.type === "Identifier") return node.name === "require";
+		if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression") {
+			node = node.expression;
+			continue;
+		}
+		if (node.type === "TSNonNullExpression") {
+			node = node.expression;
+			continue;
+		}
+		if (node.type === "ParenthesizedExpression") {
+			node = node.expression;
+			continue;
+		}
+		return false;
+	}
+	return false;
+}
+function isPropertyNamed(value, name) {
+	return isAstRecord(value) && value.type === "Identifier" && value.name === name;
+}
+function stringLiteralValue(value) {
+	if (isAstRecord(value) && value.type === "Literal" && typeof value.value === "string") return value.value;
+	return null;
+}
+function booleanLiteralValue(value) {
+	if (isAstRecord(value) && value.type === "Literal" && typeof value.value === "boolean") return value.value;
+	return null;
+}
+function regexLiteralValue(value) {
+	if (!isAstRecord(value) || value.type !== "Literal") return null;
+	const regex = value.regex;
+	if (typeof regex === "object" && regex !== null && typeof regex.pattern === "string" && typeof regex.flags === "string") return {
+		pattern: regex.pattern,
+		flags: regex.flags
+	};
+	return null;
+}
+function buildReplacement(call) {
+	const globPattern = globPatternFor(call.dir, call.recursive);
+	const glob = `import.meta.glob(${JSON.stringify(globPattern)}, { eager: true })`;
+	const base = JSON.stringify(stripTrailingSlash(call.dir));
+	const filterFlags = call.flags.replace(/[gy]/g, "");
+	const regexArgs = `${JSON.stringify(call.pattern)}, ${JSON.stringify(filterFlags)}`;
+	return [
+		"(() => {",
+		`  const __modules = ${glob};`,
+		`  const __base = ${base};`,
+		`  const __re = ${call.pattern ? `new RegExp(${regexArgs})` : "null"};`,
+		"  const __prefix = __base.endsWith('/') ? __base : __base + '/';",
+		"  const __map = Object.create(null);",
+		"  for (const __abs in __modules) {",
+		"    if (!__abs.startsWith(__prefix)) continue;",
+		"    const __key = './' + __abs.slice(__prefix.length);",
+		"    if (__re && !__re.test(__key)) continue;",
+		"    __map[__key] = __modules[__abs];",
+		"  }",
+		"  const __keys = Object.keys(__map).sort();",
+		"  const __ctx = (__key) => {",
+		"    if (__key in __map) return __map[__key];",
+		"    const __err = new Error('Cannot find module \\'' + __key + '\\'');",
+		"    __err.code = 'MODULE_NOT_FOUND';",
+		"    throw __err;",
+		"  };",
+		"  __ctx.keys = () => __keys.slice();",
+		"  __ctx.resolve = (__key) => __key;",
+		`  __ctx.id = __base;`,
+		"  return __ctx;",
+		"})()"
+	].join("\n");
+}
+function globPatternFor(dir, recursive) {
+	const base = stripTrailingSlash(dir);
+	return recursive ? `${base}/**/*` : `${base}/*`;
+}
+function stripTrailingSlash(value) {
+	return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+//#endregion
+export { createRequireContextPlugin };

package/dist/routing/app-route-graph.d.ts

@@ -24,6 +24,11 @@ type InterceptingRoute = {
   pagePath: string; /** Absolute layout paths inside the intercepting route tree, outermost to innermost */
   layoutPaths: string[]; /** Parameter names for dynamic segments */
   params: string[];
+  /**
+   * Synthetic page-carrier slot id for sibling (slot-less) interception.
+   * Set only when the marker has no `@slot` wrapper; undefined for slot intercepts.
+   */
+  slotId?: string;
 };
 type ParallelSlot = {
   /** Graph-owned semantic slot identity. Required on AppRouteGraphParallelSlot. */id?: string; /** Stable slot identity (name + owning directory), used for route serialization keys. */
@@ -73,7 +78,13 @@ type AppRoute = {
   routePath: string | null; /** Ordered list of layout files from root to leaf */
   layouts: string[]; /** Ordered list of all discovered template files from root to leaf (not necessarily aligned 1:1 with layouts) */
   templates: string[]; /** Parallel route slots (from @slot directories at the route's directory level) */
-  parallelSlots: ParallelSlot[]; /** Loading component path */
+  parallelSlots: ParallelSlot[];
+  /**
+   * Interception markers not wrapped in an `@slot` directory.
+   * On soft-nav, the intercepting page replaces the entire page response.
+   * Empty array when there are no sibling-style interception markers.
+   */
+  siblingIntercepts: InterceptingRoute[]; /** Loading component path */
   loadingPath: string | null; /** Error component path (leaf directory only) */
   errorPath: string | null;
   /**

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

@@ -33,6 +33,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 +186,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 +372,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 +476,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("/");
@@ -479,7 +501,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 +509,7 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 					slots: subSlots
 				}),
 				pattern,
-				pagePath: childrenDefault,
+				pagePath: childrenFallback,
 				routePath: null,
 				layouts: parentRoute.layouts,
 				templates: parentRoute.templates,
@@ -507,7 +529,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 +572,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 +671,8 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 		isDynamic,
 		params,
 		rootParamNames: computeRootParamNames(segments, layoutTreePositions),
-		patternParts: urlSegments
+		patternParts: urlSegments,
+		siblingIntercepts: []
 	};
 }
 function dynamicParamNameFromSegment(segment) {
@@ -1062,6 +1114,86 @@ 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 = 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`).
+*/
+function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
+	let current = dir;
+	while (true) {
+		const exact = routesByDir.get(current);
+		if (exact) return exact;
+		const currentWithSep = current + path.sep;
+		let best = null;
+		for (const route of routes) {
+			const filePath = route.pagePath ?? route.routePath;
+			if (!filePath) continue;
+			if (!filePath.startsWith(currentWithSep)) continue;
+			if (!best || route.patternParts.length < best.patternParts.length) best = route;
+		}
+		if (best) return best;
+		if (current === appDir) 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.
 */

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);
 			}
 		})
 	};