@serwist/streams 9.5.7 → 9.5.8

package/dist/index.d.mts

@@ -0,0 +1,77 @@
+import { RouteHandlerCallback, RouteHandlerCallbackOptions } from "serwist";
+
+//#region src/_types.d.ts
+type StreamSource = Response | ReadableStream | BodyInit;
+//#endregion
+//#region src/concatenate.d.ts
+/**
+ * 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;
+};
+//#endregion
+//#region src/concatenateToResponse.d.ts
+/**
+ * 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;
+};
+//#endregion
+//#region src/isSupported.d.ts
+/**
+ * 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 const isSupported: () => boolean;
+//#endregion
+//#region src/strategy.d.ts
+type 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.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 const strategy: (sourceFunctions: StreamsHandlerCallback[], headersInit: HeadersInit) => RouteHandlerCallback;
+//#endregion
+export { StreamSource, type StreamsHandlerCallback, concatenate, concatenateToResponse, isSupported, strategy };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/_types.ts","../src/concatenate.ts","../src/concatenateToResponse.ts","../src/isSupported.ts","../src/strategy.ts"],"mappings":";;;KAQY,YAAA,GAAe,QAAA,GAAW,cAAA,GAAiB,QAAA;;;;;AAAvD;;;;;;;;;iBCsCS,WAAA,CAAY,cAAA,EAAgB,OAAA,CAAQ,YAAA;EAC3C,IAAA,EAAM,OAAA;EACN,MAAA,EAAQ,cAAA;AAAA;;;;;ADxCV;;;;;;;;;;;;iBEkBS,qBAAA,CAAsB,cAAA,EAAgB,OAAA,CAAQ,YAAA,KAAiB,WAAA,EAAa,WAAA;EAAgB,IAAA,EAAM,OAAA;EAAe,QAAA,EAAU,QAAA;AAAA;;;;;;AFlBpI;;;;;;cGWa,WAAA;;;KCHD,sBAAA;EAA4B,GAAA;EAAK,OAAA;EAAS,KAAA;EAAO;AAAA,GAAU,2BAAA,KAAgC,OAAA,CAAQ,YAAA,IAAgB,YAAA;AJR/H;;;;;;;;;;;;AAAA,cIsBa,QAAA,GAAY,eAAA,EAAiB,sBAAA,IAA0B,WAAA,EAAa,WAAA,KAAc,oBAAA"}

package/dist/index.mjs

@@ -0,0 +1,181 @@
+import { Deferred, SerwistError, assert, canConstructReadableStream, logger } from "serwist/internal";
+//#region src/concatenate.ts
+/**
+* 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) {
+		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();
+			}).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) {
+						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;
+					}
+					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
+	};
+}
+//#endregion
+//#region src/utils/createHeaders.ts
+/**
+* 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 = {}) {
+	const headers = new Headers(headersInit);
+	if (!headers.has("content-type")) headers.set("content-type", "text/html");
+	return headers;
+}
+//#endregion
+//#region src/concatenateToResponse.ts
+/**
+* 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);
+	return {
+		done,
+		response: new Response(stream, { headers })
+	};
+}
+//#endregion
+//#region src/isSupported.ts
+/**
+* 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.
+*/
+const isSupported = () => canConstructReadableStream();
+//#endregion
+//#region src/strategy.ts
+/**
+* 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.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
+*/
+const strategy = (sourceFunctions, headersInit) => {
+	return async ({ event, request, url, params }) => {
+		const sourcePromises = sourceFunctions.map((fn) => {
+			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.");
+		const blobPartsPromises = sourcePromises.map(async (sourcePromise) => {
+			const source = await sourcePromise;
+			if (source instanceof Response) return source.blob();
+			return new Response(source).blob();
+		});
+		const blobParts = await Promise.all(blobPartsPromises);
+		const headers = createHeaders(headersInit);
+		return new Response(new Blob(blobParts), { headers });
+	};
+};
+//#endregion
+export { concatenate, concatenateToResponse, isSupported, strategy };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serwist/streams",
-  "version": "9.5.7",
+  "version": "9.5.8",
   "type": "module",
   "description": "A library that makes it easier to work with Streams in the browser.",
   "files": [
@@ -23,22 +23,21 @@
   "repository": "https://github.com/serwist/serwist",
   "bugs": "https://github.com/serwist/serwist/issues",
   "homepage": "https://serwist.pages.dev",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
     },
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "serwist": "9.5.7"
+    "serwist": "9.5.8"
   },
   "devDependencies": {
-    "rollup": "4.59.0",
-    "typescript": "5.9.3",
-    "@serwist/configs": "9.5.7"
+    "tsdown": "0.21.10",
+    "typescript": "6.0.3"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"
@@ -49,8 +48,8 @@
     }
   },
   "scripts": {
-    "build": "rimraf dist && NODE_ENV=production rollup --config rollup.config.js",
-    "dev": "rollup --config rollup.config.js --watch",
+    "build": "rimraf dist && NODE_ENV=production tsdown",
+    "dev": "tsdown --watch",
     "lint": "biome lint ./src",
     "typecheck": "tsc"
   }

