workbox-streams - npm Package Compare versions

Comparing version 3.2.0 to 3.3.0

build/workbox-streams.dev.js

 this.workbox = this.workbox || {};
 this.workbox.streams = (function (logger_mjs,assert_mjs) {
-'use strict';
+  'use strict';
 
-try {
-  self.workbox.v['workbox:streams:3.2.0'] = 1;
-} catch (e) {} // eslint-disable-line
+  try {
+    self.workbox.v['workbox:streams:3.3.0'] = 1;
+  } catch (e) {} // eslint-disable-line
 
-/*
- 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
+  /*
+   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
+       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.
-*/
+   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.
+  */
 
-/**
- * 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();
-  }
+  /**
+   * 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();
+    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();
   }
 
-  // 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) {
+    {
+      assert_mjs.assert.isArray(sourcePromises, {
+        moduleName: 'workbox-streams',
+        funcName: 'concatenate',
+        paramName: 'sourcePromises'
+      });
+    }
 
-/**
- * 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) {
-  {
-    assert_mjs.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 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 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) {
+            {
+              logMessages.push(['Reached the end of source:', sourcePromises[i]]);
+            }
 
-  let i = 0;
-  const logMessages = [];
-  const stream = new ReadableStream({
-    pull(controller) {
-      return readerPromises[i].then(reader => reader.read()).then(result => {
-        if (result.done) {
-          {
-            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.
-            {
-              logger_mjs.logger.groupCollapsed(`Concatenating ${readerPromises.length} sources.`);
-              for (const message of logMessages) {
-                if (Array.isArray(message)) {
-                  logger_mjs.logger.log(...message);
-                } else {
-                  logger_mjs.logger.log(message);
+            i++;
+            if (i >= readerPromises.length) {
+              // Log all the messages in the group at once in a single group.
+              {
+                logger_mjs.logger.groupCollapsed(`Concatenating ${readerPromises.length} sources.`);
+                for (const message of logMessages) {
+                  if (Array.isArray(message)) {
+                    logger_mjs.logger.log(...message);
+                  } else {
+                    logger_mjs.logger.log(message);
+                  }
                 }
+                logger_mjs.logger.log('Finished reading all sources.');
+                logger_mjs.logger.groupEnd();
               }
-              logger_mjs.logger.log('Finished reading all sources.');
-              logger_mjs.logger.groupEnd();
+
+              controller.close();
+              fullyStreamedResolve();
+              return;
             }
 
-            controller.close();
-            fullyStreamedResolve();
-            return;
+            return this.pull(controller);
+          } else {
+            controller.enqueue(result.value);
           }
+        }).catch(error => {
+          {
+            logger_mjs.logger.error('An error occurred:', error);
+          }
+          fullyStreamedReject(error);
+          throw error;
+        });
+      },
 
-          return this.pull(controller);
-        } else {
-          controller.enqueue(result.value);
-        }
-      }).catch(error => {
+      cancel() {
         {
-          logger_mjs.logger.error('An error occurred:', error);
+          logger_mjs.logger.warn('The ReadableStream was cancelled.');
         }
-        fullyStreamedReject(error);
-        throw error;
-      });
-    },
 
-    cancel() {
-      {
-        logger_mjs.logger.warn('The ReadableStream was cancelled.');
+        fullyStreamedResolve();
       }
+    });
 
-      fullyStreamedResolve();
-    }
-  });
+    return { done, stream };
+  }
 
-  return { done, stream };
-}
+  /*
+   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
 
-/*
- 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
 
-     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.
+  */
 
- 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.
-*/
-
-/**
- * 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');
+  /**
+   * 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;
   }
-  return headers;
-}
 
-/*
- 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
+  /*
+   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
+       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.
-*/
+   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.
+  */
 
-/**
- * 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);
+  /**
+   * 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 });
+    const headers = createHeaders(headersInit);
+    const response = new Response(stream, { headers });
 
-  return { done, response };
-}
+    return { done, response };
+  }
 
-/*
- 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
+  /*
+   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
+       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.
-*/
+   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.
+  */
 
-/**
- * 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.
- *
- * @return {boolean} `true`, if the current browser meets the requirements for
- * streaming responses, and `false` otherwise.
- *
- * @memberof workbox.streams
- */
-function isSupported() {
-  return 'ReadableStream' in self;
-}
+  let cachedIsSupported = undefined;
 
-/*
-  Copyright 2018 Google Inc.
+  /**
+   * 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;
+      }
+    }
 
-  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
+    return cachedIsSupported;
+  }
 
-      https://www.apache.org/licenses/LICENSE-2.0
+  /*
+    Copyright 2018 Google Inc.
 
-  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.
-*/
+    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
 
-var publicAPI = Object.freeze({
-	concatenate: concatenate,
-	concatenateToResponse: concatenateToResponse,
-	isSupported: isSupported
-});
+    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.
+  */
 
-/*
- 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
+  var publicAPI = /*#__PURE__*/Object.freeze({
+    concatenate: concatenate,
+    concatenateToResponse: concatenateToResponse,
+    isSupported: isSupported
+  });
 
-     http://www.apache.org/licenses/LICENSE-2.0
+  /*
+   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
 
- 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.
-*/
+       http://www.apache.org/licenses/LICENSE-2.0
 
-/**
- * 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
- */
-function strategy(sourceFunctions, headersInit) {
-  return (() => {
-    var _ref = babelHelpers.asyncToGenerator(function* ({ event, url, params }) {
-      if (isSupported()) {
-        const { done, response } = concatenateToResponse(sourceFunctions.map(function (sourceFunction) {
-          return sourceFunction({ event, url, params });
-        }), headersInit);
-        event.waitUntil(done);
-        return response;
-      }
+   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.
+  */
 
-      {
-        logger_mjs.logger.log(`The current browser doesn't support creating response ` + `streams. Falling back to non-streaming response instead.`);
-      }
+  /**
+   * 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
+   */
+  function strategy(sourceFunctions, headersInit) {
+    return (() => {
+      var _ref = babelHelpers.asyncToGenerator(function* ({ event, url, params }) {
+        if (isSupported()) {
+          const { done, response } = concatenateToResponse(sourceFunctions.map(function (sourceFunction) {
+            return sourceFunction({ event, url, params });
+          }), headersInit);
+          event.waitUntil(done);
+          return response;
+        }
 
-      // Fallback to waiting for everything to finish, and concatenating the
-      // responses.
-      const parts = yield Promise.all(sourceFunctions.map(function (sourceFunction) {
-        return sourceFunction({ event, url, params });
-      }).map((() => {
-        var _ref2 = babelHelpers.asyncToGenerator(function* (responsePromise) {
-          const response = yield responsePromise;
-          if (response instanceof Response) {
-            return response.blob();
-          }
+        {
+          logger_mjs.logger.log(`The current browser doesn't support creating response ` + `streams. Falling back to non-streaming response instead.`);
+        }
 
-          // Otherwise, assume it's something like a string which can be used
-          // as-is when constructing the final composite blob.
-          return response;
-        });
+        // Fallback to waiting for everything to finish, and concatenating the
+        // responses.
+        const parts = yield Promise.all(sourceFunctions.map(function (sourceFunction) {
+          return sourceFunction({ event, url, params });
+        }).map((() => {
+          var _ref2 = babelHelpers.asyncToGenerator(function* (responsePromise) {
+            const response = yield responsePromise;
+            if (response instanceof Response) {
+              return response.blob();
+            }
 
-        return function (_x2) {
-          return _ref2.apply(this, arguments);
-        };
-      })()));
+            // 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 });
-    });
+          return function (_x2) {
+            return _ref2.apply(this, arguments);
+          };
+        })()));
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  })();
-}
+        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 });
+      });
 
-var defaultExport = {
-  concatenate,
-  concatenateToResponse,
-  isSupported,
-  strategy
-};
+      return function (_x) {
+        return _ref.apply(this, arguments);
+      };
+    })();
+  }
 
-/*
-  Copyright 2018 Google Inc.
+  var defaultExport = {
+    concatenate,
+    concatenateToResponse,
+    isSupported,
+    strategy
+  };
 
-  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
+  /*
+    Copyright 2018 Google Inc.
 
-      https://www.apache.org/licenses/LICENSE-2.0
+    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
 
-  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.
-*/
+        https://www.apache.org/licenses/LICENSE-2.0
 
-const finalExport = Object.assign(defaultExport, publicAPI);
+    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.
+  */
 
-return finalExport;
+  const finalExport = Object.assign(defaultExport, publicAPI);
 
+  return finalExport;
+
 }(workbox.core._private,workbox.core._private));
 
 //# sourceMappingURL=workbox-streams.dev.js.map

