web-streams-polyfill 3.0.3 → 4.0.0-beta.1

package/package.json

@@ -1,39 +1,64 @@
 {
   "name": "web-streams-polyfill",
-  "version": "3.0.3",
+  "version": "4.0.0-beta.1",
   "description": "Web Streams, based on the WHATWG spec reference implementation",
-  "main": "dist/polyfill",
-  "browser": "dist/polyfill.min.js",
-  "module": "dist/polyfill.mjs",
-  "types": "dist/types/polyfill.d.ts",
+  "main": "dist/ponyfill.js",
+  "module": "dist/ponyfill.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/ponyfill.mjs",
+      "require": "./dist/ponyfill.js"
+    },
+    "./es5": {
+      "import": "./dist/ponyfill.es5.mjs",
+      "require": "./dist/ponyfill.es5.js"
+    },
+    "./polyfill": "./dist/polyfill.js",
+    "./polyfill/es5": "./dist/polyfill.es5.js",
+    "./dist/*": "./dist/*",
+    "./types/*": "./types/*",
+    "./package": "./package.json",
+    "./package.json": "./package.json"
+  },
+  "types": "types/ponyfill.d.ts",
   "typesVersions": {
     ">=3.6": {
-      "dist/types/*": [
-        "dist/types/ts3.6/*"
+      ".": [
+        "./types/ponyfill.d.ts"
+      ],
+      "./es5": [
+        "./types/ponyfill.d.ts"
+      ],
+      "./polyfill": [
+        "./types/polyfill.d.ts"
+      ],
+      "./polyfill/es5": [
+        "./types/polyfill.d.ts"
       ]
     }
   },
   "scripts": {
-    "test": "npm run test:types && npm run test:unit && npm run test:wpt",
+    "test": "npm run test:types && npm run test:unit && npm run test:wpt && npm run test:bundlers",
     "test:wpt": "node --expose_gc ./test/run-web-platform-tests.js",
+    "test:bundlers": "npm run test:rollup && npm run test:webpack",
+    "test:rollup": "cd test/rollup && npm ci && npm test",
+    "test:webpack": "cd test/webpack && npm ci && npm test",
     "pretest:wpt": "git submodule update --init --recursive",
     "test:types": "tsc -p ./test/types/tsconfig.json",
     "test:unit": "jasmine --config=test/unit/jasmine.json",
     "lint": "eslint \"src/**/*.ts\"",
     "build": "npm run build:bundle && npm run build:types",
     "build:bundle": "rollup -c",
-    "build:types": "tsc --project . --emitDeclarationOnly --declarationDir ./lib && api-extractor run && node ./build/downlevel-dts.js",
-    "accept:types": "tsc --project . --emitDeclarationOnly --declarationDir ./lib && api-extractor run --local && node ./build/downlevel-dts.js",
+    "build:types": "tsc --project . --emitDeclarationOnly --declarationDir ./lib && api-extractor run",
+    "accept:types": "tsc --project . --emitDeclarationOnly --declarationDir ./lib && api-extractor run --local",
     "prepare": "npm run build"
   },
   "files": [
     "dist",
-    "es6",
-    "es2018",
-    "ponyfill"
+    "types"
   ],
   "engines": {
-    "node": ">= 8"
+    "node": ">= 12"
   },
   "repository": {
     "type": "git",
@@ -54,23 +79,22 @@
   },
   "homepage": "https://github.com/MattiasBuelens/web-streams-polyfill#readme",
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.13.4",
+    "@microsoft/api-extractor": "^7.18.7",
     "@rollup/plugin-inject": "^4.0.2",
-    "@rollup/plugin-replace": "^2.4.2",
-    "@rollup/plugin-strip": "^2.0.0",
-    "@rollup/plugin-typescript": "^8.2.1",
-    "@types/node": "^14.14.37",
-    "@typescript-eslint/eslint-plugin": "^4.21.0",
-    "@typescript-eslint/parser": "^4.21.0",
+    "@rollup/plugin-replace": "^3.0.0",
+    "@rollup/plugin-strip": "^2.1.0",
+    "@rollup/plugin-typescript": "^8.2.5",
+    "@types/node": "^14.17.12",
+    "@typescript-eslint/eslint-plugin": "^4.29.3",
+    "@typescript-eslint/parser": "^4.29.3",
     "@ungap/promise-all-settled": "^1.1.2",
-    "eslint": "^7.23.0",
-    "jasmine": "^3.7.0",
-    "micromatch": "^4.0.2",
-    "rollup": "^2.44.0",
+    "eslint": "^7.32.0",
+    "jasmine": "^3.9.0",
+    "micromatch": "^4.0.4",
+    "rollup": "^2.56.3",
     "rollup-plugin-terser": "^7.0.2",
-    "ts-morph": "^10.0.2",
-    "tslib": "^2.2.0",
-    "typescript": "^4.2.4",
+    "tslib": "^2.3.0",
+    "typescript": "~4.3.5",
     "wpt-runner": "^3.2.1"
   }
 }

