vinext 1.2.1 → 1.3.1

package/dist/server/app-page-head.d.ts

@@ -1,7 +1,7 @@
 import { MetadataFileRoute } from "./metadata-routes.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { ThenableParamsObserver } from "../shims/thenable-params.js";
-import { Metadata, ResolvedViewport } from "../shims/metadata.js";
+import { Metadata, ResolvedViewport, Viewport } from "../shims/metadata.js";
 import { applyFileBasedMetadata } from "./file-based-metadata.js";
 //#region src/server/app-page-head.d.ts
 export type AppPageSearchParams = Record<string, string | string[]>;
@@ -34,14 +34,30 @@ export type ActiveParallelRouteHeadInput<TModule extends AppPageHeadModule = App
   notFoundModuleRouteSegments?: readonly string[] | null;
   notFoundParams?: AppPageParams | null;
   ownerTreePosition: number;
+  /** The `slots` key of the slot this branch renders in. */
+  slotKey?: string;
+};
+/**
+ * A branch whose head Next.js resolves but never shows: a slot intercept's
+ * layouts and page beside the source page. It renders in the slot at
+ * `parallelRouteIndex` of `parallelRoutes` and shares that slot's first
+ * `sharedLayoutCount` layouts, which resolve once for both.
+ */
+export type AppPageHiddenParallelRoute<TModule extends AppPageHeadModule = AppPageHeadModule> = {
+  parallelRouteIndex: number;
+  route: AppPageHeadParallelRoute<TModule>;
+  sharedLayoutCount: number;
 };
 type AppPageHeadSlot<TModule extends AppPageHeadModule = AppPageHeadModule> = {
   configLayouts?: readonly (TModule | null | undefined)[] | null;
   configLayoutTreePositions?: readonly number[] | null;
   layout?: TModule | null;
   layoutIndex?: number;
+  name?: string | null;
   notFound?: TModule | null;
   notFoundTreePosition?: number | null;
+  /** Directory depth of the folder holding the `@slot` directory. */
+  ownerTreePosition?: number | null;
   page?: TModule | null;
   routeSegments?: readonly string[] | null;
 };
@@ -72,9 +88,22 @@ type ResolveAppPageHeadOptions<TModule extends AppPageHeadModule = AppPageHeadMo
    */
   basePath?: string;
   fallbackOnFileMetadataError?: boolean;
+  /**
+   * Branches whose head Next.js resolves but never shows, such as a slot
+   * intercept beside the source page. Their own generateMetadata() and
+   * generateViewport() run once, after every branch before them in the loader
+   * tree, and their errors reach `hiddenErrors` rather than the head.
+   */
+  hiddenParallelRoutes?: readonly AppPageHiddenParallelRoute<TModule>[] | null;
   layoutModules: readonly (TModule | null | undefined)[];
   layoutTreePositions?: readonly number[] | null;
   metadataRoutes: readonly MetadataFileRoute[];
+  /**
+   * The index in `parallelRoutes` of a shown branch whose own errors reach
+   * `hiddenErrors` rather than `routeErrors`, such as a slot intercept that
+   * heads the route: Next.js throws them in that page's own segment.
+   */
+  outletParallelRouteIndex?: number | null;
   pageModule?: TModule | null;
   parallelRoutes?: readonly AppPageHeadParallelRoute<TModule>[] | null;
   params: AppPageParams;
@@ -103,14 +132,76 @@ export type ResolveAppPageHeadResult = {
   viewport: ResolvedViewport;
 };
 export type PreparedAppPageHead = Omit<ResolveAppPageHeadResult, "metadata" | "viewport"> & {
+  /**
+   * Rejects with the first own error, in loader-tree order, of an item of
+   * `hiddenParallelRoutes` or of `outletParallelRouteIndex`, or with the
+   * head's own failure when that outlet branch heads the route.
+   */
+  hiddenErrors: Promise<null>;
   metadata: Promise<Metadata | null>;
+  /**
+   * Rejects with the first own error, in loader-tree order, of every other
+   * item, or with the head's own failure. Those errors never wait on the
+   * outlet branch; what only the outlet branch settling makes known, a later
+   * item's failed merge or its error after reading `parent`, counts after them.
+   */
+  routeErrors: Promise<null>;
   viewport: Promise<ResolvedViewport>;
 };
