jekyll-pwa-workbox 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0882361be47338573c890c94aceb5046bbd51a1d6b24c9866e1a2699d60441a8'
-  data.tar.gz: 79eb67b6cc026d1f383ac2a4b4d1ce37fd7e9271b3fa9e483c2901956e114524
+  metadata.gz: f2d25a2da53802619324b98c3ba7456c6e9a064b0f186fbfaf7013f1d073ff5b
+  data.tar.gz: 480a8ff15bc29fb2eb151f4cbc1db1dc7863bbbf4b006d4128250e62b830cef4
 SHA512:
-  metadata.gz: b12b7dde42bf9c3356c050246c69f8ca19c6da52609534d9b5889639f050994f2a5eb6f2b2066262dac6e23fdfd07c08d723af926fc90e5afd10113cc59924f7
-  data.tar.gz: 4d92d1e96448f4579dad152af98d677bde382fa4ca9fccff52658796bfe872654d28e21948812b5aeb9c3e965226f326994b24076abb7fea5a119556cc60b73f
+  metadata.gz: 17b5256c6fc933be0c06009f3578c690acf9aa8d14fa1f03d42105fbe6ad4e88e357598e24526746e641744946f8e64496afaa9529e97ab71bebed81dce3c438
+  data.tar.gz: 3f5a7ce67d4ed5674e4da3e5b4681fc0ab5e94e72b2f69e3c24aad2e933fb2391a0dfec9f60e59043893b0f746817bc956109c129c4091914929aa5cae479a84

data/lib/jekyll-pwa-workbox.rb

