From 551dd078fbf1ec29366d42e00ea7a0f2fc811afc Mon Sep 17 00:00:00 2001 From: Mattias Buelens Date: Fri, 25 Jun 2021 22:07:22 +0200 Subject: [PATCH 01/13] Add readable byte streams --- inputfiles/addedTypes.jsonc | 14 +++++++++--- inputfiles/overridingTypes.jsonc | 37 +++++++++++++++++++++++--------- inputfiles/removedTypes.jsonc | 23 -------------------- 3 files changed, 38 insertions(+), 36 deletions(-) diff --git a/inputfiles/addedTypes.jsonc b/inputfiles/addedTypes.jsonc index 738837c91..330418863 100644 --- a/inputfiles/addedTypes.jsonc +++ b/inputfiles/addedTypes.jsonc @@ -1155,6 +1155,11 @@ }, "ReadableStreamReadDoneResult": { "name": "ReadableStreamReadDoneResult", + "typeParameters": [ + { + "name": "T" + } + ], "members": { "member": { "done": { @@ -1164,7 +1169,7 @@ }, "value": { "name": "value", - "overrideType": "undefined" + "overrideType": "T" } } } @@ -1302,7 +1307,7 @@ "type": "ReadableStreamReadDoneResult" } ], - "overrideType": "ReadableStreamReadValueResult | ReadableStreamReadDoneResult" + "overrideType": "ReadableStreamReadValueResult | ReadableStreamReadDoneResult" }, { "name": "ReadableStreamReader", @@ -1314,9 +1319,12 @@ "type": [ { "type": "ReadableStreamDefaultReader" + }, + { + "type": "ReadableStreamBYOBReader" } ], - "overrideType": "ReadableStreamDefaultReader" + "overrideType": "ReadableStreamDefaultReader | ReadableStreamBYOBReader" }, { "name": "EventListenerOrEventListenerObject", diff --git a/inputfiles/overridingTypes.jsonc b/inputfiles/overridingTypes.jsonc index 0d6fd1176..1de008bed 100644 --- a/inputfiles/overridingTypes.jsonc +++ b/inputfiles/overridingTypes.jsonc @@ -2380,11 +2380,23 @@ "methods": { "method": { "getReader": { + "additionalSignatures": [ + "getReader(options: { mode: \"byob\" }): ReadableStreamBYOBReader", + "getReader(): ReadableStreamDefaultReader" + ], "signature": { "0": { - "overrideType": "ReadableStreamDefaultReader" + "overrideType": "ReadableStreamReader" } - } + }, + "force-references": [ + { + "type": "ReadableStreamDefaultReader" + }, + { + "type": "ReadableStreamBYOBReader" + } + ] }, "pipeThrough": { "signature": { @@ -2432,11 +2444,19 @@ "read": { "signature": { "0": { - "subtype": { - "subtype": { - "type": "ArrayBufferView" + "typeParameters": [ + { + "name": "T", + "extends": "ArrayBufferView" } - } + ], + "param": [ + { + "name": "view", + "overrideType": "T" + } + ], + "overrideType": "Promise>" } } } @@ -3167,9 +3187,6 @@ }, "pull": { "overrideType": "UnderlyingSourcePullCallback" - }, - "type": { - "overrideType": "undefined" } } } @@ -3264,7 +3281,7 @@ "typedefs": { "typedef": [ { - "overrideType": "ReadableStreamDefaultController", + "overrideType": "ReadableStreamDefaultController | ReadableByteStreamController", "name": "ReadableStreamController", "typeParameters": [ { diff --git a/inputfiles/removedTypes.jsonc b/inputfiles/removedTypes.jsonc index 7fd9632a8..78641cd12 100644 --- a/inputfiles/removedTypes.jsonc +++ b/inputfiles/removedTypes.jsonc @@ -19,8 +19,6 @@ "CredentialMediationRequirement": { "value": ["conditional"] // tied to Credential#isConditionalMediationAvailable }, - "ReadableStreamReaderMode": null, - "ReadableStreamType": null, "RTCStatsType": { "value": [ "stream", @@ -73,19 +71,6 @@ "NetworkInformation": { "implements": ["NetworkInformationSaveData"] }, - "ReadableStream": { - "methods": { - "method": { - "getReader": { - "signature": { - "0": { - "param": ["options"] - } - } - } - } - } - }, "Response": { "methods": { "method": { @@ -377,7 +362,6 @@ } }, "ReadableStreamReadResult": null, - "ReadableStreamGetReaderOptions": null, "RequestInit": { "members": { "member": { @@ -575,13 +559,6 @@ } } }, - "UnderlyingSource": { - "members": { - "member": { - "autoAllocateChunkSize": null - } - } - }, "VideoConfiguration": { "members": { "member": { From 64ea82a4fc7ab670afb786741348225d2760a9e8 Mon Sep 17 00:00:00 2001 From: Mattias Buelens Date: Fri, 25 Jun 2021 22:39:19 +0200 Subject: [PATCH 02/13] Move ReadableStreamReader to overridingTypes --- inputfiles/addedTypes.jsonc | 17 ----------------- inputfiles/overridingTypes.jsonc | 17 +++++++++++++++++ 2 files changed, 17 insertions(+), 17 deletions(-) diff --git a/inputfiles/addedTypes.jsonc b/inputfiles/addedTypes.jsonc index 330418863..04490b3a9 100644 --- a/inputfiles/addedTypes.jsonc +++ b/inputfiles/addedTypes.jsonc @@ -1309,23 +1309,6 @@ ], "overrideType": "ReadableStreamReadValueResult | ReadableStreamReadDoneResult" }, - { - "name": "ReadableStreamReader", - "typeParameters": [ - { - "name": "T" - } - ], - "type": [ - { - "type": "ReadableStreamDefaultReader" - }, - { - "type": "ReadableStreamBYOBReader" - } - ], - "overrideType": "ReadableStreamDefaultReader | ReadableStreamBYOBReader" - }, { "name": "EventListenerOrEventListenerObject", "overrideType": "EventListener | EventListenerObject" diff --git a/inputfiles/overridingTypes.jsonc b/inputfiles/overridingTypes.jsonc index 1de008bed..7c01ed91e 100644 --- a/inputfiles/overridingTypes.jsonc +++ b/inputfiles/overridingTypes.jsonc @@ -3288,6 +3288,23 @@ "name": "T" } ] + }, + { + "name": "ReadableStreamReader", + "typeParameters": [ + { + "name": "T" + } + ], + "type": [ + { + "type": "ReadableStreamDefaultReader" + }, + { + "type": "ReadableStreamBYOBReader" + } + ], + "overrideType": "ReadableStreamDefaultReader | ReadableStreamBYOBReader" } ] }, From 55c6849908eb79d74f2d9b8ccb6d85fcae560365 Mon Sep 17 00:00:00 2001 From: Mattias Buelens Date: Tue, 19 Jul 2022 19:04:52 +0200 Subject: [PATCH 03/13] Update baselines --- baselines/audioworklet.generated.d.ts | 28 +++++++++++++++++++------- baselines/dom.generated.d.ts | 28 +++++++++++++++++++------- baselines/serviceworker.generated.d.ts | 28 +++++++++++++++++++------- baselines/sharedworker.generated.d.ts | 28 +++++++++++++++++++------- baselines/webworker.generated.d.ts | 28 +++++++++++++++++++------- 5 files changed, 105 insertions(+), 35 deletions(-) diff --git a/baselines/audioworklet.generated.d.ts b/baselines/audioworklet.generated.d.ts index 1f6f1241f..dd14ad829 100644 --- a/baselines/audioworklet.generated.d.ts +++ b/baselines/audioworklet.generated.d.ts @@ -75,9 +75,18 @@ interface QueuingStrategyInit { highWaterMark: number; } -interface ReadableStreamReadDoneResult { +interface ReadableStreamGetReaderOptions { + /** + * Creates a ReadableStreamBYOBReader and locks the stream to the new reader. + * + * This call behaves the same way as the no-argument variant, except that it only works on readable byte streams, i.e. streams which were constructed specifically with the ability to handle "bring your own buffer" reading. The returned BYOB reader provides the ability to directly read individual chunks from the stream via its read() method, into developer-supplied buffers, allowing more precise control over allocation. + */ + mode?: ReadableStreamReaderMode; +} + +interface ReadableStreamReadDoneResult { done: true; - value?: undefined; + value?: T; } interface ReadableStreamReadValueResult { @@ -154,10 +163,11 @@ interface UnderlyingSink { } interface UnderlyingSource { + autoAllocateChunkSize?: number; cancel?: UnderlyingSourceCancelCallback; pull?: UnderlyingSourcePullCallback; start?: UnderlyingSourceStartCallback; - type?: undefined; + type?: ReadableStreamType; } /** A controller object that allows you to abort one or more DOM requests as and when desired. */ @@ -529,7 +539,9 @@ declare var ReadableByteStreamController: { interface ReadableStream { readonly locked: boolean; cancel(reason?: any): Promise; + getReader(options: { mode: "byob" }): ReadableStreamBYOBReader; getReader(): ReadableStreamDefaultReader; + getReader(options?: ReadableStreamGetReaderOptions): ReadableStreamReader; pipeThrough(transform: ReadableWritablePair, options?: StreamPipeOptions): ReadableStream; pipeTo(destination: WritableStream, options?: StreamPipeOptions): Promise; tee(): [ReadableStream, ReadableStream]; @@ -541,7 +553,7 @@ declare var ReadableStream: { }; interface ReadableStreamBYOBReader extends ReadableStreamGenericReader { - read(view: ArrayBufferView): Promise>; + read(view: T): Promise>; releaseLock(): void; } @@ -990,7 +1002,9 @@ type DOMHighResTimeStamp = number; type EventListenerOrEventListenerObject = EventListener | EventListenerObject; type MessageEventSource = MessagePort; type PerformanceEntryList = PerformanceEntry[]; -type ReadableStreamController = ReadableStreamDefaultController; -type ReadableStreamReadResult = ReadableStreamReadValueResult | ReadableStreamReadDoneResult; -type ReadableStreamReader = ReadableStreamDefaultReader; +type ReadableStreamController = ReadableStreamDefaultController | ReadableByteStreamController; +type ReadableStreamReadResult = ReadableStreamReadValueResult | ReadableStreamReadDoneResult; +type ReadableStreamReader = ReadableStreamDefaultReader | ReadableStreamBYOBReader; type Transferable = ArrayBuffer | MessagePort; +type ReadableStreamReaderMode = "byob"; +type ReadableStreamType = "bytes"; diff --git a/baselines/dom.generated.d.ts b/baselines/dom.generated.d.ts index 053ccb504..5603914d3 100644 --- a/baselines/dom.generated.d.ts +++ b/baselines/dom.generated.d.ts @@ -1485,9 +1485,18 @@ interface RTCTransportStats extends RTCStats { tlsVersion?: string; } -interface ReadableStreamReadDoneResult { +interface ReadableStreamGetReaderOptions { + /** + * Creates a ReadableStreamBYOBReader and locks the stream to the new reader. + * + * This call behaves the same way as the no-argument variant, except that it only works on readable byte streams, i.e. streams which were constructed specifically with the ability to handle "bring your own buffer" reading. The returned BYOB reader provides the ability to directly read individual chunks from the stream via its read() method, into developer-supplied buffers, allowing more precise control over allocation. + */ + mode?: ReadableStreamReaderMode; +} + +interface ReadableStreamReadDoneResult { done: true; - value?: undefined; + value?: T; } interface ReadableStreamReadValueResult { @@ -1780,10 +1789,11 @@ interface UnderlyingSink { } interface UnderlyingSource { + autoAllocateChunkSize?: number; cancel?: UnderlyingSourceCancelCallback; pull?: UnderlyingSourcePullCallback; start?: UnderlyingSourceStartCallback; - type?: undefined; + type?: ReadableStreamType; } interface ValidityStateFlags { @@ -11365,7 +11375,9 @@ declare var ReadableByteStreamController: { interface ReadableStream { readonly locked: boolean; cancel(reason?: any): Promise; + getReader(options: { mode: "byob" }): ReadableStreamBYOBReader; getReader(): ReadableStreamDefaultReader; + getReader(options?: ReadableStreamGetReaderOptions): ReadableStreamReader; pipeThrough(transform: ReadableWritablePair, options?: StreamPipeOptions): ReadableStream; pipeTo(destination: WritableStream, options?: StreamPipeOptions): Promise; tee(): [ReadableStream, ReadableStream]; @@ -11377,7 +11389,7 @@ declare var ReadableStream: { }; interface ReadableStreamBYOBReader extends ReadableStreamGenericReader { - read(view: ArrayBufferView): Promise>; + read(view: T): Promise>; releaseLock(): void; } @@ -18080,9 +18092,9 @@ type NamedCurve = string; type OnBeforeUnloadEventHandler = OnBeforeUnloadEventHandlerNonNull | null; type OnErrorEventHandler = OnErrorEventHandlerNonNull | null; type PerformanceEntryList = PerformanceEntry[]; -type ReadableStreamController = ReadableStreamDefaultController; -type ReadableStreamReadResult = ReadableStreamReadValueResult | ReadableStreamReadDoneResult; -type ReadableStreamReader = ReadableStreamDefaultReader; +type ReadableStreamController = ReadableStreamDefaultController | ReadableByteStreamController; +type ReadableStreamReadResult = ReadableStreamReadValueResult | ReadableStreamReadDoneResult; +type ReadableStreamReader = ReadableStreamDefaultReader | ReadableStreamBYOBReader; type RenderingContext = CanvasRenderingContext2D | ImageBitmapRenderingContext | WebGLRenderingContext | WebGL2RenderingContext; type RequestInfo = Request | string; type TexImageSource = ImageBitmap | ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement; @@ -18209,6 +18221,8 @@ type RTCSdpType = "answer" | "offer" | "pranswer" | "rollback"; type RTCSignalingState = "closed" | "have-local-offer" | "have-local-pranswer" | "have-remote-offer" | "have-remote-pranswer" | "stable"; type RTCStatsIceCandidatePairState = "failed" | "frozen" | "in-progress" | "inprogress" | "succeeded" | "waiting"; type RTCStatsType = "candidate-pair" | "certificate" | "codec" | "csrc" | "data-channel" | "inbound-rtp" | "local-candidate" | "media-source" | "outbound-rtp" | "peer-connection" | "remote-candidate" | "remote-inbound-rtp" | "remote-outbound-rtp" | "track" | "transport"; +type ReadableStreamReaderMode = "byob"; +type ReadableStreamType = "bytes"; type ReadyState = "closed" | "ended" | "open"; type RecordingState = "inactive" | "paused" | "recording"; type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url"; diff --git a/baselines/serviceworker.generated.d.ts b/baselines/serviceworker.generated.d.ts index 3e7ff5c77..b7a54cc62 100644 --- a/baselines/serviceworker.generated.d.ts +++ b/baselines/serviceworker.generated.d.ts @@ -464,9 +464,18 @@ interface QueuingStrategyInit { highWaterMark: number; } -interface ReadableStreamReadDoneResult { +interface ReadableStreamGetReaderOptions { + /** + * Creates a ReadableStreamBYOBReader and locks the stream to the new reader. + * + * This call behaves the same way as the no-argument variant, except that it only works on readable byte streams, i.e. streams which were constructed specifically with the ability to handle "bring your own buffer" reading. The returned BYOB reader provides the ability to directly read individual chunks from the stream via its read() method, into developer-supplied buffers, allowing more precise control over allocation. + */ + mode?: ReadableStreamReaderMode; +} + +interface ReadableStreamReadDoneResult { done: true; - value?: undefined; + value?: T; } interface ReadableStreamReadValueResult { @@ -631,10 +640,11 @@ interface UnderlyingSink { } interface UnderlyingSource { + autoAllocateChunkSize?: number; cancel?: UnderlyingSourceCancelCallback; pull?: UnderlyingSourcePullCallback; start?: UnderlyingSourceStartCallback; - type?: undefined; + type?: ReadableStreamType; } interface VideoConfiguration { @@ -2593,7 +2603,9 @@ declare var ReadableByteStreamController: { interface ReadableStream { readonly locked: boolean; cancel(reason?: any): Promise; + getReader(options: { mode: "byob" }): ReadableStreamBYOBReader; getReader(): ReadableStreamDefaultReader; + getReader(options?: ReadableStreamGetReaderOptions): ReadableStreamReader; pipeThrough(transform: ReadableWritablePair, options?: StreamPipeOptions): ReadableStream; pipeTo(destination: WritableStream, options?: StreamPipeOptions): Promise; tee(): [ReadableStream, ReadableStream]; @@ -2605,7 +2617,7 @@ declare var ReadableStream: { }; interface ReadableStreamBYOBReader extends ReadableStreamGenericReader { - read(view: ArrayBufferView): Promise>; + read(view: T): Promise>; releaseLock(): void; } @@ -5571,9 +5583,9 @@ type NamedCurve = string; type OnErrorEventHandler = OnErrorEventHandlerNonNull | null; type PerformanceEntryList = PerformanceEntry[]; type PushMessageDataInit = BufferSource | string; -type ReadableStreamController = ReadableStreamDefaultController; -type ReadableStreamReadResult = ReadableStreamReadValueResult | ReadableStreamReadDoneResult; -type ReadableStreamReader = ReadableStreamDefaultReader; +type ReadableStreamController = ReadableStreamDefaultController | ReadableByteStreamController; +type ReadableStreamReadResult = ReadableStreamReadValueResult | ReadableStreamReadDoneResult; +type ReadableStreamReader = ReadableStreamDefaultReader | ReadableStreamBYOBReader; type RequestInfo = Request | string; type TexImageSource = ImageBitmap | ImageData | OffscreenCanvas; type TimerHandler = string | Function; @@ -5610,6 +5622,8 @@ type PermissionState = "denied" | "granted" | "prompt"; type PredefinedColorSpace = "display-p3" | "srgb"; type PremultiplyAlpha = "default" | "none" | "premultiply"; type PushEncryptionKeyName = "auth" | "p256dh"; +type ReadableStreamReaderMode = "byob"; +type ReadableStreamType = "bytes"; type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url"; type RequestCache = "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload"; type RequestCredentials = "include" | "omit" | "same-origin"; diff --git a/baselines/sharedworker.generated.d.ts b/baselines/sharedworker.generated.d.ts index 0b371128e..795893320 100644 --- a/baselines/sharedworker.generated.d.ts +++ b/baselines/sharedworker.generated.d.ts @@ -430,9 +430,18 @@ interface QueuingStrategyInit { highWaterMark: number; } -interface ReadableStreamReadDoneResult { +interface ReadableStreamGetReaderOptions { + /** + * Creates a ReadableStreamBYOBReader and locks the stream to the new reader. + * + * This call behaves the same way as the no-argument variant, except that it only works on readable byte streams, i.e. streams which were constructed specifically with the ability to handle "bring your own buffer" reading. The returned BYOB reader provides the ability to directly read individual chunks from the stream via its read() method, into developer-supplied buffers, allowing more precise control over allocation. + */ + mode?: ReadableStreamReaderMode; +} + +interface ReadableStreamReadDoneResult { done: true; - value?: undefined; + value?: T; } interface ReadableStreamReadValueResult { @@ -597,10 +606,11 @@ interface UnderlyingSink { } interface UnderlyingSource { + autoAllocateChunkSize?: number; cancel?: UnderlyingSourceCancelCallback; pull?: UnderlyingSourcePullCallback; start?: UnderlyingSourceStartCallback; - type?: undefined; + type?: ReadableStreamType; } interface VideoConfiguration { @@ -2472,7 +2482,9 @@ declare var ReadableByteStreamController: { interface ReadableStream { readonly locked: boolean; cancel(reason?: any): Promise; + getReader(options: { mode: "byob" }): ReadableStreamBYOBReader; getReader(): ReadableStreamDefaultReader; + getReader(options?: ReadableStreamGetReaderOptions): ReadableStreamReader; pipeThrough(transform: ReadableWritablePair, options?: StreamPipeOptions): ReadableStream; pipeTo(destination: WritableStream, options?: StreamPipeOptions): Promise; tee(): [ReadableStream, ReadableStream]; @@ -2484,7 +2496,7 @@ declare var ReadableStream: { }; interface ReadableStreamBYOBReader extends ReadableStreamGenericReader { - read(view: ArrayBufferView): Promise>; + read(view: T): Promise>; releaseLock(): void; } @@ -5584,9 +5596,9 @@ type MessageEventSource = MessagePort | ServiceWorker; type NamedCurve = string; type OnErrorEventHandler = OnErrorEventHandlerNonNull | null; type PerformanceEntryList = PerformanceEntry[]; -type ReadableStreamController = ReadableStreamDefaultController; -type ReadableStreamReadResult = ReadableStreamReadValueResult | ReadableStreamReadDoneResult; -type ReadableStreamReader = ReadableStreamDefaultReader; +type ReadableStreamController = ReadableStreamDefaultController | ReadableByteStreamController; +type ReadableStreamReadResult = ReadableStreamReadValueResult | ReadableStreamReadDoneResult; +type ReadableStreamReader = ReadableStreamDefaultReader | ReadableStreamBYOBReader; type RequestInfo = Request | string; type TexImageSource = ImageBitmap | ImageData | OffscreenCanvas; type TimerHandler = string | Function; @@ -5621,6 +5633,8 @@ type PermissionState = "denied" | "granted" | "prompt"; type PredefinedColorSpace = "display-p3" | "srgb"; type PremultiplyAlpha = "default" | "none" | "premultiply"; type PushEncryptionKeyName = "auth" | "p256dh"; +type ReadableStreamReaderMode = "byob"; +type ReadableStreamType = "bytes"; type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url"; type RequestCache = "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload"; type RequestCredentials = "include" | "omit" | "same-origin"; diff --git a/baselines/webworker.generated.d.ts b/baselines/webworker.generated.d.ts index e8c35828b..532321491 100644 --- a/baselines/webworker.generated.d.ts +++ b/baselines/webworker.generated.d.ts @@ -480,9 +480,18 @@ interface RTCEncodedVideoFrameMetadata { width?: number; } -interface ReadableStreamReadDoneResult { +interface ReadableStreamGetReaderOptions { + /** + * Creates a ReadableStreamBYOBReader and locks the stream to the new reader. + * + * This call behaves the same way as the no-argument variant, except that it only works on readable byte streams, i.e. streams which were constructed specifically with the ability to handle "bring your own buffer" reading. The returned BYOB reader provides the ability to directly read individual chunks from the stream via its read() method, into developer-supplied buffers, allowing more precise control over allocation. + */ + mode?: ReadableStreamReaderMode; +} + +interface ReadableStreamReadDoneResult { done: true; - value?: undefined; + value?: T; } interface ReadableStreamReadValueResult { @@ -647,10 +656,11 @@ interface UnderlyingSink { } interface UnderlyingSource { + autoAllocateChunkSize?: number; cancel?: UnderlyingSourceCancelCallback; pull?: UnderlyingSourcePullCallback; start?: UnderlyingSourceStartCallback; - type?: undefined; + type?: ReadableStreamType; } interface VideoColorSpaceInit { @@ -2691,7 +2701,9 @@ declare var ReadableByteStreamController: { interface ReadableStream { readonly locked: boolean; cancel(reason?: any): Promise; + getReader(options: { mode: "byob" }): ReadableStreamBYOBReader; getReader(): ReadableStreamDefaultReader; + getReader(options?: ReadableStreamGetReaderOptions): ReadableStreamReader; pipeThrough(transform: ReadableWritablePair, options?: StreamPipeOptions): ReadableStream; pipeTo(destination: WritableStream, options?: StreamPipeOptions): Promise; tee(): [ReadableStream, ReadableStream]; @@ -2703,7 +2715,7 @@ declare var ReadableStream: { }; interface ReadableStreamBYOBReader extends ReadableStreamGenericReader { - read(view: ArrayBufferView): Promise>; + read(view: T): Promise>; releaseLock(): void; } @@ -5876,9 +5888,9 @@ type NamedCurve = string; type OnErrorEventHandler = OnErrorEventHandlerNonNull | null; type PerformanceEntryList = PerformanceEntry[]; type PushMessageDataInit = BufferSource | string; -type ReadableStreamController = ReadableStreamDefaultController; -type ReadableStreamReadResult = ReadableStreamReadValueResult | ReadableStreamReadDoneResult; -type ReadableStreamReader = ReadableStreamDefaultReader; +type ReadableStreamController = ReadableStreamDefaultController | ReadableByteStreamController; +type ReadableStreamReadResult = ReadableStreamReadValueResult | ReadableStreamReadDoneResult; +type ReadableStreamReader = ReadableStreamDefaultReader | ReadableStreamBYOBReader; type RequestInfo = Request | string; type TexImageSource = ImageBitmap | ImageData | OffscreenCanvas; type TimerHandler = string | Function; @@ -5916,6 +5928,8 @@ type PredefinedColorSpace = "display-p3" | "srgb"; type PremultiplyAlpha = "default" | "none" | "premultiply"; type PushEncryptionKeyName = "auth" | "p256dh"; type RTCEncodedVideoFrameType = "delta" | "empty" | "key"; +type ReadableStreamReaderMode = "byob"; +type ReadableStreamType = "bytes"; type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url"; type RequestCache = "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload"; type RequestCredentials = "include" | "omit" | "same-origin"; From 27e6d7b597d81d8d8123d25450f9b8edb330fe1e Mon Sep 17 00:00:00 2001 From: Mattias Buelens Date: Wed, 20 Jul 2022 23:54:59 +0200 Subject: [PATCH 04/13] Add unit test for getReader() --- unittests/files/streams.ts | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 unittests/files/streams.ts diff --git a/unittests/files/streams.ts b/unittests/files/streams.ts new file mode 100644 index 000000000..d095d3708 --- /dev/null +++ b/unittests/files/streams.ts @@ -0,0 +1,9 @@ +const readable = new ReadableStream({ + type: "bytes", +}); + +const defaultReader = readable.getReader(); +defaultReader.read(); + +const byobReader = readable.getReader({ mode: "byob" }); +byobReader.read(new Uint8Array(1)); From 488bbdec5adb29b1ffa9ce533c41c50287f0b2be Mon Sep 17 00:00:00 2001 From: Mattias Buelens Date: Wed, 20 Jul 2022 23:57:10 +0200 Subject: [PATCH 05/13] Add unit test for byobReader.read() --- unittests/files/streams.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/unittests/files/streams.ts b/unittests/files/streams.ts index d095d3708..69d3cbddd 100644 --- a/unittests/files/streams.ts +++ b/unittests/files/streams.ts @@ -7,3 +7,8 @@ defaultReader.read(); const byobReader = readable.getReader({ mode: "byob" }); byobReader.read(new Uint8Array(1)); +byobReader.read(new DataView(new ArrayBuffer(1))).then((result) => { + if (!result.done) { + result.value.getUint8(0); + } +}); From 536a67aca762d5b0f66706dae6146b8680fbcab5 Mon Sep 17 00:00:00 2001 From: Mattias Buelens Date: Thu, 21 Jul 2022 00:40:42 +0200 Subject: [PATCH 06/13] Add separate constructors for byte streams and non-byte streams --- inputfiles/addedTypes.jsonc | 57 ++++++++++++++++++++++++++++++++ inputfiles/overridingTypes.jsonc | 43 ++++++++++++++++++++++++ 2 files changed, 100 insertions(+) diff --git a/inputfiles/addedTypes.jsonc b/inputfiles/addedTypes.jsonc index 04490b3a9..c710b7576 100644 --- a/inputfiles/addedTypes.jsonc +++ b/inputfiles/addedTypes.jsonc @@ -1195,6 +1195,63 @@ } } } + }, + "UnderlyingByteSource": { + "name": "UnderlyingByteSource", + "members": { + "member": { + "type": { + "name": "type", + "required": true, + "overrideType": "\"bytes\"" + }, + "autoAllocateChunkSize": { + "name": "autoAllocateChunkSize", + "overrideType": "number" + }, + "start": { + "name": "start", + "overrideType": "(controller: ReadableByteStreamController) => any" + }, + "pull": { + "name": "pull", + "overrideType": "(controller: ReadableByteStreamController) => void | PromiseLike" + }, + "cancel": { + "name": "cancel", + "type": "UnderlyingSourceCancelCallback" + } + } + } + }, + "UnderlyingDefaultSource": { + "name": "UnderlyingDefaultSource", + "typeParameters": [ + { + "name": "R", + "default": "any" + } + ], + "members": { + "member": { + "type": { + "name": "type", + "type": "undefined" + }, + "start": { + "name": "start", + "overrideType": "(controller: ReadableStreamDefaultController) => any" + }, + "pull": { + "name": "pull", + "overrideType": "(controller: ReadableStreamDefaultController) => void | PromiseLike" + }, + "cancel": { + "name": "cancel", + "type": "UnderlyingSourceCancelCallback" + } + } + } } } }, diff --git a/inputfiles/overridingTypes.jsonc b/inputfiles/overridingTypes.jsonc index 7c01ed91e..8bb48ba99 100644 --- a/inputfiles/overridingTypes.jsonc +++ b/inputfiles/overridingTypes.jsonc @@ -2349,6 +2349,20 @@ "constructor": { "signature": { "0": { + "param": [ + { + "name": "underlyingSource", + "optional": false, + "overrideType": "UnderlyingByteSource" + }, + { + "name": "strategy", + "overrideType": "{ highWaterMark?: number }" + } + ], + "overrideType": "ReadableStream" + }, + "1": { "typeParameters": [ { "name": "R", @@ -2358,10 +2372,33 @@ "param": [ { "name": "underlyingSource", + "optional": false, + "overrideType": "UnderlyingDefaultSource" + }, + { + "name": "strategy", + "optional": true, + "overrideType": "QueuingStrategy" + } + ], + "overrideType": "ReadableStream" + }, + "2": { + "typeParameters": [ + { + "name": "R", + "default": "any" + } + ], + "param": [ + { + "name": "underlyingSource", + "optional": true, "overrideType": "UnderlyingSource" }, { "name": "strategy", + "optional": true, "overrideType": "QueuingStrategy" } ], @@ -2372,6 +2409,12 @@ { "type": "UnderlyingSource" }, + { + "type": "UnderlyingByteSource" + }, + { + "type": "UnderlyingDefaultSource" + }, { "type": "QueuingStrategy" } From 8f1891fe167fe107ab2a788c66c058723e667c05 Mon Sep 17 00:00:00 2001 From: Mattias Buelens Date: Thu, 21 Jul 2022 00:41:00 +0200 Subject: [PATCH 07/13] Update baselines --- baselines/audioworklet.generated.d.ts | 17 +++++++++++++++++ baselines/dom.generated.d.ts | 17 +++++++++++++++++ baselines/serviceworker.generated.d.ts | 17 +++++++++++++++++ baselines/sharedworker.generated.d.ts | 17 +++++++++++++++++ baselines/webworker.generated.d.ts | 17 +++++++++++++++++ 5 files changed, 85 insertions(+) diff --git a/baselines/audioworklet.generated.d.ts b/baselines/audioworklet.generated.d.ts index dd14ad829..991a2dd7a 100644 --- a/baselines/audioworklet.generated.d.ts +++ b/baselines/audioworklet.generated.d.ts @@ -154,6 +154,21 @@ interface Transformer { writableType?: undefined; } +interface UnderlyingByteSource { + autoAllocateChunkSize?: number; + cancel?: UnderlyingSourceCancelCallback; + pull?: (controller: ReadableByteStreamController) => void | PromiseLike; + start?: (controller: ReadableByteStreamController) => any; + type: "bytes"; +} + +interface UnderlyingDefaultSource { + cancel?: UnderlyingSourceCancelCallback; + pull?: (controller: ReadableStreamDefaultController) => void | PromiseLike; + start?: (controller: ReadableStreamDefaultController) => any; + type?: undefined; +} + interface UnderlyingSink { abort?: UnderlyingSinkAbortCallback; close?: UnderlyingSinkCloseCallback; @@ -549,6 +564,8 @@ interface ReadableStream { declare var ReadableStream: { prototype: ReadableStream; + new(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number }): ReadableStream; + new(underlyingSource: UnderlyingDefaultSource, strategy?: QueuingStrategy): ReadableStream; new(underlyingSource?: UnderlyingSource, strategy?: QueuingStrategy): ReadableStream; }; diff --git a/baselines/dom.generated.d.ts b/baselines/dom.generated.d.ts index 5603914d3..ac97630dc 100644 --- a/baselines/dom.generated.d.ts +++ b/baselines/dom.generated.d.ts @@ -1780,6 +1780,21 @@ interface ULongRange { min?: number; } +interface UnderlyingByteSource { + autoAllocateChunkSize?: number; + cancel?: UnderlyingSourceCancelCallback; + pull?: (controller: ReadableByteStreamController) => void | PromiseLike; + start?: (controller: ReadableByteStreamController) => any; + type: "bytes"; +} + +interface UnderlyingDefaultSource { + cancel?: UnderlyingSourceCancelCallback; + pull?: (controller: ReadableStreamDefaultController) => void | PromiseLike; + start?: (controller: ReadableStreamDefaultController) => any; + type?: undefined; +} + interface UnderlyingSink { abort?: UnderlyingSinkAbortCallback; close?: UnderlyingSinkCloseCallback; @@ -11385,6 +11400,8 @@ interface ReadableStream { declare var ReadableStream: { prototype: ReadableStream; + new(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number }): ReadableStream; + new(underlyingSource: UnderlyingDefaultSource, strategy?: QueuingStrategy): ReadableStream; new(underlyingSource?: UnderlyingSource, strategy?: QueuingStrategy): ReadableStream; }; diff --git a/baselines/serviceworker.generated.d.ts b/baselines/serviceworker.generated.d.ts index b7a54cc62..cb17d2b06 100644 --- a/baselines/serviceworker.generated.d.ts +++ b/baselines/serviceworker.generated.d.ts @@ -631,6 +631,21 @@ interface Transformer { writableType?: undefined; } +interface UnderlyingByteSource { + autoAllocateChunkSize?: number; + cancel?: UnderlyingSourceCancelCallback; + pull?: (controller: ReadableByteStreamController) => void | PromiseLike; + start?: (controller: ReadableByteStreamController) => any; + type: "bytes"; +} + +interface UnderlyingDefaultSource { + cancel?: UnderlyingSourceCancelCallback; + pull?: (controller: ReadableStreamDefaultController) => void | PromiseLike; + start?: (controller: ReadableStreamDefaultController) => any; + type?: undefined; +} + interface UnderlyingSink { abort?: UnderlyingSinkAbortCallback; close?: UnderlyingSinkCloseCallback; @@ -2613,6 +2628,8 @@ interface ReadableStream { declare var ReadableStream: { prototype: ReadableStream; + new(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number }): ReadableStream; + new(underlyingSource: UnderlyingDefaultSource, strategy?: QueuingStrategy): ReadableStream; new(underlyingSource?: UnderlyingSource, strategy?: QueuingStrategy): ReadableStream; }; diff --git a/baselines/sharedworker.generated.d.ts b/baselines/sharedworker.generated.d.ts index 795893320..6e6b0d353 100644 --- a/baselines/sharedworker.generated.d.ts +++ b/baselines/sharedworker.generated.d.ts @@ -597,6 +597,21 @@ interface Transformer { writableType?: undefined; } +interface UnderlyingByteSource { + autoAllocateChunkSize?: number; + cancel?: UnderlyingSourceCancelCallback; + pull?: (controller: ReadableByteStreamController) => void | PromiseLike; + start?: (controller: ReadableByteStreamController) => any; + type: "bytes"; +} + +interface UnderlyingDefaultSource { + cancel?: UnderlyingSourceCancelCallback; + pull?: (controller: ReadableStreamDefaultController) => void | PromiseLike; + start?: (controller: ReadableStreamDefaultController) => any; + type?: undefined; +} + interface UnderlyingSink { abort?: UnderlyingSinkAbortCallback; close?: UnderlyingSinkCloseCallback; @@ -2492,6 +2507,8 @@ interface ReadableStream { declare var ReadableStream: { prototype: ReadableStream; + new(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number }): ReadableStream; + new(underlyingSource: UnderlyingDefaultSource, strategy?: QueuingStrategy): ReadableStream; new(underlyingSource?: UnderlyingSource, strategy?: QueuingStrategy): ReadableStream; }; diff --git a/baselines/webworker.generated.d.ts b/baselines/webworker.generated.d.ts index 532321491..e13cd5c61 100644 --- a/baselines/webworker.generated.d.ts +++ b/baselines/webworker.generated.d.ts @@ -647,6 +647,21 @@ interface Transformer { writableType?: undefined; } +interface UnderlyingByteSource { + autoAllocateChunkSize?: number; + cancel?: UnderlyingSourceCancelCallback; + pull?: (controller: ReadableByteStreamController) => void | PromiseLike; + start?: (controller: ReadableByteStreamController) => any; + type: "bytes"; +} + +interface UnderlyingDefaultSource { + cancel?: UnderlyingSourceCancelCallback; + pull?: (controller: ReadableStreamDefaultController) => void | PromiseLike; + start?: (controller: ReadableStreamDefaultController) => any; + type?: undefined; +} + interface UnderlyingSink { abort?: UnderlyingSinkAbortCallback; close?: UnderlyingSinkCloseCallback; @@ -2711,6 +2726,8 @@ interface ReadableStream { declare var ReadableStream: { prototype: ReadableStream; + new(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number }): ReadableStream; + new(underlyingSource: UnderlyingDefaultSource, strategy?: QueuingStrategy): ReadableStream; new(underlyingSource?: UnderlyingSource, strategy?: QueuingStrategy): ReadableStream; }; From 43cd68158d8fa6eb2c132d6aef4305aae35f5001 Mon Sep 17 00:00:00 2001 From: Mattias Buelens Date: Thu, 21 Jul 2022 00:41:28 +0200 Subject: [PATCH 08/13] Add unit tests for constructing a byte stream --- unittests/files/streams.ts | 26 ++++++++++++++++++++++---- 1 file changed, 22 insertions(+), 4 deletions(-) diff --git a/unittests/files/streams.ts b/unittests/files/streams.ts index 69d3cbddd..343144664 100644 --- a/unittests/files/streams.ts +++ b/unittests/files/streams.ts @@ -1,11 +1,29 @@ -const readable = new ReadableStream({ +const readableByteStream = new ReadableStream({ type: "bytes", + start(controller) { + controller.byobRequest; + }, + pull(controller) { + if (controller.byobRequest) { + controller.byobRequest.view; + controller.byobRequest.respond(1); + controller.byobRequest.respondWithNewView(new Uint32Array(1)); + } else { + controller.enqueue(new Uint8Array(1)); + } + controller.close(); + }, }); -const defaultReader = readable.getReader(); -defaultReader.read(); +const defaultReader = readableByteStream.getReader(); +defaultReader.read().then((result) => { + if (!result.done) { + result.value.buffer; + result.value[0]; + } +}); -const byobReader = readable.getReader({ mode: "byob" }); +const byobReader = readableByteStream.getReader({ mode: "byob" }); byobReader.read(new Uint8Array(1)); byobReader.read(new DataView(new ArrayBuffer(1))).then((result) => { if (!result.done) { From bde4c62873a739bb7b5c277848515cbc3d98af94 Mon Sep 17 00:00:00 2001 From: Mattias Buelens Date: Thu, 21 Jul 2022 00:43:57 +0200 Subject: [PATCH 09/13] Add unit tests for constructign a non-byte stream --- unittests/files/streams.ts | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-) diff --git a/unittests/files/streams.ts b/unittests/files/streams.ts index 343144664..1b1bee4a4 100644 --- a/unittests/files/streams.ts +++ b/unittests/files/streams.ts @@ -1,6 +1,25 @@ +const readableStream = new ReadableStream({ + start(controller) { + controller.desiredSize; + controller.enqueue("a"); + }, + pull(controller) { + controller.enqueue("b"); + controller.close(); + }, +}); + +const defaultReader1 = readableStream.getReader(); +defaultReader1.read().then((result) => { + if (!result.done) { + result.value.charAt(0); + } +}); + const readableByteStream = new ReadableStream({ type: "bytes", start(controller) { + controller.desiredSize; controller.byobRequest; }, pull(controller) { @@ -15,8 +34,8 @@ const readableByteStream = new ReadableStream({ }, }); -const defaultReader = readableByteStream.getReader(); -defaultReader.read().then((result) => { +const defaultReader2 = readableByteStream.getReader(); +defaultReader2.read().then((result) => { if (!result.done) { result.value.buffer; result.value[0]; From 97ef752361ec7f8d2fa0a124d9329465643003f6 Mon Sep 17 00:00:00 2001 From: Mattias Buelens Date: Thu, 21 Jul 2022 00:53:33 +0200 Subject: [PATCH 10/13] Remove unnecessary force-references --- inputfiles/overridingTypes.jsonc | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/inputfiles/overridingTypes.jsonc b/inputfiles/overridingTypes.jsonc index 8bb48ba99..f9d47a9e4 100644 --- a/inputfiles/overridingTypes.jsonc +++ b/inputfiles/overridingTypes.jsonc @@ -2431,15 +2431,7 @@ "0": { "overrideType": "ReadableStreamReader" } - }, - "force-references": [ - { - "type": "ReadableStreamDefaultReader" - }, - { - "type": "ReadableStreamBYOBReader" - } - ] + } }, "pipeThrough": { "signature": { From 19fe04a99d7523c3f667e14c70985c8a23d5e403 Mon Sep 17 00:00:00 2001 From: Mattias Buelens <649348+MattiasBuelens@users.noreply.github.com> Date: Wed, 3 Aug 2022 23:17:31 +0200 Subject: [PATCH 11/13] Address review suggestions Co-authored-by: Kagami Sascha Rosylight --- inputfiles/addedTypes.jsonc | 2 +- inputfiles/overridingTypes.jsonc | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/inputfiles/addedTypes.jsonc b/inputfiles/addedTypes.jsonc index c710b7576..dcabbbaef 100644 --- a/inputfiles/addedTypes.jsonc +++ b/inputfiles/addedTypes.jsonc @@ -1207,7 +1207,7 @@ }, "autoAllocateChunkSize": { "name": "autoAllocateChunkSize", - "overrideType": "number" + "type": "unsigned long long" }, "start": { "name": "start", diff --git a/inputfiles/overridingTypes.jsonc b/inputfiles/overridingTypes.jsonc index f9d47a9e4..a450dec09 100644 --- a/inputfiles/overridingTypes.jsonc +++ b/inputfiles/overridingTypes.jsonc @@ -2353,7 +2353,7 @@ { "name": "underlyingSource", "optional": false, - "overrideType": "UnderlyingByteSource" + "type": "UnderlyingByteSource" }, { "name": "strategy", From 82181d6b8db08c414d1e8352603b8374b7205ccd Mon Sep 17 00:00:00 2001 From: Mattias Buelens Date: Wed, 3 Aug 2022 23:27:22 +0200 Subject: [PATCH 12/13] Assert types in unit tests --- unittests/files/streams.ts | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/unittests/files/streams.ts b/unittests/files/streams.ts index 1b1bee4a4..9b6b2e6b8 100644 --- a/unittests/files/streams.ts +++ b/unittests/files/streams.ts @@ -1,16 +1,22 @@ +function assertType(_x: T) {} + const readableStream = new ReadableStream({ start(controller) { + assertType>(controller); controller.desiredSize; controller.enqueue("a"); }, pull(controller) { + assertType>(controller); controller.enqueue("b"); controller.close(); }, }); const defaultReader1 = readableStream.getReader(); +assertType>(defaultReader1); defaultReader1.read().then((result) => { + assertType>(result); if (!result.done) { result.value.charAt(0); } @@ -19,11 +25,14 @@ defaultReader1.read().then((result) => { const readableByteStream = new ReadableStream({ type: "bytes", start(controller) { + assertType(controller); controller.desiredSize; controller.byobRequest; }, pull(controller) { + assertType(controller); if (controller.byobRequest) { + assertType(controller.byobRequest); controller.byobRequest.view; controller.byobRequest.respond(1); controller.byobRequest.respondWithNewView(new Uint32Array(1)); @@ -35,7 +44,9 @@ const readableByteStream = new ReadableStream({ }); const defaultReader2 = readableByteStream.getReader(); +assertType>(defaultReader2); defaultReader2.read().then((result) => { + assertType>(result); if (!result.done) { result.value.buffer; result.value[0]; @@ -43,8 +54,10 @@ defaultReader2.read().then((result) => { }); const byobReader = readableByteStream.getReader({ mode: "byob" }); +assertType(byobReader); byobReader.read(new Uint8Array(1)); byobReader.read(new DataView(new ArrayBuffer(1))).then((result) => { + assertType>(result); if (!result.done) { result.value.getUint8(0); } From ce50595a2012912fc38875cf4824571139ceef0b Mon Sep 17 00:00:00 2001 From: Mattias Buelens Date: Wed, 3 Aug 2022 23:33:18 +0200 Subject: [PATCH 13/13] Add some more unit tests --- unittests/files/streams.ts | 46 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) diff --git a/unittests/files/streams.ts b/unittests/files/streams.ts index 9b6b2e6b8..a5237a26a 100644 --- a/unittests/files/streams.ts +++ b/unittests/files/streams.ts @@ -11,6 +11,9 @@ const readableStream = new ReadableStream({ controller.enqueue("b"); controller.close(); }, + cancel(reason) { + assertType(reason); + }, }); const defaultReader1 = readableStream.getReader(); @@ -41,6 +44,9 @@ const readableByteStream = new ReadableStream({ } controller.close(); }, + cancel(reason) { + assertType(reason); + }, }); const defaultReader2 = readableByteStream.getReader(); @@ -62,3 +68,43 @@ byobReader.read(new DataView(new ArrayBuffer(1))).then((result) => { result.value.getUint8(0); } }); + +const writableStream = new WritableStream({ + start(controller) { + assertType(controller); + }, + write(chunk, controller) { + assertType(chunk); + assertType(controller); + chunk.toFixed(3); + controller.error("boom!"); + }, + close() {}, + abort(reason) { + assertType(reason); + }, +}); + +const defaultWriter = writableStream.getWriter(); +assertType>(defaultWriter); +defaultWriter.write(42); +defaultWriter.close(); +defaultWriter.abort("boom!"); + +const transformStream = new TransformStream({ + start(controller) { + assertType>(controller); + }, + transform(chunk, controller) { + assertType(chunk); + assertType>(controller); + controller.enqueue(chunk.length); + controller.error("boom!"); + }, + flush(controller) { + assertType>(controller); + controller.terminate(); + }, +}); +assertType>(transformStream.readable); +assertType>(transformStream.writable);