package/dist/_types.d.ts

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

package/dist/_types.d.ts.map

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

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

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

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

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

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

@@ -1 +0,0 @@
-{"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,147 +0,0 @@
-import { assert, Deferred, logger, SerwistError, canConstructReadableStream } from 'serwist/internal';
-
-function _getReaderFromSource(source) {
-    if (source instanceof Response) {
-        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();
-}
-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();
-                }
-                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) {
-                        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;
-                    }
-                    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
-    };
-}
-
-function createHeaders(headersInit = {}) {
-    const headers = new Headers(headersInit);
-    if (!headers.has("content-type")) {
-        headers.set("content-type", "text/html");
-    }
-    return headers;
-}
-
-function concatenateToResponse(sourcePromises, headersInit) {
-    const { done, stream } = concatenate(sourcePromises);
-    const headers = createHeaders(headersInit);
-    const response = new Response(stream, {
-        headers
-    });
-    return {
-        done,
-        response
-    };
-}
-
-const isSupported = ()=>canConstructReadableStream();
-
-const strategy = (sourceFunctions, headersInit)=>{
-    return async ({ event, request, url, params })=>{
-        const sourcePromises = sourceFunctions.map((fn)=>{
-            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.");
-        }
-        const blobPartsPromises = sourcePromises.map(async (sourcePromise)=>{
-            const source = await sourcePromise;
-            if (source instanceof Response) {
-                return source.blob();
-            }
-            return new Response(source).blob();
-        });
-        const blobParts = await Promise.all(blobPartsPromises);
-        const headers = createHeaders(headersInit);
-        return new Response(new Blob(blobParts), {
-            headers
-        });
-    };
-};
-
-export { concatenate, concatenateToResponse, isSupported, strategy };

package/dist/isSupported.d.ts

@@ -1,11 +0,0 @@
-/**
- * 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.
- */
-export declare const isSupported: () => boolean;
-//# sourceMappingURL=isSupported.d.ts.map

package/dist/isSupported.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isSupported.d.ts","sourceRoot":"","sources":["../src/isSupported.ts"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,QAAO,OAAuC,CAAC"}

package/dist/strategy.d.ts

@@ -1,17 +0,0 @@
-import type { RouteHandlerCallback, RouteHandlerCallbackOptions } from "serwist";
-import type { StreamSource } from "./_types.js";
-export type 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.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
- */
-export declare const strategy: (sourceFunctions: StreamsHandlerCallback[], headersInit: HeadersInit) => RouteHandlerCallback;
-//# sourceMappingURL=strategy.d.ts.map

package/dist/strategy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../src/strategy.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAC;AAGjF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAKhD,MAAM,MAAM,sBAAsB,GAAG,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,2BAA2B,KAAK,OAAO,CAAC,YAAY,CAAC,GAAG,YAAY,CAAC;AAE5I;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,GAAI,iBAAiB,sBAAsB,EAAE,EAAE,aAAa,WAAW,KAAG,oBAwC9F,CAAC"}

package/dist/utils/createHeaders.d.ts

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

@@ -1 +0,0 @@
-{"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"}