vinext 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/server/app-page-request.js

@@ -46,8 +46,14 @@ function collectParentParamNames(routeSegments, boundaryPosition) {
 	}
 	return names;
 }
-function getLayoutGenerateStaticParamsBoundary(layoutTreePosition) {
-	return (layoutTreePosition ?? 0) - 1;
+function getLayoutGenerateStaticParamsBoundary(routeSegments, layoutTreePosition) {
+	let boundary = Math.min((layoutTreePosition ?? 0) - 1, routeSegments.length - 1);
+	while (boundary >= 0) {
+		const segment = routeSegments[boundary];
+		if (!segment.startsWith("@") && !(segment.startsWith("(") && segment.endsWith(")"))) break;
+		boundary -= 1;
+	}
+	return boundary;
 }
 function getParallelParentParamNames(routeParamNames, branch, boundaryPosition) {
 	const slotParamNames = branch.paramNames ?? routeParamNames;
@@ -64,11 +70,13 @@ function resolveAppPageGenerateStaticParamsSources(options) {
 	options.layouts?.forEach((layout, index) => {
 		if (typeof layout?.generateStaticParams !== "function") return;
 		sources.push({
+			chained: true,
 			generateStaticParams: layout.generateStaticParams,
-			parentParamNames: collectParentParamNames(options.routeSegments, getLayoutGenerateStaticParamsBoundary(options.layoutTreePositions?.[index]))
+			parentParamNames: collectParentParamNames(options.routeSegments, getLayoutGenerateStaticParamsBoundary(options.routeSegments, options.layoutTreePositions?.[index]))
 		});
 	});
 	if (typeof options.page?.generateStaticParams === "function") sources.push({
+		chained: true,
 		generateStaticParams: options.page.generateStaticParams,
 		parentParamNames: collectParentParamNames(options.routeSegments, Math.max(0, options.routeSegments.length - 1))
 	});
@@ -76,7 +84,7 @@ function resolveAppPageGenerateStaticParamsSources(options) {
 		const name = getAppPageSegmentParamName(segment);
 		return name ? [name] : [];
 	});
-	for (const parallelBranch of options.parallelBranches ?? []) {
+	for (const [independentChain, parallelBranch] of (options.parallelBranches ?? []).entries()) {
 		if (!parallelBranch) continue;
 		const slotParamNames = parallelBranch.paramNames ?? routeParamNames;
 		const paramAliases = Object.fromEntries(routeParamNames.flatMap((routeParamName, index) => {
@@ -87,6 +95,7 @@ function resolveAppPageGenerateStaticParamsSources(options) {
 			if (typeof module?.generateStaticParams !== "function") return;
 			sources.push({
 				generateStaticParams: module.generateStaticParams,
+				independentChain,
 				...Object.keys(paramAliases).length > 0 ? { paramAliases } : {},
 				...parallelBranch.patternParts ? { paramPatternParts: parallelBranch.patternParts } : {},
 				...options.routePatternParts ? { routePatternParts: options.routePatternParts } : {},
@@ -95,24 +104,101 @@ function resolveAppPageGenerateStaticParamsSources(options) {
 		};
 		addParallelSource(parallelBranch.layout, -1);
 		parallelBranch.configLayouts?.forEach((layout, index) => {
-			addParallelSource(layout, getLayoutGenerateStaticParamsBoundary(parallelBranch.configLayoutTreePositions?.[index]));
+			addParallelSource(layout, getLayoutGenerateStaticParamsBoundary(parallelBranch.routeSegments ?? [], parallelBranch.configLayoutTreePositions?.[index]));
 		});
 		addParallelSource(parallelBranch.page, Math.max(0, (parallelBranch.routeSegments?.length ?? 0) - 1));
 	}
 	return sources;
 }
-function areStaticParamsAllowed(params, staticParams) {
+function areStaticParamsAllowed(params, staticParams, allowMissingValues = false) {
 	const paramKeys = Object.keys(params);
+	const stringParamMatches = (value, staticValue) => value === encodeURIComponent(staticValue);
 	return staticParams.some((staticParamSet) => paramKeys.every((key) => {
 		const value = params[key];
 		const staticValue = staticParamSet[key];
-		if (staticValue === void 0) return true;
-		if (Array.isArray(value)) return Array.isArray(staticValue) && value.length === staticValue.length && value.every((part, index) => typeof staticValue[index] === "string" ? part.toLowerCase() === staticValue[index].toLowerCase() : part === staticValue[index]);
-		if (typeof staticValue === "string") return value.toLowerCase() === staticValue.toLowerCase();
+		if (!Object.hasOwn(staticParamSet, key)) return allowMissingValues;
+		if (Array.isArray(value)) return Array.isArray(staticValue) && value.length === staticValue.length && value.every((part, index) => typeof staticValue[index] === "string" ? stringParamMatches(part, staticValue[index]) : part === staticValue[index]);
+		if (typeof staticValue === "string") return stringParamMatches(value, staticValue);
 		if (typeof staticValue === "number" || typeof staticValue === "boolean") return String(value) === String(staticValue);
 		return JSON.stringify(value) === JSON.stringify(staticValue);
 	}));
 }
+function remapStaticParamsToRouteParams(staticParams, source) {
+	if (!source.paramAliases) return [...staticParams];
+	const routeParamNamesBySourceName = new Map(Object.entries(source.paramAliases).map(([routeParamName, sourceParamName]) => [sourceParamName, routeParamName]));
+	return staticParams.map((params) => Object.fromEntries(Object.entries(params).map(([name, value]) => [routeParamNamesBySourceName.get(name) ?? name, value])));
+}
+async function generateIndependentStaticParams(sources, primaryParams, requestParams) {
+	let rows = (primaryParams ?? []).map((params) => ({
+		params,
+		branchParams: {}
+	}));
+	let hasParentParams = rows.length > 0;
+	let validated = false;
+	for (const source of sources) {
+		const parents = hasParentParams ? rows : [{
+			params: {},
+			branchParams: {}
+		}];
+		const nextRows = [];
+		for (const parent of parents) {
+			const sourceParams = remapRouteParams({
+				...requestParams,
+				...parent.params
+			}, source);
+			const branchParams = remapRouteParams(parent.branchParams, source);
+			const result = await runWithFetchDedupe(() => source.generateStaticParams({ params: {
+				...pickRouteParams(sourceParams, source.parentParamNames),
+				...branchParams
+			} }));
+			if (!Array.isArray(result)) {
+				if (hasParentParams) nextRows.push(parent);
+				continue;
+			}
+			validated = true;
+			const routeResults = remapStaticParamsToRouteParams(result, source);
+			if (routeResults.length === 0) {
+				if (hasParentParams) nextRows.push(parent);
+				continue;
+			}
+			for (const routeResult of routeResults) nextRows.push({
+				params: {
+					...parent.params,
+					...routeResult
+				},
+				branchParams: {
+					...parent.branchParams,
+					...routeResult
+				}
+			});
+		}
+		rows = nextRows;
+		hasParentParams = rows.length > 0;
+	}
+	return {
+		staticParams: rows.map((row) => row.params),
+		validated
+	};
+}
+async function generateChainedStaticParams(sources) {
+	let generatedParams = [];
+	for (const source of sources) {
+		const hasParentParams = generatedParams.length > 0;
+		const parents = hasParentParams ? generatedParams : [{}];
+		const nextParams = [];
+		for (const parentParams of parents) {
+			const result = await runWithFetchDedupe(() => source.generateStaticParams({ params: parentParams }));
+			if (Array.isArray(result) && result.length > 0) {
+				for (const item of result) if (item !== null && typeof item === "object" && !Array.isArray(item)) nextParams.push({
+					...parentParams,
+					...item
+				});
+			} else if (hasParentParams) nextParams.push(parentParams);
+		}
+		generatedParams = nextParams;
+	}
+	return generatedParams;
+}
 function normalizeGenerateStaticParams(generateStaticParams) {
 	return (Array.isArray(generateStaticParams) ? generateStaticParams : [generateStaticParams]).flatMap((source) => {
 		if (typeof source === "function") return [{
@@ -130,10 +216,28 @@ async function validateAppPageDynamicParams(options) {
 		options.clearRequestContext();
 		return notFoundResponse();
 	}
-	for (const source of generateStaticParamsSources) {
-		const sourceParams = remapRouteParams(options.params, source);
-		const staticParams = await runWithFetchDedupe(() => source.generateStaticParams({ params: pickRouteParams(sourceParams, source.parentParamNames) }));
-		if (Array.isArray(staticParams) && !areStaticParamsAllowed(sourceParams, staticParams)) {
+	const chainedSources = generateStaticParamsSources.filter((source) => source.chained);
+	let chainedStaticParams = null;
+	if (chainedSources.length > 0) chainedStaticParams = await generateChainedStaticParams(chainedSources);
+	const independentChains = /* @__PURE__ */ new Map();
+	for (const source of generateStaticParamsSources.filter((source) => !source.chained)) {
+		const chain = independentChains.get(source.independentChain ?? source) ?? [];
+		chain.push(source);
+		independentChains.set(source.independentChain ?? source, chain);
+	}
+	let validatedIndependentResults = false;
+	for (const sources of independentChains.values()) {
+		const result = await generateIndependentStaticParams(sources, chainedStaticParams, options.params);
+		if (result.validated) {
+			validatedIndependentResults = true;
+			if (!areStaticParamsAllowed(options.params, result.staticParams, true)) {
+				options.clearRequestContext();
+				return notFoundResponse();
+			}
+		}
+	}
+	if (chainedStaticParams && !validatedIndependentResults) {
+		if (!areStaticParamsAllowed(options.params, chainedStaticParams)) {
 			options.clearRequestContext();
 			return notFoundResponse();
 		}
@@ -187,7 +291,23 @@ async function resolveAppPageInterceptState(options) {
 		if (loadState) loadState.pageLoading = loading;
 		await loading;
 	}
-	if (intercept.__loadInterceptLayouts) await loadAppInterceptLayouts(intercept);
+	if (loadState?.notFound != null) intercept.notFound = loadState.notFound;
+	if (intercept.__loadNotFound && intercept.notFound == null) {
+		const loading = loadState?.notFoundLoading ?? intercept.__loadNotFound().then((notFound) => {
+			intercept.notFound = notFound;
+			if (loadState) {
+				loadState.notFound = notFound;
+				loadState.notFoundLoading = null;
+			}
+			return notFound;
+		}).catch((error) => {
+			if (loadState) loadState.notFoundLoading = null;
+			throw error;
+		});
+		if (loadState) loadState.notFoundLoading = loading;
+		await loading;
+	}
+	if (intercept.__loadInterceptLayouts || intercept.__loadInterceptLoadings) await loadAppInterceptLayouts(intercept);
 	const sourceRoute = await options.getSourceRoute(intercept.sourceRouteIndex);
 	if (!sourceRoute) return { kind: "none" };
 	if (sourceRoute === options.currentRoute) return {

package/dist/server/app-page-response.js

@@ -1,6 +1,6 @@
 import { VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_TIMING_HEADER } from "./headers.js";
-import { setCacheStateHeaders } from "./cache-headers.js";
 import { NO_STORE_CACHE_CONTROL, STATIC_CACHE_CONTROL, buildRevalidateCacheControl } from "./cache-control.js";
+import { setCacheStateHeaders } from "./cache-headers.js";
 import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 //#region src/server/app-page-response.ts

package/dist/server/app-page-route-wiring.d.ts

@@ -37,6 +37,11 @@ type AppPageRouteWiringSlot<TModule extends AppPageModule = AppPageModule, TErro
   layout?: TModule | null;
   layoutIndex: number;
   loading?: TModule | null;
+  loadings?: readonly (TModule | null | undefined)[] | null;
+  loadingTreePositions?: readonly number[] | null;
+  ownerTreePosition?: number | null;
+  notFound?: TModule | null;
+  notFoundTreePosition?: number | null;
   page?: TModule | null;
   routeSegments?: readonly string[] | null;
   /**
@@ -57,11 +62,16 @@ type AppPageRouteWiringRoute<TModule extends AppPageModule = AppPageModule, TErr
   layoutTreePositions?: readonly number[] | null;
   layouts: readonly (TModule | null | undefined)[];
   loading?: TModule | null;
+  loadings?: readonly (TModule | null | undefined)[] | null;
+  loadingTreePositions?: readonly number[] | null;
   notFound?: TModule | null;
   notFounds?: readonly (TModule | null | undefined)[] | null;
+  notFoundTreePosition?: number | null;
   forbidden?: TModule | null;
+  forbiddenTreePosition?: number | null;
   forbiddens?: readonly (TModule | null | undefined)[] | null;
   unauthorized?: TModule | null;
+  unauthorizedTreePosition?: number | null;
   unauthorizeds?: readonly (TModule | null | undefined)[] | null;
   routeSegments?: readonly string[];
   childrenRouteSegments?: readonly string[] | null;
@@ -94,6 +104,8 @@ type AppPageSlotOverride<TModule extends AppPageModule = AppPageModule> = {
   branchSegments?: readonly string[] | null;
   layoutSegments?: readonly (readonly string[])[] | null;
   layoutModules?: readonly (TModule | null | undefined)[] | null;
+  loadingModules?: readonly (TModule | null | undefined)[] | null;
+  loadingTreePositions?: readonly number[] | null;
   /**
    * The page module to render for this slot. Optional — when omitted, the
    * slot's existing `page` is used (e.g. when the override only changes the
@@ -124,6 +136,10 @@ type BuildAppPageRouteElementOptions<TModule extends AppPageModule = AppPageModu
   resolvedMetadata: Metadata | null;
   resolvedMetadataPathname?: string;
   resolvedViewport: Viewport;
+  streamingMetadata?: Promise<Metadata | null> | null;
+  streamingMetadataOutlet?: Promise<unknown> | null;
+  streamingMetadataOutletSuspended?: boolean;
+  streamingMetadataTags?: Promise<Metadata | null> | null;
   trailingSlash?: boolean;
   rootForbiddenModule?: TModule | null;
   rootNotFoundModule?: TModule | null;