streams.idl (6911B)
1 // GENERATED CONTENT - DO NOT EDIT 2 // Content was automatically extracted by Reffy into webref 3 // (https://github.com/w3c/webref) 4 // Source: Streams Standard (https://streams.spec.whatwg.org/) 5 6 [Exposed=*, Transferable] 7 interface ReadableStream { 8 constructor(optional object underlyingSource, optional QueuingStrategy strategy = {}); 9 10 static ReadableStream from(any asyncIterable); 11 12 readonly attribute boolean locked; 13 14 Promise<undefined> cancel(optional any reason); 15 ReadableStreamReader getReader(optional ReadableStreamGetReaderOptions options = {}); 16 ReadableStream pipeThrough(ReadableWritablePair transform, optional StreamPipeOptions options = {}); 17 Promise<undefined> pipeTo(WritableStream destination, optional StreamPipeOptions options = {}); 18 sequence<ReadableStream> tee(); 19 20 async_iterable<any>(optional ReadableStreamIteratorOptions options = {}); 21 }; 22 23 typedef (ReadableStreamDefaultReader or ReadableStreamBYOBReader) ReadableStreamReader; 24 25 enum ReadableStreamReaderMode { "byob" }; 26 27 dictionary ReadableStreamGetReaderOptions { 28 ReadableStreamReaderMode mode; 29 }; 30 31 dictionary ReadableStreamIteratorOptions { 32 boolean preventCancel = false; 33 }; 34 35 dictionary ReadableWritablePair { 36 required ReadableStream readable; 37 required WritableStream writable; 38 }; 39 40 dictionary StreamPipeOptions { 41 boolean preventClose = false; 42 boolean preventAbort = false; 43 boolean preventCancel = false; 44 AbortSignal signal; 45 }; 46 47 dictionary UnderlyingSource { 48 UnderlyingSourceStartCallback start; 49 UnderlyingSourcePullCallback pull; 50 UnderlyingSourceCancelCallback cancel; 51 ReadableStreamType type; 52 [EnforceRange] unsigned long long autoAllocateChunkSize; 53 }; 54 55 typedef (ReadableStreamDefaultController or ReadableByteStreamController) ReadableStreamController; 56 57 callback UnderlyingSourceStartCallback = any (ReadableStreamController controller); 58 callback UnderlyingSourcePullCallback = Promise<undefined> (ReadableStreamController controller); 59 callback UnderlyingSourceCancelCallback = Promise<undefined> (optional any reason); 60 61 enum ReadableStreamType { "bytes" }; 62 63 interface mixin ReadableStreamGenericReader { 64 readonly attribute Promise<undefined> closed; 65 66 Promise<undefined> cancel(optional any reason); 67 }; 68 69 [Exposed=*] 70 interface ReadableStreamDefaultReader { 71 constructor(ReadableStream stream); 72 73 Promise<ReadableStreamReadResult> read(); 74 undefined releaseLock(); 75 }; 76 ReadableStreamDefaultReader includes ReadableStreamGenericReader; 77 78 dictionary ReadableStreamReadResult { 79 any value; 80 boolean done; 81 }; 82 83 [Exposed=*] 84 interface ReadableStreamBYOBReader { 85 constructor(ReadableStream stream); 86 87 Promise<ReadableStreamReadResult> read(ArrayBufferView view, optional ReadableStreamBYOBReaderReadOptions options = {}); 88 undefined releaseLock(); 89 }; 90 ReadableStreamBYOBReader includes ReadableStreamGenericReader; 91 92 dictionary ReadableStreamBYOBReaderReadOptions { 93 [EnforceRange] unsigned long long min = 1; 94 }; 95 96 [Exposed=*] 97 interface ReadableStreamDefaultController { 98 readonly attribute unrestricted double? desiredSize; 99 100 undefined close(); 101 undefined enqueue(optional any chunk); 102 undefined error(optional any e); 103 }; 104 105 [Exposed=*] 106 interface ReadableByteStreamController { 107 readonly attribute ReadableStreamBYOBRequest? byobRequest; 108 readonly attribute unrestricted double? desiredSize; 109 110 undefined close(); 111 undefined enqueue(ArrayBufferView chunk); 112 undefined error(optional any e); 113 }; 114 115 [Exposed=*] 116 interface ReadableStreamBYOBRequest { 117 readonly attribute ArrayBufferView? view; 118 119 undefined respond([EnforceRange] unsigned long long bytesWritten); 120 undefined respondWithNewView(ArrayBufferView view); 121 }; 122 123 [Exposed=*, Transferable] 124 interface WritableStream { 125 constructor(optional object underlyingSink, optional QueuingStrategy strategy = {}); 126 127 readonly attribute boolean locked; 128 129 Promise<undefined> abort(optional any reason); 130 Promise<undefined> close(); 131 WritableStreamDefaultWriter getWriter(); 132 }; 133 134 dictionary UnderlyingSink { 135 UnderlyingSinkStartCallback start; 136 UnderlyingSinkWriteCallback write; 137 UnderlyingSinkCloseCallback close; 138 UnderlyingSinkAbortCallback abort; 139 any type; 140 }; 141 142 callback UnderlyingSinkStartCallback = any (WritableStreamDefaultController controller); 143 callback UnderlyingSinkWriteCallback = Promise<undefined> (any chunk, WritableStreamDefaultController controller); 144 callback UnderlyingSinkCloseCallback = Promise<undefined> (); 145 callback UnderlyingSinkAbortCallback = Promise<undefined> (optional any reason); 146 147 [Exposed=*] 148 interface WritableStreamDefaultWriter { 149 constructor(WritableStream stream); 150 151 readonly attribute Promise<undefined> closed; 152 readonly attribute unrestricted double? desiredSize; 153 readonly attribute Promise<undefined> ready; 154 155 Promise<undefined> abort(optional any reason); 156 Promise<undefined> close(); 157 undefined releaseLock(); 158 Promise<undefined> write(optional any chunk); 159 }; 160 161 [Exposed=*] 162 interface WritableStreamDefaultController { 163 readonly attribute AbortSignal signal; 164 undefined error(optional any e); 165 }; 166 167 [Exposed=*, Transferable] 168 interface TransformStream { 169 constructor(optional object transformer, 170 optional QueuingStrategy writableStrategy = {}, 171 optional QueuingStrategy readableStrategy = {}); 172 173 readonly attribute ReadableStream readable; 174 readonly attribute WritableStream writable; 175 }; 176 177 dictionary Transformer { 178 TransformerStartCallback start; 179 TransformerTransformCallback transform; 180 TransformerFlushCallback flush; 181 TransformerCancelCallback cancel; 182 any readableType; 183 any writableType; 184 }; 185 186 callback TransformerStartCallback = any (TransformStreamDefaultController controller); 187 callback TransformerFlushCallback = Promise<undefined> (TransformStreamDefaultController controller); 188 callback TransformerTransformCallback = Promise<undefined> (any chunk, TransformStreamDefaultController controller); 189 callback TransformerCancelCallback = Promise<undefined> (any reason); 190 191 [Exposed=*] 192 interface TransformStreamDefaultController { 193 readonly attribute unrestricted double? desiredSize; 194 195 undefined enqueue(optional any chunk); 196 undefined error(optional any reason); 197 undefined terminate(); 198 }; 199 200 dictionary QueuingStrategy { 201 unrestricted double highWaterMark; 202 QueuingStrategySize size; 203 }; 204 205 callback QueuingStrategySize = unrestricted double (any chunk); 206 207 dictionary QueuingStrategyInit { 208 required unrestricted double highWaterMark; 209 }; 210 211 [Exposed=*] 212 interface ByteLengthQueuingStrategy { 213 constructor(QueuingStrategyInit init); 214 215 readonly attribute unrestricted double highWaterMark; 216 readonly attribute Function size; 217 }; 218 219 [Exposed=*] 220 interface CountQueuingStrategy { 221 constructor(QueuingStrategyInit init); 222 223 readonly attribute unrestricted double highWaterMark; 224 readonly attribute Function size; 225 }; 226 227 interface mixin GenericTransformStream { 228 readonly attribute ReadableStream readable; 229 readonly attribute WritableStream writable; 230 };