package/types/polyfill.d.ts

@@ -0,0 +1,62 @@
+/// <reference lib="dom" />
+/// <reference lib="es2018.asynciterable" />
+
+import type {
+  ReadableStreamAsyncIterator,
+  ReadableStreamBYOBReader,
+  ReadableStreamBYOBReadResult,
+  ReadableStreamIteratorOptions
+} from './ponyfill';
+
+export type {
+  ReadableStreamAsyncIterator,
+  ReadableStreamBYOBReader,
+  ReadableStreamBYOBReadResult,
+  ReadableStreamIteratorOptions
+};
+
+declare global {
+  interface ReadableStream<R = any> {
+    /**
+     * Creates a {@link 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
+     * {@link ReadableStreamBYOBReader.read | read()} method, into developer-supplied buffers, allowing more precise
+     * control over allocation.
+     */
+    getReader({ mode }: {
+      mode: 'byob';
+    }): ReadableStreamBYOBReader;
+
+    /**
+     * Creates a {@link ReadableStreamDefaultReader} and locks the stream to the new reader.
+     * While the stream is locked, no other reader can be acquired until this one is released.
+     *
+     * This functionality is especially useful for creating abstractions that desire the ability to consume a stream
+     * in its entirety. By getting a reader for the stream, you can ensure nobody else can interleave reads with yours
+     * or cancel the stream, which would interfere with your abstraction.
+     */
+    getReader(): ReadableStreamDefaultReader<R>;
+
+    /**
+     * Asynchronously iterates over the chunks in the stream's internal queue.
+     *
+     * Asynchronously iterating over the stream will lock it, preventing any other consumer from acquiring a reader.
+     * The lock will be released if the async iterator's {@link ReadableStreamAsyncIterator.return | return()} method
+     * is called, e.g. by breaking out of the loop.
+     *
+     * By default, calling the async iterator's {@link ReadableStreamAsyncIterator.return | return()} method will also
+     * cancel the stream. To prevent this, use the stream's {@link ReadableStream.values | values()} method, passing
+     * `true` for the `preventCancel` option.
+     */
+    values(options?: ReadableStreamIteratorOptions): ReadableStreamAsyncIterator<R>;
+
+    /**
+     * {@inheritDoc ReadableStream.values}
+     */
+    [Symbol.asyncIterator]: (options?: ReadableStreamIteratorOptions) => ReadableStreamAsyncIterator<R>;
+  }
+}
+

package/{dist/types/ts3.6/polyfill.d.ts → types/ponyfill.d.ts}

@@ -87,9 +87,11 @@ export declare interface QueuingStrategyInit {
     highWaterMark: number;
 }
 
-declare type QueuingStrategySizeCallback<T = any> = (chunk: T) => number;
-
-declare type ReadableByteStream = ReadableStream<Uint8Array>;
+/**
+ * {@inheritDoc QueuingStrategy.size}
+ * @public
+ */
+export declare type QueuingStrategySizeCallback<T = any> = (chunk: T) => number;
 
 /**
  * Allows control of a {@link ReadableStream | readable byte stream}'s state and internal queue.
@@ -144,7 +146,7 @@ export declare class ReadableStream<R = any> {
      * The supplied `reason` argument will be given to the underlying source's {@link UnderlyingSource.cancel | cancel()}
      * method, which might or might not use it.
      */
-    cancel(reason?: any): Promise<undefined>;
+    cancel(reason?: any): Promise<void>;
     /**
      * Creates a {@link ReadableStreamBYOBReader} and locks the stream to the new reader.
      *
@@ -173,7 +175,10 @@ export declare class ReadableStream<R = any> {
      *
      * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
      */
-    pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
+    pipeThrough<RS extends ReadableStream>(transform: {
+        readable: RS;
+        writable: WritableStream<R>;
+    }, options?: StreamPipeOptions): RS;
     /**
      * Pipes this readable stream to a given writable stream. The way in which the piping process behaves under
      * various error conditions can be customized with a number of passed options. It returns a promise that fulfills
@@ -181,7 +186,7 @@ export declare class ReadableStream<R = any> {
      *
      * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
      */
