@serwist/streams 8.4.4 → 9.0.0-preview.1

package/dist/_types.d.ts

@@ -1 +1,2 @@
 export type StreamSource = Response | ReadableStream | BodyInit;
+//# sourceMappingURL=_types.d.ts.map

package/dist/_types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_types.d.ts","sourceRoot":"","sources":["../src/_types.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,cAAc,GAAG,QAAQ,CAAC"}

package/dist/concatenate.d.ts

@@ -15,3 +15,4 @@ declare function concatenate(sourcePromises: Promise<StreamSource>[]): {
     stream: ReadableStream;
 };
 export { concatenate };
+//# sourceMappingURL=concatenate.d.ts.map

package/dist/concatenate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concatenate.d.ts","sourceRoot":"","sources":["../src/concatenate.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAyBhD;;;;;;;;;;GAUG;AACH,iBAAS,WAAW,CAAC,cAAc,EAAE,OAAO,CAAC,YAAY,CAAC,EAAE,GAAG;IAC7D,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACpB,MAAM,EAAE,cAAc,CAAC;CACxB,CA+EA;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/concatenateToResponse.d.ts

@@ -18,3 +18,4 @@ declare function concatenateToResponse(sourcePromises: Promise<StreamSource>[],
     response: Response;
 };
 export { concatenateToResponse };
+//# sourceMappingURL=concatenateToResponse.d.ts.map

package/dist/concatenateToResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concatenateToResponse.d.ts","sourceRoot":"","sources":["../src/concatenateToResponse.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIhD;;;;;;;;;;;;;GAaG;AACH,iBAAS,qBAAqB,CAAC,cAAc,EAAE,OAAO,CAAC,YAAY,CAAC,EAAE,EAAE,WAAW,EAAE,WAAW,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE,CAO7I;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/index.d.ts

@@ -6,3 +6,4 @@ import { strategy } from "./strategy.js";
 export { concatenate, concatenateToResponse, isSupported, strategy };
 export type { StreamsHandlerCallback };
 export * from "./_types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,OAAO,EAAE,WAAW,EAAE,qBAAqB,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC;AAErE,YAAY,EAAE,sBAAsB,EAAE,CAAC;AAEvC,cAAc,aAAa,CAAC"}

package/dist/index.js

@@ -1,16 +1,7 @@
 import { assert, Deferred, logger, SerwistError, canConstructReadableStream } from '@serwist/core/internal';
 
