@serwist/streams 8.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Google LLC, 2019 ShadowWalker w@weiw.io https://weiw.io, 2023 Serwist
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+This module's documentation can be found at https://developers.google.com/web/tools/workbox/reference-docs/latest/module-workbox-streams

package/dist/_types.d.ts

@@ -0,0 +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

@@ -0,0 +1,18 @@
+import type { StreamSource } from "./_types.js";
+/**
+ * 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
+ */
+declare function concatenate(sourcePromises: Promise<StreamSource>[]): {
+    done: Promise<void>;
+    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,CAiFA;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/concatenateToResponse.d.ts

@@ -0,0 +1,21 @@
+import type { StreamSource } from "./_types.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
+ */
+declare function concatenateToResponse(sourcePromises: Promise<StreamSource>[], headersInit: HeadersInit): {
+    done: Promise<void>;
+    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

@@ -0,0 +1,9 @@
+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";
+//# 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

@@ -0,0 +1,231 @@
+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) {
+    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).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") {
+        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 Deferred();
+    let i = 0;
+    const logMessages = [];
+    const stream = new ReadableStream({
+        pull (controller) {
+            return readerPromises[i].then((reader)=>{
+                if (reader instanceof ReadableStreamDefaultReader) {
+                    return reader.read();
+                } else {
+                    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);
+                } else {
+                    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
+    };
+}
+
+/*
+  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 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") {
+            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();
+            } else {
+                // 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 { concatenate, concatenateToResponse, isSupported, strategy };

package/dist/index.old.cjs

@@ -0,0 +1,236 @@
+'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();
+                } else {
+                    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);
+                } else {
+                    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();
+            } else {
+                // 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;

package/dist/isSupported.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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.
+ */
+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

@@ -0,0 +1,20 @@
+import type { RouteHandlerCallback, RouteHandlerCallbackOptions } from "@serwist/core";
+import type { StreamSource } from "./_types.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
+ */
+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,CAyC3G;AAED,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/dist/utils/createHeaders.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+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

@@ -0,0 +1,47 @@
+{
+  "name": "@serwist/streams",
+  "version": "8.0.0",
+  "type": "module",
+  "description": "A library that makes it easier to work with Streams in the browser.",
+  "files": [
+    "dist",
+    "!dist/**/dts"
+  ],
+  "keywords": [
+    "serwist",
+    "serwistjs",
+    "service worker",
+    "sw",
+    "streams",
+    "readablestream"
+  ],
+  "author": "Google's Web DevRel Team, Serwist's Team",
+  "license": "MIT",
+  "repository": "serwist/serwist",
+  "bugs": "https://github.com/serwist/serwist/issues",
+  "homepage": "https://ducanh-next-pwa.vercel.app",
+  "module": "./dist/index.js",
+  "main": "./dist/index.old.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.old.cjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@serwist/core": "8.0.0",
+    "@serwist/routing": "8.0.0"
+  },
+  "devDependencies": {
+    "rollup": "3.28.1",
+    "@serwist/constants": "8.0.0"
+  },
+  "scripts": {
+    "build": "rimraf dist && cross-env NODE_ENV=production rollup --config rollup.config.js",
+    "lint": "eslint src --ext ts,tsx,js,jsx,cjs,mjs",
+    "typecheck": "tsc"
+  }
+}