.

node_modules/next/dist/server/app-render/vary-params.d.ts

@@ -0,0 +1,72 @@
+import type { Params } from '../request/params';
+import type { SearchParams } from '../request/search-params';
+import type { VaryParamsThenable, VaryParams } from '../../shared/lib/segment-cache/vary-params-decoding';
+/**
+ * Accumulates vary params for a single segment (or for metadata/rootParams).
+ *
+ * VaryParamsAccumulator is also a thenable that can be serialized by React
+ * Flight. The accumulator starts as 'pending' and accumulates param accesses
+ * during render. Call `finishTrackingVaryParams()` after rendering to resolve
+ * all accumulators.
+ *
+ * The `status` and `value` fields follow the React Flight thenable protocol:
+ * when `status === 'fulfilled'`, Flight can read `value` synchronously without
+ * scheduling a microtask via `.then()`.
+ */
+export type VaryParamsAccumulator = {
+    varyParams: VaryParams;
+    status: 'pending' | 'fulfilled';
+    value: VaryParams;
+    then(onfulfilled?: ((value: Set<string>) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): void;
+    resolvers: Array<(value: Set<string>) => void>;
+};
+/**
+ * A mutable data structure for accumulating per-segment vary params for an
+ * entire server response. It's only used during prerenders. It describes
+ * metadata about the response itself.
+ */
+export type ResponseVaryParamsAccumulator = {
+    /** Vary params accumulator for metadata/viewport (the "head" segment) */
+    head: VaryParamsAccumulator;
+    /** Vary params accumulator for root params access */
+    rootParams: VaryParamsAccumulator;
+    /** Vary params accumulators for each route segment */
+    segments: Set<VaryParamsAccumulator>;
+};
+export declare const emptyVaryParamsAccumulator: VaryParamsAccumulator;
+export declare function createResponseVaryParamsAccumulator(): ResponseVaryParamsAccumulator;
+/**
+ * Allocates a new VaryParamsAccumulator and adds it to the response accumulator
+ * associated with the current WorkUnitStore.
+ *
+ * Returns a thenable that resolves to the segment's vary params once rendering
+ * is complete. The thenable can be passed directly to React Flight for
+ * serialization.
+ */
+export declare function createVaryParamsAccumulator(): VaryParamsAccumulator | null;
+export declare function getMetadataVaryParamsAccumulator(): VaryParamsAccumulator | null;
+export declare function getVaryParamsThenable(accumulator: VaryParamsAccumulator): VaryParamsThenable | null;
+export declare function getMetadataVaryParamsThenable(): VaryParamsThenable | null;
+export declare const getViewportVaryParamsAccumulator: typeof getMetadataVaryParamsAccumulator;
+export declare function getRootParamsVaryParamsAccumulator(): VaryParamsAccumulator | null;
+/**
+ * Records that a param was accessed. Adds the param name to the accumulator's
+ * varyParams set.
+ */
+export declare function accumulateVaryParam(accumulator: VaryParamsAccumulator, paramName: string): void;
+/**
+ * Records a root param access.
+ */
+export declare function accumulateRootVaryParam(paramName: string): void;
+export declare function createVaryingParams(accumulator: VaryParamsAccumulator, originalParamsObject: Params, optionalCatchAllParamName: string | null): Params;
+export declare function createVaryingSearchParams(accumulator: VaryParamsAccumulator, originalSearchParamsObject: SearchParams): SearchParams;
+/**
+ * Resolves all segment accumulators in a ResponseVaryParamsAccumulator with
+ * their final vary params. Call this after rendering is complete.
+ *
+ * Each segment's thenable is resolved with its vary params merged with the
+ * root params. If we can't track vary params (e.g., legacy prerender), simply
+ * don't call this function - the client treats unresolved thenables as
+ * "unknown" vary params.
+ */
+export declare function finishAccumulatingVaryParams(responseAccumulator: ResponseVaryParamsAccumulator): Promise<void>;