/**

* Copyright 2016 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.

*/

// DO NOT EDIT THIS GENERATED OUTPUT DIRECTLY!

// This file should be overwritten as part of your build process.

// If you need to extend the behavior of the generated service worker, the best approach is to write

// additional code and include it using the importScripts option:

// https://github.com/GoogleChrome/sw-precache#importscripts-arraystring

//

// Alternatively, it's possible to make changes to the underlying template file and then use that as the

// new base for generating output, via the templateFilePath option:

// https://github.com/GoogleChrome/sw-precache#templatefilepath-string

//

// If you go that route, make sure that whenever you update your sw-precache dependency, you reconcile any

// changes made to this original template file with your modified copy.

// This generated service worker JavaScript will precache your site's resources.

// The code needs to be saved in a .js file at the top-level of your site, and registered

// from your pages in order to be used. See

// https://github.com/googlechrome/sw-precache/blob/master/demo/app/js/service-worker-registration.js

// for an example of how you can register this script and handle various service worker events.

/* eslint-env worker, serviceworker */

/* eslint-disable indent, no-unused-vars, no-multiple-empty-lines, max-nested-callbacks, space-before-function-paren, quotes, comma-spacing */

'use strict';

var precacheConfig = <%= precacheConfig %>;

var cacheName = 'sw-precache-<%= version %>-<%= cacheId %>-' + (self.registration ? self.registration.scope : '');

<% if (handleFetch) { %>

var ignoreUrlParametersMatching = [<%= ignoreUrlParametersMatching %>];

<% } %>

<% Object.keys(externalFunctions).sort().forEach(function(functionName) {%>

var <%- functionName %> = <%= externalFunctions[functionName] %>;

<% }); %>

var hashParamName = '_sw-precache';

var urlsToCacheKeys = new Map(

precacheConfig.map(function(item) {

var relativeUrl = item[0];

var hash = item[1];

var absoluteUrl = new URL(relativeUrl, self.location);

var cacheKey = createCacheKey(absoluteUrl, hashParamName, hash, <%= dontCacheBustUrlsMatching %>);

return [absoluteUrl.toString(), cacheKey];

})

);

function setOfCachedUrls(cache) {

return cache.keys().then(function(requests) {

return requests.map(function(request) {

return request.url;

});

}).then(function(urls) {

return new Set(urls);

});

}

self.addEventListener('install', function(event) {

event.waitUntil(

caches.open(cacheName).then(function(cache) {

return setOfCachedUrls(cache).then(function(cachedUrls) {

return Promise.all(

Array.from(urlsToCacheKeys.values()).map(function(cacheKey) {

// If we don't have a key matching url in the cache already, add it.

if (!cachedUrls.has(cacheKey)) {

var request = new Request(cacheKey, {credentials: 'same-origin'});

return fetch(request).then(function(response) {

// Bail out of installation unless we get back a 200 OK for

// every request.

if (!response.ok) {

throw new Error('Request for ' + cacheKey + ' returned a ' +

'response with status ' + response.status);

}

return cleanResponse(response).then(function(responseToCache) {

return cache.put(cacheKey, responseToCache);

});

});

}

})

);

});

}).then(function() {

<% if (skipWaiting) { %>

// Force the SW to transition from installing -> active state

return self.skipWaiting();

<% } %>

})

);

});

self.addEventListener('activate', function(event) {

var setOfExpectedUrls = new Set(urlsToCacheKeys.values());

event.waitUntil(

caches.open(cacheName).then(function(cache) {

return cache.keys().then(function(existingRequests) {

return Promise.all(

existingRequests.map(function(existingRequest) {

if (!setOfExpectedUrls.has(existingRequest.url)) {

return cache.delete(existingRequest);

}

})

);

});

}).then(function() {

<% if (clientsClaim) { %>

return self.clients.claim();

<% } %>

})

);

});

<% if (handleFetch) { %>

self.addEventListener('fetch', function(event) {

if (event.request.method === 'GET') {

// Should we call event.respondWith() inside this fetch event handler?

// This needs to be determined synchronously, which will give other fetch

// handlers a chance to handle the request if need be.

var shouldRespond;

// First, remove all the ignored parameters and hash fragment, and see if we

// have that URL in our cache. If so, great! shouldRespond will be true.

var url = stripIgnoredUrlParameters(event.request.url, ignoreUrlParametersMatching);

shouldRespond = urlsToCacheKeys.has(url);

// If shouldRespond is false, check again, this time with 'index.html'

// (or whatever the directoryIndex option is set to) at the end.

var directoryIndex = '<%= directoryIndex %>';

if (!shouldRespond && directoryIndex) {

url = addDirectoryIndex(url, directoryIndex);

shouldRespond = urlsToCacheKeys.has(url);

}

// If shouldRespond is still false, check to see if this is a navigation

// request, and if so, whether the URL matches navigateFallbackWhitelist.

var navigateFallback = '<%= navigateFallback %>';

if (!shouldRespond &&

navigateFallback &&

(event.request.mode === 'navigate') &&

isPathWhitelisted(<%= navigateFallbackWhitelist %>, event.request.url)) {

url = new URL(navigateFallback, self.location).toString();

shouldRespond = urlsToCacheKeys.has(url);

}

// If shouldRespond was set to true at any point, then call

// event.respondWith(), using the appropriate cache key.

// console.log("[SW] fetch url " + url, shouldRespond);

if (shouldRespond) {

event.respondWith(

caches.open(cacheName).then(function(cache) {

return cache.match(urlsToCacheKeys.get(url)).then(function(response) {

if (response) {

let url = event.request.url;

// console.log("[SW] found cached url " + url);

/*if (url.indexOf(".wasm") > -1) {

console.log("[SW] wasm not modified");

let responseInit = {

status: 304,

statusText: 'Not Modified'

};

let notModifiedResponse = new Response('', responseInit);

return notModifiedResponse;

}*/

return response;

}

throw Error('The cached response that was expected is missing.');

});

}).catch(function(e) {

// Fall back to just fetch()ing the request if some unexpected error

// prevented the cached response from being valid.

console.warn('Couldn\'t serve response for "%s" from cache: %O', event.request.url, e);

return fetch(event.request);

})

);

}

}

});

<% if (swToolboxCode) { %>

// *** Start of auto-included sw-toolbox code. ***

<%= swToolboxCode %>

// *** End of auto-included sw-toolbox code. ***

<% } %>

<% if (runtimeCaching) { %>

// Runtime cache configuration, using the sw-toolbox library.

<%= runtimeCaching %>

<% } %>

<% } %>

<% if (importScripts) { %>

importScripts(<%= importScripts %>);

<% } %>