build/workbox-streams.prod.js

@@ -1,3 +0,3 @@
-this.workbox=this.workbox||{},this.workbox.streams=function(){"use strict";try{self.workbox.v["workbox:streams:3.2.0"]=1}catch(e){}function e(e){const n=e.map(e=>Promise.resolve(e).then(e=>(e=e).body&&e.body.getReader?e.body.getReader():e.getReader?e.getReader():new Response(e).body.getReader()));var t;let r,s;let o=0;return{done:new Promise((e,n)=>{r=e,s=n}),stream:new ReadableStream({pull(e){return n[o].then(e=>e.read()).then(t=>{if(t.done)return++o>=n.length?(e.close(),void r()):this.pull(e);e.enqueue(t.value)}).catch(e=>{throw s(e),e})},cancel(){r()}})}}function n(e={}){const n=new Headers(e);return n.has("content-type")||n.set("content-type","text/html"),n}function t(t,r){const{done:s,stream:o}=e(t),c=n(r);return{done:s,response:new Response(o,{headers:c})}}function r(){return"ReadableStream"in self}var s=Object.freeze({concatenate:e,concatenateToResponse:t,isSupported:r});var o={concatenate:e,concatenateToResponse:t,isSupported:r,strategy:function(e,s){return o=babelHelpers.asyncToGenerator(function*({event:o,url:c,params:a}){if(r()){const{done:n,response:r}=t(e.map(function(e){return e({event:o,url:c,params:a})}),s);return o.waitUntil(n),r}const u=yield Promise.all(e.map(function(e){return e({event:o,url:c,params:a})}).map((i=babelHelpers.asyncToGenerator(function*(e){const n=yield e;return n instanceof Response?n.blob():n}),function(e){return i.apply(this,arguments)})));var i;const l=n(s);return new Response(new Blob(u),{headers:l})}),function(e){return o.apply(this,arguments)};var o}};return Object.assign(o,s)}();
+this.workbox=this.workbox||{},this.workbox.streams=function(){"use strict";try{self.workbox.v["workbox:streams:3.3.0"]=1}catch(e){}function e(e){const n=e.map(e=>Promise.resolve(e).then(e=>(e=e).body&&e.body.getReader?e.body.getReader():e.getReader?e.getReader():new Response(e).body.getReader()));var t;let r,o;let s=0;return{done:new Promise((e,n)=>{r=e,o=n}),stream:new ReadableStream({pull(e){return n[s].then(e=>e.read()).then(t=>{if(t.done)return++s>=n.length?(e.close(),void r()):this.pull(e);e.enqueue(t.value)}).catch(e=>{throw o(e),e})},cancel(){r()}})}}function n(e={}){const n=new Headers(e);return n.has("content-type")||n.set("content-type","text/html"),n}function t(t,r){const{done:o,stream:s}=e(t),c=n(r);return{done:o,response:new Response(s,{headers:c})}}let r=void 0;function o(){if(void 0===r)try{new ReadableStream({start(){}}),r=!0}catch(e){r=!1}return r}var s=Object.freeze({concatenate:e,concatenateToResponse:t,isSupported:o});var c={concatenate:e,concatenateToResponse:t,isSupported:o,strategy:function(e,r){return s=babelHelpers.asyncToGenerator(function*({event:s,url:c,params:a}){if(o()){const{done:n,response:o}=t(e.map(function(e){return e({event:s,url:c,params:a})}),r);return s.waitUntil(n),o}const u=yield Promise.all(e.map(function(e){return e({event:s,url:c,params:a})}).map((i=babelHelpers.asyncToGenerator(function*(e){const n=yield e;return n instanceof Response?n.blob():n}),function(e){return i.apply(this,arguments)})));var i;const l=n(r);return new Response(new Blob(u),{headers:l})}),function(e){return s.apply(this,arguments)};var s}};return Object.assign(c,s)}();
 
 //# sourceMappingURL=workbox-streams.prod.js.map

package.json

 {
   "name": "workbox-streams",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "license": "Apache-2.0",
@@ -30,4 +30,4 @@ "author": "Google's Web DevRel Team",
   "dependencies": {
-    "workbox-core": "^3.2.0"
+    "workbox-core": "^3.3.0"
   }
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

No README

Quality

Package does not have a README. This may indicate a failed publish or a low quality package.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

47889

increased by5.41%

Number of package files

16

increased by6.67%

Lines of code

723

increased by2.99%

Number of medium quality alerts

0

decreased by-100%

Number of lines in readme file

2

increased byInfinity%

Dependency changes

• Updatedworkbox-core@^3.3.0