+/**
+ * A route's head as one render prepared it, for a later render to reuse. Each
+ * branch already settled its own signals, so neither rejects.
+ */
+export type AppPagePreparedRouteHead = {
+  /** The `dynamic = "error"` access error either branch dropped, which still fails the render. */
+  accessError: Promise<Error | null>;
+  metadata: Promise<Metadata | null>;
+  /** Where that render places generateMetadata()'s tags: "body" streams them. */
+  metadataPlacement: "body" | "head";
+  /** `null` when its resolution failed, so the head has no viewport tags. */
+  viewport: Promise<Viewport | null>;
+};
+/**
+ * A special-error fallback for a signal the matched route's render threw keeps
+ * the route's own head: the head that render prepared, or, when it never
+ * started one, a fresh resolution with that render's query and placement.
+ */
+export type AppPageFallbackRouteHead = {
+  /** Whether metadata's `searchParams` reads count as dynamic usage, as in the render. */
+  observeSearchParams: boolean;
+  prepared: AppPagePreparedRouteHead | null;
+  /** The query the render read: a rewrite's, or none for a static render. */
+  searchParams: URLSearchParams;
+  /** Whether the render streams generated metadata into the body. */
+  streamMetadata: boolean;
+};
 type AppPageSearchParamsCollection = {
   hasSearchParams: boolean;
   pageSearchParams: AppPageSearchParams;
 };
 export declare function resolveActiveParallelRouteHeadInputs<TModule extends AppPageHeadModule>(options: ResolveActiveParallelRouteHeadInputsOptions<TModule>): ActiveParallelRouteHeadInput<TModule>[];
+/**
+ * Whether a slot intercept keeps the source route's head. Next.js's client
+ * renders the head of the first leaf on a children-first walk of its router
+ * tree that skips `default` segments, and a slot intercept keeps the leaves
+ * before its slot from the source route. When one of them is a page, such as
+ * the source page in `children`, the source head stays; otherwise the walk
+ * reaches the intercept's leaf, headed by the intercepting render.
+ * `sourceParallelRoutes` are the source route's own slot branches, in the
+ * walk's order (resolveActiveParallelRouteHeadInputs).
+ * https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/router-reducer/reducers/find-head-in-cache.ts
+ */
+export declare function slotInterceptKeepsSourceHead(options: {
+  interceptSlotKey: string;
+  /** The source route; its `children` is a page unless it renders a default. */
+  route: {
+    childrenSlot?: {
+      state: string;
+    } | null;
+    page?: unknown;
+  };
+  sourceParallelRoutes: readonly ActiveParallelRouteHeadInput[];
+}): boolean;
 export declare function collectAppPageSearchParams(searchParams: URLSearchParams | null | undefined): AppPageSearchParamsCollection;
 /**
  * Resolve an explicit metadata-source sequence.
@@ -125,7 +216,7 @@ export declare function resolveAppPageHead<TModule extends AppPageHeadModule>(op
  * Whether any segment of the page's head exports `generateMetadata()`. Known
  * from the modules alone, so callers can place the head before resolving it.
  */
-export declare function hasAppPageDynamicMetadata<TModule extends AppPageHeadModule>(options: Pick<ResolveAppPageHeadOptions<TModule>, "layoutModules" | "pageModule" | "parallelRoutes">): boolean;
+export declare function hasAppPageDynamicMetadata<TModule extends AppPageHeadModule>(options: Pick<ResolveAppPageHeadOptions<TModule>, "hiddenParallelRoutes" | "layoutModules" | "pageModule" | "parallelRoutes">): boolean;
 /**
  * Start metadata and viewport resolution without coupling their completion.
  *
@@ -134,4 +225,5 @@ export declare function hasAppPageDynamicMetadata<TModule extends AppPageHeadMod
  * callers use {@link resolveAppPageHead} and observe the same result as before.
  */
 export declare function prepareAppPageHead<TModule extends AppPageHeadModule>(options: ResolveAppPageHeadOptions<TModule>): PreparedAppPageHead;
-//#endregion
+//#endregion
+export {};