v1.0 with SW PWA enabled

frontend/node_modules/workbox-streams/src/_types.ts

@@ -0,0 +1,23 @@
+/*
+  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 './_version.js';
+
+export type StreamSource = Response | ReadableStream | BodyInit;
+
+// * * * IMPORTANT! * * *
+// ------------------------------------------------------------------------- //
+// jdsoc type definitions cannot be declared above TypeScript definitions or
+// they'll be stripped from the built `.js` files, and they'll only be in the
+// `d.ts` files, which aren't read by the jsdoc generator. As a result we
+// have to put declare them below.
+
+/**
+ * @typedef {Response|ReadableStream|BodyInit} StreamSource
+ * @memberof workbox-streams
+ */

frontend/node_modules/workbox-streams/src/_version.ts

@@ -0,0 +1,2 @@
+// @ts-ignore
+try{self['workbox:streams:7.4.0']&&_()}catch(e){}

frontend/node_modules/workbox-streams/src/concatenate.ts

@@ -0,0 +1,146 @@
+/*
+  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} from 'workbox-core/_private/assert.js';
+import {Deferred} from 'workbox-core/_private/Deferred.js';
+import {logger} from 'workbox-core/_private/logger.js';
+import {StreamSource} from './_types.js';
+import {WorkboxError} from 'workbox-core/_private/WorkboxError.js';
+
+import './_version.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 {workbox-streams.StreamSource} source
+ * @return {ReadableStreamReader}
+ * @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 WorkboxError('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 {Array<Promise<workbox-streams.StreamSource>>} sourcePromises
+ * @return {Object<{done: Promise, stream: ReadableStream}>}
+ *
+ * @memberof workbox-streams
+ */
+function concatenate(sourcePromises: Promise<StreamSource>[]): {
+  done: Promise<void>;
+  stream: ReadableStream;
+} {
+  if (process.env.NODE_ENV !== 'production') {
+    assert!.isArray(sourcePromises, {
+      moduleName: 'workbox-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();
+          } 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};
+}
+
+export {concatenate};

frontend/node_modules/workbox-streams/src/concatenateToResponse.ts

@@ -0,0 +1,43 @@
+/*
+  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 {createHeaders} from './utils/createHeaders.js';
+import {concatenate} from './concatenate.js';
+import {StreamSource} from './_types.js';
+import './_version.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 {Array<Promise<workbox-streams.StreamSource>>} sourcePromises
+ * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,
+ * `'text/html'` will be used by default.
+ * @return {Object<{done: Promise, response: Response}>}
+ *
+ * @memberof workbox-streams
+ */
+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};

frontend/node_modules/workbox-streams/src/index.ts

@@ -0,0 +1,28 @@
+/*
+  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 {strategy, StreamsHandlerCallback} from './strategy.js';
+
+import './_version.js';
+
+/**
+ * @module workbox-streams
+ */
+
+export {
+  concatenate,
+  concatenateToResponse,
+  isSupported,
+  strategy,
+  StreamsHandlerCallback,
+};
+
+export * from './_types.js';

frontend/node_modules/workbox-streams/src/isSupported.ts

@@ -0,0 +1,27 @@
+/*
+  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 'workbox-core/_private/canConstructReadableStream.js';
+import './_version.js';
+
+/**
+ * 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.
+ *
+ * @return {boolean} `true`, if the current browser meets the requirements for
+ * streaming responses, and `false` otherwise.
+ *
+ * @memberof workbox-streams
+ */
+function isSupported(): boolean {
+  return canConstructReadableStream();
+}
+
+export {isSupported};

frontend/node_modules/workbox-streams/src/strategy.ts

@@ -0,0 +1,94 @@
+/*
+  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 {logger} from 'workbox-core/_private/logger.js';
+import {
+  RouteHandlerCallback,
+  RouteHandlerCallbackOptions,
+} from 'workbox-core/types.js';
+import {createHeaders} from './utils/createHeaders.js';
+import {concatenateToResponse} from './concatenateToResponse.js';
+import {isSupported} from './isSupported.js';
+import {StreamSource} from './_types.js';
+import './_version.js';
+
+export interface StreamsHandlerCallback {
+  ({url, request, event, params}: RouteHandlerCallbackOptions):
+    | Promise<StreamSource>
+    | StreamSource;
+}
+
+/**
+ * A shortcut to create a strategy that could be dropped-in to Workbox'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 {Array<function({event, request, url, params})>} sourceFunctions
+ * An array of functions similar to {@link workbox-routing~handlerCallback}
+ * but that instead return a {@link workbox-streams.StreamSource} (or a
+ * Promise which resolves to one).
+ * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,
+ * `'text/html'` will be used by default.
+ * @return {workbox-routing~handlerCallback}
+ * @memberof workbox-streams
+ */
+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();
+      } 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 {strategy};

frontend/node_modules/workbox-streams/src/utils/createHeaders.ts

@@ -0,0 +1,34 @@
+/*
+  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 '../_version.js';
+
+/**
+ * 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} [headersInit] If there's no `Content-Type` specified,
+ * `'text/html'` will be used by default.
+ * @return {boolean} `true`, if the current browser meets the requirements for
+ * streaming responses, and `false` otherwise.
+ *
+ * @memberof workbox-streams
+ */
+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};