67 lines
3.7 KiB
TypeScript
67 lines
3.7 KiB
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 {};
|