refactor(op_crate/fetch): align streams to spec (#9103)

Fixes #8814

op_crates/fetch/11_streams_types.d.ts

@@ -0,0 +1,49 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+
+// ** Internal Interfaces **
+
+interface PendingAbortRequest {
+  deferred: Deferred<void>;
+  // deno-lint-ignore no-explicit-any
+  reason: any;
+  wasAlreadyErroring: boolean;
+}
+
+// deno-lint-ignore no-explicit-any
+interface ReadRequest<R = any> {
+  chunkSteps: (chunk: R) => void;
+  closeSteps: () => void;
+  // deno-lint-ignore no-explicit-any
+  errorSteps: (error: any) => void;
+}
+
+interface ReadableByteStreamQueueEntry {
+  buffer: ArrayBufferLike;
+  byteOffset: number;
+  byteLength: number;
+}
+
+interface ReadableStreamGetReaderOptions {
+  mode?: "byob";
+}
+
+interface ReadableStreamIteratorOptions {
+  preventCancel?: boolean;
+}
+
+interface ValueWithSize<T> {
+  value: T;
+  size: number;
+}
+
+interface VoidFunction {
+  (): void;
+}
+
+// ** Ambient Definitions and Interfaces not provided by fetch **
+
+declare function queueMicrotask(callback: VoidFunction): void;
+
+declare namespace Deno {
+  function inspect(value: unknown, options?: Record<string, unknown>): string;
+}

op_crates/fetch/lib.deno_fetch.d.ts

@@ -37,12 +37,22 @@ interface ReadableStreamDefaultReader<R = any> {
   releaseLock(): void;
 }
 
+declare var ReadableStreamDefaultReader: {
+  prototype: ReadableStreamDefaultReader;
+  new <R>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
+};
+
 interface ReadableStreamReader<R = any> {
   cancel(): Promise<void>;
   read(): Promise<ReadableStreamReadResult<R>>;
   releaseLock(): void;
 }
 
+declare var ReadableStreamReader: {
+  prototype: ReadableStreamReader;
+  new (): ReadableStreamReader;
+};
+
 interface ReadableByteStreamControllerCallback {
   (controller: ReadableByteStreamController): void | PromiseLike<void>;
 }
@@ -55,6 +65,14 @@ interface UnderlyingByteSource {
   type: "bytes";
 }
 
+interface UnderlyingSink<W = any> {
+  abort?: WritableStreamErrorCallback;
+  close?: WritableStreamDefaultControllerCloseCallback;
+  start?: WritableStreamDefaultControllerStartCallback;
+  type?: undefined;
+  write?: WritableStreamDefaultControllerWriteCallback<W>;
+}
+
 interface UnderlyingSource<R = any> {
   cancel?: ReadableStreamErrorCallback;
   pull?: ReadableStreamDefaultControllerCallback<R>;
@@ -77,6 +95,11 @@ interface ReadableStreamDefaultController<R = any> {
   error(error?: any): void;
 }
 
+declare var ReadableStreamDefaultController: {
+  prototype: ReadableStreamDefaultController;
+  new (): ReadableStreamDefaultController;
+};
+
 interface ReadableByteStreamController {
   readonly byobRequest: undefined;
   readonly desiredSize: number | null;
@@ -85,6 +108,11 @@ interface ReadableByteStreamController {
   error(error?: any): void;
 }
 
+declare var ReadableByteStreamController: {
+  prototype: ReadableByteStreamController;
+  new (): ReadableByteStreamController;
+};
+
 interface PipeOptions {
   preventAbort?: boolean;
   preventCancel?: boolean;
@@ -122,14 +150,9 @@ declare class ByteLengthQueuingStrategy
 interface ReadableStream<R = any> {
   readonly locked: boolean;
   cancel(reason?: any): Promise<void>;
-  getIterator(options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
-  // getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
   getReader(): ReadableStreamDefaultReader<R>;
   pipeThrough<T>(
-    {
-      writable,
-      readable,
-    }: {
+    { writable, readable }: {
       writable: WritableStream<R>;
       readable: ReadableStream<T>;
     },
@@ -174,28 +197,23 @@ interface WritableStreamErrorCallback {
   (reason: any): void | PromiseLike<void>;
 }
 
-interface UnderlyingSink<W = any> {
-  abort?: WritableStreamErrorCallback;
-  close?: WritableStreamDefaultControllerCloseCallback;
-  start?: WritableStreamDefaultControllerStartCallback;
-  type?: undefined;
-  write?: WritableStreamDefaultControllerWriteCallback<W>;
-}
-
 /** 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. */
-declare class WritableStream<W = any> {
-  constructor(
-    underlyingSink?: UnderlyingSink<W>,
-    strategy?: QueuingStrategy<W>,
-  );
+interface WritableStream<W = any> {
   readonly locked: boolean;
   abort(reason?: any): Promise<void>;
-  close(): Promise<void>;
   getWriter(): WritableStreamDefaultWriter<W>;
 }
 
+declare var WritableStream: {
+  prototype: WritableStream;
+  new <W = any>(
+    underlyingSink?: UnderlyingSink<W>,
+    strategy?: QueuingStrategy<W>,
+  ): WritableStream<W>;
+};
+
 /** 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
@@ -218,16 +236,25 @@ interface WritableStreamDefaultWriter<W = any> {
   write(chunk: W): Promise<void>;
 }
 
-declare class TransformStream<I = any, O = any> {
-  constructor(
-    transformer?: Transformer<I, O>,
-    writableStrategy?: QueuingStrategy<I>,
-    readableStrategy?: QueuingStrategy<O>,
-  );
+declare var WritableStreamDefaultWriter: {
+  prototype: WritableStreamDefaultWriter;
+  new (): WritableStreamDefaultWriter;
+};
+
+interface TransformStream<I = any, O = any> {
   readonly readable: ReadableStream<O>;
   readonly writable: WritableStream<I>;
 }
 
+declare var TransformStream: {
+  prototype: TransformStream;
+  new <I = any, O = any>(
+    transformer?: Transformer<I, O>,
+    writableStrategy?: QueuingStrategy<I>,
+    readableStrategy?: QueuingStrategy<O>,
+  ): TransformStream<I, O>;
+};
+
 interface TransformStreamDefaultController<O = any> {
   readonly desiredSize: number | null;
   enqueue(chunk: O): void;