@@ -1,125 +1,125 @@
-class SWHelper
-    WORKBOX_VERSION = 'v3.6.3'
-    def initialize(site, config)
-        @site = site
-        @config = config
-        @sw_filename = @config['sw_dest_filename'] || 'service-worker.js'
-        @sw_src_filepath = @config['sw_src_filepath'] || 'service-worker.js'
-    end
-
-    def write_sw_register()
-        sw_register_filename = 'sw-register.js'
-        sw_register_file = File.new(@site.in_dest_dir(sw_register_filename), 'w')
-        # add build version in url params
-        sw_register_file.puts(
-        <<-SCRIPT
-		"serviceWorker"in navigator&&navigator.serviceWorker.register("#{@site.baseurl.to_s}/#{@sw_filename}?v=#{@site.time.to_i.to_s}").then(function(e){e.onupdatefound=function(){var t=e.installing;t.onstatechange=function(){switch(t.state){case"installed":if(navigator.serviceWorker.controller){var e=document.createEvent("Event");e.initEvent("sw.update",!0,!0),window.dispatchEvent(e)}}}}}).catch(function(e){console.error("Error during service worker registration:",e)});
-        SCRIPT
-        )
-        sw_register_file.close
-    end
-
-    def generate_workbox_precache()
-        directory = @config['precache_glob_directory'] || '/'
-        directory = @site.in_dest_dir(directory)
-        patterns = @config['precache_glob_patterns'] || ['**/*.{html,js,css,eot,svg,ttf,woff}']
-        ignores = @config['precache_glob_ignores'] || []
-        recent_posts_num = @config['precache_recent_posts_num']
-
-        # according to workbox precache {url: 'main.js', revision: 'xxxx'}
-        @precache_list = []
-
-        # find precache files with glob
-        precache_files = []
-        patterns.each do |pattern|
-            Dir.glob(File.join(directory, pattern)) do |filepath|
-                precache_files.push(filepath)
-            end
-        end
-        precache_files = precache_files.uniq
-
-        # precache recent n posts
-        posts_path_url_map = {}
-        if recent_posts_num
-            precache_files.concat(
-                @site.posts.docs
-                    .reverse.take(recent_posts_num)
-                    .map do |post|
-                        posts_path_url_map[post.path] = post.url
-                        post.path
-                    end
-            )
-        end
-
-        # filter with ignores
-        ignores.each do |pattern|
-            Dir.glob(File.join(directory, pattern)) do |ignored_filepath|
-                precache_files.delete(ignored_filepath)
-            end
-        end
-
-        # generate md5 for each precache file
-        md5 = Digest::MD5.new
-        precache_files.each do |filepath|
-            md5.reset
-            md5 << File.read(filepath)
-            if posts_path_url_map[filepath]
-                url = posts_path_url_map[filepath]
-            else
-                url = filepath.sub(@site.dest, '')
-            end
-            @precache_list.push({
-                url: @site.baseurl.to_s + url,
-                revision: md5.hexdigest
-            })
-        end
-    end
-
-    def write_sw()
-
-        dest_js_directory = @config['dest_js_directory'] || 'js'
-
-        # copy polyfill & workbox.js to js/
-        script_directory = @site.in_dest_dir(dest_js_directory)
-        FileUtils.mkdir_p(script_directory) unless Dir.exist?(script_directory)
-        FileUtils.cp_r(File.expand_path('../vendor/', __FILE__) + '/.', script_directory)
-
-        # generate precache list
-        precache_list_str = @precache_list.map do |precache_item|
-            precache_item.to_json
-        end
-        .join(",")
-
-        # write service-worker.js
-        sw_src_file_str = File.read(@site.in_source_dir(@sw_src_filepath))
-        workbox_dir = File.join(@site.baseurl.to_s, dest_js_directory, "workbox-#{SWHelper::WORKBOX_VERSION}")
-        import_scripts_str = 
-        <<-SCRIPT
-            importScripts("#{workbox_dir}/workbox-sw.js");
-            workbox.setConfig({modulePathPrefix: "#{workbox_dir}"});
-        SCRIPT
-
-        sw_dest_file = File.new(@site.in_dest_dir(@sw_filename), 'w')
-        sw_dest_file.puts(
-        <<-SCRIPT
-            #{import_scripts_str}
-            self.__precacheManifest = [#{precache_list_str}];
-            #{sw_src_file_str}
-        SCRIPT
-        )
-        sw_dest_file.close
-    end
-end
-
-module Jekyll
-
-    Hooks.register :site, :post_write do |site|
-        pwa_config = site.config['pwa'] || {}
-        sw_helper = SWHelper.new(site, pwa_config)
-
-        sw_helper.write_sw_register()
-        sw_helper.generate_workbox_precache()
-        sw_helper.write_sw()
-    end
-
-end
+class SWHelper
+    WORKBOX_VERSION = 'v4.1.1'
+    def initialize(site, config)
+        @site = site
+        @config = config
+        @sw_filename = @config['sw_dest_filename'] || 'service-worker.js'
+        @sw_src_filepath = @config['sw_src_filepath'] || 'service-worker.js'
+    end
+
+    def write_sw_register()
+        sw_register_filename = 'sw-register.js'
+        sw_register_file = File.new(@site.in_dest_dir(sw_register_filename), 'w')
+        # add build version in url params
+        sw_register_file.puts(
+        <<-SCRIPT
+		"serviceWorker"in navigator&&navigator.serviceWorker.register("#{@site.baseurl.to_s}/#{@sw_filename}?v=#{@site.time.to_i.to_s}").then(function(e){e.onupdatefound=function(){var t=e.installing;t.onstatechange=function(){switch(t.state){case"installed":if(navigator.serviceWorker.controller){var e=document.createEvent("Event");e.initEvent("sw.update",!0,!0),window.dispatchEvent(e)}}}}}).catch(function(e){console.error("Error during service worker registration:",e)});
+        SCRIPT
+        )
+        sw_register_file.close
+    end
+
+    def generate_workbox_precache()
+        directory = @config['precache_glob_directory'] || '/'
+        directory = @site.in_dest_dir(directory)
+        patterns = @config['precache_glob_patterns'] || ['**/*.{html,js,css,eot,svg,ttf,woff}']
+        ignores = @config['precache_glob_ignores'] || []
+        recent_posts_num = @config['precache_recent_posts_num']
+
+        # according to workbox precache {url: 'main.js', revision: 'xxxx'}
+        @precache_list = []
+
+        # find precache files with glob
+        precache_files = []
+        patterns.each do |pattern|
+            Dir.glob(File.join(directory, pattern)) do |filepath|
+                precache_files.push(filepath)
+            end
+        end
+        precache_files = precache_files.uniq
+
+        # precache recent n posts
+        posts_path_url_map = {}
+        if recent_posts_num
+            precache_files.concat(
+                @site.posts.docs
+                    .reverse.take(recent_posts_num)
+                    .map do |post|
+                        posts_path_url_map[post.path] = post.url
+                        post.path
+                    end
+            )
+        end
+
+        # filter with ignores
+        ignores.each do |pattern|
+            Dir.glob(File.join(directory, pattern)) do |ignored_filepath|
+                precache_files.delete(ignored_filepath)
+            end
+        end
+
+        # generate md5 for each precache file
+        md5 = Digest::MD5.new
+        precache_files.each do |filepath|
+            md5.reset
+            md5 << File.read(filepath)
+            if posts_path_url_map[filepath]
+                url = posts_path_url_map[filepath]
+            else
+                url = filepath.sub(@site.dest, '')
+            end
+            @precache_list.push({
+                url: @site.baseurl.to_s + url,
+                revision: md5.hexdigest
+            })
+        end
+    end
+
+    def write_sw()
+
+        dest_js_directory = @config['dest_js_directory'] || 'js'
+
+        # copy polyfill & workbox.js to js/
+        script_directory = @site.in_dest_dir(dest_js_directory)
+        FileUtils.mkdir_p(script_directory) unless Dir.exist?(script_directory)
+        FileUtils.cp_r(File.expand_path('../vendor/', __FILE__) + '/.', script_directory)
+
+        # generate precache list
+        precache_list_str = @precache_list.map do |precache_item|
+            precache_item.to_json
+        end
+        .join(",")
+
+        # write service-worker.js
+        sw_src_file_str = File.read(@site.in_source_dir(@sw_src_filepath))
+        workbox_dir = File.join(@site.baseurl.to_s, dest_js_directory, "workbox-#{SWHelper::WORKBOX_VERSION}")
+        import_scripts_str = 
+        <<-SCRIPT
+            importScripts("#{workbox_dir}/workbox-sw.js");
+            workbox.setConfig({modulePathPrefix: "#{workbox_dir}"});
+        SCRIPT
+
+        sw_dest_file = File.new(@site.in_dest_dir(@sw_filename), 'w')
+        sw_dest_file.puts(
+        <<-SCRIPT
+            #{import_scripts_str}
+            self.__precacheManifest = [#{precache_list_str}];
+            #{sw_src_file_str}
+        SCRIPT
+        )
+        sw_dest_file.close
+    end
+end
+
+module Jekyll
+
+    Hooks.register :site, :post_write do |site|
+        pwa_config = site.config['pwa'] || {}
+        sw_helper = SWHelper.new(site, pwa_config)
+
+        sw_helper.write_sw_register()
+        sw_helper.generate_workbox_precache()
+        sw_helper.write_sw()
+    end
+
+end

data/lib/vendor/workbox-v4.1.1/workbox-background-sync.dev.js

@@ -0,0 +1,729 @@
+this.workbox = this.workbox || {};
+this.workbox.backgroundSync = (function (exports, WorkboxError_mjs, logger_mjs, assert_mjs, getFriendlyURL_mjs, DBWrapper_mjs) {
+  'use strict';
+
+  try {
+    self['workbox:background-sync:4.1.1'] && _();
+  } catch (e) {} // eslint-disable-line
+
+  /*
+    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.
+  */
+  const DB_VERSION = 3;
+  const DB_NAME = 'workbox-background-sync';
+  const OBJECT_STORE_NAME = 'requests';
+  const INDEXED_PROP = 'queueName';
+  /**
+   * A class to manage storing requests from a Queue in IndexedbDB,
+   * indexed by their queue name for easier access.
+   *
+   * @private
+   */
+
+  class QueueStore {
+    /**
+     * Associates this instance with a Queue instance, so entries added can be
+     * identified by their queue name.
+     *
+     * @param {string} queueName
+     * @private
+     */
+    constructor(queueName) {
+      this._queueName = queueName;
+      this._db = new DBWrapper_mjs.DBWrapper(DB_NAME, DB_VERSION, {
+        onupgradeneeded: evt => this._upgradeDb(evt)
+      });
+    }
+    /**
+     * Append an entry last in the queue.
+     *
+     * @param {Object} entry
+     * @param {Object} entry.requestData
+     * @param {number} [entry.timestamp]
+     * @param {Object} [entry.metadata]
+     */
+
+
+    async pushEntry(entry) {
+      {
+        assert_mjs.assert.isType(entry, 'object', {
+          moduleName: 'workbox-background-sync',
+          className: 'QueueStore',
+          funcName: 'pushEntry',
+          paramName: 'entry'
+        });
+        assert_mjs.assert.isType(entry.requestData, 'object', {
+          moduleName: 'workbox-background-sync',
+          className: 'QueueStore',
+          funcName: 'pushEntry',
+          paramName: 'entry.requestData'
+        });
+      } // Don't specify an ID since one is automatically generated.
+
+
+      delete entry.id;
+      entry.queueName = this._queueName;
+      await this._db.add(OBJECT_STORE_NAME, entry);
+    }
+    /**
+     * Preppend an entry first in the queue.
+     *
+     * @param {Object} entry
+     * @param {Object} entry.requestData
+     * @param {number} [entry.timestamp]
+     * @param {Object} [entry.metadata]
+     */
+
+
+    async unshiftEntry(entry) {
+      {
+        assert_mjs.assert.isType(entry, 'object', {
+          moduleName: 'workbox-background-sync',
+          className: 'QueueStore',
+          funcName: 'unshiftEntry',
+          paramName: 'entry'
+        });
+        assert_mjs.assert.isType(entry.requestData, 'object', {
+          moduleName: 'workbox-background-sync',
+          className: 'QueueStore',
+          funcName: 'unshiftEntry',
+          paramName: 'entry.requestData'
+        });
+      }
+
+      const [firstEntry] = await this._db.getAllMatching(OBJECT_STORE_NAME, {
+        count: 1
+      });
+
+      if (firstEntry) {
+        // Pick an ID one less than the lowest ID in the object store.
+        entry.id = firstEntry.id - 1;
+      } else {
+        delete entry.id;
+      }
+
+      entry.queueName = this._queueName;
+      await this._db.add(OBJECT_STORE_NAME, entry);
+    }
+    /**
+     * Removes and returns the last entry in the queue matching the `queueName`.
+     *
+     * @return {Promise<Object>}
+     */
+
+
+    async popEntry() {
+      return this._removeEntry({
+        direction: 'prev'
+      });
+    }
+    /**
+     * Removes and returns the first entry in the queue matching the `queueName`.
+     *
+     * @return {Promise<Object>}
+     */
+
+
+    async shiftEntry() {
+      return this._removeEntry({
+        direction: 'next'
+      });
+    }
+    /**
+     * Removes and returns the first or last entry in the queue (based on the
+     * `direction` argument) matching the `queueName`.
+     *
+     * @return {Promise<Object>}
+     */
+
+
+    async _removeEntry({
+      direction
+    }) {
+      const [entry] = await this._db.getAllMatching(OBJECT_STORE_NAME, {
+        direction,
+        index: INDEXED_PROP,
+        query: IDBKeyRange.only(this._queueName),
+        count: 1
+      });
+
+      if (entry) {
+        await this._db.delete(OBJECT_STORE_NAME, entry.id); // Dont' expose the ID or queueName;
+
+        delete entry.id;
+        delete entry.queueName;
+        return entry;
+      }
+    }
+    /**
+     * Upgrades the database given an `upgradeneeded` event.
+     *
+     * @param {Event} event
+     */
+
+
+    _upgradeDb(event) {
+      const db = event.target.result;
+
+      if (event.oldVersion > 0 && event.oldVersion < DB_VERSION) {
+        db.deleteObjectStore(OBJECT_STORE_NAME);
+      }
+
+      const objStore = db.createObjectStore(OBJECT_STORE_NAME, {
+        autoIncrement: true,
+        keyPath: 'id'
+      });
+      objStore.createIndex(INDEXED_PROP, INDEXED_PROP, {
+        unique: false
+      });
+    }
+
+  }
+
+  /*
+    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.
+  */
+  const serializableProperties = ['method', 'referrer', 'referrerPolicy', 'mode', 'credentials', 'cache', 'redirect', 'integrity', 'keepalive'];
+  /**
+   * A class to make it easier to serialize and de-serialize requests so they
+   * can be stored in IndexedDB.
+   *
+   * @private
+   */
+
+  class StorableRequest {
+    /**
+     * Converts a Request object to a plain object that can be structured
+     * cloned or JSON-stringified.
+     *
+     * @param {Request} request
+     * @return {Promise<StorableRequest>}
+     *
+     * @private
+     */
+    static async fromRequest(request) {
+      const requestData = {
+        url: request.url,
+        headers: {}
+      }; // Set the body if present.
+
+      if (request.method !== 'GET') {
+        // Use ArrayBuffer to support non-text request bodies.
+        // NOTE: we can't use Blobs becuse Safari doesn't support storing
+        // Blobs in IndexedDB in some cases:
+        // https://github.com/dfahlander/Dexie.js/issues/618#issuecomment-398348457
+        requestData.body = await request.clone().arrayBuffer();
+      } // Convert the headers from an iterable to an object.
+
+
+      for (const [key, value] of request.headers.entries()) {
+        requestData.headers[key] = value;
+      } // Add all other serializable request properties
+
+
+      for (const prop of serializableProperties) {
+        if (request[prop] !== undefined) {
+          requestData[prop] = request[prop];
+        }
+      }
+
+      return new StorableRequest(requestData);
+    }
+    /**
+     * Accepts an object of request data that can be used to construct a
+     * `Request` but can also be stored in IndexedDB.
+     *
+     * @param {Object} requestData An object of request data that includes the
+     *     `url` plus any relevant properties of
+     *     [requestInit]{@link https://fetch.spec.whatwg.org/#requestinit}.
+     * @private
+     */
+
+
+    constructor(requestData) {
+      {
+        assert_mjs.assert.isType(requestData, 'object', {
+          moduleName: 'workbox-background-sync',
+          className: 'StorableRequest',
+          funcName: 'constructor',
+          paramName: 'requestData'
+        });
+        assert_mjs.assert.isType(requestData.url, 'string', {
+          moduleName: 'workbox-background-sync',
+          className: 'StorableRequest',
+          funcName: 'constructor',
+          paramName: 'requestData.url'
+        });
+      }
+
+      this._requestData = requestData;
+    }
+    /**
+     * Returns a deep clone of the instances `_requestData` object.
+     *
+     * @return {Object}
+     *
+     * @private
+     */
+
+
+    toObject() {
+      const requestData = Object.assign({}, this._requestData);
+      requestData.headers = Object.assign({}, this._requestData.headers);
+
+      if (requestData.body) {
+        requestData.body = requestData.body.slice(0);
+      }
+
+      return requestData;
+    }
+    /**
+     * Converts this instance to a Request.
+     *
+     * @return {Request}
+     *
+     * @private
+     */
+
+
+    toRequest() {
+      return new Request(this._requestData.url, this._requestData);
+    }
+    /**
+     * Creates and returns a deep clone of the instance.
+     *
+     * @return {StorableRequest}
+     *
+     * @private
+     */
+
+
+    clone() {
+      return new StorableRequest(this.toObject());
+    }
+
+  }
+
+  /*
+    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.
+  */
+  const TAG_PREFIX = 'workbox-background-sync';
+  const MAX_RETENTION_TIME = 60 * 24 * 7; // 7 days in minutes
+
+  const queueNames = new Set();
+  /**
+   * A class to manage storing failed requests in IndexedDB and retrying them
+   * later. All parts of the storing and replaying process are observable via
+   * callbacks.
+   *
+   * @memberof workbox.backgroundSync
+   */
+
+  class Queue {
+    /**
+     * Creates an instance of Queue with the given options
+     *
+     * @param {string} name The unique name for this queue. This name must be
+     *     unique as it's used to register sync events and store requests
+     *     in IndexedDB specific to this instance. An error will be thrown if
+     *     a duplicate name is detected.
+     * @param {Object} [options]
+     * @param {Function} [options.onSync] A function that gets invoked whenever
+     *     the 'sync' event fires. The function is invoked with an object
+     *     containing the `queue` property (referencing this instance), and you
+     *     can use the callback to customize the replay behavior of the queue.
+     *     When not set the `replayRequests()` method is called.
+     *     Note: if the replay fails after a sync event, make sure you throw an
+     *     error, so the browser knows to retry the sync event later.
+     * @param {number} [options.maxRetentionTime=7 days] The amount of time (in
+     *     minutes) a request may be retried. After this amount of time has
+     *     passed, the request will be deleted from the queue.
+     */
+    constructor(name, {
+      onSync,
+      maxRetentionTime
+    } = {}) {
+      // Ensure the store name is not already being used
+      if (queueNames.has(name)) {
+        throw new WorkboxError_mjs.WorkboxError('duplicate-queue-name', {
+          name
+        });
+      } else {
+        queueNames.add(name);
+      }
+
+      this._name = name;
+      this._onSync = onSync || this.replayRequests;
+      this._maxRetentionTime = maxRetentionTime || MAX_RETENTION_TIME;
+      this._queueStore = new QueueStore(this._name);
+
+      this._addSyncListener();
+    }
+    /**
+     * @return {string}
+     */
+
+
+    get name() {
+      return this._name;
+    }
+    /**
+     * Stores the passed request in IndexedDB (with its timestamp and any
+     * metadata) at the end of the queue.
+     *
+     * @param {Object} entry
+     * @param {Request} entry.request The request to store in the queue.
+     * @param {Object} [entry.metadata] Any metadata you want associated with the
+     *     stored request. When requests are replayed you'll have access to this
+     *     metadata object in case you need to modify the request beforehand.
+     * @param {number} [entry.timestamp] The timestamp (Epoch time in
+     *     milliseconds) when the request was first added to the queue. This is
+     *     used along with `maxRetentionTime` to remove outdated requests. In
+     *     general you don't need to set this value, as it's automatically set
+     *     for you (defaulting to `Date.now()`), but you can update it if you
+     *     don't want particular requests to expire.
+     */
+
+
+    async pushRequest(entry) {
+      {
+        assert_mjs.assert.isType(entry, 'object', {
+          moduleName: 'workbox-background-sync',
+          className: 'Queue',
+          funcName: 'pushRequest',
+          paramName: 'entry'
+        });
+        assert_mjs.assert.isInstance(entry.request, Request, {
+          moduleName: 'workbox-background-sync',
+          className: 'Queue',
+          funcName: 'pushRequest',
+          paramName: 'entry.request'
+        });
+      }
+
+      await this._addRequest(entry, 'push');
+    }
+    /**
+     * Stores the passed request in IndexedDB (with its timestamp and any
+     * metadata) at the beginning of the queue.
+     *
+     * @param {Object} entry
+     * @param {Request} entry.request The request to store in the queue.
+     * @param {Object} [entry.metadata] Any metadata you want associated with the
+     *     stored request. When requests are replayed you'll have access to this
+     *     metadata object in case you need to modify the request beforehand.
+     * @param {number} [entry.timestamp] The timestamp (Epoch time in
+     *     milliseconds) when the request was first added to the queue. This is
+     *     used along with `maxRetentionTime` to remove outdated requests. In
+     *     general you don't need to set this value, as it's automatically set
+     *     for you (defaulting to `Date.now()`), but you can update it if you
+     *     don't want particular requests to expire.
+     */
+
+
+    async unshiftRequest(entry) {
+      {
+        assert_mjs.assert.isType(entry, 'object', {
+          moduleName: 'workbox-background-sync',
+          className: 'Queue',
+          funcName: 'unshiftRequest',
+          paramName: 'entry'
+        });
+        assert_mjs.assert.isInstance(entry.request, Request, {
+          moduleName: 'workbox-background-sync',
+          className: 'Queue',
+          funcName: 'unshiftRequest',
+          paramName: 'entry.request'
+        });
+      }
+
+      await this._addRequest(entry, 'unshift');
+    }
+    /**
+     * Removes and returns the last request in the queue (along with its
+     * timestamp and any metadata). The returned object takes the form:
+     * `{request, timestamp, metadata}`.
+     *
+     * @return {Promise<Object>}
+     */
+
+
+    async popRequest() {
+      return this._removeRequest('pop');
+    }
+    /**
+     * Removes and returns the first request in the queue (along with its
+     * timestamp and any metadata). The returned object takes the form:
+     * `{request, timestamp, metadata}`.
+     *
+     * @return {Promise<Object>}
+     */
+
+
+    async shiftRequest() {
+      return this._removeRequest('shift');
+    }
+    /**
+     * Adds the entry to the QueueStore and registers for a sync event.
+     *
+     * @param {Object} entry
+     * @param {Request} entry.request
+     * @param {Object} [entry.metadata]
+     * @param {number} [entry.timestamp=Date.now()]
+     * @param {string} operation ('push' or 'unshift')
+     */
+
+
+    async _addRequest({
+      request,
+      metadata,
+      timestamp = Date.now()
+    }, operation) {
+      const storableRequest = await StorableRequest.fromRequest(request.clone());
+      const entry = {
+        requestData: storableRequest.toObject(),
+        timestamp
+      }; // Only include metadata if it's present.
+
+      if (metadata) {
+        entry.metadata = metadata;
+      }
+
+      await this._queueStore[`${operation}Entry`](entry);
+
+      {
+        logger_mjs.logger.log(`Request for '${getFriendlyURL_mjs.getFriendlyURL(request.url)}' has ` + `been added to background sync queue '${this._name}'.`);
+      } // Don't register for a sync if we're in the middle of a sync. Instead,
+      // we wait until the sync is complete and call register if
+      // `this._requestsAddedDuringSync` is true.
+
+
+      if (this._syncInProgress) {
+        this._requestsAddedDuringSync = true;
+      } else {
+        await this.registerSync();
+      }
+    }
+    /**
+     * Removes and returns the first or last (depending on `operation`) entry
+     * form the QueueStore that's not older than the `maxRetentionTime`.
+     *
+     * @param {string} operation ('pop' or 'shift')
+     * @return {Object|undefined}
+     */
+
+
+    async _removeRequest(operation) {
+      const now = Date.now();
+      const entry = await this._queueStore[`${operation}Entry`]();
+
+      if (entry) {
+        // Ignore requests older than maxRetentionTime. Call this function
+        // recursively until an unexpired request is found.
+        const maxRetentionTimeInMs = this._maxRetentionTime * 60 * 1000;
+
+        if (now - entry.timestamp > maxRetentionTimeInMs) {
+          return this._removeRequest(operation);
+        }
+
+        entry.request = new StorableRequest(entry.requestData).toRequest();
+        delete entry.requestData;
+        return entry;
+      }
+    }
+    /**
+     * Loops through each request in the queue and attempts to re-fetch it.
+     * If any request fails to re-fetch, it's put back in the same position in
+     * the queue (which registers a retry for the next sync event).
+     */
+
+
+    async replayRequests() {
+      let entry;
+
+      while (entry = await this.shiftRequest()) {
+        try {
+          await fetch(entry.request);
+
+          {
+            logger_mjs.logger.log(`Request for '${getFriendlyURL_mjs.getFriendlyURL(entry.request.url)}'` + `has been replayed in queue '${this._name}'`);
+          }
+        } catch (error) {
+          await this.unshiftRequest(entry);
+
+          {
+            logger_mjs.logger.log(`Request for '${getFriendlyURL_mjs.getFriendlyURL(entry.request.url)}'` + `failed to replay, putting it back in queue '${this._name}'`);
+          }
+
+          throw new WorkboxError_mjs.WorkboxError('queue-replay-failed', {
+            name: this._name
+          });
+        }
+      }
+
+      {
+        logger_mjs.logger.log(`All requests in queue '${this.name}' have successfully ` + `replayed; the queue is now empty!`);
+      }
+    }
+    /**
+     * Registers a sync event with a tag unique to this instance.
+     */
+
+
+    async registerSync() {
+      if ('sync' in registration) {
+        try {
+          await registration.sync.register(`${TAG_PREFIX}:${this._name}`);
+        } catch (err) {
+          // This means the registration failed for some reason, possibly due to
+          // the user disabling it.
+          {
+            logger_mjs.logger.warn(`Unable to register sync event for '${this._name}'.`, err);
+          }
+        }
+      }
+    }
+    /**
+     * In sync-supporting browsers, this adds a listener for the sync event.
+     * In non-sync-supporting browsers, this will retry the queue on service
+     * worker startup.
+     *
+     * @private
+     */
+
+
+    _addSyncListener() {
+      if ('sync' in registration) {
+        self.addEventListener('sync', event => {
+          if (event.tag === `${TAG_PREFIX}:${this._name}`) {
+            {
+              logger_mjs.logger.log(`Background sync for tag '${event.tag}'` + `has been received`);
+            }
+
+            const syncComplete = async () => {
+              this._syncInProgress = true;
+              let syncError;
+
+              try {
+                await this._onSync({
+                  queue: this
+                });
+              } catch (error) {
+                syncError = error; // Rethrow the error. Note: the logic in the finally clause
+                // will run before this gets rethrown.
+
+                throw syncError;
+              } finally {
+                // New items may have been added to the queue during the sync,
+                // so we need to register for a new sync if that's happened...
+                // Unless there was an error during the sync, in which
+                // case the browser will automatically retry later, as long
+                // as `event.lastChance` is not true.
+                if (this._requestsAddedDuringSync && !(syncError && !event.lastChance)) {
+                  await this.registerSync();
+                }
+
+                this._syncInProgress = false;
+                this._requestsAddedDuringSync = false;
+              }
+            };
+
+            event.waitUntil(syncComplete());
+          }
+        });
+      } else {
+        {
+          logger_mjs.logger.log(`Background sync replaying without background sync event`);
+        } // If the browser doesn't support background sync, retry
+        // every time the service worker starts up as a fallback.
+
+
+        this._onSync({
+          queue: this
+        });
+      }
+    }
+    /**
+     * Returns the set of queue names. This is primarily used to reset the list
+     * of queue names in tests.
+     *
+     * @return {Set}
+     *
+     * @private
+     */
+
+
+    static get _queueNames() {
+      return queueNames;
+    }
+
+  }
+
+  /*
+    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.
+  */
+  /**
+   * A class implementing the `fetchDidFail` lifecycle callback. This makes it
+   * easier to add failed requests to a background sync Queue.
+   *
+   * @memberof workbox.backgroundSync
+   */
+
+  class Plugin {
+    /**
+     * @param {...*} queueArgs Args to forward to the composed Queue instance.
+     *    See the [Queue]{@link workbox.backgroundSync.Queue} documentation for
+     *    parameter details.
+     */
+    constructor(...queueArgs) {
+      this._queue = new Queue(...queueArgs);
+      this.fetchDidFail = this.fetchDidFail.bind(this);
+    }
+    /**
+     * @param {Object} options
+     * @param {Request} options.request
+     * @private
+     */
+
+
+    async fetchDidFail({
+      request
+    }) {
+      await this._queue.pushRequest({
+        request
+      });
+    }
+
+  }
+
+  /*
+    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.
+  */
+
+  exports.Queue = Queue;
+  exports.Plugin = Plugin;
+
+  return exports;
+
+}({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private));
+//# sourceMappingURL=workbox-background-sync.dev.js.map