Initial commit

frontend/webapp/node_modules/next/dist/server/app-render/app-render-prerender-utils.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 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 {};