-/**
- * Takes either a Response, a ReadableStream, or a
- * [BodyInit](https://fetch.spec.whatwg.org/#bodyinit) and returns the
- * ReadableStreamReader object associated with it.
- *
- * @param source
- * @returns
- * @private
- */ function _getReaderFromSource(source) {
+function _getReaderFromSource(source) {
     if (source instanceof Response) {
-        // See https://github.com/GoogleChrome/workbox/issues/2998
         if (source.body) {
             return source.body.getReader();
         }
@@ -23,17 +14,7 @@ import { assert, Deferred, logger, SerwistError, canConstructReadableStream } fr
     }
     return new Response(source).body.getReader();
 }
-/**
- * Takes multiple source Promises, each of which could resolve to a Response, a
- * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit).
- *
- * Returns an object exposing a ReadableStream with each individual stream's
- * data returned in sequence, along with a Promise which signals when the
- * stream is finished (useful for passing to a FetchEvent's waitUntil()).
- *
- * @param sourcePromises
- * @returns
- */ function concatenate(sourcePromises) {
+function concatenate(sourcePromises) {
     if (process.env.NODE_ENV !== "production") {
         assert.isArray(sourcePromises, {
             moduleName: "@serwist/streams",
@@ -66,7 +47,6 @@ import { assert, Deferred, logger, SerwistError, canConstructReadableStream } fr
                     }
                     i++;
                     if (i >= readerPromises.length) {
-                        // Log all the messages in the group at once in a single group.
                         if (process.env.NODE_ENV !== "production") {
                             logger.groupCollapsed(`Concatenating ${readerPromises.length} sources.`);
                             for (const message of logMessages){
@@ -83,7 +63,6 @@ import { assert, Deferred, logger, SerwistError, canConstructReadableStream } fr
                         streamDeferred.resolve();
                         return;
                     }
-                    // The `pull` method is defined because we're inside it.
                     return this.pull(controller);
                 }
                 controller.enqueue(result?.value);
@@ -108,24 +87,7 @@ import { assert, Deferred, logger, SerwistError, canConstructReadableStream } fr
     };
 }
 
-/*
-  Copyright 2018 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ /**
- * This is a utility method that determines whether the current browser supports
- * the features required to create streamed responses. Currently, it checks if
- * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)
- * is available.
- *
- * @private
- * @param headersInit If there's no `Content-Type` specified, `'text/html'` will be used by default.
- * @returns `true`, if the current browser meets the requirements for
- * streaming responses, and `false` otherwise.
- */ function createHeaders(headersInit = {}) {
-    // See https://github.com/GoogleChrome/workbox/issues/1461
+function createHeaders(headersInit = {}) {
     const headers = new Headers(headersInit);
     if (!headers.has("content-type")) {
         headers.set("content-type", "text/html");
@@ -133,20 +95,7 @@ import { assert, Deferred, logger, SerwistError, canConstructReadableStream } fr
     return headers;
 }
 
-/**
- * Takes multiple source Promises, each of which could resolve to a Response, a
- * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit),
- * along with a
- * [HeadersInit](https://fetch.spec.whatwg.org/#typedefdef-headersinit).
- *
- * Returns an object exposing a Response whose body consists of each individual
- * stream's data returned in sequence, along with a Promise which signals when
- * the stream is finished (useful for passing to a FetchEvent's waitUntil()).
- *
- * @param sourcePromises
- * @param headersInit If there's no `Content-Type` specified,`'text/html'` will be used by default.
- * @returns
- */ function concatenateToResponse(sourcePromises, headersInit) {
+function concatenateToResponse(sourcePromises, headersInit) {
     const { done, stream } = concatenate(sourcePromises);
     const headers = createHeaders(headersInit);
     const response = new Response(stream, {
@@ -158,33 +107,13 @@ import { assert, Deferred, logger, SerwistError, canConstructReadableStream } fr
     };
 }
 
-/**
- * This is a utility method that determines whether the current browser supports
- * the features required to create streamed responses. Currently, it checks if
- * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)
- * can be created.
- *
- * @returns `true`, if the current browser meets the requirements for
- * streaming responses, and `false` otherwise.
- */ function isSupported() {
+function isSupported() {
     return canConstructReadableStream();
 }
 
-/**
- * A shortcut to create a strategy that could be dropped-in to Serwist's router.
- *
- * On browsers that do not support constructing new `ReadableStream`s, this
- * strategy will automatically wait for all the `sourceFunctions` to complete,
- * and create a final response that concatenates their values together.
- *
- * @param sourceFunctions An array of functions similar to `@serwist/routing.handlerCallback`
- * but that instead return a `@serwist/streams.StreamSource` (or a Promise which resolves to one).
- * @param headersInit If there's no `Content-Type` specified, `'text/html'` will be used by default.
- * @returns
- */ function strategy(sourceFunctions, headersInit) {
+function strategy(sourceFunctions, headersInit) {
     return async ({ event, request, url, params })=>{
         const sourcePromises = sourceFunctions.map((fn)=>{
-            // Ensure the return value of the function is always a promise.
             return Promise.resolve(fn({
                 event,
                 request,
@@ -202,23 +131,15 @@ import { assert, Deferred, logger, SerwistError, canConstructReadableStream } fr
         if (process.env.NODE_ENV !== "production") {
             logger.log(`The current browser doesn't support creating response ` + "streams. Falling back to non-streaming response instead.");
         }
-        // Fallback to waiting for everything to finish, and concatenating the
-        // responses.
         const blobPartsPromises = sourcePromises.map(async (sourcePromise)=>{
             const source = await sourcePromise;
             if (source instanceof Response) {
                 return source.blob();
             }
-            // Technically, a `StreamSource` object can include any valid
-            // `BodyInit` type, including `FormData` and `URLSearchParams`, which
-            // cannot be passed to the Blob constructor directly, so we have to
-            // convert them to actual Blobs first.
             return new Response(source).blob();
         });
         const blobParts = await Promise.all(blobPartsPromises);
         const headers = createHeaders(headersInit);
-        // Constructing a new Response from a Blob source is well-supported.
-        // So is constructing a new Blob from multiple source Blobs or strings.
         return new Response(new Blob(blobParts), {
             headers
         });

package/dist/isSupported.d.ts

@@ -9,3 +9,4 @@
  */
 declare function isSupported(): boolean;
 export { isSupported };
+//# sourceMappingURL=isSupported.d.ts.map

package/dist/isSupported.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSupported.d.ts","sourceRoot":"","sources":["../src/isSupported.ts"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH,iBAAS,WAAW,IAAI,OAAO,CAE9B;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/strategy.d.ts

@@ -17,3 +17,4 @@ export interface StreamsHandlerCallback {
  */
 declare function strategy(sourceFunctions: StreamsHandlerCallback[], headersInit: HeadersInit): RouteHandlerCallback;
 export { strategy };
+//# sourceMappingURL=strategy.d.ts.map

package/dist/strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../src/strategy.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAGvF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAKhD,MAAM,WAAW,sBAAsB;IACrC,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,2BAA2B,GAAG,OAAO,CAAC,YAAY,CAAC,GAAG,YAAY,CAAC;CACtG;AAED;;;;;;;;;;;GAWG;AACH,iBAAS,QAAQ,CAAC,eAAe,EAAE,sBAAsB,EAAE,EAAE,WAAW,EAAE,WAAW,GAAG,oBAAoB,CAwC3G;AAED,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/dist/utils/createHeaders.d.ts

@@ -11,3 +11,4 @@
  */
 declare function createHeaders(headersInit?: {}): Headers;
 export { createHeaders };
+//# sourceMappingURL=createHeaders.d.ts.map

package/dist/utils/createHeaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHeaders.d.ts","sourceRoot":"","sources":["../../src/utils/createHeaders.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,iBAAS,aAAa,CAAC,WAAW,KAAK,GAAG,OAAO,CAOhD;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@serwist/streams",
-  "version": "8.4.4",
+  "version": "9.0.0-preview.1",
   "type": "module",
   "description": "A library that makes it easier to work with Streams in the browser.",
   "files": [
-    "dist",
-    "!dist/**/dts"
+    "src",
+    "dist"
   ],
   "keywords": [
     "serwist",
@@ -20,29 +20,31 @@
   "repository": "serwist/serwist",
   "bugs": "https://github.com/serwist/serwist/issues",
   "homepage": "https://serwist.pages.dev",
-  "module": "./dist/index.js",
-  "main": "./dist/index.cjs",
+  "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@serwist/core": "8.4.4",
-    "@serwist/routing": "8.4.4"
+    "@serwist/core": "9.0.0-preview.1",
+    "@serwist/routing": "9.0.0-preview.1"
   },
   "devDependencies": {
-    "rollup": "4.9.1",
-    "@serwist/constants": "8.4.4"
+    "rollup": "4.9.6",
+    "typescript": "5.4.0-dev.20240203",
+    "@serwist/constants": "9.0.0-preview.1"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
   },
   "scripts": {
     "build": "rimraf dist && cross-env NODE_ENV=production rollup --config rollup.config.js",

package/src/_types.ts

@@ -0,0 +1,9 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+export type StreamSource = Response | ReadableStream | BodyInit;

package/src/concatenate.ts

@@ -0,0 +1,131 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import { assert, Deferred, SerwistError, logger } from "@serwist/core/internal";
+
+import type { StreamSource } from "./_types.js";
+
+/**
+ * Takes either a Response, a ReadableStream, or a
+ * [BodyInit](https://fetch.spec.whatwg.org/#bodyinit) and returns the
+ * ReadableStreamReader object associated with it.
+ *
+ * @param source
+ * @returns
+ * @private
+ */
+function _getReaderFromSource(source: StreamSource): ReadableStreamReader<unknown> {
+  if (source instanceof Response) {
+    // See https://github.com/GoogleChrome/workbox/issues/2998
+    if (source.body) {
+      return source.body.getReader();
+    }
+    throw new SerwistError("opaque-streams-source", { type: source.type });
+  }
+  if (source instanceof ReadableStream) {
+    return source.getReader();
+  }
+  return new Response(source as BodyInit).body!.getReader();
+}
+
+/**
+ * Takes multiple source Promises, each of which could resolve to a Response, a
+ * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit).
+ *
+ * Returns an object exposing a ReadableStream with each individual stream's
+ * data returned in sequence, along with a Promise which signals when the
+ * stream is finished (useful for passing to a FetchEvent's waitUntil()).
+ *
+ * @param sourcePromises
+ * @returns
+ */
+function concatenate(sourcePromises: Promise<StreamSource>[]): {
+  done: Promise<void>;
+  stream: ReadableStream;
+} {
+  if (process.env.NODE_ENV !== "production") {
+    assert!.isArray(sourcePromises, {
+      moduleName: "@serwist/streams",
+      funcName: "concatenate",
+      paramName: "sourcePromises",
+    });
+  }
+
+  const readerPromises = sourcePromises.map((sourcePromise) => {
+    return Promise.resolve(sourcePromise).then((source) => {
+      return _getReaderFromSource(source);
+    });
+  });
+
+  const streamDeferred: Deferred<void> = new Deferred();
+
+  let i = 0;
+  const logMessages: any[] = [];
+  const stream = new ReadableStream({
+    pull(controller: ReadableStreamDefaultController<any>) {
+      return readerPromises[i]
+        .then((reader) => {
+          if (reader instanceof ReadableStreamDefaultReader) {
+            return reader.read();
+          }
+          return;
+        })
+        .then((result) => {
+          if (result?.done) {
+            if (process.env.NODE_ENV !== "production") {
+              logMessages.push(["Reached the end of source:", sourcePromises[i]]);
+            }
+
+            i++;
+            if (i >= readerPromises.length) {
+              // Log all the messages in the group at once in a single group.
+              if (process.env.NODE_ENV !== "production") {
+                logger.groupCollapsed(`Concatenating ${readerPromises.length} sources.`);
+                for (const message of logMessages) {
+                  if (Array.isArray(message)) {
+                    logger.log(...message);
+                  } else {
+                    logger.log(message);
+                  }
+                }
+                logger.log("Finished reading all sources.");
+                logger.groupEnd();
+              }
+
+              controller.close();
+              streamDeferred.resolve();
+              return;
+            }
+
+            // The `pull` method is defined because we're inside it.
+            return this.pull!(controller);
+          }
+          controller.enqueue(result?.value);
+        })
+        .catch((error) => {
+          if (process.env.NODE_ENV !== "production") {
+            logger.error("An error occurred:", error);
+          }
+          streamDeferred.reject(error);
+          throw error;
+        });
+    },
+
+    cancel() {
+      if (process.env.NODE_ENV !== "production") {
+        logger.warn("The ReadableStream was cancelled.");
+      }
+
+      streamDeferred.resolve();
+    },
+  });
+
+  return { done: streamDeferred.promise, stream };
+}
+
+export { concatenate };

package/src/concatenateToResponse.ts

@@ -0,0 +1,36 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import type { StreamSource } from "./_types.js";
+import { concatenate } from "./concatenate.js";
+import { createHeaders } from "./utils/createHeaders.js";
+
+/**
+ * Takes multiple source Promises, each of which could resolve to a Response, a
+ * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit),
+ * along with a
+ * [HeadersInit](https://fetch.spec.whatwg.org/#typedefdef-headersinit).
+ *
+ * Returns an object exposing a Response whose body consists of each individual
+ * stream's data returned in sequence, along with a Promise which signals when
+ * the stream is finished (useful for passing to a FetchEvent's waitUntil()).
+ *
+ * @param sourcePromises
+ * @param headersInit If there's no `Content-Type` specified,`'text/html'` will be used by default.
+ * @returns
+ */
+function concatenateToResponse(sourcePromises: Promise<StreamSource>[], headersInit: HeadersInit): { done: Promise<void>; response: Response } {
+  const { done, stream } = concatenate(sourcePromises);
+
+  const headers = createHeaders(headersInit);
+  const response = new Response(stream, { headers });
+
+  return { done, response };
+}
+
+export { concatenateToResponse };

package/{dist/index.d.cts → src/index.ts}

@@ -1,8 +1,19 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
 import { concatenate } from "./concatenate.js";
 import { concatenateToResponse } from "./concatenateToResponse.js";
 import { isSupported } from "./isSupported.js";
 import type { StreamsHandlerCallback } from "./strategy.js";
 import { strategy } from "./strategy.js";
+
 export { concatenate, concatenateToResponse, isSupported, strategy };
+
 export type { StreamsHandlerCallback };
+
 export * from "./_types.js";

package/src/isSupported.ts

@@ -0,0 +1,24 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import { canConstructReadableStream } from "@serwist/core/internal";
+
+/**
+ * This is a utility method that determines whether the current browser supports
+ * the features required to create streamed responses. Currently, it checks if
+ * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)
+ * can be created.
+ *
+ * @returns `true`, if the current browser meets the requirements for
+ * streaming responses, and `false` otherwise.
+ */
+function isSupported(): boolean {
+  return canConstructReadableStream();
+}
+
+export { isSupported };

package/src/strategy.ts

@@ -0,0 +1,75 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import type { RouteHandlerCallback, RouteHandlerCallbackOptions } from "@serwist/core";
+import { logger } from "@serwist/core/internal";
+
+import type { StreamSource } from "./_types.js";
+import { concatenateToResponse } from "./concatenateToResponse.js";
+import { isSupported } from "./isSupported.js";
+import { createHeaders } from "./utils/createHeaders.js";
+
+export interface StreamsHandlerCallback {
+  ({ url, request, event, params }: RouteHandlerCallbackOptions): Promise<StreamSource> | StreamSource;
+}
+
+/**
+ * A shortcut to create a strategy that could be dropped-in to Serwist's router.
+ *
+ * On browsers that do not support constructing new `ReadableStream`s, this
+ * strategy will automatically wait for all the `sourceFunctions` to complete,
+ * and create a final response that concatenates their values together.
+ *
+ * @param sourceFunctions An array of functions similar to `@serwist/routing.handlerCallback`
+ * but that instead return a `@serwist/streams.StreamSource` (or a Promise which resolves to one).
+ * @param headersInit If there's no `Content-Type` specified, `'text/html'` will be used by default.
+ * @returns
+ */
+function strategy(sourceFunctions: StreamsHandlerCallback[], headersInit: HeadersInit): RouteHandlerCallback {
+  return async ({ event, request, url, params }: RouteHandlerCallbackOptions) => {
+    const sourcePromises = sourceFunctions.map((fn) => {
+      // Ensure the return value of the function is always a promise.
+      return Promise.resolve(fn({ event, request, url, params }));
+    });
+
+    if (isSupported()) {
+      const { done, response } = concatenateToResponse(sourcePromises, headersInit);
+
+      if (event) {
+        event.waitUntil(done);
+      }
+      return response;
+    }
+
+    if (process.env.NODE_ENV !== "production") {
+      logger.log(`The current browser doesn't support creating response ` + "streams. Falling back to non-streaming response instead.");
+    }
+
+    // Fallback to waiting for everything to finish, and concatenating the
+    // responses.
+    const blobPartsPromises = sourcePromises.map(async (sourcePromise) => {
+      const source = await sourcePromise;
+      if (source instanceof Response) {
+        return source.blob();
+      }
+      // Technically, a `StreamSource` object can include any valid
+      // `BodyInit` type, including `FormData` and `URLSearchParams`, which
+      // cannot be passed to the Blob constructor directly, so we have to
+      // convert them to actual Blobs first.
+      return new Response(source).blob();
+    });
+    const blobParts = await Promise.all(blobPartsPromises);
+    const headers = createHeaders(headersInit);
+
+    // Constructing a new Response from a Blob source is well-supported.
+    // So is constructing a new Blob from multiple source Blobs or strings.
+    return new Response(new Blob(blobParts), { headers });
+  };
+}
+
+export { strategy };

package/src/utils/createHeaders.ts

@@ -0,0 +1,29 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+/**
+ * This is a utility method that determines whether the current browser supports
+ * the features required to create streamed responses. Currently, it checks if
+ * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)
+ * is available.
+ *
+ * @private
+ * @param headersInit If there's no `Content-Type` specified, `'text/html'` will be used by default.
+ * @returns `true`, if the current browser meets the requirements for
+ * streaming responses, and `false` otherwise.
+ */
+function createHeaders(headersInit = {}): Headers {
+  // See https://github.com/GoogleChrome/workbox/issues/1461
+  const headers = new Headers(headersInit);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "text/html");
+  }
+  return headers;
+}
+
+export { createHeaders };

package/dist/index.cjs

@@ -1,233 +0,0 @@
-'use strict';
-
-var internal = require('@serwist/core/internal');
-
-/**
- * Takes either a Response, a ReadableStream, or a
- * [BodyInit](https://fetch.spec.whatwg.org/#bodyinit) and returns the
- * ReadableStreamReader object associated with it.
- *
- * @param source
- * @returns
- * @private
- */ function _getReaderFromSource(source) {
-    if (source instanceof Response) {
-        // See https://github.com/GoogleChrome/workbox/issues/2998
-        if (source.body) {
-            return source.body.getReader();
-        }
-        throw new internal.SerwistError("opaque-streams-source", {
-            type: source.type
-        });
-    }
-    if (source instanceof ReadableStream) {
-        return source.getReader();
-    }
-    return new Response(source).body.getReader();
-}
-/**
- * Takes multiple source Promises, each of which could resolve to a Response, a
- * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit).
- *
- * Returns an object exposing a ReadableStream with each individual stream's
- * data returned in sequence, along with a Promise which signals when the
- * stream is finished (useful for passing to a FetchEvent's waitUntil()).
- *
- * @param sourcePromises
- * @returns
- */ function concatenate(sourcePromises) {
-    if (process.env.NODE_ENV !== "production") {
-        internal.assert.isArray(sourcePromises, {
-            moduleName: "@serwist/streams",
-            funcName: "concatenate",
-            paramName: "sourcePromises"
-        });
-    }
-    const readerPromises = sourcePromises.map((sourcePromise)=>{
-        return Promise.resolve(sourcePromise).then((source)=>{
-            return _getReaderFromSource(source);
-        });
-    });
-    const streamDeferred = new internal.Deferred();
-    let i = 0;
-    const logMessages = [];
-    const stream = new ReadableStream({
-        pull (controller) {
-            return readerPromises[i].then((reader)=>{
-                if (reader instanceof ReadableStreamDefaultReader) {
-                    return reader.read();
-                }
-                return;
-            }).then((result)=>{
-                if (result?.done) {
-                    if (process.env.NODE_ENV !== "production") {
-                        logMessages.push([
-                            "Reached the end of source:",
-                            sourcePromises[i]
-                        ]);
-                    }
-                    i++;
-                    if (i >= readerPromises.length) {
-                        // Log all the messages in the group at once in a single group.
-                        if (process.env.NODE_ENV !== "production") {
-                            internal.logger.groupCollapsed(`Concatenating ${readerPromises.length} sources.`);
-                            for (const message of logMessages){
-                                if (Array.isArray(message)) {
-                                    internal.logger.log(...message);
-                                } else {
-                                    internal.logger.log(message);
-                                }
-                            }
-                            internal.logger.log("Finished reading all sources.");
-                            internal.logger.groupEnd();
-                        }
-                        controller.close();
-                        streamDeferred.resolve();
-                        return;
-                    }
-                    // The `pull` method is defined because we're inside it.
-                    return this.pull(controller);
-                }
-                controller.enqueue(result?.value);
-            }).catch((error)=>{
-                if (process.env.NODE_ENV !== "production") {
-                    internal.logger.error("An error occurred:", error);
-                }
-                streamDeferred.reject(error);
-                throw error;
-            });
-        },
-        cancel () {
-            if (process.env.NODE_ENV !== "production") {
-                internal.logger.warn("The ReadableStream was cancelled.");
-            }
-            streamDeferred.resolve();
-        }
-    });
-    return {
-        done: streamDeferred.promise,
-        stream
-    };
-}
-
-/*
-  Copyright 2018 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ /**
- * This is a utility method that determines whether the current browser supports
- * the features required to create streamed responses. Currently, it checks if
- * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)
- * is available.
- *
- * @private
- * @param headersInit If there's no `Content-Type` specified, `'text/html'` will be used by default.
- * @returns `true`, if the current browser meets the requirements for
- * streaming responses, and `false` otherwise.
- */ function createHeaders(headersInit = {}) {
-    // See https://github.com/GoogleChrome/workbox/issues/1461
-    const headers = new Headers(headersInit);
-    if (!headers.has("content-type")) {
-        headers.set("content-type", "text/html");
-    }
-    return headers;
-}
-
-/**
- * Takes multiple source Promises, each of which could resolve to a Response, a
- * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit),
- * along with a
- * [HeadersInit](https://fetch.spec.whatwg.org/#typedefdef-headersinit).
- *
- * Returns an object exposing a Response whose body consists of each individual
- * stream's data returned in sequence, along with a Promise which signals when
- * the stream is finished (useful for passing to a FetchEvent's waitUntil()).
- *
- * @param sourcePromises
- * @param headersInit If there's no `Content-Type` specified,`'text/html'` will be used by default.
- * @returns
- */ function concatenateToResponse(sourcePromises, headersInit) {
-    const { done, stream } = concatenate(sourcePromises);
-    const headers = createHeaders(headersInit);
-    const response = new Response(stream, {
-        headers
-    });
-    return {
-        done,
-        response
-    };
-}
-
-/**
- * This is a utility method that determines whether the current browser supports
- * the features required to create streamed responses. Currently, it checks if
- * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)
- * can be created.
- *
- * @returns `true`, if the current browser meets the requirements for
- * streaming responses, and `false` otherwise.
- */ function isSupported() {
-    return internal.canConstructReadableStream();
-}
-
-/**
- * A shortcut to create a strategy that could be dropped-in to Serwist's router.
- *
- * On browsers that do not support constructing new `ReadableStream`s, this
- * strategy will automatically wait for all the `sourceFunctions` to complete,
- * and create a final response that concatenates their values together.
- *
- * @param sourceFunctions An array of functions similar to `@serwist/routing.handlerCallback`
- * but that instead return a `@serwist/streams.StreamSource` (or a Promise which resolves to one).
- * @param headersInit If there's no `Content-Type` specified, `'text/html'` will be used by default.
- * @returns
- */ function strategy(sourceFunctions, headersInit) {
-    return async ({ event, request, url, params })=>{
-        const sourcePromises = sourceFunctions.map((fn)=>{
-            // Ensure the return value of the function is always a promise.
-            return Promise.resolve(fn({
-                event,
-                request,
-                url,
-                params
-            }));
-        });
-        if (isSupported()) {
-            const { done, response } = concatenateToResponse(sourcePromises, headersInit);
-            if (event) {
-                event.waitUntil(done);
-            }
-            return response;
-        }
-        if (process.env.NODE_ENV !== "production") {
-            internal.logger.log(`The current browser doesn't support creating response ` + "streams. Falling back to non-streaming response instead.");
-        }
-        // Fallback to waiting for everything to finish, and concatenating the
-        // responses.
-        const blobPartsPromises = sourcePromises.map(async (sourcePromise)=>{
-            const source = await sourcePromise;
-            if (source instanceof Response) {
-                return source.blob();
-            }
-            // Technically, a `StreamSource` object can include any valid
-            // `BodyInit` type, including `FormData` and `URLSearchParams`, which
-            // cannot be passed to the Blob constructor directly, so we have to
-            // convert them to actual Blobs first.
-            return new Response(source).blob();
-        });
-        const blobParts = await Promise.all(blobPartsPromises);
-        const headers = createHeaders(headersInit);
-        // Constructing a new Response from a Blob source is well-supported.
-        // So is constructing a new Blob from multiple source Blobs or strings.
-        return new Response(new Blob(blobParts), {
-            headers
-        });
-    };
-}
-
-exports.concatenate = concatenate;
-exports.concatenateToResponse = concatenateToResponse;
-exports.isSupported = isSupported;
-exports.strategy = strategy;