-    pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<undefined>;
+    pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
     /**
      * Tees this readable stream, returning a two-element array containing the two resulting branches as
      * new {@link ReadableStream} instances.
@@ -218,7 +223,7 @@ export declare class ReadableStream<R = any> {
  * @public
  */
 export declare interface ReadableStreamAsyncIterator<R> extends AsyncIterator<R> {
-    next(): Promise<IteratorResult<R>>;
+    next(): Promise<IteratorResult<R, undefined>>;
     return(value?: any): Promise<IteratorResult<any>>;
 }
 
@@ -228,7 +233,7 @@ export declare interface ReadableStreamAsyncIterator<R> extends AsyncIterator<R>
  * @public
  */
 export declare class ReadableStreamBYOBReader {
-    constructor(stream: ReadableByteStream);
+    constructor(stream: ReadableStream<Uint8Array>);
     /**
      * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
      * the reader's lock is released before the stream finishes closing.
@@ -237,7 +242,7 @@ export declare class ReadableStreamBYOBReader {
     /**
      * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
      */
-    cancel(reason?: any): Promise<undefined>;
+    cancel(reason?: any): Promise<void>;
     /**
      * Attempts to reads bytes into view, and returns a promise resolved with the result.
      *
@@ -262,8 +267,11 @@ export declare class ReadableStreamBYOBReader {
  * @public
  */
 export declare type ReadableStreamBYOBReadResult<T extends ArrayBufferView> = {
-    done: boolean;
+    done: false;
     value: T;
+} | {
+    done: true;
+    value: T | undefined;
 };
 
 /**
@@ -337,7 +345,7 @@ export declare class ReadableStreamDefaultReader<R = any> {
     /**
      * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
      */
-    cancel(reason?: any): Promise<undefined>;
+    cancel(reason?: any): Promise<void>;
     /**
      * Returns a promise that allows access to the next chunk from the stream's internal queue, if available.
      *
@@ -366,7 +374,7 @@ export declare type ReadableStreamDefaultReadResult<T> = {
     value: T;
 } | {
     done: true;
-    value: undefined;
+    value?: undefined;
 };
 
 /**
@@ -649,7 +657,7 @@ export declare class WritableStream<W = any> {
      * that there was an error doing so. Additionally, it will reject with a `TypeError` (without attempting to cancel
      * the stream) if the stream is currently locked.
      */
-    abort(reason?: any): Promise<undefined>;
+    abort(reason?: any): Promise<void>;
     /**
      * Closes the stream. The underlying sink will finish processing any previously-written chunks, before invoking its
      * close behavior. During this time any further attempts to write will fail (without erroring the stream).
@@ -677,6 +685,14 @@ export declare class WritableStream<W = any> {
  */
 export declare class WritableStreamDefaultController<W = any> {
     private constructor();
+    /**
+     * The reason which was passed to `WritableStream.abort(reason)` when the stream was aborted.
+     */
+    get abortReason(): any;
+    /**
+     * An `AbortSignal` that can be used to abort the pending write or close operation when the stream is aborted.
+     */
+    get signal(): AbortSignal;
     /**
      * Closes the controlled writable stream, making all future interactions with it fail with the given error `e`.
      *
@@ -720,11 +736,11 @@ export declare class WritableStreamDefaultWriter<W = any> {
     /**
      * If the reader is active, behaves the same as {@link WritableStream.abort | stream.abort(reason)}.
      */
-    abort(reason?: any): Promise<undefined>;
+    abort(reason?: any): Promise<void>;
     /**
      * If the reader is active, behaves the same as {@link WritableStream.close | stream.close()}.
      */
-    close(): Promise<undefined>;
+    close(): Promise<void>;
     /**
      * Releases the writer’s lock on the corresponding stream. After the lock is released, the writer is no longer active.
      * If the associated stream is errored when the lock is released, the writer will appear errored in the same way from
@@ -745,7 +761,7 @@ export declare class WritableStreamDefaultWriter<W = any> {
      * Note that what "success" means is up to the underlying sink; it might indicate simply that the chunk has been
      * accepted, and not necessarily that it is safely saved to its ultimate destination.
      */
-    write(chunk: W): Promise<undefined>;
+    write(chunk: W): Promise<void>;
 }
 
 export { }

package/{dist/types → types}/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.13.4"
+      "packageVersion": "7.18.7"
     }
   ]
 }