@samitouri / QOS-React-2
Code Commits Issues Pulls Sessions CI/CD
main
main
js 136 lines 3.07 KB
Raw
1 // flow-typed signature: e6e6768618776352dd676f63502aea4d
2 // flow-typed version: 40e7dfcbd5/streams/flow_>=v0.261.x
3
4 type TextEncodeOptions = {options?: boolean, ...};
5
6 declare class ReadableStreamController {
7 constructor(
8 stream: ReadableStream,
9 underlyingSource: UnderlyingSource,
10 size: number,
11 highWaterMark: number
12 ): void;
13
14 desiredSize: number;
15
16 close(): void;
17 enqueue(chunk: any): void;
18 error(error: Error): void;
19 }
20
21 declare class ReadableStreamBYOBRequest {
22 constructor(controller: ReadableStreamController, view: $TypedArray): void;
23
24 view: $TypedArray;
25
26 respond(bytesWritten: number): ?any;
27 respondWithNewView(view: $TypedArray): ?any;
28 }
29
30 declare class ReadableByteStreamController extends ReadableStreamController {
31 constructor(
32 stream: ReadableStream,
33 underlyingSource: UnderlyingSource,
34 highWaterMark: number
35 ): void;
36
37 byobRequest: ReadableStreamBYOBRequest;
38 }
39
40 declare class ReadableStreamReader {
41 constructor(stream: ReadableStream): void;
42
43 closed: boolean;
44
45 cancel(reason: string): Promise<void>;
46 read(): Promise<{
47 value: ?any,
48 done: boolean,
49 ...
50 }>;
51 releaseLock(): void;
52 }
53
54 declare interface UnderlyingSource {
55 autoAllocateChunkSize?: number;
56 type?: string;
57
58 start?: (controller: ReadableStreamController) => ?Promise<void>;
59 pull?: (controller: ReadableStreamController) => ?Promise<void>;
60 cancel?: (reason: string) => ?Promise<void>;
61 }
62
63 declare class TransformStream {
64 readable: ReadableStream;
65 writable: WritableStream;
66 }
67
68 interface PipeThroughTransformStream {
69 readable: ReadableStream;
70 writable: WritableStream;
71 }
72
73 type PipeToOptions = {
74 preventClose?: boolean,
75 preventAbort?: boolean,
76 preventCancel?: boolean,
77 ...
78 };
79
80 type QueuingStrategy = {
81 highWaterMark: number,
82 size(chunk: ?any): number,
83 ...
84 };
85
86 declare class ReadableStream {
87 constructor(
88 underlyingSource: ?UnderlyingSource,
89 queuingStrategy: ?QueuingStrategy
90 ): void;
91
92 locked: boolean;
93
94 cancel(reason: string): void;
95 getReader(): ReadableStreamReader;
96 pipeThrough(transform: PipeThroughTransformStream, options: ?any): void;
97 pipeTo(dest: WritableStream, options: ?PipeToOptions): Promise<void>;
98 tee(): [ReadableStream, ReadableStream];
99 }
100
101 declare interface WritableStreamController {
102 error(error: Error): void;
103 }
104
105 declare interface UnderlyingSink {
106 autoAllocateChunkSize?: number;
107 type?: string;
108
109 abort?: (reason: string) => ?Promise<void>;
110 close?: (controller: WritableStreamController) => ?Promise<void>;
111 start?: (controller: WritableStreamController) => ?Promise<void>;
112 write?: (chunk: any, controller: WritableStreamController) => ?Promise<void>;
113 }
114
115 declare interface WritableStreamWriter {
116 closed: Promise<any>;
117 desiredSize?: number;
118 ready: Promise<any>;
119
120 abort(reason: string): ?Promise<any>;
121 close(): Promise<any>;
122 releaseLock(): void;
123 write(chunk: any): Promise<any>;
124 }
125
126 declare class WritableStream {
127 constructor(
128 underlyingSink: ?UnderlyingSink,
129 queuingStrategy: QueuingStrategy
130 ): void;
131
132 locked: boolean;
133
134 abort(reason: string): void;
135 getWriter(): WritableStreamWriter;
136 }