From 5814315b708d154ebb2c29810c16e5af7e726741 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 14 Jun 2021 13:51:02 +0200 Subject: [PATCH] refactor: move streams implementation to deno_web crate (#10935) --- extensions/fetch/20_headers.js | 2 +- extensions/fetch/21_formdata.js | 2 +- extensions/fetch/22_body.js | 2 +- extensions/fetch/22_http_client.js | 2 +- extensions/fetch/23_request.js | 2 +- extensions/fetch/23_response.js | 2 +- extensions/fetch/26_fetch.js | 2 +- extensions/fetch/internal.d.ts | 5 - extensions/fetch/lib.deno_fetch.d.ts | 271 ------------------ extensions/fetch/lib.rs | 1 - .../11_streams.js => web/06_streams.js} | 2 +- .../06_streams_types.d.ts} | 0 extensions/web/internal.d.ts | 5 + extensions/web/lib.deno_web.d.ts | 271 ++++++++++++++++++ extensions/web/lib.rs | 1 + 15 files changed, 285 insertions(+), 285 deletions(-) rename extensions/{fetch/11_streams.js => web/06_streams.js} (99%) rename extensions/{fetch/11_streams_types.d.ts => web/06_streams_types.d.ts} (100%) diff --git a/extensions/fetch/20_headers.js b/extensions/fetch/20_headers.js index 24dcdb74a5..b5051a149c 100644 --- a/extensions/fetch/20_headers.js +++ b/extensions/fetch/20_headers.js @@ -5,7 +5,7 @@ /// /// /// -/// +/// /// /// "use strict"; diff --git a/extensions/fetch/21_formdata.js b/extensions/fetch/21_formdata.js index 32a4e69a76..bbf051da12 100644 --- a/extensions/fetch/21_formdata.js +++ b/extensions/fetch/21_formdata.js @@ -5,7 +5,7 @@ /// /// /// -/// +/// /// /// "use strict"; diff --git a/extensions/fetch/22_body.js b/extensions/fetch/22_body.js index 5039ab9103..d74269f249 100644 --- a/extensions/fetch/22_body.js +++ b/extensions/fetch/22_body.js @@ -7,7 +7,7 @@ /// /// /// -/// +/// /// /// "use strict"; diff --git a/extensions/fetch/22_http_client.js b/extensions/fetch/22_http_client.js index 9900cfb587..60b069aa7c 100644 --- a/extensions/fetch/22_http_client.js +++ b/extensions/fetch/22_http_client.js @@ -6,7 +6,7 @@ /// /// /// -/// +/// /// /// "use strict"; diff --git a/extensions/fetch/23_request.js b/extensions/fetch/23_request.js index ad05b5cd8b..4d79d74be4 100644 --- a/extensions/fetch/23_request.js +++ b/extensions/fetch/23_request.js @@ -5,7 +5,7 @@ /// /// /// -/// +/// /// /// "use strict"; diff --git a/extensions/fetch/23_response.js b/extensions/fetch/23_response.js index a8fd52162e..a016ca6c7b 100644 --- a/extensions/fetch/23_response.js +++ b/extensions/fetch/23_response.js @@ -6,7 +6,7 @@ /// /// /// -/// +/// /// /// "use strict"; diff --git a/extensions/fetch/26_fetch.js b/extensions/fetch/26_fetch.js index 6e1d4d4c83..4a22c2aa99 100644 --- a/extensions/fetch/26_fetch.js +++ b/extensions/fetch/26_fetch.js @@ -5,7 +5,7 @@ /// /// /// -/// +/// /// /// /// diff --git a/extensions/fetch/internal.d.ts b/extensions/fetch/internal.d.ts index f34e5e12ca..6bdcc34ae6 100644 --- a/extensions/fetch/internal.d.ts +++ b/extensions/fetch/internal.d.ts @@ -52,11 +52,6 @@ declare namespace globalThis { declare function formDataFromEntries(entries: FormDataEntry[]): FormData; } - declare var streams: { - ReadableStream: typeof ReadableStream; - isReadableStreamDisturbed(stream: ReadableStream): boolean; - }; - declare namespace fetchBody { function mixinBody( prototype: any, diff --git a/extensions/fetch/lib.deno_fetch.d.ts b/extensions/fetch/lib.deno_fetch.d.ts index af21d8c447..7fe7d94532 100644 --- a/extensions/fetch/lib.deno_fetch.d.ts +++ b/extensions/fetch/lib.deno_fetch.d.ts @@ -16,277 +16,6 @@ interface DomIterable { ): void; } -interface ReadableStreamReadDoneResult { - done: true; - value?: T; -} - -interface ReadableStreamReadValueResult { - done: false; - value: T; -} - -type ReadableStreamReadResult = - | ReadableStreamReadValueResult - | ReadableStreamReadDoneResult; - -interface ReadableStreamDefaultReader { - readonly closed: Promise; - cancel(reason?: any): Promise; - read(): Promise>; - releaseLock(): void; -} - -declare var ReadableStreamDefaultReader: { - prototype: ReadableStreamDefaultReader; - new (stream: ReadableStream): ReadableStreamDefaultReader; -}; - -interface ReadableStreamReader { - cancel(): Promise; - read(): Promise>; - releaseLock(): void; -} - -declare var ReadableStreamReader: { - prototype: ReadableStreamReader; - new (): ReadableStreamReader; -}; - -interface ReadableByteStreamControllerCallback { - (controller: ReadableByteStreamController): void | PromiseLike; -} - -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 ReadableStreamErrorCallback { - (reason: any): void | PromiseLike; -} - -interface ReadableStreamDefaultControllerCallback { - (controller: ReadableStreamDefaultController): void | PromiseLike; -} - -interface ReadableStreamDefaultController { - readonly desiredSize: number | null; - close(): void; - enqueue(chunk: R): void; - error(error?: any): void; -} - -declare var ReadableStreamDefaultController: { - prototype: ReadableStreamDefaultController; - new (): ReadableStreamDefaultController; -}; - -interface ReadableByteStreamController { - readonly byobRequest: undefined; - readonly desiredSize: number | null; - close(): void; - enqueue(chunk: ArrayBufferView): void; - error(error?: any): void; -} - -declare var ReadableByteStreamController: { - prototype: ReadableByteStreamController; - new (): ReadableByteStreamController; -}; - -interface PipeOptions { - preventAbort?: boolean; - preventCancel?: boolean; - preventClose?: boolean; - signal?: AbortSignal; -} - -interface QueuingStrategySizeCallback { - (chunk: T): number; -} - -interface QueuingStrategy { - highWaterMark?: number; - size?: QueuingStrategySizeCallback; -} - -/** This Streams API interface provides a built-in byte length queuing strategy - * that can be used when constructing streams. */ -declare class CountQueuingStrategy implements QueuingStrategy { - constructor(options: { highWaterMark: number }); - highWaterMark: number; - size(chunk: any): 1; -} - -declare class ByteLengthQueuingStrategy - implements QueuingStrategy { - constructor(options: { highWaterMark: number }); - highWaterMark: number; - size(chunk: ArrayBufferView): number; -} - -/** This Streams API interface represents a readable stream of byte data. The - * Fetch API offers a concrete instance of a ReadableStream through the body - * property of a Response object. */ -interface ReadableStream { - readonly locked: boolean; - cancel(reason?: any): Promise; - /** - * @deprecated This is no longer part of the Streams standard and the async - * iterable should be obtained by just using the stream as an - * async iterator. - */ - getIterator(options?: { preventCancel?: boolean }): AsyncIterableIterator; - getReader(): ReadableStreamDefaultReader; - pipeThrough( - { writable, readable }: { - writable: WritableStream; - readable: ReadableStream; - }, - options?: PipeOptions, - ): ReadableStream; - pipeTo(dest: WritableStream, options?: PipeOptions): Promise; - tee(): [ReadableStream, ReadableStream]; - [Symbol.asyncIterator](options?: { - preventCancel?: boolean; - }): AsyncIterableIterator; -} - -declare var ReadableStream: { - prototype: ReadableStream; - new ( - underlyingSource: UnderlyingByteSource, - strategy?: { highWaterMark?: number; size?: undefined }, - ): ReadableStream; - new ( - underlyingSource?: UnderlyingSource, - strategy?: QueuingStrategy, - ): ReadableStream; -}; - -interface WritableStreamDefaultControllerCloseCallback { - (): void | PromiseLike; -} - -interface WritableStreamDefaultControllerStartCallback { - (controller: WritableStreamDefaultController): void | PromiseLike; -} - -interface WritableStreamDefaultControllerWriteCallback { - (chunk: W, controller: WritableStreamDefaultController): - | void - | PromiseLike< - void - >; -} - -interface WritableStreamErrorCallback { - (reason: any): void | PromiseLike; -} - -/** This Streams API interface provides a standard abstraction for writing - * streaming data to a destination, known as a sink. This object comes with - * built-in backpressure and queuing. */ -interface WritableStream { - readonly locked: boolean; - abort(reason?: any): Promise; - getWriter(): WritableStreamDefaultWriter; -} - -declare var WritableStream: { - prototype: WritableStream; - new ( - underlyingSink?: UnderlyingSink, - strategy?: QueuingStrategy, - ): WritableStream; -}; - -/** This Streams API interface represents a controller allowing control of a - * WritableStream's state. When constructing a WritableStream, the underlying - * sink is given a corresponding WritableStreamDefaultController instance to - * manipulate. */ -interface WritableStreamDefaultController { - error(error?: any): void; -} - -/** This Streams API interface is the object returned by - * WritableStream.getWriter() and once created locks the < writer to the - * WritableStream ensuring that no other streams can write to the underlying - * sink. */ -interface WritableStreamDefaultWriter { - readonly closed: Promise; - readonly desiredSize: number | null; - readonly ready: Promise; - abort(reason?: any): Promise; - close(): Promise; - releaseLock(): void; - write(chunk: W): Promise; -} - -declare var WritableStreamDefaultWriter: { - prototype: WritableStreamDefaultWriter; - new (): WritableStreamDefaultWriter; -}; - -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 Transformer { - flush?: TransformStreamDefaultControllerCallback; - readableType?: undefined; - start?: TransformStreamDefaultControllerCallback; - transform?: TransformStreamDefaultControllerTransformCallback; - writableType?: undefined; -} - -interface TransformStreamDefaultControllerCallback { - (controller: TransformStreamDefaultController): void | PromiseLike; -} - -interface TransformStreamDefaultControllerTransformCallback { - ( - chunk: I, - controller: TransformStreamDefaultController, - ): void | PromiseLike; -} - type FormDataEntryValue = File | string; /** Provides a way to easily construct a set of key/value pairs representing diff --git a/extensions/fetch/lib.rs b/extensions/fetch/lib.rs index 5638b1f334..cdac0d64c1 100644 --- a/extensions/fetch/lib.rs +++ b/extensions/fetch/lib.rs @@ -61,7 +61,6 @@ pub fn init( .js(include_js_files!( prefix "deno:extensions/fetch", "01_fetch_util.js", - "11_streams.js", "20_headers.js", "21_formdata.js", "22_body.js", diff --git a/extensions/fetch/11_streams.js b/extensions/web/06_streams.js similarity index 99% rename from extensions/fetch/11_streams.js rename to extensions/web/06_streams.js index 9d784bc7b4..e59f8e9459 100644 --- a/extensions/fetch/11_streams.js +++ b/extensions/web/06_streams.js @@ -1,7 +1,7 @@ // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. // @ts-check -/// +/// /// /// "use strict"; diff --git a/extensions/fetch/11_streams_types.d.ts b/extensions/web/06_streams_types.d.ts similarity index 100% rename from extensions/fetch/11_streams_types.d.ts rename to extensions/web/06_streams_types.d.ts diff --git a/extensions/web/internal.d.ts b/extensions/web/internal.d.ts index 4492e65549..8ab1010771 100644 --- a/extensions/web/internal.d.ts +++ b/extensions/web/internal.d.ts @@ -80,5 +80,10 @@ declare namespace globalThis { [globalThis.__bootstrap.file._byteSequence]: Uint8Array; }; }; + + declare var streams: { + ReadableStream: typeof ReadableStream; + isReadableStreamDisturbed(stream: ReadableStream): boolean; + }; } } diff --git a/extensions/web/lib.deno_web.d.ts b/extensions/web/lib.deno_web.d.ts index a1b6a0595b..888fe9de94 100644 --- a/extensions/web/lib.deno_web.d.ts +++ b/extensions/web/lib.deno_web.d.ts @@ -377,3 +377,274 @@ declare class File extends Blob { readonly lastModified: number; readonly name: string; } + +interface ReadableStreamReadDoneResult { + done: true; + value?: T; +} + +interface ReadableStreamReadValueResult { + done: false; + value: T; +} + +type ReadableStreamReadResult = + | ReadableStreamReadValueResult + | ReadableStreamReadDoneResult; + +interface ReadableStreamDefaultReader { + readonly closed: Promise; + cancel(reason?: any): Promise; + read(): Promise>; + releaseLock(): void; +} + +declare var ReadableStreamDefaultReader: { + prototype: ReadableStreamDefaultReader; + new (stream: ReadableStream): ReadableStreamDefaultReader; +}; + +interface ReadableStreamReader { + cancel(): Promise; + read(): Promise>; + releaseLock(): void; +} + +declare var ReadableStreamReader: { + prototype: ReadableStreamReader; + new (): ReadableStreamReader; +}; + +interface ReadableByteStreamControllerCallback { + (controller: ReadableByteStreamController): void | PromiseLike; +} + +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 ReadableStreamErrorCallback { + (reason: any): void | PromiseLike; +} + +interface ReadableStreamDefaultControllerCallback { + (controller: ReadableStreamDefaultController): void | PromiseLike; +} + +interface ReadableStreamDefaultController { + readonly desiredSize: number | null; + close(): void; + enqueue(chunk: R): void; + error(error?: any): void; +} + +declare var ReadableStreamDefaultController: { + prototype: ReadableStreamDefaultController; + new (): ReadableStreamDefaultController; +}; + +interface ReadableByteStreamController { + readonly byobRequest: undefined; + readonly desiredSize: number | null; + close(): void; + enqueue(chunk: ArrayBufferView): void; + error(error?: any): void; +} + +declare var ReadableByteStreamController: { + prototype: ReadableByteStreamController; + new (): ReadableByteStreamController; +}; + +interface PipeOptions { + preventAbort?: boolean; + preventCancel?: boolean; + preventClose?: boolean; + signal?: AbortSignal; +} + +interface QueuingStrategySizeCallback { + (chunk: T): number; +} + +interface QueuingStrategy { + highWaterMark?: number; + size?: QueuingStrategySizeCallback; +} + +/** This Streams API interface provides a built-in byte length queuing strategy + * that can be used when constructing streams. */ +declare class CountQueuingStrategy implements QueuingStrategy { + constructor(options: { highWaterMark: number }); + highWaterMark: number; + size(chunk: any): 1; +} + +declare class ByteLengthQueuingStrategy + implements QueuingStrategy { + constructor(options: { highWaterMark: number }); + highWaterMark: number; + size(chunk: ArrayBufferView): number; +} + +/** This Streams API interface represents a readable stream of byte data. The + * Fetch API offers a concrete instance of a ReadableStream through the body + * property of a Response object. */ +interface ReadableStream { + readonly locked: boolean; + cancel(reason?: any): Promise; + /** + * @deprecated This is no longer part of the Streams standard and the async + * iterable should be obtained by just using the stream as an + * async iterator. + */ + getIterator(options?: { preventCancel?: boolean }): AsyncIterableIterator; + getReader(): ReadableStreamDefaultReader; + pipeThrough( + { writable, readable }: { + writable: WritableStream; + readable: ReadableStream; + }, + options?: PipeOptions, + ): ReadableStream; + pipeTo(dest: WritableStream, options?: PipeOptions): Promise; + tee(): [ReadableStream, ReadableStream]; + [Symbol.asyncIterator](options?: { + preventCancel?: boolean; + }): AsyncIterableIterator; +} + +declare var ReadableStream: { + prototype: ReadableStream; + new ( + underlyingSource: UnderlyingByteSource, + strategy?: { highWaterMark?: number; size?: undefined }, + ): ReadableStream; + new ( + underlyingSource?: UnderlyingSource, + strategy?: QueuingStrategy, + ): ReadableStream; +}; + +interface WritableStreamDefaultControllerCloseCallback { + (): void | PromiseLike; +} + +interface WritableStreamDefaultControllerStartCallback { + (controller: WritableStreamDefaultController): void | PromiseLike; +} + +interface WritableStreamDefaultControllerWriteCallback { + (chunk: W, controller: WritableStreamDefaultController): + | void + | PromiseLike< + void + >; +} + +interface WritableStreamErrorCallback { + (reason: any): void | PromiseLike; +} + +/** This Streams API interface provides a standard abstraction for writing + * streaming data to a destination, known as a sink. This object comes with + * built-in backpressure and queuing. */ +interface WritableStream { + readonly locked: boolean; + abort(reason?: any): Promise; + getWriter(): WritableStreamDefaultWriter; +} + +declare var WritableStream: { + prototype: WritableStream; + new ( + underlyingSink?: UnderlyingSink, + strategy?: QueuingStrategy, + ): WritableStream; +}; + +/** This Streams API interface represents a controller allowing control of a + * WritableStream's state. When constructing a WritableStream, the underlying + * sink is given a corresponding WritableStreamDefaultController instance to + * manipulate. */ +interface WritableStreamDefaultController { + error(error?: any): void; +} + +/** This Streams API interface is the object returned by + * WritableStream.getWriter() and once created locks the < writer to the + * WritableStream ensuring that no other streams can write to the underlying + * sink. */ +interface WritableStreamDefaultWriter { + readonly closed: Promise; + readonly desiredSize: number | null; + readonly ready: Promise; + abort(reason?: any): Promise; + close(): Promise; + releaseLock(): void; + write(chunk: W): Promise; +} + +declare var WritableStreamDefaultWriter: { + prototype: WritableStreamDefaultWriter; + new (): WritableStreamDefaultWriter; +}; + +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 Transformer { + flush?: TransformStreamDefaultControllerCallback; + readableType?: undefined; + start?: TransformStreamDefaultControllerCallback; + transform?: TransformStreamDefaultControllerTransformCallback; + writableType?: undefined; +} + +interface TransformStreamDefaultControllerCallback { + (controller: TransformStreamDefaultController): void | PromiseLike; +} + +interface TransformStreamDefaultControllerTransformCallback { + ( + chunk: I, + controller: TransformStreamDefaultController, + ): void | PromiseLike; +} diff --git a/extensions/web/lib.rs b/extensions/web/lib.rs index b2906acafd..9f78366205 100644 --- a/extensions/web/lib.rs +++ b/extensions/web/lib.rs @@ -46,6 +46,7 @@ pub fn init( "03_abort_signal.js", "04_global_interfaces.js", "05_base64.js", + "06_streams.js", "08_text_encoding.js", "09_file.js", "10_filereader.js",