switch to vuepress

12 files changed, 475 insertions, 0 deletions

diff --git a/node_modules/workbox-streams/README.md b/node_modules/workbox-streams/README.md
new file mode 100644
index 00000000..de74a674
--- /dev/null
+++ b/node_modules/workbox-streams/README.md
@@ -0,0 +1 @@
+This module's documentation can be found at https://developers.google.com/web/tools/workbox/reference-docs/latest/workbox.streams
diff --git a/node_modules/workbox-streams/_public.mjs b/node_modules/workbox-streams/_public.mjs
new file mode 100644
index 00000000..2fbaa524
--- /dev/null
+++ b/node_modules/workbox-streams/_public.mjs
@@ -0,0 +1,29 @@
+/*
+  Copyright 2018 Google Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import {concatenate} from './concatenate.mjs';
+import {concatenateToResponse} from './concatenateToResponse.mjs';
+import {isSupported} from './isSupported.mjs';
+import {strategy} from './strategy.mjs';
+
+import './_version.mjs';
+
+export {
+  concatenate,
+  concatenateToResponse,
+  isSupported,
+  strategy,
+};
diff --git a/node_modules/workbox-streams/_types.mjs b/node_modules/workbox-streams/_types.mjs
new file mode 100644
index 00000000..5e55f97e
--- /dev/null
+++ b/node_modules/workbox-streams/_types.mjs
@@ -0,0 +1,21 @@
+/*
+ Copyright 2018 Google Inc. All Rights Reserved.
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+import './_version.mjs';
+
+/**
+ * @typedef {Response|ReadableStream|BodyInit} StreamSource
+ * @memberof workbox.streams
+ */
diff --git a/node_modules/workbox-streams/_version.mjs b/node_modules/workbox-streams/_version.mjs
new file mode 100644
index 00000000..44559edf
--- /dev/null
+++ b/node_modules/workbox-streams/_version.mjs
@@ -0,0 +1 @@
+try{self.workbox.v['workbox:streams:3.6.3']=1;}catch(e){} // eslint-disable-line
\ No newline at end of file
diff --git a/node_modules/workbox-streams/browser.mjs b/node_modules/workbox-streams/browser.mjs
new file mode 100644
index 00000000..5e9a1c22
--- /dev/null
+++ b/node_modules/workbox-streams/browser.mjs
@@ -0,0 +1,19 @@
+/*
+  Copyright 2018 Google Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import './_version.mjs';
+
+export * from './_public.mjs';
diff --git a/node_modules/workbox-streams/concatenate.mjs b/node_modules/workbox-streams/concatenate.mjs
new file mode 100644
index 00000000..1985907c
--- /dev/null
+++ b/node_modules/workbox-streams/concatenate.mjs
@@ -0,0 +1,140 @@
+/*
+ Copyright 2018 Google Inc. All Rights Reserved.
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+import {logger} from 'workbox-core/_private/logger.mjs';
+import {assert} from 'workbox-core/_private/assert.mjs';
+
+import './_version.mjs';
+
+/**
+ * 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) {
+  if (source.body && source.body.getReader) {
+    return source.body.getReader();
+  }
+
+  if (source.getReader) {
+    return source.getReader();
+  }
+
+  // TODO: This should be possible to do by constructing a ReadableStream, but
+  // I can't get it to work. As a hack, construct a new Response, and use the
+  // reader associated with its body.
+  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 {Array<Promise<workbox.streams.StreamSource>>} sourcePromises
+ * @return {Object<{done: Promise, stream: ReadableStream}>}
+ *
+ * @memberof workbox.streams
+ */
+function concatenate(sourcePromises) {
+  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);
+    });
+  });
+
+  let fullyStreamedResolve;
+  let fullyStreamedReject;
+  const done = new Promise((resolve, reject) => {
+    fullyStreamedResolve = resolve;
+    fullyStreamedReject = reject;
+  });
+
+  let i = 0;
+  const logMessages = [];
+  const stream = new ReadableStream({
+    pull(controller) {
+      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();
+              fullyStreamedResolve();
+              return;
+            }
+
+            return this.pull(controller);
+          } else {
+            controller.enqueue(result.value);
+          }
+        }).catch((error) => {
+          if (process.env.NODE_ENV !== 'production') {
+            logger.error('An error occurred:', error);
+          }
+          fullyStreamedReject(error);
+          throw error;
+        });
+    },
+
+    cancel() {
+      if (process.env.NODE_ENV !== 'production') {
+        logger.warn('The ReadableStream was cancelled.');
+      }
+
+      fullyStreamedResolve();
+    },
+  });
+
+  return {done, stream};
+}
+
+export {concatenate};
diff --git a/node_modules/workbox-streams/concatenateToResponse.mjs b/node_modules/workbox-streams/concatenateToResponse.mjs
new file mode 100644
index 00000000..dae1a802
--- /dev/null
+++ b/node_modules/workbox-streams/concatenateToResponse.mjs
@@ -0,0 +1,47 @@
+/*
+ Copyright 2018 Google Inc. All Rights Reserved.
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+import {createHeaders} from './utils/createHeaders.mjs';
+import {concatenate} from './concatenate.mjs';
+
+import './_version.mjs';
+
+/**
+ * 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, headersInit) {
+  const {done, stream} = concatenate(sourcePromises);
+
+  const headers = createHeaders(headersInit);
+  const response = new Response(stream, {headers});
+
+  return {done, response};
+}
+
+export {concatenateToResponse};
diff --git a/node_modules/workbox-streams/index.mjs b/node_modules/workbox-streams/index.mjs
new file mode 100644
index 00000000..31239541
--- /dev/null
+++ b/node_modules/workbox-streams/index.mjs
@@ -0,0 +1,23 @@
+/*
+  Copyright 2018 Google Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import './_version.mjs';
+
+/**
+ * @namespace workbox.streams
+ */
+
+export * from './_public.mjs';
diff --git a/node_modules/workbox-streams/isSupported.mjs b/node_modules/workbox-streams/isSupported.mjs
new file mode 100644
index 00000000..21027dd2
--- /dev/null
+++ b/node_modules/workbox-streams/isSupported.mjs
@@ -0,0 +1,45 @@
+/*
+ Copyright 2018 Google Inc. All Rights Reserved.
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+import './_version.mjs';
+
+let cachedIsSupported = undefined;
+
+/**
+ * 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() {
+  if (cachedIsSupported === undefined) {
+    // See https://github.com/GoogleChrome/workbox/issues/1473
+    try {
+      new ReadableStream({start() {}});
+      cachedIsSupported = true;
+    } catch (error) {
+      cachedIsSupported = false;
+    }
+  }
+
+  return cachedIsSupported;
+}
+
+export {isSupported};
diff --git a/node_modules/workbox-streams/package.json b/node_modules/workbox-streams/package.json
new file mode 100644
index 00000000..b9e3f8ef
--- /dev/null
+++ b/node_modules/workbox-streams/package.json
@@ -0,0 +1,32 @@
+{
+  "name": "workbox-streams",
+  "version": "3.6.3",
+  "license": "Apache-2.0",
+  "author": "Google's Web DevRel Team",
+  "description": "A library that makes it easier to work with Streams in the browser.",
+  "repository": "googlechrome/workbox",
+  "bugs": "https://github.com/googlechrome/workbox/issues",
+  "homepage": "https://github.com/GoogleChrome/workbox",
+  "keywords": [
+    "workbox",
+    "workboxjs",
+    "service worker",
+    "sw",
+    "streams",
+    "readablestream"
+  ],
+  "scripts": {
+    "build": "gulp build-packages --package workbox-streams",
+    "version": "npm run build",
+    "prepare": "npm run build"
+  },
+  "workbox": {
+    "browserNamespace": "workbox.streams",
+    "packageType": "browser"
+  },
+  "main": "build/workbox-streams.prod.js",
+  "module": "index.mjs",
+  "dependencies": {
+    "workbox-core": "^3.6.3"
+  }
+}
diff --git a/node_modules/workbox-streams/strategy.mjs b/node_modules/workbox-streams/strategy.mjs
new file mode 100644
index 00000000..bcf3bfc5
--- /dev/null
+++ b/node_modules/workbox-streams/strategy.mjs
@@ -0,0 +1,77 @@
+/*
+ Copyright 2018 Google Inc. All Rights Reserved.
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+import {logger} from 'workbox-core/_private/logger.mjs';
+
+import {createHeaders} from './utils/createHeaders.mjs';
+import {concatenateToResponse} from './concatenateToResponse.mjs';
+import {isSupported} from './isSupported.mjs';
+
+import './_version.mjs';
+
+/**
+ * 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(workbox.routing.Route~handlerCallback)>} sourceFunctions
+ * Each function should 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.Route~handlerCallback}
+ *
+ * @memberof workbox.streams
+ */
+export function strategy(sourceFunctions, headersInit) {
+  return async ({event, url, params}) => {
+    if (isSupported()) {
+      const {done, response} = concatenateToResponse(sourceFunctions.map(
+        (sourceFunction) => sourceFunction({event, url, params})), headersInit);
+      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 parts = await Promise.all(
+      sourceFunctions.map(
+        (sourceFunction) => sourceFunction({event, url, params})
+      ).map(async (responsePromise) => {
+        const response = await responsePromise;
+        if (response instanceof Response) {
+          return response.blob();
+        }
+
+        // Otherwise, assume it's something like a string which can be used
+        // as-is when constructing the final composite blob.
+        return response;
+      })
+    );
+
+    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(parts), {headers});
+  };
+}
diff --git a/node_modules/workbox-streams/utils/createHeaders.mjs b/node_modules/workbox-streams/utils/createHeaders.mjs
new file mode 100644
index 00000000..c4efc085
--- /dev/null
+++ b/node_modules/workbox-streams/utils/createHeaders.mjs
@@ -0,0 +1,40 @@
+/*
+ Copyright 2018 Google Inc. All Rights Reserved.
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+import '../_version.mjs';
+
+/**
+ * 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.
+ *
+ * @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 = {}) {
+  // 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};