applying transfer to react app

node_modules/workbox-streams/src/_types.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 './_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 module:workbox-streams
+ */

node_modules/workbox-streams/src/_version.ts

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

node_modules/workbox-streams/src/concatenate.ts

@@ -0,0 +1,128 @@
+/*
+  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 {assert} from 'workbox-core/_private/assert.js';
+import {Deferred} from 'workbox-core/_private/Deferred.js';
+import {StreamSource} from './_types.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 {module:workbox-streams.StreamSource} source
+ * @return {ReadableStreamReader}
+ * @private
+ */
+function _getReaderFromSource(source: StreamSource): ReadableStreamReader {
+  if (source instanceof Response) {
+    return source.body!.getReader();
+  }
+  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<module:workbox-streams.StreamSource>>} sourcePromises
+ * @return {Object<{done: Promise, stream: ReadableStream}>}
+ *
+ * @memberof module: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) => 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) {
+              // 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};

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<module: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 module: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};

node_modules/workbox-streams/src/index.ts

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

node_modules/workbox-streams/src/isSupported.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 {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 module:workbox-streams
+ */
+function isSupported() {
+  return canConstructReadableStream();
+}
+
+export {isSupported}

node_modules/workbox-streams/src/strategy.ts

@@ -0,0 +1,86 @@
+/*
+  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';
+
+
+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 module:workbox-routing~handlerCallback}
+ * but that instead return a {@link module: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 {module:workbox-routing~handlerCallback}
+ * @memberof module: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}

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 module:workbox-streams
+ */
+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;
+}
+
+export {createHeaders};