next
Version:
The React Framework
67 lines (66 loc) • 3.84 kB
TypeScript
/**
* This is a utility function to make scheduling sequential tasks that run back to back easier.
* We schedule on the same queue (setImmediate) at the same time to ensure no other events can sneak in between.
*/
export declare function prerenderAndAbortInSequentialTasks<R>(prerender: () => Promise<R>, abort: () => void): Promise<R>;
export declare function prerenderServerWithPhases(signal: AbortSignal, render: () => ReadableStream<Uint8Array>, finalPhase: () => void): Promise<ServerPrerenderStreamResult>;
export declare function prerenderServerWithPhases(signal: AbortSignal, render: () => ReadableStream<Uint8Array>, secondPhase: () => void, finalPhase: () => void): Promise<ServerPrerenderStreamResult>;
export declare function prerenderServerWithPhases(signal: AbortSignal, render: () => ReadableStream<Uint8Array>, secondPhase: () => void, thirdPhase: () => void, ...remainingPhases: Array<() => void>): Promise<ServerPrerenderStreamResult>;
export declare class ServerPrerenderStreamResult {
private currentChunks;
private chunksByPhase;
private trailingChunks;
private status;
private reason;
constructor(stream: ReadableStream<Uint8Array>);
markPhase(): void;
markComplete(): void;
markInterrupted(): void;
/**
* Returns a stream which only releases chunks when `releasePhase` is called. This stream will never "complete" because
* we rely upon the stream remaining open when prerendering to avoid triggering errors for incomplete chunks in the client.
*
* asPhasedStream is expected to be called once per result however it is safe to call multiple times as long as we have not
* transferred the underlying data. Generally this will only happen when streaming to a response
*/
asPhasedStream(): PhasedStream<Uint8Array<ArrayBufferLike>>;
/**
* Returns a stream which will release all chunks immediately. This stream will "complete" synchronously. It should be used outside
* of render use cases like loading client chunks ahead of SSR or writing the streamed content to disk.
*/
asStream(): ReadableStream<any>;
}
declare class PhasedStream<T> extends ReadableStream<T> {
private nextPhase;
private chunksByPhase;
private destination;
constructor(chunksByPhase: Array<Array<T>>);
releasePhase(): void;
assertExhausted(): void;
}
export declare function prerenderClientWithPhases<T>(render: () => Promise<T>, finalPhase: () => void): Promise<T>;
export declare function prerenderClientWithPhases<T>(render: () => Promise<T>, secondPhase: () => void, finalPhase: () => void): Promise<T>;
export declare function prerenderClientWithPhases<T>(render: () => Promise<T>, secondPhase: () => void, thirdPhase: () => void, ...remainingPhases: Array<() => void>): Promise<T>;
export declare class ReactServerResult {
private _stream;
constructor(stream: ReadableStream<Uint8Array>);
tee(): ReadableStream<Uint8Array<ArrayBufferLike>>;
consume(): ReadableStream<Uint8Array<ArrayBufferLike>>;
}
export type ReactServerPrerenderResolveToType = {
prelude: ReadableStream<Uint8Array>;
};
export declare function createReactServerPrerenderResult(underlying: Promise<ReactServerPrerenderResolveToType>): Promise<ReactServerPrerenderResult>;
export declare function createReactServerPrerenderResultFromRender(underlying: ReadableStream<Uint8Array>): Promise<ReactServerPrerenderResult>;
export declare class ReactServerPrerenderResult {
private _chunks;
private assertChunks;
private consumeChunks;
consume(): void;
constructor(chunks: Array<Uint8Array>);
asUnclosingStream(): ReadableStream<Uint8Array>;
consumeAsUnclosingStream(): ReadableStream<Uint8Array>;
asStream(): ReadableStream<Uint8Array>;
consumeAsStream(): ReadableStream<Uint8Array>;
}
export {};