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

The React Framework

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