mirror of https://github.com/nodejs/node.git
231 lines
6.7 KiB
Plaintext
231 lines
6.7 KiB
Plaintext
// GENERATED CONTENT - DO NOT EDIT
|
|
// Content was automatically extracted by Reffy into webref
|
|
// (https://github.com/w3c/webref)
|
|
// Source: Streams Standard (https://streams.spec.whatwg.org/)
|
|
|
|
[Exposed=*, Transferable]
|
|
interface ReadableStream {
|
|
constructor(optional object underlyingSource, optional QueuingStrategy strategy = {});
|
|
|
|
static ReadableStream from(any asyncIterable);
|
|
|
|
readonly attribute boolean locked;
|
|
|
|
Promise<undefined> cancel(optional any reason);
|
|
ReadableStreamReader getReader(optional ReadableStreamGetReaderOptions options = {});
|
|
ReadableStream pipeThrough(ReadableWritablePair transform, optional StreamPipeOptions options = {});
|
|
Promise<undefined> pipeTo(WritableStream destination, optional StreamPipeOptions options = {});
|
|
sequence<ReadableStream> tee();
|
|
|
|
async iterable<any>(optional ReadableStreamIteratorOptions options = {});
|
|
};
|
|
|
|
typedef (ReadableStreamDefaultReader or ReadableStreamBYOBReader) ReadableStreamReader;
|
|
|
|
enum ReadableStreamReaderMode { "byob" };
|
|
|
|
dictionary ReadableStreamGetReaderOptions {
|
|
ReadableStreamReaderMode mode;
|
|
};
|
|
|
|
dictionary ReadableStreamIteratorOptions {
|
|
boolean preventCancel = false;
|
|
};
|
|
|
|
dictionary ReadableWritablePair {
|
|
required ReadableStream readable;
|
|
required WritableStream writable;
|
|
};
|
|
|
|
dictionary StreamPipeOptions {
|
|
boolean preventClose = false;
|
|
boolean preventAbort = false;
|
|
boolean preventCancel = false;
|
|
AbortSignal signal;
|
|
};
|
|
|
|
dictionary UnderlyingSource {
|
|
UnderlyingSourceStartCallback start;
|
|
UnderlyingSourcePullCallback pull;
|
|
UnderlyingSourceCancelCallback cancel;
|
|
ReadableStreamType type;
|
|
[EnforceRange] unsigned long long autoAllocateChunkSize;
|
|
};
|
|
|
|
typedef (ReadableStreamDefaultController or ReadableByteStreamController) ReadableStreamController;
|
|
|
|
callback UnderlyingSourceStartCallback = any (ReadableStreamController controller);
|
|
callback UnderlyingSourcePullCallback = Promise<undefined> (ReadableStreamController controller);
|
|
callback UnderlyingSourceCancelCallback = Promise<undefined> (optional any reason);
|
|
|
|
enum ReadableStreamType { "bytes" };
|
|
|
|
interface mixin ReadableStreamGenericReader {
|
|
readonly attribute Promise<undefined> closed;
|
|
|
|
Promise<undefined> cancel(optional any reason);
|
|
};
|
|
|
|
[Exposed=*]
|
|
interface ReadableStreamDefaultReader {
|
|
constructor(ReadableStream stream);
|
|
|
|
Promise<ReadableStreamReadResult> read();
|
|
undefined releaseLock();
|
|
};
|
|
ReadableStreamDefaultReader includes ReadableStreamGenericReader;
|
|
|
|
dictionary ReadableStreamReadResult {
|
|
any value;
|
|
boolean done;
|
|
};
|
|
|
|
[Exposed=*]
|
|
interface ReadableStreamBYOBReader {
|
|
constructor(ReadableStream stream);
|
|
|
|
Promise<ReadableStreamReadResult> read(ArrayBufferView view, optional ReadableStreamBYOBReaderReadOptions options = {});
|
|
undefined releaseLock();
|
|
};
|
|
ReadableStreamBYOBReader includes ReadableStreamGenericReader;
|
|
|
|
dictionary ReadableStreamBYOBReaderReadOptions {
|
|
[EnforceRange] unsigned long long min = 1;
|
|
};
|
|
|
|
[Exposed=*]
|
|
interface ReadableStreamDefaultController {
|
|
readonly attribute unrestricted double? desiredSize;
|
|
|
|
undefined close();
|
|
undefined enqueue(optional any chunk);
|
|
undefined error(optional any e);
|
|
};
|
|
|
|
[Exposed=*]
|
|
interface ReadableByteStreamController {
|
|
readonly attribute ReadableStreamBYOBRequest? byobRequest;
|
|
readonly attribute unrestricted double? desiredSize;
|
|
|
|
undefined close();
|
|
undefined enqueue(ArrayBufferView chunk);
|
|
undefined error(optional any e);
|
|
};
|
|
|
|
[Exposed=*]
|
|
interface ReadableStreamBYOBRequest {
|
|
readonly attribute ArrayBufferView? view;
|
|
|
|
undefined respond([EnforceRange] unsigned long long bytesWritten);
|
|
undefined respondWithNewView(ArrayBufferView view);
|
|
};
|
|
|
|
[Exposed=*, Transferable]
|
|
interface WritableStream {
|
|
constructor(optional object underlyingSink, optional QueuingStrategy strategy = {});
|
|
|
|
readonly attribute boolean locked;
|
|
|
|
Promise<undefined> abort(optional any reason);
|
|
Promise<undefined> close();
|
|
WritableStreamDefaultWriter getWriter();
|
|
};
|
|
|
|
dictionary UnderlyingSink {
|
|
UnderlyingSinkStartCallback start;
|
|
UnderlyingSinkWriteCallback write;
|
|
UnderlyingSinkCloseCallback close;
|
|
UnderlyingSinkAbortCallback abort;
|
|
any type;
|
|
};
|
|
|
|
callback UnderlyingSinkStartCallback = any (WritableStreamDefaultController controller);
|
|
callback UnderlyingSinkWriteCallback = Promise<undefined> (any chunk, WritableStreamDefaultController controller);
|
|
callback UnderlyingSinkCloseCallback = Promise<undefined> ();
|
|
callback UnderlyingSinkAbortCallback = Promise<undefined> (optional any reason);
|
|
|
|
[Exposed=*]
|
|
interface WritableStreamDefaultWriter {
|
|
constructor(WritableStream stream);
|
|
|
|
readonly attribute Promise<undefined> closed;
|
|
readonly attribute unrestricted double? desiredSize;
|
|
readonly attribute Promise<undefined> ready;
|
|
|
|
Promise<undefined> abort(optional any reason);
|
|
Promise<undefined> close();
|
|
undefined releaseLock();
|
|
Promise<undefined> write(optional any chunk);
|
|
};
|
|
|
|
[Exposed=*]
|
|
interface WritableStreamDefaultController {
|
|
readonly attribute AbortSignal signal;
|
|
undefined error(optional any e);
|
|
};
|
|
|
|
[Exposed=*, Transferable]
|
|
interface TransformStream {
|
|
constructor(optional object transformer,
|
|
optional QueuingStrategy writableStrategy = {},
|
|
optional QueuingStrategy readableStrategy = {});
|
|
|
|
readonly attribute ReadableStream readable;
|
|
readonly attribute WritableStream writable;
|
|
};
|
|
|
|
dictionary Transformer {
|
|
TransformerStartCallback start;
|
|
TransformerTransformCallback transform;
|
|
TransformerFlushCallback flush;
|
|
TransformerCancelCallback cancel;
|
|
any readableType;
|
|
any writableType;
|
|
};
|
|
|
|
callback TransformerStartCallback = any (TransformStreamDefaultController controller);
|
|
callback TransformerFlushCallback = Promise<undefined> (TransformStreamDefaultController controller);
|
|
callback TransformerTransformCallback = Promise<undefined> (any chunk, TransformStreamDefaultController controller);
|
|
callback TransformerCancelCallback = Promise<undefined> (any reason);
|
|
|
|
[Exposed=*]
|
|
interface TransformStreamDefaultController {
|
|
readonly attribute unrestricted double? desiredSize;
|
|
|
|
undefined enqueue(optional any chunk);
|
|
undefined error(optional any reason);
|
|
undefined terminate();
|
|
};
|
|
|
|
dictionary QueuingStrategy {
|
|
unrestricted double highWaterMark;
|
|
QueuingStrategySize size;
|
|
};
|
|
|
|
callback QueuingStrategySize = unrestricted double (any chunk);
|
|
|
|
dictionary QueuingStrategyInit {
|
|
required unrestricted double highWaterMark;
|
|
};
|
|
|
|
[Exposed=*]
|
|
interface ByteLengthQueuingStrategy {
|
|
constructor(QueuingStrategyInit init);
|
|
|
|
readonly attribute unrestricted double highWaterMark;
|
|
readonly attribute Function size;
|
|
};
|
|
|
|
[Exposed=*]
|
|
interface CountQueuingStrategy {
|
|
constructor(QueuingStrategyInit init);
|
|
|
|
readonly attribute unrestricted double highWaterMark;
|
|
readonly attribute Function size;
|
|
};
|
|
|
|
interface mixin GenericTransformStream {
|
|
readonly attribute ReadableStream readable;
|
|
readonly attribute WritableStream writable;
|
|
};
|