diff --git a/baselines/dom.generated.d.ts b/baselines/dom.generated.d.ts index 858b9b53e..45f674577 100644 --- a/baselines/dom.generated.d.ts +++ b/baselines/dom.generated.d.ts @@ -890,6 +890,12 @@ interface PeriodicWaveOptions extends PeriodicWaveConstraints { real?: number[] | Float32Array; } +interface PipeOptions { + preventAbort?: boolean; + preventCancel?: boolean; + preventClose?: boolean; +} + interface PointerEventInit extends MouseEventInit { height?: number; isPrimary?: boolean; @@ -942,9 +948,9 @@ interface PushSubscriptionOptionsInit { userVisibleOnly?: boolean; } -interface QueuingStrategy { +interface QueuingStrategy { highWaterMark?: number; - size?: WritableStreamChunkCallback; + size?: QueuingStrategySizeCallback; } interface RTCAnswerOptions extends RTCOfferAnswerOptions { @@ -1500,6 +1506,14 @@ interface TrackEventInit extends EventInit { track?: VideoTrack | AudioTrack | TextTrack | null; } +interface Transformer { + flush?: TransformStreamDefaultControllerCallback; + readableType?: undefined; + start?: TransformStreamDefaultControllerCallback; + transform?: TransformStreamDefaultControllerTransformCallback; + writableType?: undefined; +} + interface TransitionEventInit extends EventInit { elapsedTime?: number; propertyName?: string; @@ -1511,11 +1525,27 @@ interface UIEventInit extends EventInit { view?: Window | null; } -interface UnderlyingSink { +interface UnderlyingByteSource { + autoAllocateChunkSize?: number; + cancel?: ReadableStreamErrorCallback; + pull?: ReadableByteStreamControllerCallback; + start?: ReadableByteStreamControllerCallback; + type: "bytes"; +} + +interface UnderlyingSink { abort?: WritableStreamErrorCallback; - close?: WritableStreamDefaultControllerCallback; - start: WritableStreamDefaultControllerCallback; - write?: WritableStreamChunkCallback; + close?: WritableStreamDefaultControllerCloseCallback; + start?: WritableStreamDefaultControllerStartCallback; + type?: undefined; + write?: WritableStreamDefaultControllerWriteCallback; +} + +interface UnderlyingSource { + cancel?: ReadableStreamErrorCallback; + pull?: ReadableStreamDefaultControllerCallback; + start?: ReadableStreamDefaultControllerCallback; + type?: undefined; } interface VRDisplayEventInit extends EventInit { @@ -2172,7 +2202,7 @@ declare var Blob: { }; interface Body { - readonly body: ReadableStream | null; + readonly body: ReadableStream | null; readonly bodyUsed: boolean; arrayBuffer(): Promise; blob(): Promise; @@ -2217,14 +2247,14 @@ interface BroadcastChannelEventMap { messageerror: MessageEvent; } -interface ByteLengthQueuingStrategy { +interface ByteLengthQueuingStrategy extends QueuingStrategy { highWaterMark: number; - size(chunk?: any): number; + size(chunk: ArrayBufferView): number; } declare var ByteLengthQueuingStrategy: { prototype: ByteLengthQueuingStrategy; - new(strategy: QueuingStrategy): ByteLengthQueuingStrategy; + new(options: { highWaterMark: number }): ByteLengthQueuingStrategy; }; interface CDATASection extends Text { @@ -3308,14 +3338,14 @@ interface Coordinates { readonly speed: number | null; } -interface CountQueuingStrategy { +interface CountQueuingStrategy extends QueuingStrategy { highWaterMark: number; - size(): number; + size(chunk: any): 1; } declare var CountQueuingStrategy: { prototype: CountQueuingStrategy; - new(strategy: QueuingStrategy): CountQueuingStrategy; + new(options: { highWaterMark: number }): CountQueuingStrategy; }; interface Crypto { @@ -11834,20 +11864,70 @@ declare var Range: { readonly START_TO_START: number; }; -interface ReadableStream { +interface ReadableByteStreamController { + readonly byobRequest: ReadableStreamBYOBRequest | undefined; + readonly desiredSize: number | null; + close(): void; + enqueue(chunk: ArrayBufferView): void; + error(error?: any): void; +} + +interface ReadableStream { readonly locked: boolean; - cancel(): Promise; - getReader(): ReadableStreamReader; + cancel(reason?: any): Promise; + getReader(options: { mode: "byob" }): ReadableStreamBYOBReader; + getReader(): ReadableStreamDefaultReader; + pipeThrough({ writable, readable }: { writable: WritableStream, readable: ReadableStream }, options?: PipeOptions): ReadableStream; + pipeTo(dest: WritableStream, options?: PipeOptions): Promise; + tee(): [ReadableStream, ReadableStream]; } declare var ReadableStream: { prototype: ReadableStream; - new(): ReadableStream; + new(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number, size?: undefined }): ReadableStream; + new(underlyingSource?: UnderlyingSource, strategy?: QueuingStrategy): ReadableStream; +}; + +interface ReadableStreamBYOBReader { + readonly closed: Promise; + cancel(reason?: any): Promise; + read(view: T): Promise>; + releaseLock(): void; +} + +declare var ReadableStreamBYOBReader: { + prototype: ReadableStreamBYOBReader; + new(stream: ReadableStream): ReadableStreamBYOBReader; }; -interface ReadableStreamReader { +interface ReadableStreamBYOBRequest { + readonly view: ArrayBufferView; + respond(bytesWritten: number): void; + respondWithNewView(view: ArrayBufferView): void; +} + +interface ReadableStreamDefaultController { + readonly desiredSize: number | null; + close(): void; + enqueue(chunk: R): void; + error(error?: any): void; +} + +interface ReadableStreamDefaultReader { + readonly closed: Promise; + cancel(reason?: any): Promise; + read(): Promise>; + releaseLock(): void; +} + +interface ReadableStreamReadResult { + done: boolean; + value: T; +} + +interface ReadableStreamReader { cancel(): Promise; - read(): Promise; + read(): Promise>; releaseLock(): void; } @@ -14904,6 +14984,23 @@ declare var TrackEvent: { new(typeArg: string, eventInitDict?: TrackEventInit): TrackEvent; }; +interface TransformStream { + readonly readable: ReadableStream; + readonly writable: WritableStream; +} + +declare var TransformStream: { + prototype: TransformStream; + new(transformer?: Transformer, writableStrategy?: QueuingStrategy, readableStrategy?: QueuingStrategy): TransformStream; +}; + +interface TransformStreamDefaultController { + readonly desiredSize: number | null; + enqueue(chunk: O): void; + error(reason?: any): void; + terminate(): void; +} + interface TransitionEvent extends Event { readonly elapsedTime: number; readonly propertyName: string; @@ -16637,41 +16734,31 @@ declare var Worklet: { new(): Worklet; }; -interface WritableStream { +interface WritableStream { readonly locked: boolean; abort(reason?: any): Promise; - getWriter(): WritableStreamDefaultWriter; + getWriter(): WritableStreamDefaultWriter; } declare var WritableStream: { prototype: WritableStream; - new(underlyingSink?: UnderlyingSink, strategy?: QueuingStrategy): WritableStream; + new(underlyingSink?: UnderlyingSink, strategy?: QueuingStrategy): WritableStream; }; interface WritableStreamDefaultController { error(error?: any): void; } -declare var WritableStreamDefaultController: { - prototype: WritableStreamDefaultController; - new(): WritableStreamDefaultController; -}; - -interface WritableStreamDefaultWriter { +interface WritableStreamDefaultWriter { readonly closed: Promise; - readonly desiredSize: number; + readonly desiredSize: number | null; readonly ready: Promise; abort(reason?: any): Promise; close(): Promise; releaseLock(): void; - write(chunk?: any): Promise; + write(chunk: W): Promise; } -declare var WritableStreamDefaultWriter: { - prototype: WritableStreamDefaultWriter; - new(): WritableStreamDefaultWriter; -}; - interface XMLDocument extends Document { addEventListener(type: K, listener: (this: XMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; @@ -17021,6 +17108,10 @@ interface PositionErrorCallback { (positionError: PositionError): void; } +interface QueuingStrategySizeCallback { + (chunk: T): number; +} + interface RTCPeerConnectionErrorCallback { (error: DOMException): void; } @@ -17033,20 +17124,44 @@ interface RTCStatsCallback { (report: RTCStatsReport): void; } +interface ReadableByteStreamControllerCallback { + (controller: ReadableByteStreamController): void | PromiseLike; +} + +interface ReadableStreamDefaultControllerCallback { + (controller: ReadableStreamDefaultController): void | PromiseLike; +} + +interface ReadableStreamErrorCallback { + (reason: any): void | PromiseLike; +} + +interface TransformStreamDefaultControllerCallback { + (controller: TransformStreamDefaultController): void | PromiseLike; +} + +interface TransformStreamDefaultControllerTransformCallback { + (chunk: I, controller: TransformStreamDefaultController): void | PromiseLike; +} + interface VoidFunction { (): void; } -interface WritableStreamChunkCallback { - (chunk: any, controller: WritableStreamDefaultController): void; +interface WritableStreamDefaultControllerCloseCallback { + (): void | PromiseLike; +} + +interface WritableStreamDefaultControllerStartCallback { + (controller: WritableStreamDefaultController): void | PromiseLike; } -interface WritableStreamDefaultControllerCallback { - (controller: WritableStreamDefaultController): void; +interface WritableStreamDefaultControllerWriteCallback { + (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike; } interface WritableStreamErrorCallback { - (reason: string): void; + (reason: any): void | PromiseLike; } interface HTMLElementTagNameMap { @@ -17680,7 +17795,7 @@ declare function removeEventListener(type: K, li declare function removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; type BlobPart = BufferSource | Blob | string; type HeadersInit = Headers | string[][] | Record; -type BodyInit = Blob | BufferSource | FormData | URLSearchParams | ReadableStream | string; +type BodyInit = Blob | BufferSource | FormData | URLSearchParams | ReadableStream | string; type RequestInfo = Request | string; type DOMHighResTimeStamp = number; type RenderingContext = CanvasRenderingContext2D | ImageBitmapRenderingContext | WebGLRenderingContext; diff --git a/baselines/webworker.generated.d.ts b/baselines/webworker.generated.d.ts index 5013f3802..55adc1e88 100644 --- a/baselines/webworker.generated.d.ts +++ b/baselines/webworker.generated.d.ts @@ -283,6 +283,12 @@ interface PerformanceObserverInit { entryTypes: string[]; } +interface PipeOptions { + preventAbort?: boolean; + preventCancel?: boolean; + preventClose?: boolean; +} + interface ProgressEventInit extends EventInit { lengthComputable?: boolean; loaded?: number; @@ -314,6 +320,11 @@ interface PushSubscriptionOptionsInit { userVisibleOnly?: boolean; } +interface QueuingStrategy { + highWaterMark?: number; + size?: QueuingStrategySizeCallback; +} + interface RegistrationOptions { scope?: string; type?: WorkerType; @@ -388,6 +399,37 @@ interface TextDecoderOptions { ignoreBOM?: boolean; } +interface Transformer { + flush?: TransformStreamDefaultControllerCallback; + readableType?: undefined; + start?: TransformStreamDefaultControllerCallback; + transform?: TransformStreamDefaultControllerTransformCallback; + writableType?: undefined; +} + +interface UnderlyingByteSource { + autoAllocateChunkSize?: number; + cancel?: ReadableStreamErrorCallback; + pull?: ReadableByteStreamControllerCallback; + start?: ReadableByteStreamControllerCallback; + type: "bytes"; +} + +interface UnderlyingSink { + abort?: WritableStreamErrorCallback; + close?: WritableStreamDefaultControllerCloseCallback; + start?: WritableStreamDefaultControllerStartCallback; + type?: undefined; + write?: WritableStreamDefaultControllerWriteCallback; +} + +interface UnderlyingSource { + cancel?: ReadableStreamErrorCallback; + pull?: ReadableStreamDefaultControllerCallback; + start?: ReadableStreamDefaultControllerCallback; + type?: undefined; +} + interface WebGLContextAttributes { alpha?: GLboolean; antialias?: GLboolean; @@ -491,7 +533,7 @@ declare var Blob: { }; interface Body { - readonly body: ReadableStream | null; + readonly body: ReadableStream | null; readonly bodyUsed: boolean; arrayBuffer(): Promise; blob(): Promise; @@ -536,6 +578,16 @@ interface BroadcastChannelEventMap { messageerror: MessageEvent; } +interface ByteLengthQueuingStrategy extends QueuingStrategy { + highWaterMark: number; + size(chunk: ArrayBufferView): number; +} + +declare var ByteLengthQueuingStrategy: { + prototype: ByteLengthQueuingStrategy; + new(options: { highWaterMark: number }): ByteLengthQueuingStrategy; +}; + interface Cache { add(request: RequestInfo): Promise; addAll(requests: RequestInfo[]): Promise; @@ -684,6 +736,16 @@ declare var Console: { new(): Console; }; +interface CountQueuingStrategy extends QueuingStrategy { + highWaterMark: number; + size(chunk: any): 1; +} + +declare var CountQueuingStrategy: { + prototype: CountQueuingStrategy; + new(options: { highWaterMark: number }): CountQueuingStrategy; +}; + interface Crypto { readonly subtle: SubtleCrypto; getRandomValues(array: T): T; @@ -2256,20 +2318,70 @@ declare var PushSubscriptionOptions: { new(): PushSubscriptionOptions; }; -interface ReadableStream { +interface ReadableByteStreamController { + readonly byobRequest: ReadableStreamBYOBRequest | undefined; + readonly desiredSize: number | null; + close(): void; + enqueue(chunk: ArrayBufferView): void; + error(error?: any): void; +} + +interface ReadableStream { readonly locked: boolean; - cancel(): Promise; - getReader(): ReadableStreamReader; + cancel(reason?: any): Promise; + getReader(options: { mode: "byob" }): ReadableStreamBYOBReader; + getReader(): ReadableStreamDefaultReader; + pipeThrough({ writable, readable }: { writable: WritableStream, readable: ReadableStream }, options?: PipeOptions): ReadableStream; + pipeTo(dest: WritableStream, options?: PipeOptions): Promise; + tee(): [ReadableStream, ReadableStream]; } declare var ReadableStream: { prototype: ReadableStream; - new(): ReadableStream; + new(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number, size?: undefined }): ReadableStream; + new(underlyingSource?: UnderlyingSource, strategy?: QueuingStrategy): ReadableStream; +}; + +interface ReadableStreamBYOBReader { + readonly closed: Promise; + cancel(reason?: any): Promise; + read(view: T): Promise>; + releaseLock(): void; +} + +declare var ReadableStreamBYOBReader: { + prototype: ReadableStreamBYOBReader; + new(stream: ReadableStream): ReadableStreamBYOBReader; }; -interface ReadableStreamReader { +interface ReadableStreamBYOBRequest { + readonly view: ArrayBufferView; + respond(bytesWritten: number): void; + respondWithNewView(view: ArrayBufferView): void; +} + +interface ReadableStreamDefaultController { + readonly desiredSize: number | null; + close(): void; + enqueue(chunk: R): void; + error(error?: any): void; +} + +interface ReadableStreamDefaultReader { + readonly closed: Promise; + cancel(reason?: any): Promise; + read(): Promise>; + releaseLock(): void; +} + +interface ReadableStreamReadResult { + done: boolean; + value: T; +} + +interface ReadableStreamReader { cancel(): Promise; - read(): Promise; + read(): Promise>; releaseLock(): void; } @@ -2626,6 +2738,23 @@ declare var TextMetrics: { new(): TextMetrics; }; +interface TransformStream { + readonly readable: ReadableStream; + readonly writable: WritableStream; +} + +declare var TransformStream: { + prototype: TransformStream; + new(transformer?: Transformer, writableStrategy?: QueuingStrategy, readableStrategy?: QueuingStrategy): TransformStream; +}; + +interface TransformStreamDefaultController { + readonly desiredSize: number | null; + enqueue(chunk: O): void; + error(reason?: any): void; + terminate(): void; +} + interface URL { hash: string; host: string; @@ -3810,6 +3939,31 @@ interface WorkerUtils extends WindowBase64 { importScripts(...urls: string[]): void; } +interface WritableStream { + readonly locked: boolean; + abort(reason?: any): Promise; + getWriter(): WritableStreamDefaultWriter; +} + +declare var WritableStream: { + prototype: WritableStream; + new(underlyingSink?: UnderlyingSink, strategy?: QueuingStrategy): WritableStream; +}; + +interface WritableStreamDefaultController { + error(error?: any): void; +} + +interface WritableStreamDefaultWriter { + readonly closed: Promise; + readonly desiredSize: number | null; + readonly ready: Promise; + abort(reason?: any): Promise; + close(): Promise; + releaseLock(): void; + write(chunk: W): Promise; +} + interface XMLHttpRequestEventMap extends XMLHttpRequestEventTargetEventMap { "readystatechange": Event; } @@ -3971,6 +4125,46 @@ interface PerformanceObserverCallback { (entries: PerformanceObserverEntryList, observer: PerformanceObserver): void; } +interface QueuingStrategySizeCallback { + (chunk: T): number; +} + +interface ReadableByteStreamControllerCallback { + (controller: ReadableByteStreamController): void | PromiseLike; +} + +interface ReadableStreamDefaultControllerCallback { + (controller: ReadableStreamDefaultController): void | PromiseLike; +} + +interface ReadableStreamErrorCallback { + (reason: any): void | PromiseLike; +} + +interface TransformStreamDefaultControllerCallback { + (controller: TransformStreamDefaultController): void | PromiseLike; +} + +interface TransformStreamDefaultControllerTransformCallback { + (chunk: I, controller: TransformStreamDefaultController): void | PromiseLike; +} + +interface WritableStreamDefaultControllerCloseCallback { + (): void | PromiseLike; +} + +interface WritableStreamDefaultControllerStartCallback { + (controller: WritableStreamDefaultController): void | PromiseLike; +} + +interface WritableStreamDefaultControllerWriteCallback { + (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike; +} + +interface WritableStreamErrorCallback { + (reason: any): void | PromiseLike; +} + declare var onmessage: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any) | null; declare function close(): void; declare function postMessage(message: any, transfer?: Transferable[]): void; @@ -4020,7 +4214,7 @@ declare function removeEventListener; -type BodyInit = Blob | BufferSource | FormData | URLSearchParams | ReadableStream | string; +type BodyInit = Blob | BufferSource | FormData | URLSearchParams | ReadableStream | string; type RequestInfo = Request | string; type DOMHighResTimeStamp = number; type CanvasImageSource = ImageBitmap; diff --git a/inputfiles/idl/Streams.widl b/inputfiles/idl/Streams.widl new file mode 100644 index 000000000..900569ec3 --- /dev/null +++ b/inputfiles/idl/Streams.widl @@ -0,0 +1,181 @@ +[Constructor(optional UnderlyingSource underlyingSource, optional QueuingStrategy strategy), + Constructor(optional UnderlyingByteSource underlyingSource, optional QueuingStrategy strategy), + Exposed=(Window,Worker)] +interface ReadableStream { + readonly attribute boolean locked; + Promise cancel(optional any reason); + ReadableStreamBYOBReader getReader(any options); + ReadableStreamDefaultReader getReader(); + any pipeThrough(any pair, optional PipeOptions options); + Promise pipeTo(WritableStream dest, optional PipeOptions options); + [ReadableStream, ReadableStream] tee(); +}; + +callback QueuingStrategySizeCallback = double (any chunk); + +dictionary QueuingStrategy { + unrestricted double? highWaterMark; + QueuingStrategySizeCallback? size; +}; + +callback ReadableByteStreamControllerCallback = any (ReadableByteStreamController controller); +callback ReadableStreamDefaultControllerCallback = any (ReadableStreamDefaultController controller); +callback ReadableStreamErrorCallback = any (any reason); + +dictionary UnderlyingSource { + ReadableStreamDefaultControllerCallback? start; + ReadableStreamDefaultControllerCallback? pull; + ReadableStreamErrorCallback? cancel; + + any type; +}; + +dictionary UnderlyingByteSource { + ReadableByteStreamControllerCallback? start; + ReadableByteStreamControllerCallback? pull; + ReadableStreamErrorCallback? cancel; + + required DOMString type; + unsigned long? autoAllocateChunkSize; +}; + +dictionary PipeOptions { + boolean? preventClose; + boolean? preventAbort; + boolean? preventCancel; +}; + +[Exposed=(Window,Worker)] +interface ReadableStreamReadResult { + attribute boolean done; + attribute any value; +}; + +[Constructor(ReadableStream stream), + Exposed=(Window,Worker)] +interface ReadableStreamDefaultReader { + readonly attribute Promise closed; + + Promise cancel(optional any reason); + Promise read(); + void releaseLock(); +}; + +[Constructor(ReadableStream stream), + Exposed=(Window,Worker)] +interface ReadableStreamBYOBReader { + readonly attribute Promise closed; + + Promise cancel(optional any reason); + Promise read(ArrayBufferView view); + void releaseLock(); +}; + +[Exposed=(Window,Worker)] +interface ReadableStreamDefaultController { + readonly attribute unrestricted double? desiredSize; + + void close(); + void enqueue(any chunk); + void error(optional any error); +}; + +[Exposed=(Window,Worker)] +interface ReadableByteStreamController { + readonly attribute ReadableStreamBYOBRequest byobRequest; + readonly attribute unrestricted double? desiredSize; + + void close(); + void enqueue(ArrayBufferView chunk); + void error(optional any error); +}; + +[Exposed=(Window,Worker)] +interface ReadableStreamBYOBRequest { + readonly attribute ArrayBufferView view; + + void respond(unsigned long bytesWritten); + void respondWithNewView(ArrayBufferView view); +}; + +[Constructor(optional UnderlyingSink underlyingSink, optional QueuingStrategy strategy), + Exposed=(Window,Worker)] +interface WritableStream { + readonly attribute boolean locked; + Promise abort(optional any reason); + WritableStreamDefaultWriter getWriter(); +}; + +callback WritableStreamDefaultControllerStartCallback = any (WritableStreamDefaultController controller); +callback WritableStreamDefaultControllerWriteCallback = any (any chunk, WritableStreamDefaultController controller); +callback WritableStreamDefaultControllerCloseCallback = any (); +callback WritableStreamErrorCallback = any (any reason); + +dictionary UnderlyingSink { + WritableStreamDefaultControllerStartCallback? start; + WritableStreamDefaultControllerWriteCallback? write; + WritableStreamDefaultControllerCloseCallback? close; + WritableStreamErrorCallback? abort; + + any type; +}; + +[Constructor(ReadableStream stream), + Exposed=(Window,Worker)] +interface WritableStreamDefaultWriter { + readonly attribute Promise closed; + readonly attribute unrestricted double? desiredSize; + readonly attribute Promise ready; + + Promise abort(optional any reason); + Promise close(); + void releaseLock(); + Promise write(any chunk); +}; + +[Exposed=(Window,Worker)] +interface WritableStreamDefaultController { + void error(optional any error); +}; + +[Constructor(optional Transformer transformer, optional QueuingStrategy writableStrategy, optional QueuingStrategy readableStrategy), + Exposed=(Window,Worker)] +interface TransformStream { + readonly attribute ReadableStream readable; + readonly attribute WritableStream writable; +}; + +callback TransformStreamDefaultControllerCallback = any (TransformStreamDefaultController controller); +callback TransformStreamDefaultControllerTransformCallback = any (any chunk, TransformStreamDefaultController controller); + +dictionary Transformer { + TransformStreamDefaultControllerCallback? start; + TransformStreamDefaultControllerTransformCallback? transform; + TransformStreamDefaultControllerCallback? flush; + + any readableType; + any writableType; +}; + +[Exposed=(Window,Worker)] +interface TransformStreamDefaultController { + readonly attribute unrestricted double? desiredSize; + + void enqueue(any chunk); + void error(optional any reason); + void terminate(); +}; + +[Constructor(any options), + Exposed=(Window,Worker)] +interface ByteLengthQueuingStrategy: QueuingStrategy { + attribute unrestricted double highWaterMark; + double size(ArrayBufferView chunk); +}; + +[Constructor(any options), + Exposed=(Window,Worker)] +interface CountQueuingStrategy: QueuingStrategy { + attribute unrestricted double highWaterMark; + double size(any chunk); +}; diff --git a/inputfiles/idlSources.json b/inputfiles/idlSources.json index 2582c2f29..e0986acfd 100644 --- a/inputfiles/idlSources.json +++ b/inputfiles/idlSources.json @@ -210,6 +210,11 @@ "url": "https://storage.spec.whatwg.org/", "title": "Storage" }, + { + "url": "https://streams.spec.whatwg.org/", + "title": "Streams", + "local": true + }, { "url": "https://svgwg.org/svg2-draft/types.html", "title": "SVG - Basic Data Types and Interfaces" diff --git a/inputfiles/overridingTypes.json b/inputfiles/overridingTypes.json index 2304b63e3..f894a8fdd 100644 --- a/inputfiles/overridingTypes.json +++ b/inputfiles/overridingTypes.json @@ -180,6 +180,15 @@ } } } + }, + "Body": { + "properties": { + "property": { + "body": { + "override-type": "ReadableStream | null" + } + } + } } } }, @@ -196,6 +205,85 @@ "override-signatures": [ "(error: DOMException): void" ] + }, + "QueuingStrategySizeCallback": { + "type-parameters": [ + { + "name": "T", + "default": "any" + } + ], + "override-signatures": [ + "(chunk: T): number" + ] + }, + "ReadableByteStreamControllerCallback": { + "override-signatures": [ + "(controller: ReadableByteStreamController): void | PromiseLike" + ] + }, + "ReadableStreamDefaultControllerCallback": { + "type-parameters": [ + { + "name": "R" + } + ], + "override-signatures": [ + "(controller: ReadableStreamDefaultController): void | PromiseLike" + ] + }, + "ReadableStreamErrorCallback": { + "override-signatures": [ + "(reason: any): void | PromiseLike" + ] + }, + "WritableStreamDefaultControllerStartCallback": { + "override-signatures": [ + "(controller: WritableStreamDefaultController): void | PromiseLike" + ] + }, + "WritableStreamDefaultControllerWriteCallback": { + "type-parameters": [ + { + "name": "W" + } + ], + "override-signatures": [ + "(chunk: W, controller: WritableStreamDefaultController): void | PromiseLike" + ] + }, + "WritableStreamDefaultControllerCloseCallback": { + "override-signatures": [ + "(): void | PromiseLike" + ] + }, + "WritableStreamErrorCallback": { + "override-signatures": [ + "(reason: any): void | PromiseLike" + ] + }, + "TransformStreamDefaultControllerCallback": { + "type-parameters": [ + { + "name": "O" + } + ], + "override-signatures": [ + "(controller: TransformStreamDefaultController): void | PromiseLike" + ] + }, + "TransformStreamDefaultControllerTransformCallback": { + "type-parameters": [ + { + "name": "I" + }, + { + "name": "O" + } + ], + "override-signatures": [ + "(chunk: I, controller: TransformStreamDefaultController): void | PromiseLike" + ] } } }, @@ -2235,14 +2323,6 @@ } } }, - "ReadableStream": { - "name": "ReadableStream", - "override-exposed": "Window Worker" - }, - "ReadableStreamReader": { - "name": "ReadableStreamReader", - "override-exposed": "Window Worker" - }, "Worker": { "name": "Worker", "override-exposed": "Window Worker", @@ -2416,6 +2496,261 @@ } } } + }, + "ReadableStream": { + "type-parameters": [ + { + "name": "R", + "default": "any" + } + ], + "constructor": { + "override-signatures": [ + "new(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number, size?: undefined }): ReadableStream", + "new(underlyingSource?: UnderlyingSource, strategy?: QueuingStrategy): ReadableStream" + ] + }, + "methods": { + "method": { + "getReader": { + "override-signatures": [ + "getReader(options: { mode: \"byob\" }): ReadableStreamBYOBReader", + "getReader(): ReadableStreamDefaultReader" + ] + }, + "pipeThrough": { + "override-signatures": [ + "pipeThrough({ writable, readable }: { writable: WritableStream, readable: ReadableStream }, options?: PipeOptions): ReadableStream" + ] + }, + "pipeTo": { + "override-signatures": [ + "pipeTo(dest: WritableStream, options?: PipeOptions): Promise" + ] + }, + "tee": { + "override-signatures": [ + "tee(): [ReadableStream, ReadableStream]" + ] + } + } + } + }, + "ReadableStreamReader": { + "override-exposed": "Window Worker", + "type-parameters": [ + { + "name": "R", + "default": "any" + } + ], + "methods": { + "method": { + "read": { + "override-signatures": [ + "read(): Promise>" + ] + } + } + } + }, + "ReadableStreamReadResult": { + "type-parameters": [ + { + "name": "T" + } + ], + "properties": { + "property": { + "value": { + "override-type": "T" + } + } + }, + "no-interface-object": "1" + }, + "ReadableStreamBYOBReader": { + "constructor": { + "override-signatures": [ + "new(stream: ReadableStream): ReadableStreamBYOBReader" + ] + }, + "methods": { + "method": { + "read": { + "override-signatures": [ + "read(view: T): Promise>" + ] + } + } + } + }, + "ReadableStreamBYOBRequest": { + "no-interface-object": 1 + }, + "ReadableStreamDefaultReader": { + "type-parameters": [ + { + "name": "R", + "default": "any" + } + ], + "methods": { + "method": { + "read": { + "override-signatures": [ + "read(): Promise>" + ] + } + } + }, + "no-interface-object": 1 + }, + "ReadableByteStreamController": { + "properties": { + "property": { + "byobRequest": { + "override-type": "ReadableStreamBYOBRequest | undefined" + } + } + }, + "no-interface-object": 1 + }, + "ReadableStreamDefaultController": { + "type-parameters": [ + { + "name": "R", + "default": "any" + } + ], + "methods": { + "method": { + "enqueue": { + "override-signatures": [ + "enqueue(chunk: R): void" + ] + } + } + }, + "no-interface-object": 1 + }, + "WritableStream": { + "override-exposed": "Window Worker", + "constructor": { + "override-signatures": [ + "new(underlyingSink?: UnderlyingSink, strategy?: QueuingStrategy): WritableStream" + ] + }, + "type-parameters": [ + { + "name": "W", + "default": "any" + } + ], + "methods": { + "method": { + "getWriter": { + "override-signatures": [ + "getWriter(): WritableStreamDefaultWriter" + ] + } + } + } + }, + "WritableStreamDefaultController": { + "override-exposed": "Window Worker", + "no-interface-object": 1 + }, + "WritableStreamDefaultWriter": { + "override-exposed": "Window Worker", + "type-parameters": [ + { + "name": "W", + "default": "any" + } + ], + "methods": { + "method": { + "write": { + "override-signatures": [ + "write(chunk: W): Promise" + ] + } + } + }, + "no-interface-object": 1 + }, + "TransformStream": { + "type-parameters": [ + { + "name": "I", + "default": "any" + }, + { + "name": "O", + "default": "any" + } + ], + "properties": { + "property": { + "readable": { + "override-type": "ReadableStream" + }, + "writable": { + "override-type": "WritableStream" + } + } + }, + "constructor": { + "override-signatures": [ + "new(transformer?: Transformer, writableStrategy?: QueuingStrategy, readableStrategy?: QueuingStrategy): TransformStream" + ] + } + }, + "TransformStreamDefaultController": { + "override-exposed": "Window Worker", + "type-parameters": [ + { + "name": "O", + "default": "any" + } + ], + "methods": { + "method": { + "enqueue": { + "override-signatures": [ + "enqueue(chunk: O): void" + ] + } + } + }, + "no-interface-object": 1 + }, + "ByteLengthQueuingStrategy": { + "override-exposed": "Window Worker", + "extends": "QueuingStrategy", + "constructor": { + "override-signatures": [ + "new(options: { highWaterMark: number }): ByteLengthQueuingStrategy" + ] + } + }, + "CountQueuingStrategy": { + "override-exposed": "Window Worker", + "constructor": { + "override-signatures": [ + "new(options: { highWaterMark: number }): CountQueuingStrategy" + ] + }, + "methods": { + "method": { + "size": { + "override-signatures": [ + "size(chunk: any): 1" + ] + } + } + } } } }, @@ -2616,10 +2951,158 @@ "override-index-signatures": [ "[property: string]: string | number | null | undefined" ] + }, + "PipeOptions": { + "members": { + "member": { + "preventClose": { + "nullable": 0 + }, + "preventAbort": { + "nullable": 0 + }, + "preventCancel": { + "nullable": 0 + } + } + } + }, + "QueuingStrategy": { + "type-parameters": [ + { + "name": "T", + "default": "any" + } + ], + "members": { + "member": { + "highWaterMark": { + "nullable": 0 + }, + "size": { + "override-type": "QueuingStrategySizeCallback", + "nullable": 0 + } + } + } + }, + "UnderlyingByteSource": { + "members": { + "member": { + "start": { + "nullable": 0 + }, + "pull": { + "nullable": 0 + }, + "cancel": { + "nullable": 0 + }, + "autoAllocateChunkSize": { + "nullable": 0 + }, + "type": { + "override-type": "\"bytes\"" + } + } + } + }, + "UnderlyingSource": { + "type-parameters": [ + { + "name": "R", + "default": "any" + } + ], + "members": { + "member": { + "start": { + "override-type": "ReadableStreamDefaultControllerCallback", + "nullable": 0 + }, + "pull": { + "override-type": "ReadableStreamDefaultControllerCallback", + "nullable": 0 + }, + "cancel": { + "nullable": 0 + }, + "type": { + "override-type": "undefined" + } + } + } + }, + "UnderlyingSink": { + "type-parameters": [ + { + "name": "W", + "default": "any" + } + ], + "members": { + "member": { + "start": { + "nullable": 0 + }, + "write": { + "override-type": "WritableStreamDefaultControllerWriteCallback", + "nullable": 0 + }, + "close": { + "nullable": 0 + }, + "abort": { + "nullable": 0 + }, + "type": { + "override-type": "undefined" + } + } + } + }, + "Transformer": { + "type-parameters": [ + { + "name": "I", + "default": "any" + }, + { + "name": "O", + "default": "any" + } + ], + "members": { + "member": { + "start": { + "override-type": "TransformStreamDefaultControllerCallback", + "nullable": 0 + }, + "transform": { + "override-type": "TransformStreamDefaultControllerTransformCallback", + "nullable": 0 + }, + "flush": { + "override-type": "TransformStreamDefaultControllerCallback", + "nullable": 0 + }, + "readableType": { + "override-type": "undefined" + }, + "writableType": { + "override-type": "undefined" + } + } + } } } }, "typedefs": { - "typedef": [] + "typedef": [ + { + "override-type": "Blob | BufferSource | FormData | URLSearchParams | ReadableStream | string", + "new-type": "BodyInit" + } + ] } } diff --git a/src/emitter.ts b/src/emitter.ts index 67c02d950..6dc3cbca5 100644 --- a/src/emitter.ts +++ b/src/emitter.ts @@ -388,9 +388,11 @@ export function emitWebIDl(webidl: Browser.WebIdl, flavor: Flavor) { expectedParamType.every((pt, idx) => convertDomTypeToTsType(m.signature[0].param![idx]) === pt); } - function processInterfaceType(i: Browser.Interface | Browser.Dictionary, name: string) { + function processInterfaceType(i: Browser.Interface | Browser.Dictionary | Browser.CallbackFunction, name: string) { function typeParameterWithDefault (type: Browser.TypeParameter) { - return type.default ? type.name + " = " + type.default : type.name + return `${type.name}` + + (type.extends ? ` extends ${type.extends}` : ``) + + (type.default ? ` = ${type.default}` : ``) } return i["type-parameters"] ? name + "<" + i["type-parameters"]!.map(typeParameterWithDefault).join(", ") + ">" : name; @@ -527,7 +529,7 @@ export function emitWebIDl(webidl: Browser.WebIdl, flavor: Flavor) { } function emitCallBackFunction(cb: Browser.CallbackFunction) { - printer.printLine(`interface ${cb.name} {`); + printer.printLine(`interface ${processInterfaceType(cb, cb.name)} {`); printer.increaseIndent(); emitSignatures(cb, "", "", s => printer.printLine(s)); printer.decreaseIndent(); diff --git a/src/fetcher.ts b/src/fetcher.ts index 3054611ee..55ef42204 100644 --- a/src/fetcher.ts +++ b/src/fetcher.ts @@ -9,6 +9,7 @@ interface IDLSource { url: string; title: string; deprecated?: boolean; + local?: boolean; } const idlSelector = [ @@ -23,6 +24,9 @@ async function fetchIDLs(filter: string[]) { const idlSources = (require("../inputfiles/idlSources.json") as IDLSource[]) .filter(source => !filter.length || filter.includes(source.title)); await Promise.all(idlSources.map(async source => { + if (source.local) { + return; + } const { idl, comments } = await fetchIDL(source); fs.writeFileSync(path.join(__dirname, `../inputfiles/idl/${source.title}.widl`), idl + '\n'); if (comments) { diff --git a/src/types.d.ts b/src/types.d.ts index db381cbc0..c5e13b948 100644 --- a/src/types.d.ts +++ b/src/types.d.ts @@ -103,6 +103,7 @@ export interface CallbackFunction { tags?: string; "override-signatures"?: string[]; specs?: string; + "type-parameters"?: TypeParameter[]; } export interface Constructor { @@ -141,6 +142,7 @@ export interface Element { export interface TypeParameter { name: string; + extends?: string; default?: string; }