From 3b76e96113e51c681d22211366e948cd1b1debc8 Mon Sep 17 00:00:00 2001 From: Christian Semmler Date: Thu, 17 Jul 2025 18:21:25 -0700 Subject: [PATCH] Add offline play feature --- .gitignore | 2 +- app.js | 436 +++++++ index.html | 1237 +++--------------- install_off.webp | Bin 0 -> 3742 bytes install_on.webp | Bin 0 -> 4020 bytes style.css | 762 +++++++++++ sw.js | 213 ++++ uninstall_off.webp | Bin 0 -> 3580 bytes uninstall_on.webp | Bin 0 -> 4266 bytes workbox/workbox-cacheable-response.dev.js | 176 +++ workbox/workbox-cacheable-response.prod.js | 2 + workbox/workbox-core.dev.js | 1059 ++++++++++++++++ workbox/workbox-core.prod.js | 2 + workbox/workbox-precaching.dev.js | 1201 ++++++++++++++++++ workbox/workbox-precaching.prod.js | 2 + workbox/workbox-range-requests.dev.js | 242 ++++ workbox/workbox-range-requests.prod.js | 2 + workbox/workbox-routing.dev.js | 884 +++++++++++++ workbox/workbox-routing.prod.js | 2 + workbox/workbox-strategies.dev.js | 1334 ++++++++++++++++++++ workbox/workbox-strategies.prod.js | 2 + workbox/workbox-sw.js | 2 + 22 files changed, 6498 insertions(+), 1062 deletions(-) create mode 100644 app.js create mode 100644 install_off.webp create mode 100644 install_on.webp create mode 100644 style.css create mode 100644 sw.js create mode 100644 uninstall_off.webp create mode 100644 uninstall_on.webp create mode 100644 workbox/workbox-cacheable-response.dev.js create mode 100644 workbox/workbox-cacheable-response.prod.js create mode 100644 workbox/workbox-core.dev.js create mode 100644 workbox/workbox-core.prod.js create mode 100644 workbox/workbox-precaching.dev.js create mode 100644 workbox/workbox-precaching.prod.js create mode 100644 workbox/workbox-range-requests.dev.js create mode 100644 workbox/workbox-range-requests.prod.js create mode 100644 workbox/workbox-routing.dev.js create mode 100644 workbox/workbox-routing.prod.js create mode 100644 workbox/workbox-strategies.dev.js create mode 100644 workbox/workbox-strategies.prod.js create mode 100644 workbox/workbox-sw.js diff --git a/.gitignore b/.gitignore index 621c639..b560bcc 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,3 @@ isle.wasm isle.js - +LEGO diff --git a/app.js b/app.js new file mode 100644 index 0000000..012eb17 --- /dev/null +++ b/app.js @@ -0,0 +1,436 @@ +var Module = { + arguments: ['--ini', '/config/isle.ini'], + running: false, + preRun: function () { + Module["addRunDependency"]("isle"); + Module.running = true; + }, + canvas: (function () { + return document.getElementById('canvas'); + })(), + onExit: function () { + window.location.reload(); + } +}; + +document.addEventListener('DOMContentLoaded', function () { + // --- Elements --- + const video = document.getElementById('install-video'); + const soundToggleEmoji = document.getElementById('sound-toggle-emoji'); + const mainContainer = document.getElementById('main-container'); + const topContent = document.getElementById('top-content'); + const controlsWrapper = document.getElementById('controls-wrapper'); + const footer = document.querySelector('.footer-disclaimer'); + const allPages = document.querySelectorAll('.page-content'); + const pageButtons = document.querySelectorAll('[data-target]'); + const backButtons = document.querySelectorAll('.page-back-button'); + const languageSelect = document.getElementById('language-select'); + const installBtn = document.getElementById('install-btn'); + const uninstallBtn = document.getElementById('uninstall-btn'); + const controlsContainer = document.querySelector('.offline-play-controls'); + + // --- Sound Toggle --- + function updateSoundEmojiState() { + soundToggleEmoji.textContent = video.muted ? '🔇' : '🔊'; + soundToggleEmoji.title = video.muted ? 'Unmute Audio' : 'Mute Audio'; + } + + if (video && soundToggleEmoji) { + updateSoundEmojiState(); + soundToggleEmoji.addEventListener('click', function () { + video.muted = !video.muted; + updateSoundEmojiState(); + }); + video.addEventListener('volumechange', updateSoundEmojiState); + } + + // --- Control Image Hover --- + const imageControls = document.querySelectorAll('.control-img'); + imageControls.forEach(control => { + const hoverImage = new Image(); + if (control.dataset.on) { + hoverImage.src = control.dataset.on; + } + control.addEventListener('mouseover', function () { if (this.dataset.on) { this.src = this.dataset.on; } }); + control.addEventListener('mouseout', function () { if (this.dataset.off) { this.src = this.dataset.off; } }); + }); + + // --- Emscripten Launch Logic --- + const runGameButton = document.getElementById('run-game-btn'); + const emscriptenCanvas = document.getElementById('canvas'); + const canvasWrapper = document.getElementById('canvas-wrapper'); + const loadingGifOverlay = document.getElementById('loading-gif-overlay'); + const statusMessageBar = document.getElementById('emscripten-status-message'); + + runGameButton.addEventListener('click', function () { + if (!Module.running) return; + video.muted = true; + updateSoundEmojiState(); + this.src = this.dataset.on; + + mainContainer.style.display = 'none'; + canvasWrapper.style.display = 'grid'; + + document.documentElement.style.overflow = 'hidden'; + document.documentElement.style.overscrollBehavior = 'none'; + + Module["disableOffscreenCanvases"] ||= document.getElementById('renderer-select').value == "0 0x682656f3 0x0 0x0 0x2000000"; + console.log("disableOffscreenCanvases: " + Module["disableOffscreenCanvases"]); + + Module["removeRunDependency"]("isle"); + emscriptenCanvas.focus(); + }); + + let progressUpdates = 0; + emscriptenCanvas.addEventListener('presenterProgress', function (event) { + // Intro animation is ready + if (event.detail.objectName == 'Lego_Smk' && event.detail.tickleState == 1) { + loadingGifOverlay.style.display = 'none'; + emscriptenCanvas.style.setProperty('display', 'block', 'important'); + } + else if (progressUpdates < 1003) { + progressUpdates++; + const percent = (progressUpdates / 1003 * 100).toFixed(); + statusMessageBar.innerHTML = 'Loading LEGO® Island... please wait! ' + percent + '%'; + } + }); + + // --- Page Navigation Logic --- + function showPage(pageId, pushState = true) { + const page = document.querySelector(pageId); + if (!page) return; + + // Hide main content + topContent.style.display = 'none'; + controlsWrapper.style.display = 'none'; + + // Show selected page + page.style.display = 'flex'; + window.scroll(0, 0); + + if (pushState) { + const newPath = pageId.replace('-page', ''); + history.pushState({ page: pageId }, '', newPath); + } + } + + function showMainMenu() { + // Hide all pages + allPages.forEach(p => p.style.display = 'none'); + + // Show main content + topContent.style.display = 'flex'; + controlsWrapper.style.display = 'flex'; + } + + pageButtons.forEach(button => { + button.addEventListener('click', (e) => { + const targetId = e.currentTarget.dataset.target; + showPage(targetId); + }); + }); + + backButtons.forEach(button => { + button.addEventListener('click', () => { + history.back(); + }); + }); + + window.addEventListener('popstate', (e) => { + if (e.state && e.state.page && e.state.page !== 'main') { + showPage(e.state.page, false); + } else { + showMainMenu(); + } + }); + + // --- OPFS Config Manager --- + const configManager = { + form: document.querySelector('.config-form'), + filePath: 'isle.ini', + + async init() { + if (!this.form) return; + await this.loadConfig(); + this.form.addEventListener('change', () => this.saveConfig()); + }, + + async getFileHandle() { + try { + const root = await navigator.storage.getDirectory(); + return await root.getFileHandle(this.filePath, { create: true }); + } catch (e) { + console.error("OPFS not available or permission denied.", e); + document.getElementById('opfs-disabled').style.display = ''; + document.getElementById('config-form').querySelectorAll('input, select').forEach(element => { + element.disabled = true; + }); + return null; + } + }, + + async saveConfig() { + // This function now uses an inline Web Worker for maximum compatibility, + // especially with Safari, which does not support createWritable(). + + let iniContent = '[isle]\n'; + const elements = this.form.elements; + + for (const element of elements) { + if (!element.name || element.dataset.notIni == "true") continue; + + let value; + switch (element.type) { + case 'checkbox': + value = element.checked ? 'YES' : 'NO'; + iniContent += `${element.name}=${value}\n`; + break; + case 'radio': + if (element.checked) { + value = element.value; + iniContent += `${element.name}=${value}\n`; + } + break; + default: + value = element.value; + iniContent += `${element.name}=${value}\n`; + break; + } + } + + const workerCode = ` + self.onmessage = async (e) => { + if (e.data.action === 'save') { + try { + const root = await navigator.storage.getDirectory(); + const handle = await root.getFileHandle(e.data.filePath, { create: true }); + const accessHandle = await handle.createSyncAccessHandle(); + const encoder = new TextEncoder(); + const encodedData = encoder.encode(e.data.content); + + accessHandle.truncate(0); + accessHandle.write(encodedData, { at: 0 }); + accessHandle.flush(); + accessHandle.close(); + + self.postMessage({ status: 'success', message: 'Config saved to ' + e.data.filePath }); + } catch (err) { + self.postMessage({ status: 'error', message: 'Failed to save config: ' + err.message }); + } + } + }; + `; + + const blob = new Blob([workerCode], { type: 'application/javascript' }); + const workerUrl = URL.createObjectURL(blob); + const worker = new Worker(workerUrl); + + worker.postMessage({ + action: 'save', + content: iniContent, + filePath: this.filePath + }); + + worker.onmessage = (e) => { + console.log(e.data.message); + URL.revokeObjectURL(workerUrl); // Clean up the temporary URL + worker.terminate(); + }; + + worker.onerror = (e) => { + console.error('An error occurred in the config-saving worker:', e.message); + URL.revokeObjectURL(workerUrl); + worker.terminate(); + }; + }, + + async loadConfig() { + const handle = await this.getFileHandle(); + if (!handle) return; + + const file = await handle.getFile(); + const text = await file.text(); + if (!text) { + console.log('No existing config file found, using defaults.'); + await this.saveConfig(); + return; + } + + const config = {}; + const lines = text.split('\n'); + for (const line of lines) { + if (line.startsWith('[') || !line.includes('=')) continue; + const [key, ...valueParts] = line.split('='); + const value = valueParts.join('=').trim(); + config[key.trim()] = value; + } + + this.applyConfigToForm(config); + console.log('Config loaded from', this.filePath); + }, + + applyConfigToForm(config) { + const elements = this.form.elements; + for (const key in config) { + const element = elements[key]; + if (!element) continue; + + const value = config[key]; + + if (element.type === 'checkbox') { + element.checked = (value === 'YES'); + } else if (element.nodeName === 'RADIO') { // radio nodelist + for (const radio of element) { + if (radio.value === value) { + radio.checked = true; + break; + } + } + } + else { + element.value = value; + } + } + } + }; + + // Handle initial page load with a hash + const initialHash = window.location.hash; + if (initialHash) { + const initialPageId = initialHash + '-page'; + if (document.querySelector(initialPageId)) { + const urlPath = window.location.pathname; + history.replaceState({ page: 'main' }, '', urlPath); + showPage(initialPageId, true); + } + } else { + history.replaceState({ page: 'main' }, '', window.location.pathname); + } + + if (document.documentElement.requestFullscreen) { + const fullscreenElement = document.getElementById('window-fullscreen'); + const windowedElement = document.getElementById('window-windowed'); + + fullscreenElement.addEventListener('change', () => { + if (fullscreenElement.checked) { + document.documentElement.requestFullscreen().catch(err => { + console.error(`Error attempting to enable full-screen mode: ${err.message} (${err.name})`); + }); + } + }); + + windowedElement.addEventListener('change', () => { + if (windowedElement.checked && document.fullscreenElement) { + document.exitFullscreen(); + } + }); + + // Event listener for changes in fullscreen state (e.g., F11 or Esc key) + document.addEventListener('fullscreenchange', () => { + if (document.fullscreenElement) { + fullscreenElement.checked = true; + } else { + windowedElement.checked = true; + } + }); + } + else { + document.getElementById('window-form').style.display = 'none'; + } + + if (!window.matchMedia('(any-pointer: coarse)').matches) { + document.getElementById('touch-section').style.display = 'none'; + } + + if ('serviceWorker' in navigator) { + Promise.all([ + configManager.init(), + navigator.serviceWorker.register('/sw.js').then(() => navigator.serviceWorker.ready) + ]).then(([configResult, swRegistration]) => { + checkInitialCacheStatus(); + }).catch(error => { + console.error('Initialization failed:', error); + }); + + navigator.serviceWorker.addEventListener('message', handleServiceWorkerMessage); + } + else { + configManager.init(); + } + + const progressCircular = document.createElement('div'); + progressCircular.className = 'progress-circular'; + controlsContainer.appendChild(progressCircular); + + installBtn.addEventListener('click', () => { + if (navigator.serviceWorker.controller) { + const selectedLanguage = languageSelect.value; + installBtn.style.display = 'none'; + uninstallBtn.style.display = 'none'; + progressCircular.style.display = 'flex'; + progressCircular.textContent = '0%'; + progressCircular.style.background = 'conic-gradient(#FFD700 0deg, #333 0deg)'; + + navigator.serviceWorker.controller.postMessage({ + action: 'install_language_pack', + language: selectedLanguage + }); + } + }); + + uninstallBtn.addEventListener('click', () => { + const selectedLanguage = languageSelect.value; + navigator.serviceWorker.controller.postMessage({ + action: 'uninstall_language_pack', + language: selectedLanguage + }); + }); + + languageSelect.addEventListener('change', () => { + checkInitialCacheStatus(); + }); + + function checkInitialCacheStatus() { + if (navigator.serviceWorker.controller) { + const selectedLanguage = languageSelect.value; + navigator.serviceWorker.controller.postMessage({ + action: 'check_cache_status', + language: selectedLanguage + }); + } + } + + function updateInstallUI(isInstalled, inProgress = false) { + progressCircular.style.display = inProgress ? 'flex' : 'none'; + installBtn.style.display = !isInstalled && !inProgress ? 'block' : 'none'; + uninstallBtn.style.display = isInstalled && !inProgress ? 'block' : 'none'; + } + + function handleServiceWorkerMessage(event) { + const { action, language, progress, exists, success } = event.data; + if (language !== languageSelect.value) return; + + switch (action) { + case 'cache_status': + updateInstallUI(exists); + break; + case 'install_progress': + updateInstallUI(false, true); + const angle = (progress / 100) * 360; + progressCircular.textContent = `${Math.round(progress)}%`; + progressCircular.style.background = + `radial-gradient(#181818 60%, transparent 61%), conic-gradient(#FFD700 ${angle}deg, #333 ${angle}deg)`; + break; + case 'install_complete': + updateInstallUI(success); + break; + case 'uninstall_complete': + updateInstallUI(!success); + break; + case 'install_failed': + alert('Download failed. Please check your internet connection and try again.'); + updateInstallUI(false); + break; + } + } +}); diff --git a/index.html b/index.html index 9d7c121..85a143d 100644 --- a/index.html +++ b/index.html @@ -1,12 +1,21 @@ + LEGO® Island - - + + + + + + + + @@ -22,642 +31,12 @@ + - - +
@@ -673,31 +52,41 @@
Run Game - Configure - Free Stuff + data-off="run_game_off.webp" data-on="run_game_on.webp"> + Configure + Free Stuff Read Me + data-off="read_me_off.webp" data-on="read_me_on.webp" data-target="#read-me-page"> Cancel + data-off="cancel_off.webp" data-on="cancel_on.webp" onclick="location.href = 'https://legoisland.org';">
- +
← Back

Read Me

-

Welcome to the LEGO Island web port project! This is a recreation of the classic 1997 PC game, rebuilt to run in modern web browsers using Emscripten.

-

This incredible project stands on the shoulders of giants. It was made possible by the original decompilation project, which was then adapted into a portable version. This represents a year-long effort, involving thousands of hours of work from many awesome contributors dedicated to preserving this piece of gaming history.

-

Our goal is to make this classic accessible to everyone. The project is still in development, so you may encounter bugs. Your patience and feedback are greatly appreciated!

+

Welcome to the LEGO Island web port project! This is a recreation of the classic 1997 PC game, + rebuilt to run in modern web browsers using Emscripten.

+

This incredible project stands on the shoulders of giants. It was made possible by the original decompilation project, which was then adapted into a portable version. This represents a year-long effort, involving + thousands of hours of work from many awesome contributors dedicated to preserving this piece of + gaming history.

+

Our goal is to make this classic accessible to everyone. The project is still in development, so you + may encounter bugs. Your patience and feedback are greatly appreciated!

- +
← Back
@@ -710,7 +99,7 @@
- @@ -722,14 +111,15 @@ - +
- +
@@ -742,11 +132,14 @@
- +
@@ -759,11 +152,14 @@
- +
@@ -782,17 +178,20 @@ Touch Control Scheme ? -
Virtual Gamepad (Recommended): Slide your finger to move and turn.

-
Virtual Arrow Keys: Tap screen areas to move. The top moves forward, the bottom turns or moves back.

-
Virtual Mouse: Emulates classic mouse controls with touch.
- +
Virtual Gamepad (Recommended): Slide your finger to + move and turn.

+
Virtual Arrow Keys: Tap screen areas to move. The top + moves forward, the bottom turns or moves back.

+
Virtual Mouse: Emulates classic mouse controls with + touch.
+
- - +
@@ -800,13 +199,15 @@ Options ? -
Haptic feedback: On supported devices and browsers, this provides physical feedback, like a vibration, while you play the game.
- +
Haptic feedback: On supported devices and browsers, + this provides physical feedback, like a vibration, while you play the + game.
+
- - + +
@@ -819,7 +220,9 @@
@@ -854,7 +257,9 @@ @@ -863,10 +268,13 @@ - +
@@ -876,44 +284,63 @@
- - +
- - +
-

Sound

-
+

Sound

+
- - + +
- - + +
+
+

Offline Play

+
+
+

Install for Offline Access

+

By installing, the game will be available to play even when you are not connected to + the internet. This will download all necessary files to your device (about 550MB in + size).

+

Note: browsers enforce strict storage and memory quotas, especially when using private/incognito windows. If you encounter an error during installation, please use a regular window and make sure you have enough disk space available on your device.

+
+
+ Install Game + +
+
+
@@ -923,73 +350,104 @@
-

"In November of 2010, after all was said and done, I started getting emails from a few kids and some adults telling me how cool they thought LEGO Island was. Some people actually still play it. I was quite thrilled by these emails and actually quite honored."

+

"In November of 2010, after all was said and done, I started getting emails from a few kids + and some adults telling me how cool they thought LEGO Island was. Some people actually still + play it. I was quite thrilled by these emails and actually quite honored."

- Wes Jenkins, Creative Director
- +

The Making of LEGO Island: A Documentary

-

An in-depth documentary by MattKC that explores the fascinating and chaotic development story behind the classic game.

+

An in-depth documentary by MattKC that explores the fascinating and chaotic development story + behind the classic game.

 - +

LEGO Island Radio 24/7

-

Enjoy the iconic, high-quality soundtrack of LEGO Island anytime with this continuous live stream, complete with the original DJ interludes.

+

Enjoy the iconic, high-quality soundtrack of LEGO Island anytime with this continuous live + stream, complete with the original DJ interludes.

 - +

LEGO Island Wiki

-

Your ultimate resource for all things LEGO Island. This fan-run wiki contains a wealth of information, research, and details about the game.

+

Your ultimate resource for all things LEGO Island. This fan-run wiki contains a wealth of + information, research, and details about the game.

 - +

LEGO Island Decompilation

-

The core open-source project that reverse-engineered the original game, making this web port and other mods possible. Dive into the source code here.

+

The core open-source project that reverse-engineered the original game, making this web port + and other mods possible. Dive into the source code here.

 - +

LEGO Island, Portable Version

-

A portable, cross-platform version of the decompilation project which serves as the direct foundation for this web-based port.

+

A portable, cross-platform version of the decompilation project which serves as the direct + foundation for this web-based port.

 - +

isle.pizza Frontend

-

The source code for this website! A custom-built frontend for the Emscripten version of the portable decompilation project.

+

The source code for this website! A custom-built frontend for the Emscripten version of the + portable decompilation project.

 - +

LEGO Island Rebuilder

-

A powerful launcher and tool for patching and modding the original 1997 PC version of LEGO Island. Essential for play and modding.

+

A powerful launcher and tool for patching and modding the original 1997 PC version of LEGO + Island. Essential for play and modding.

 - +

SIEdit

-

A suite of tools developed by the decompilation team for viewing and editing the ".si" script and resource files from the original game.

+

A suite of tools developed by the decompilation team for viewing and editing the ".si" script + and resource files from the original game.

 - +

The Making of LEGO Island, a memoir by Wes Jenkins

-

Read the fascinating, incomplete memoir from Creative Director Wes Jenkins, detailing the development process and the team behind the game.

+

Read the fascinating, incomplete memoir from Creative Director Wes Jenkins, detailing the + development process and the team behind the game.

LEGO Island: Free Poster

-

Download a copy of the iconic poster that was originally included with the retail release of the game.

+

Download a copy of the iconic poster that was originally included with the retail release of + the game.

 - +

Development Materials Archive

-

Explore a collection of development materials, concept art, and other historical assets from the creation of LEGO Island.

+

Explore a collection of development materials, concept art, and other historical assets from + the creation of LEGO Island.

 - +

Video Game Flashback: An Interview with Wes Jenkins

-

A detailed interview with LEGO Island's Creative Director, Wes Jenkins, offering unique insights into the game's production.

+

A detailed interview with LEGO Island's Creative Director, Wes Jenkins, offering unique + insights into the game's production.

 - +

LEGO® Island - Behind the Scenes

-

Watch a rare promotional video created during the game's development, showcasing its progress and vision at the time.

+

Watch a rare promotional video created during the game's development, showcasing its progress + and vision at the time.

 - +

The Cutting Room Floor

-

Discover unused assets, hidden data, and other secrets left in the retail version of the game. A fascinating look at what might have been.

+

Discover unused assets, hidden data, and other secrets left in the retail version of the + game. A fascinating look at what might have been.

 - +

Project Island High Quality Music

-

A complete, high-quality re-digitization of the LEGO Island soundtrack, restored by the game's main composer, Lorin Nelson.

+

A complete, high-quality re-digitization of the LEGO Island soundtrack, restored by the + game's main composer, Lorin Nelson.
- +

LEGO® and LEGO Island™ are trademarks of The LEGO Group.

This is an unofficial fan project and is not affiliated with or endorsed by The LEGO Group.

@@ -999,12 +457,15 @@
Loading game... -

"Whoops! You have to put the CD in your computer"

+
+

"Whoops! You have to put the CD in your computer"

- The Infomaniac (1997)

-

"Hello! Hola! Aloha! How ya doin'? YO!" It's your pal, the Infomaniac, with a 2025 update! No need to search for that CD case, my friend!

-

This amazing LEGO Island adventure is now streaming directly from... well, from a really, really big digital box of bricks! Keep an eye on the status below!

+

"Hello! Hola! Aloha! How ya doin'? YO!" It's your pal, the Infomaniac, with a 2025 update! No need to + search for that CD case, my friend!

+

This amazing LEGO Island adventure is now streaming directly from... well, from a really, really big + digital box of bricks! Keep an eye on the status below!

Loading LEGO® Island... please wait! 0% @@ -1012,355 +473,9 @@
- - - - - + + - + \ No newline at end of file diff --git a/install_off.webp b/install_off.webp new file mode 100644 index 0000000000000000000000000000000000000000..683d2605c55f85cb9a7423fe7925ad85ffc6d441 GIT binary patch literal 3742 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 IqsRaN0Lh>~MgRZ+ literal 0 HcmV?d00001 diff --git a/install_on.webp b/install_on.webp new file mode 100644 index 0000000000000000000000000000000000000000..1d490205031eac9001c8d49017804f04e00f02bc GIT binary patch literal 4020 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 literal 0 HcmV?d00001 diff --git a/style.css b/style.css new file mode 100644 index 0000000..cb0c5c4 --- /dev/null +++ b/style.css @@ -0,0 +1,762 @@ +@charset "UTF-8"; + +html { + height: 100%; +} + +body { + margin: 0; + background-color: #000000; + display: flex; + justify-content: center; + align-items: center; + overflow-y: auto; + padding: 10px; + box-sizing: border-box; + font-family: Arial, sans-serif; +} + +#canvas-wrapper { + display: none; + position: fixed; + top: 0; + left: 0; + width: 100vw; + height: 100dvh; + background-color: #000000; + outline: none; + place-items: center; + + touch-action: none; + -webkit-touch-callout: none; + user-select: none; + -webkit-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + -khtml-user-select: none; + -webkit-user-drag: none; + user-drag: none; +} + +#loading-gif-overlay { + grid-column: 1 / -1; + grid-row: 1 / -1; + width: 100%; + height: 100%; + max-width: calc(100dvh * (640 / 480)); + max-height: calc(100dvw * (480 / 640)); + aspect-ratio: 640 / 480; + box-sizing: border-box; + outline: none; +} + +#canvas { + display: none !important; + grid-column: 1 / -1; + grid-row: 1 / -1; + background-color: #000000; + border: none; + z-index: 1; + outline: none; +} + +#loading-gif-overlay { + background-color: #000000; + border: none; + z-index: 2; + display: flex; + flex-direction: column; + justify-content: center; + align-items: center; +} + +.quote-block { + max-width: 80%; + text-align: center; + box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2); +} + +.quote-block .quote-text { + font-size: 0.5em; + color: #f0f0f0; + margin-bottom: 10px; + font-style: italic; + line-height: 1.4; +} + +.quote-block .quote-attribution { + font-size: 0.1em; + color: #c0c0c0; + text-align: right; +} + +.loading-info-text { + margin-top: 15px; + padding: 10px 15px; + max-width: 280px; + width: 80%; + font-size: 0.8em; + color: #b0b0b0; + line-height: 1.5; + text-align: center; + border-top: 1px dashed #444; + padding-top: 15px; +} + +.loading-info-text p { + margin: 0 0 8px 0; +} + +.loading-info-text p:last-child { + margin-bottom: 0; +} + +.status-message-bar { + margin-top: 20px; + padding: 8px 12px; + width: 85%; + max-width: 340px; + background-color: #181818; + color: #c0c0c0; + font-family: 'Consolas', 'Menlo', 'Courier New', Courier, monospace; + font-size: 0.75em; + border-radius: 4px; + text-align: center; + line-height: 1.4; + border: 1px solid #303030; + box-shadow: 0 1px 3px rgba(0, 0, 0, 0.3); +} + +.status-message-bar code { + color: #FFD700; + background-color: #2a2a2a; + padding: 1px 5px; + border-radius: 3px; + font-weight: bold; +} + +#main-container { + display: flex; + flex-direction: column; + align-items: center; + gap: 25px; + background-color: #000000; + padding: 20px; + border-radius: 10px; + max-width: 95vw; + box-shadow: none; + width: 900px; + max-width: 95vw; +} + +#top-content { + display: flex; + justify-content: center; + align-items: center; + flex-wrap: wrap; + gap: 20px; + width: 100%; +} + +.video-container { + position: relative; + display: flex; + justify-content: center; +} + +#install-video { + max-width: 100%; + width: 300px; + height: auto; + display: block; + aspect-ratio: 1 / 1; + border: none; + box-sizing: border-box; +} + +#sound-toggle-emoji { + position: absolute; + top: 10px; + left: 10px; + font-size: 26px; + color: white; + text-shadow: 0 0 3px black; + cursor: pointer; + opacity: 0.7; + transition: opacity 0.2s ease-in-out; + z-index: 10; + padding: 2px; + user-select: none; +} + +#sound-toggle-emoji:hover { + opacity: 1; +} + +#island-logo-img { + max-width: 100%; + width: 400px; + height: auto; + display: block; + aspect-ratio: 567 / 198; +} + +#controls-wrapper { + display: flex; + justify-content: space-around; + align-items: flex-end; + flex-wrap: wrap; + gap: 10px; + width: 100%; + max-width: 700px; + padding: 10px 0; +} + +.control-img { + cursor: pointer; + height: auto; + max-width: 18%; + display: block; + transition: transform 0.1s ease-in-out; +} + +#run-game-btn { + aspect-ratio: 135 / 164; +} + +#configure-btn { + aspect-ratio: 130 / 147; +} + +#free-stuff-btn { + aspect-ratio: 134 / 149; +} + +#read-me-btn { + aspect-ratio: 134 / 149; +} + +#cancel-btn { + aspect-ratio: 93 / 145; +} + +#install-btn { + aspect-ratio: 94 / 166; +} + +#uninstall-btn { + aspect-ratio: 122 / 144; +} + +.control-img:hover { + transform: scale(1.08); +} + +.footer-disclaimer { + font-size: 0.7em; + color: #888888; + text-align: center; + line-height: 1.4; + max-width: 600px; + width: 90%; +} + +.footer-disclaimer p { + margin: 4px 0; +} + +.page-content { + display: none; + flex-direction: column; + align-items: center; + justify-content: flex-start; + color: #f0f0f0; + width: 100%; +} + +.page-back-button { + display: block; + width: 100%; + text-align: left; + font-size: 24px; + font-weight: bold; + color: white; + text-decoration: none; + cursor: pointer; + opacity: 0.8; + transition: all 0.2s ease-in-out; + margin-bottom: 20px; +} + +.page-back-button:hover { + opacity: 1; + color: #FFD700; +} + +.page-inner-content { + max-width: 700px; + width: 100%; + text-align: center; +} + +.page-inner-content h1 { + color: #FFD700; + /* LEGO yellow */ + font-size: 2.5em; + margin-bottom: 20px; + text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.5); +} + +.page-inner-content p { + color: #c0c0c0; + line-height: 1.6; + font-size: 1.1em; + margin-bottom: 15px; + text-align: left; +} + +.page-inner-content a { + color: #FFD700; + text-decoration: none; +} + +.page-inner-content a:hover { + text-decoration: underline; +} + +#configure-page .page-inner-content { + display: flex; + background-color: #181818; + border: 1px solid #303030; + border-radius: 8px; +} + +.config-art-panel { + flex: 0 0 180px; + border-radius: 8px 0 0 8px; +} + +.config-art-panel img { + width: 100%; + height: 100%; + object-fit: cover; + display: block; + border-radius: 8px 0 0 8px; +} + +.config-form { + flex-grow: 1; + padding: 25px; +} + +.config-section { + margin-bottom: 25px; +} + +.config-section:last-child { + margin-bottom: 0; +} + +.config-legend { + color: #FFD700; + font-size: 1.1em; + font-weight: bold; + margin: 0 0 15px 0; + padding-bottom: 10px; + border-bottom: 1px solid #444; +} + +.form-grid { + display: grid; + grid-template-columns: 1fr 1fr; + gap: 20px 30px; +} + +.form-group-label { + position: relative; + display: inline-flex; + align-items: center; + gap: 8px; + color: #e0e0e0; + font-weight: bold; + font-size: 0.9em; + margin-bottom: 10px; +} + +.tooltip-trigger { + position: relative; + cursor: pointer; + width: 16px; + height: 16px; + border-radius: 50%; + background-color: #444; + color: #eee; + display: inline-flex; + align-items: center; + justify-content: center; + font-size: 12px; + font-weight: bold; + user-select: none; +} + +.tooltip-content { + position: absolute; + bottom: 140%; + left: 50%; + transform: translateX(-50%); + width: 220px; + background-color: #2a2a2a; + color: #f0f0f0; + padding: 10px; + border-radius: 5px; + font-size: 0.85em; + font-weight: normal; + line-height: 1.4; + text-align: left; + box-shadow: 0 2px 5px rgba(0, 0, 0, 0.5); + z-index: 20; + opacity: 0; + visibility: hidden; + transition: opacity 0.2s, visibility 0.2s; + pointer-events: none; +} + +.tooltip-trigger:hover>.tooltip-content, +.tooltip-trigger.active>.tooltip-content { + opacity: 1; + visibility: visible; +} + +.option-list { + display: flex; + flex-direction: column; + gap: 12px; +} + +.option-item { + display: flex; + align-items: center; +} + +.option-item input { + position: absolute; + opacity: 0; + width: 0; + height: 0; +} + +.option-item label { + display: inline-flex; + align-items: center; + cursor: pointer; + font-size: 0.9em; + color: #c0c0c0; +} + +.option-item label::before { + content: ''; + width: 14px; + height: 14px; + margin-right: 10px; + background-color: #333; + border: 1px solid #555; + transition: all 0.2s ease; +} + +.option-item input:checked+label::before { + background-color: #FFD700; + border-color: #fff; + box-shadow: 0 0 5px #FFD700; +} + +.radio-group .option-item label::before { + border-radius: 50%; +} + +.checkbox-group .option-item label::before { + border-radius: 3px; +} + +input[type="range"] { + -webkit-appearance: none; + appearance: none; + width: 100%; + height: 6px; + background: #444; + outline: none; + border-radius: 6px; +} + +input[type="range"]::-webkit-slider-thumb { + -webkit-appearance: none; + appearance: none; + width: 18px; + height: 18px; + background: #FFD700; + cursor: pointer; + border-radius: 50%; + border: 2px solid #000; +} + +input[type="range"]::-moz-range-thumb { + width: 18px; + height: 18px; + background: #FFD700; + cursor: pointer; + border-radius: 50%; + border: 2px solid #000; +} + +.select-wrapper { + position: relative; +} + +.select-wrapper::after { + content: '▼'; + position: absolute; + top: 50%; + right: 12px; + transform: translateY(-50%); + color: #FFD700; + pointer-events: none; +} + +select { + -webkit-appearance: none; + -moz-appearance: none; + appearance: none; + display: block; + width: 100%; + padding: 10px 15px; + font-size: 0.9em; + color: #c0c0c0; + background-color: #333; + border: 1px solid #555; + border-radius: 4px; + cursor: pointer; +} + +.resource-list { + display: flex; + flex-direction: column; + gap: 15px; + width: 100%; +} + +.resource-item { + display: block; + background-color: #1c1c1c; + border: 1px solid #333; + border-radius: 8px; + padding: 20px; + text-decoration: none; + transition: background-color 0.2s ease, border-color 0.2s ease; +} + +.resource-item:hover { + background-color: #252525; + border-color: #555; +} + +.resource-item h3 { + margin: 0 0 8px 0; + color: #FFD700; + font-size: 1.2em; +} + +.resource-item p { + margin: 0; + color: #b0b0b0; + font-size: 0.9em; + line-height: 1.5; +} + +.page-quote { + padding: 15px 20px; + margin-bottom: 25px; + border-left: 3px solid #FFD700; + background-color: #1c1c1c; + border-radius: 0 8px 8px 0; +} + +.page-quote p { + font-style: italic; + color: #e0e0e0; + margin: 0; + font-size: 1em; +} + +.page-quote footer { + text-align: right; + margin-top: 10px; + font-size: 0.9em; + color: #888; +} + +.error-box { + padding: 15px 20px; + margin-bottom: 25px; + border-left: 3px solid #ff0011; + background-color: #1c1c1c; + border-radius: 0 8px 8px 0; +} + +.error-box p { + font-style: italic; + color: #e0e0e0; + margin: 0; + font-size: 1em; +} + +.offline-play-grid { + display: grid; + grid-template-columns: 2fr 1fr; + align-items: center; +} + +.offline-play-text h4 { + color: #FFD700; + margin-top: 0; + margin-bottom: 10px; +} + +.offline-play-text p { + text-align: left; + line-height: 1.5; + font-size: 0.9em; +} + +.offline-play-controls { + display: flex; + justify-content: center; + align-items: center; + min-height: 150px; +} + +#install-btn { + max-width: 50%; + margin: 0 auto; +} + +#uninstall-btn { + max-width: 70%; + margin: 0 auto; +} + +.progress-circular { + display: none; + position: relative; + width: 80px; + height: 80px; + border-radius: 50%; + background: + radial-gradient(#181818 60%, transparent 61%), + conic-gradient(#FFD700 0deg, #333 0deg); + + align-items: center; + justify-content: center; + + color: #f0f0f0; + font-size: 1.2em; + font-weight: bold; + font-family: 'Consolas', 'Menlo', monospace; + transition: background 0.2s ease-out; +} + +/* Responsive adjustments */ +@media (max-width: 768px) { + #install-video { + width: 260px; + } + + #island-logo-img { + width: 360px; + } + + .control-img { + max-width: 19%; + } + + #sound-toggle-emoji { + font-size: 24px; + top: 8px; + left: 8px; + } + + .loading-info-text { + max-width: 90%; + font-size: 0.75em; + } + + .page-inner-content h1 { + font-size: 2em; + } + + .page-inner-content p { + font-size: 1em; + } + + .config-art-panel { + display: none; + } + + #configure-page .page-inner-content { + background-color: transparent; + border: none; + padding: 0; + } + + .config-form { + background-color: #181818; + border: 1px solid #303030; + border-radius: 8px; + } + + .offline-play-grid { + grid-template-columns: 1fr; + text-align: center; + } + + .offline-play-text p { + text-align: center; + } +} + +@media (max-width: 480px) { + #install-video { + width: 90%; + max-width: 280px; + } + + #island-logo-img { + width: 90%; + max-width: 320px; + } + + .control-img { + max-width: 45%; + margin: 3px 0; + } + + #sound-toggle-emoji { + font-size: 22px; + top: 6px; + left: 6px; + } + + .loading-info-text { + max-width: 95%; + font-size: 0.7em; + margin-top: 10px; + padding-top: 10px; + } + + .page-content .page-back-button { + font-size: 22px; + } + + .form-grid { + grid-template-columns: 1fr; + gap: 25px; + } +} \ No newline at end of file diff --git a/sw.js b/sw.js new file mode 100644 index 0000000..1894630 --- /dev/null +++ b/sw.js @@ -0,0 +1,213 @@ +importScripts('/workbox/workbox-sw.js'); + +workbox.setConfig({ + modulePathPrefix: '/workbox/' +}); + +const { registerRoute } = workbox.routing; +const { StaleWhileRevalidate, CacheFirst, Strategy } = workbox.strategies; +const { CacheableResponsePlugin } = workbox.cacheableResponse; +const { RangeRequestsPlugin } = workbox.rangeRequests; + +const coreAppFiles = [ + '/', '/index.html', '/cancel_off.webp', '/cancel_on.webp', '/cdspin.gif', + '/configure_off.webp', '/configure_on.webp', '/favicon.png', '/favicon.svg', + '/free_stuff_off.webp', '/free_stuff_on.webp', '/install.mp4', '/install_off.webp', + '/install_on.webp', '/install.webm', '/island.webp', '/isle.js', '/isle.wasm', + '/poster.pdf', '/read_me_off.webp', '/read_me_on.webp', '/run_game_off.webp', + '/run_game_on.webp', '/shark.webp', '/uninstall_off.webp', '/uninstall_on.webp', + 'app.js', 'style.css', 'manifest.json' +]; + +const gameFiles = [ + "/LEGO/Scripts/CREDITS.SI", "/LEGO/Scripts/INTRO.SI", "/LEGO/Scripts/NOCD.SI", "/LEGO/Scripts/SNDANIM.SI", + "/LEGO/Scripts/Act2/ACT2MAIN.SI", "/LEGO/Scripts/Act3/ACT3.SI", "/LEGO/Scripts/Build/COPTER.SI", + "/LEGO/Scripts/Build/DUNECAR.SI", "/LEGO/Scripts/Build/JETSKI.SI", "/LEGO/Scripts/Build/RACECAR.SI", + "/LEGO/Scripts/Garage/GARAGE.SI", "/LEGO/Scripts/Hospital/HOSPITAL.SI", "/LEGO/Scripts/Infocntr/ELEVBOTT.SI", + "/LEGO/Scripts/Infocntr/HISTBOOK.SI", "/LEGO/Scripts/Infocntr/INFODOOR.SI", "/LEGO/Scripts/Infocntr/INFOMAIN.SI", + "/LEGO/Scripts/Infocntr/INFOSCOR.SI", "/LEGO/Scripts/Infocntr/REGBOOK.SI", "/LEGO/Scripts/Isle/ISLE.SI", + "/LEGO/Scripts/Isle/JUKEBOX.SI", "/LEGO/Scripts/Isle/JUKEBOXW.SI", "/LEGO/Scripts/Police/POLICE.SI", + "/LEGO/Scripts/Race/CARRACE.SI", "/LEGO/Scripts/Race/CARRACER.SI", "/LEGO/Scripts/Race/JETRACE.SI", + "/LEGO/Scripts/Race/JETRACER.SI", "/LEGO/data/WORLD.WDB" +]; + +const STATIC_CACHE_NAME = 'static-assets-v1'; + +self.addEventListener('install', (event) => { + event.waitUntil( + caches.open(STATIC_CACHE_NAME).then((cache) => { + return cache.addAll(coreAppFiles); + }) + ); + self.skipWaiting(); +}); + +registerRoute( + ({ url }) => coreAppFiles.includes(url.pathname), + new StaleWhileRevalidate({ + cacheName: STATIC_CACHE_NAME, + }) +); + +const rangeRequestsPlugin = new RangeRequestsPlugin(); +const normalizePathPlugin = { + cacheKeyWillBeUsed: async ({ request }) => { + const url = new URL(request.url); + const normalizedPath = url.pathname.replace(/\/{2,}/g, '/'); + const normalizedUrl = url.origin + normalizedPath; + if (request.url === normalizedUrl) { + return request; + } + return new Request(normalizedUrl, { + headers: request.headers, method: request.method, + credentials: request.credentials, redirect: request.redirect, + referrer: request.referrer, body: request.body, + }); + }, +}; + +class LegoCacheStrategy extends Strategy { + async _handle(request, handler) { + const cacheKeyRequest = await normalizePathPlugin.cacheKeyWillBeUsed({ request }); + const cachedResponse = await caches.match(cacheKeyRequest); + + if (cachedResponse) { + return await rangeRequestsPlugin.cachedResponseWillBeUsed({ + request: cacheKeyRequest, + cachedResponse: cachedResponse, + }); + } + + return handler.fetch(request); + } +} + +registerRoute( + ({ url }) => url.pathname.startsWith('/LEGO/'), + new LegoCacheStrategy() +); + +self.addEventListener('message', (event) => { + if (event.data && event.data.action) { + switch (event.data.action) { + case 'install_language_pack': + installLanguagePack(event.data.language, event.source); + break; + case 'uninstall_language_pack': + uninstallLanguagePack(event.data.language, event.source); + break; + case 'check_cache_status': + checkCacheStatus(event.data.language, event.source); + break; + } + } +}); + +const getLanguageCacheName = (language) => `game-assets-${language}`; + +async function installLanguagePack(language, client) { + const THROTTLE_MS = 100; + const cacheName = getLanguageCacheName(language); + + try { + const fileMetadataPromises = gameFiles.map(fileUrl => + fetch(fileUrl, { method: 'HEAD', headers: { 'Accept-Language': language } }) + .then(response => { + if (!response.ok) throw new Error(`Failed to HEAD ${fileUrl}`); + return { url: fileUrl, size: Number(response.headers.get('content-length')) || 0 }; + }) + ); + const fileMetadata = await Promise.all(fileMetadataPromises); + const totalBytesToDownload = fileMetadata.reduce((sum, file) => sum + file.size, 0); + let bytesDownloaded = 0; + let lastProgressUpdate = 0; + + const cache = await caches.open(cacheName); + + for (const file of fileMetadata) { + const request = new Request(file.url, { headers: { 'Accept-Language': language } }); + + try { + const response = await fetch(request); + + if (!response.ok || !response.body) { + throw new Error(`Failed to fetch ${file.url}`); + } + + const [streamForCaching, streamForProgress] = response.body.tee(); + + const responseToCache = new Response(streamForCaching, response); + const cachePromise = cache.put(request, responseToCache); + + const reader = streamForProgress.getReader(); + while (true) { + const { done, value } = await reader.read(); + if (done) break; + + bytesDownloaded += value.length; + const now = Date.now(); + + if (now - lastProgressUpdate > THROTTLE_MS) { + lastProgressUpdate = now; + client.postMessage({ + action: 'install_progress', + progress: (bytesDownloaded / totalBytesToDownload) * 100, + language: language + }); + } + } + + await cachePromise; + } catch (error) { + console.error("Aborting installation due to a persistent error:", error); + await caches.delete(cacheName); + client.postMessage({ action: 'install_failed', language: language }); + } + } + + client.postMessage({ + action: 'install_progress', + progress: 100, + language: language + }); + client.postMessage({ action: 'install_complete', success: true, language: language }); + } catch (error) { + console.error('Error during language pack installation:', error); + client.postMessage({ action: 'install_failed', success: false, language: language, error: error.message }); + } +} + +async function uninstallLanguagePack(language, client) { + const cacheName = getLanguageCacheName(language); + try { + const deleted = await caches.delete(cacheName); + if (deleted) { + console.log(`Cache ${cacheName} deleted successfully.`); + } + client.postMessage({ action: 'uninstall_complete', success: deleted, language: language }); + } catch (error) { + console.error('Error during language pack uninstallation:', error); + client.postMessage({ action: 'uninstall_complete', success: false, language: language, error: error.message }); + } +} + +async function checkCacheStatus(language, client) { + const cacheName = getLanguageCacheName(language); + const hasCache = await caches.has(cacheName); + client.postMessage({ action: 'cache_status', exists: hasCache, language: language }); +} + +self.addEventListener('activate', (event) => { + event.waitUntil( + caches.keys().then((cacheNames) => { + return Promise.all( + cacheNames.map((cacheName) => { + if (cacheName.startsWith('static-assets-') && cacheName !== STATIC_CACHE_NAME) { + return caches.delete(cacheName); + } + }) + ); + }) + ); + self.clients.claim(); +}); diff --git a/uninstall_off.webp b/uninstall_off.webp new file mode 100644 index 0000000000000000000000000000000000000000..7f8c6dbc54e2cb005ef29a6236b6bcf930dcbe31 GIT binary patch literal 3580 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 C1N5T+ literal 0 HcmV?d00001 diff --git a/uninstall_on.webp b/uninstall_on.webp new file mode 100644 index 0000000000000000000000000000000000000000..d9c16901804d9ee7ec0dc8e0abbd1b3966ff5b0d GIT binary patch literal 4266 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 [config.statuses] One or more status codes that a + * `Response` can have and be considered cacheable. + * @param {Object} [config.headers] A mapping of header names + * and expected values that a `Response` can have and be considered cacheable. + * If multiple headers are provided, only one needs to be present. + */ + constructor(config = {}) { + { + if (!(config.statuses || config.headers)) { + throw new WorkboxError_js.WorkboxError('statuses-or-headers-required', { + moduleName: 'workbox-cacheable-response', + className: 'CacheableResponse', + funcName: 'constructor' + }); + } + if (config.statuses) { + assert_js.assert.isArray(config.statuses, { + moduleName: 'workbox-cacheable-response', + className: 'CacheableResponse', + funcName: 'constructor', + paramName: 'config.statuses' + }); + } + if (config.headers) { + assert_js.assert.isType(config.headers, 'object', { + moduleName: 'workbox-cacheable-response', + className: 'CacheableResponse', + funcName: 'constructor', + paramName: 'config.headers' + }); + } + } + this._statuses = config.statuses; + this._headers = config.headers; + } + /** + * Checks a response to see whether it's cacheable or not, based on this + * object's configuration. + * + * @param {Response} response The response whose cacheability is being + * checked. + * @return {boolean} `true` if the `Response` is cacheable, and `false` + * otherwise. + */ + isResponseCacheable(response) { + { + assert_js.assert.isInstance(response, Response, { + moduleName: 'workbox-cacheable-response', + className: 'CacheableResponse', + funcName: 'isResponseCacheable', + paramName: 'response' + }); + } + let cacheable = true; + if (this._statuses) { + cacheable = this._statuses.includes(response.status); + } + if (this._headers && cacheable) { + cacheable = Object.keys(this._headers).some(headerName => { + return response.headers.get(headerName) === this._headers[headerName]; + }); + } + { + if (!cacheable) { + logger_js.logger.groupCollapsed(`The request for ` + `'${getFriendlyURL_js.getFriendlyURL(response.url)}' returned a response that does ` + `not meet the criteria for being cached.`); + logger_js.logger.groupCollapsed(`View cacheability criteria here.`); + logger_js.logger.log(`Cacheable statuses: ` + JSON.stringify(this._statuses)); + logger_js.logger.log(`Cacheable headers: ` + JSON.stringify(this._headers, null, 2)); + logger_js.logger.groupEnd(); + const logFriendlyHeaders = {}; + response.headers.forEach((value, key) => { + logFriendlyHeaders[key] = value; + }); + logger_js.logger.groupCollapsed(`View response status and headers here.`); + logger_js.logger.log(`Response status: ${response.status}`); + logger_js.logger.log(`Response headers: ` + JSON.stringify(logFriendlyHeaders, null, 2)); + logger_js.logger.groupEnd(); + logger_js.logger.groupCollapsed(`View full response details here.`); + logger_js.logger.log(response.headers); + logger_js.logger.log(response); + logger_js.logger.groupEnd(); + logger_js.logger.groupEnd(); + } + } + return cacheable; + } + } + + /* + 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 `cacheWillUpdate` lifecycle callback. This makes it + * easier to add in cacheability checks to requests made via Workbox's built-in + * strategies. + * + * @memberof workbox-cacheable-response + */ + class CacheableResponsePlugin { + /** + * To construct a new CacheableResponsePlugin instance you must provide at + * least one of the `config` properties. + * + * If both `statuses` and `headers` are specified, then both conditions must + * be met for the `Response` to be considered cacheable. + * + * @param {Object} config + * @param {Array} [config.statuses] One or more status codes that a + * `Response` can have and be considered cacheable. + * @param {Object} [config.headers] A mapping of header names + * and expected values that a `Response` can have and be considered cacheable. + * If multiple headers are provided, only one needs to be present. + */ + constructor(config) { + /** + * @param {Object} options + * @param {Response} options.response + * @return {Response|null} + * @private + */ + this.cacheWillUpdate = async ({ + response + }) => { + if (this._cacheableResponse.isResponseCacheable(response)) { + return response; + } + return null; + }; + this._cacheableResponse = new CacheableResponse(config); + } + } + + exports.CacheableResponse = CacheableResponse; + exports.CacheableResponsePlugin = CacheableResponsePlugin; + + return exports; + +})({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private); +//# sourceMappingURL=workbox-cacheable-response.dev.js.map diff --git a/workbox/workbox-cacheable-response.prod.js b/workbox/workbox-cacheable-response.prod.js new file mode 100644 index 0000000..33feb24 --- /dev/null +++ b/workbox/workbox-cacheable-response.prod.js @@ -0,0 +1,2 @@ +this.workbox=this.workbox||{},this.workbox.cacheableResponse=function(s){"use strict";try{self["workbox:cacheable-response:7.3.0"]&&_()}catch(s){}class t{constructor(s={}){this._=s.statuses,this.G=s.headers}isResponseCacheable(s){let t=!0;return this._&&(t=this._.includes(s.status)),this.G&&t&&(t=Object.keys(this.G).some((t=>s.headers.get(t)===this.G[t]))),t}}return s.CacheableResponse=t,s.CacheableResponsePlugin=class{constructor(s){this.cacheWillUpdate=async({response:s})=>this.H.isResponseCacheable(s)?s:null,this.H=new t(s)}},s}({}); +//# sourceMappingURL=workbox-cacheable-response.prod.js.map diff --git a/workbox/workbox-core.dev.js b/workbox/workbox-core.dev.js new file mode 100644 index 0000000..f3c74af --- /dev/null +++ b/workbox/workbox-core.dev.js @@ -0,0 +1,1059 @@ +this.workbox = this.workbox || {}; +this.workbox.core = (function (exports) { + 'use strict'; + + // @ts-ignore + try { + self['workbox:core:7.3.0'] && _(); + } catch (e) {} + + /* + Copyright 2019 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 logger = (() => { + // Don't overwrite this value if it's already set. + // See https://github.com/GoogleChrome/workbox/pull/2284#issuecomment-560470923 + if (!('__WB_DISABLE_DEV_LOGS' in globalThis)) { + self.__WB_DISABLE_DEV_LOGS = false; + } + let inGroup = false; + const methodToColorMap = { + debug: `#7f8c8d`, + log: `#2ecc71`, + warn: `#f39c12`, + error: `#c0392b`, + groupCollapsed: `#3498db`, + groupEnd: null // No colored prefix on groupEnd + }; + const print = function (method, args) { + if (self.__WB_DISABLE_DEV_LOGS) { + return; + } + if (method === 'groupCollapsed') { + // Safari doesn't print all console.groupCollapsed() arguments: + // https://bugs.webkit.org/show_bug.cgi?id=182754 + if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) { + console[method](...args); + return; + } + } + const styles = [`background: ${methodToColorMap[method]}`, `border-radius: 0.5em`, `color: white`, `font-weight: bold`, `padding: 2px 0.5em`]; + // When in a group, the workbox prefix is not displayed. + const logPrefix = inGroup ? [] : ['%cworkbox', styles.join(';')]; + console[method](...logPrefix, ...args); + if (method === 'groupCollapsed') { + inGroup = true; + } + if (method === 'groupEnd') { + inGroup = false; + } + }; + // eslint-disable-next-line @typescript-eslint/ban-types + const api = {}; + const loggerMethods = Object.keys(methodToColorMap); + for (const key of loggerMethods) { + const method = key; + api[method] = (...args) => { + print(method, args); + }; + } + return api; + })(); + + /* + 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 messages = { + 'invalid-value': ({ + paramName, + validValueDescription, + value + }) => { + if (!paramName || !validValueDescription) { + throw new Error(`Unexpected input to 'invalid-value' error.`); + } + return `The '${paramName}' parameter was given a value with an ` + `unexpected value. ${validValueDescription} Received a value of ` + `${JSON.stringify(value)}.`; + }, + 'not-an-array': ({ + moduleName, + className, + funcName, + paramName + }) => { + if (!moduleName || !className || !funcName || !paramName) { + throw new Error(`Unexpected input to 'not-an-array' error.`); + } + return `The parameter '${paramName}' passed into ` + `'${moduleName}.${className}.${funcName}()' must be an array.`; + }, + 'incorrect-type': ({ + expectedType, + paramName, + moduleName, + className, + funcName + }) => { + if (!expectedType || !paramName || !moduleName || !funcName) { + throw new Error(`Unexpected input to 'incorrect-type' error.`); + } + const classNameStr = className ? `${className}.` : ''; + return `The parameter '${paramName}' passed into ` + `'${moduleName}.${classNameStr}` + `${funcName}()' must be of type ${expectedType}.`; + }, + 'incorrect-class': ({ + expectedClassName, + paramName, + moduleName, + className, + funcName, + isReturnValueProblem + }) => { + if (!expectedClassName || !moduleName || !funcName) { + throw new Error(`Unexpected input to 'incorrect-class' error.`); + } + const classNameStr = className ? `${className}.` : ''; + if (isReturnValueProblem) { + return `The return value from ` + `'${moduleName}.${classNameStr}${funcName}()' ` + `must be an instance of class ${expectedClassName}.`; + } + return `The parameter '${paramName}' passed into ` + `'${moduleName}.${classNameStr}${funcName}()' ` + `must be an instance of class ${expectedClassName}.`; + }, + 'missing-a-method': ({ + expectedMethod, + paramName, + moduleName, + className, + funcName + }) => { + if (!expectedMethod || !paramName || !moduleName || !className || !funcName) { + throw new Error(`Unexpected input to 'missing-a-method' error.`); + } + return `${moduleName}.${className}.${funcName}() expected the ` + `'${paramName}' parameter to expose a '${expectedMethod}' method.`; + }, + 'add-to-cache-list-unexpected-type': ({ + entry + }) => { + return `An unexpected entry was passed to ` + `'workbox-precaching.PrecacheController.addToCacheList()' The entry ` + `'${JSON.stringify(entry)}' isn't supported. You must supply an array of ` + `strings with one or more characters, objects with a url property or ` + `Request objects.`; + }, + 'add-to-cache-list-conflicting-entries': ({ + firstEntry, + secondEntry + }) => { + if (!firstEntry || !secondEntry) { + throw new Error(`Unexpected input to ` + `'add-to-cache-list-duplicate-entries' error.`); + } + return `Two of the entries passed to ` + `'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` + `${firstEntry} but different revision details. Workbox is ` + `unable to cache and version the asset correctly. Please remove one ` + `of the entries.`; + }, + 'plugin-error-request-will-fetch': ({ + thrownErrorMessage + }) => { + if (!thrownErrorMessage) { + throw new Error(`Unexpected input to ` + `'plugin-error-request-will-fetch', error.`); + } + return `An error was thrown by a plugins 'requestWillFetch()' method. ` + `The thrown error message was: '${thrownErrorMessage}'.`; + }, + 'invalid-cache-name': ({ + cacheNameId, + value + }) => { + if (!cacheNameId) { + throw new Error(`Expected a 'cacheNameId' for error 'invalid-cache-name'`); + } + return `You must provide a name containing at least one character for ` + `setCacheDetails({${cacheNameId}: '...'}). Received a value of ` + `'${JSON.stringify(value)}'`; + }, + 'unregister-route-but-not-found-with-method': ({ + method + }) => { + if (!method) { + throw new Error(`Unexpected input to ` + `'unregister-route-but-not-found-with-method' error.`); + } + return `The route you're trying to unregister was not previously ` + `registered for the method type '${method}'.`; + }, + 'unregister-route-route-not-registered': () => { + return `The route you're trying to unregister was not previously ` + `registered.`; + }, + 'queue-replay-failed': ({ + name + }) => { + return `Replaying the background sync queue '${name}' failed.`; + }, + 'duplicate-queue-name': ({ + name + }) => { + return `The Queue name '${name}' is already being used. ` + `All instances of backgroundSync.Queue must be given unique names.`; + }, + 'expired-test-without-max-age': ({ + methodName, + paramName + }) => { + return `The '${methodName}()' method can only be used when the ` + `'${paramName}' is used in the constructor.`; + }, + 'unsupported-route-type': ({ + moduleName, + className, + funcName, + paramName + }) => { + return `The supplied '${paramName}' parameter was an unsupported type. ` + `Please check the docs for ${moduleName}.${className}.${funcName} for ` + `valid input types.`; + }, + 'not-array-of-class': ({ + value, + expectedClass, + moduleName, + className, + funcName, + paramName + }) => { + return `The supplied '${paramName}' parameter must be an array of ` + `'${expectedClass}' objects. Received '${JSON.stringify(value)},'. ` + `Please check the call to ${moduleName}.${className}.${funcName}() ` + `to fix the issue.`; + }, + 'max-entries-or-age-required': ({ + moduleName, + className, + funcName + }) => { + return `You must define either config.maxEntries or config.maxAgeSeconds` + `in ${moduleName}.${className}.${funcName}`; + }, + 'statuses-or-headers-required': ({ + moduleName, + className, + funcName + }) => { + return `You must define either config.statuses or config.headers` + `in ${moduleName}.${className}.${funcName}`; + }, + 'invalid-string': ({ + moduleName, + funcName, + paramName + }) => { + if (!paramName || !moduleName || !funcName) { + throw new Error(`Unexpected input to 'invalid-string' error.`); + } + return `When using strings, the '${paramName}' parameter must start with ` + `'http' (for cross-origin matches) or '/' (for same-origin matches). ` + `Please see the docs for ${moduleName}.${funcName}() for ` + `more info.`; + }, + 'channel-name-required': () => { + return `You must provide a channelName to construct a ` + `BroadcastCacheUpdate instance.`; + }, + 'invalid-responses-are-same-args': () => { + return `The arguments passed into responsesAreSame() appear to be ` + `invalid. Please ensure valid Responses are used.`; + }, + 'expire-custom-caches-only': () => { + return `You must provide a 'cacheName' property when using the ` + `expiration plugin with a runtime caching strategy.`; + }, + 'unit-must-be-bytes': ({ + normalizedRangeHeader + }) => { + if (!normalizedRangeHeader) { + throw new Error(`Unexpected input to 'unit-must-be-bytes' error.`); + } + return `The 'unit' portion of the Range header must be set to 'bytes'. ` + `The Range header provided was "${normalizedRangeHeader}"`; + }, + 'single-range-only': ({ + normalizedRangeHeader + }) => { + if (!normalizedRangeHeader) { + throw new Error(`Unexpected input to 'single-range-only' error.`); + } + return `Multiple ranges are not supported. Please use a single start ` + `value, and optional end value. The Range header provided was ` + `"${normalizedRangeHeader}"`; + }, + 'invalid-range-values': ({ + normalizedRangeHeader + }) => { + if (!normalizedRangeHeader) { + throw new Error(`Unexpected input to 'invalid-range-values' error.`); + } + return `The Range header is missing both start and end values. At least ` + `one of those values is needed. The Range header provided was ` + `"${normalizedRangeHeader}"`; + }, + 'no-range-header': () => { + return `No Range header was found in the Request provided.`; + }, + 'range-not-satisfiable': ({ + size, + start, + end + }) => { + return `The start (${start}) and end (${end}) values in the Range are ` + `not satisfiable by the cached response, which is ${size} bytes.`; + }, + 'attempt-to-cache-non-get-request': ({ + url, + method + }) => { + return `Unable to cache '${url}' because it is a '${method}' request and ` + `only 'GET' requests can be cached.`; + }, + 'cache-put-with-no-response': ({ + url + }) => { + return `There was an attempt to cache '${url}' but the response was not ` + `defined.`; + }, + 'no-response': ({ + url, + error + }) => { + let message = `The strategy could not generate a response for '${url}'.`; + if (error) { + message += ` The underlying error is ${error}.`; + } + return message; + }, + 'bad-precaching-response': ({ + url, + status + }) => { + return `The precaching request for '${url}' failed` + (status ? ` with an HTTP status of ${status}.` : `.`); + }, + 'non-precached-url': ({ + url + }) => { + return `createHandlerBoundToURL('${url}') was called, but that URL is ` + `not precached. Please pass in a URL that is precached instead.`; + }, + 'add-to-cache-list-conflicting-integrities': ({ + url + }) => { + return `Two of the entries passed to ` + `'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` + `${url} with different integrity values. Please remove one of them.`; + }, + 'missing-precache-entry': ({ + cacheName, + url + }) => { + return `Unable to find a precached response in ${cacheName} for ${url}.`; + }, + 'cross-origin-copy-response': ({ + origin + }) => { + return `workbox-core.copyResponse() can only be used with same-origin ` + `responses. It was passed a response with origin ${origin}.`; + }, + 'opaque-streams-source': ({ + type + }) => { + const message = `One of the workbox-streams sources resulted in an ` + `'${type}' response.`; + if (type === 'opaqueredirect') { + return `${message} Please do not use a navigation request that results ` + `in a redirect as a source.`; + } + return `${message} Please ensure your sources are CORS-enabled.`; + } + }; + + /* + 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 generatorFunction = (code, details = {}) => { + const message = messages[code]; + if (!message) { + throw new Error(`Unable to find message for code '${code}'.`); + } + return message(details); + }; + const messageGenerator = generatorFunction; + + /* + 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. + */ + /** + * Workbox errors should be thrown with this class. + * This allows use to ensure the type easily in tests, + * helps developers identify errors from workbox + * easily and allows use to optimise error + * messages correctly. + * + * @private + */ + class WorkboxError extends Error { + /** + * + * @param {string} errorCode The error code that + * identifies this particular error. + * @param {Object=} details Any relevant arguments + * that will help developers identify issues should + * be added as a key on the context object. + */ + constructor(errorCode, details) { + const message = messageGenerator(errorCode, details); + super(message); + this.name = errorCode; + this.details = details; + } + } + + /* + 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. + */ + /* + * This method throws if the supplied value is not an array. + * The destructed values are required to produce a meaningful error for users. + * The destructed and restructured object is so it's clear what is + * needed. + */ + const isArray = (value, details) => { + if (!Array.isArray(value)) { + throw new WorkboxError('not-an-array', details); + } + }; + const hasMethod = (object, expectedMethod, details) => { + const type = typeof object[expectedMethod]; + if (type !== 'function') { + details['expectedMethod'] = expectedMethod; + throw new WorkboxError('missing-a-method', details); + } + }; + const isType = (object, expectedType, details) => { + if (typeof object !== expectedType) { + details['expectedType'] = expectedType; + throw new WorkboxError('incorrect-type', details); + } + }; + const isInstance = (object, + // Need the general type to do the check later. + // eslint-disable-next-line @typescript-eslint/ban-types + expectedClass, details) => { + if (!(object instanceof expectedClass)) { + details['expectedClassName'] = expectedClass.name; + throw new WorkboxError('incorrect-class', details); + } + }; + const isOneOf = (value, validValues, details) => { + if (!validValues.includes(value)) { + details['validValueDescription'] = `Valid values are ${JSON.stringify(validValues)}.`; + throw new WorkboxError('invalid-value', details); + } + }; + const isArrayOfClass = (value, + // Need general type to do check later. + expectedClass, + // eslint-disable-line + details) => { + const error = new WorkboxError('not-array-of-class', details); + if (!Array.isArray(value)) { + throw error; + } + for (const item of value) { + if (!(item instanceof expectedClass)) { + throw error; + } + } + }; + const finalAssertExports = { + hasMethod, + isArray, + isInstance, + isOneOf, + isType, + isArrayOfClass + }; + + /* + 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. + */ + // Callbacks to be executed whenever there's a quota error. + // Can't change Function type right now. + // eslint-disable-next-line @typescript-eslint/ban-types + const quotaErrorCallbacks = new Set(); + + /* + Copyright 2019 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. + */ + /** + * Adds a function to the set of quotaErrorCallbacks that will be executed if + * there's a quota error. + * + * @param {Function} callback + * @memberof workbox-core + */ + // Can't change Function type + // eslint-disable-next-line @typescript-eslint/ban-types + function registerQuotaErrorCallback(callback) { + { + finalAssertExports.isType(callback, 'function', { + moduleName: 'workbox-core', + funcName: 'register', + paramName: 'callback' + }); + } + quotaErrorCallbacks.add(callback); + { + logger.log('Registered a callback to respond to quota errors.', callback); + } + } + + /* + 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 _cacheNameDetails = { + googleAnalytics: 'googleAnalytics', + precache: 'precache-v2', + prefix: 'workbox', + runtime: 'runtime', + suffix: typeof registration !== 'undefined' ? registration.scope : '' + }; + const _createCacheName = cacheName => { + return [_cacheNameDetails.prefix, cacheName, _cacheNameDetails.suffix].filter(value => value && value.length > 0).join('-'); + }; + const eachCacheNameDetail = fn => { + for (const key of Object.keys(_cacheNameDetails)) { + fn(key); + } + }; + const cacheNames$1 = { + updateDetails: details => { + eachCacheNameDetail(key => { + if (typeof details[key] === 'string') { + _cacheNameDetails[key] = details[key]; + } + }); + }, + getGoogleAnalyticsName: userCacheName => { + return userCacheName || _createCacheName(_cacheNameDetails.googleAnalytics); + }, + getPrecacheName: userCacheName => { + return userCacheName || _createCacheName(_cacheNameDetails.precache); + }, + getPrefix: () => { + return _cacheNameDetails.prefix; + }, + getRuntimeName: userCacheName => { + return userCacheName || _createCacheName(_cacheNameDetails.runtime); + }, + getSuffix: () => { + return _cacheNameDetails.suffix; + } + }; + + /* + Copyright 2020 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. + */ + function stripParams(fullURL, ignoreParams) { + const strippedURL = new URL(fullURL); + for (const param of ignoreParams) { + strippedURL.searchParams.delete(param); + } + return strippedURL.href; + } + /** + * Matches an item in the cache, ignoring specific URL params. This is similar + * to the `ignoreSearch` option, but it allows you to ignore just specific + * params (while continuing to match on the others). + * + * @private + * @param {Cache} cache + * @param {Request} request + * @param {Object} matchOptions + * @param {Array} ignoreParams + * @return {Promise} + */ + async function cacheMatchIgnoreParams(cache, request, ignoreParams, matchOptions) { + const strippedRequestURL = stripParams(request.url, ignoreParams); + // If the request doesn't include any ignored params, match as normal. + if (request.url === strippedRequestURL) { + return cache.match(request, matchOptions); + } + // Otherwise, match by comparing keys + const keysOptions = Object.assign(Object.assign({}, matchOptions), { + ignoreSearch: true + }); + const cacheKeys = await cache.keys(request, keysOptions); + for (const cacheKey of cacheKeys) { + const strippedCacheKeyURL = stripParams(cacheKey.url, ignoreParams); + if (strippedRequestURL === strippedCacheKeyURL) { + return cache.match(cacheKey, matchOptions); + } + } + return; + } + + /* + Copyright 2019 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. + */ + let supportStatus$1; + /** + * A utility function that determines whether the current browser supports + * constructing a [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream) + * object. + * + * @return {boolean} `true`, if the current browser can successfully + * construct a `ReadableStream`, `false` otherwise. + * + * @private + */ + function canConstructReadableStream() { + if (supportStatus$1 === undefined) { + // See https://github.com/GoogleChrome/workbox/issues/1473 + try { + new ReadableStream({ + start() {} + }); + supportStatus$1 = true; + } catch (error) { + supportStatus$1 = false; + } + } + return supportStatus$1; + } + + /* + Copyright 2019 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. + */ + let supportStatus; + /** + * A utility function that determines whether the current browser supports + * constructing a new `Response` from a `response.body` stream. + * + * @return {boolean} `true`, if the current browser can successfully + * construct a `Response` from a `response.body` stream, `false` otherwise. + * + * @private + */ + function canConstructResponseFromBodyStream() { + if (supportStatus === undefined) { + const testResponse = new Response(''); + if ('body' in testResponse) { + try { + new Response(testResponse.body); + supportStatus = true; + } catch (error) { + supportStatus = false; + } + } + supportStatus = false; + } + return supportStatus; + } + + /* + Copyright 2019 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 helper function that prevents a promise from being flagged as unused. + * + * @private + **/ + function dontWaitFor(promise) { + // Effective no-op. + void promise.then(() => {}); + } + + /* + 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. + */ + /** + * The Deferred class composes Promises in a way that allows for them to be + * resolved or rejected from outside the constructor. In most cases promises + * should be used directly, but Deferreds can be necessary when the logic to + * resolve a promise must be separate. + * + * @private + */ + class Deferred { + /** + * Creates a promise and exposes its resolve and reject functions as methods. + */ + constructor() { + this.promise = new Promise((resolve, reject) => { + this.resolve = resolve; + this.reject = reject; + }); + } + } + + /* + 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. + */ + /** + * Runs all of the callback functions, one at a time sequentially, in the order + * in which they were registered. + * + * @memberof workbox-core + * @private + */ + async function executeQuotaErrorCallbacks() { + { + logger.log(`About to run ${quotaErrorCallbacks.size} ` + `callbacks to clean up caches.`); + } + for (const callback of quotaErrorCallbacks) { + await callback(); + { + logger.log(callback, 'is complete.'); + } + } + { + logger.log('Finished running callbacks.'); + } + } + + /* + 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 getFriendlyURL = url => { + const urlObj = new URL(String(url), location.href); + // See https://github.com/GoogleChrome/workbox/issues/2323 + // We want to include everything, except for the origin if it's same-origin. + return urlObj.href.replace(new RegExp(`^${location.origin}`), ''); + }; + + /* + Copyright 2019 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. + */ + /** + * Returns a promise that resolves and the passed number of milliseconds. + * This utility is an async/await-friendly version of `setTimeout`. + * + * @param {number} ms + * @return {Promise} + * @private + */ + function timeout(ms) { + return new Promise(resolve => setTimeout(resolve, ms)); + } + + /* + Copyright 2019 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 MAX_RETRY_TIME = 2000; + /** + * Returns a promise that resolves to a window client matching the passed + * `resultingClientId`. For browsers that don't support `resultingClientId` + * or if waiting for the resulting client to apper takes too long, resolve to + * `undefined`. + * + * @param {string} [resultingClientId] + * @return {Promise} + * @private + */ + async function resultingClientExists(resultingClientId) { + if (!resultingClientId) { + return; + } + let existingWindows = await self.clients.matchAll({ + type: 'window' + }); + const existingWindowIds = new Set(existingWindows.map(w => w.id)); + let resultingWindow; + const startTime = performance.now(); + // Only wait up to `MAX_RETRY_TIME` to find a matching client. + while (performance.now() - startTime < MAX_RETRY_TIME) { + existingWindows = await self.clients.matchAll({ + type: 'window' + }); + resultingWindow = existingWindows.find(w => { + if (resultingClientId) { + // If we have a `resultingClientId`, we can match on that. + return w.id === resultingClientId; + } else { + // Otherwise match on finding a window not in `existingWindowIds`. + return !existingWindowIds.has(w.id); + } + }); + if (resultingWindow) { + break; + } + // Sleep for 100ms and retry. + await timeout(100); + } + return resultingWindow; + } + + /* + Copyright 2020 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 utility method that makes it easier to use `event.waitUntil` with + * async functions and return the result. + * + * @param {ExtendableEvent} event + * @param {Function} asyncFn + * @return {Function} + * @private + */ + function waitUntil(event, asyncFn) { + const returnPromise = asyncFn(); + event.waitUntil(returnPromise); + return returnPromise; + } + + /* + 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. + */ + + var _private = /*#__PURE__*/Object.freeze({ + __proto__: null, + assert: finalAssertExports, + cacheMatchIgnoreParams: cacheMatchIgnoreParams, + cacheNames: cacheNames$1, + canConstructReadableStream: canConstructReadableStream, + canConstructResponseFromBodyStream: canConstructResponseFromBodyStream, + dontWaitFor: dontWaitFor, + Deferred: Deferred, + executeQuotaErrorCallbacks: executeQuotaErrorCallbacks, + getFriendlyURL: getFriendlyURL, + logger: logger, + resultingClientExists: resultingClientExists, + timeout: timeout, + waitUntil: waitUntil, + WorkboxError: WorkboxError + }); + + /* + Copyright 2019 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. + */ + /** + * Get the current cache names and prefix/suffix used by Workbox. + * + * `cacheNames.precache` is used for precached assets, + * `cacheNames.googleAnalytics` is used by `workbox-google-analytics` to + * store `analytics.js`, and `cacheNames.runtime` is used for everything else. + * + * `cacheNames.prefix` can be used to retrieve just the current prefix value. + * `cacheNames.suffix` can be used to retrieve just the current suffix value. + * + * @return {Object} An object with `precache`, `runtime`, `prefix`, and + * `googleAnalytics` properties. + * + * @memberof workbox-core + */ + const cacheNames = { + get googleAnalytics() { + return cacheNames$1.getGoogleAnalyticsName(); + }, + get precache() { + return cacheNames$1.getPrecacheName(); + }, + get prefix() { + return cacheNames$1.getPrefix(); + }, + get runtime() { + return cacheNames$1.getRuntimeName(); + }, + get suffix() { + return cacheNames$1.getSuffix(); + } + }; + + /* + Copyright 2019 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. + */ + /** + * Allows developers to copy a response and modify its `headers`, `status`, + * or `statusText` values (the values settable via a + * [`ResponseInit`]{@link https://developer.mozilla.org/en-US/docs/Web/API/Response/Response#Syntax} + * object in the constructor). + * To modify these values, pass a function as the second argument. That + * function will be invoked with a single object with the response properties + * `{headers, status, statusText}`. The return value of this function will + * be used as the `ResponseInit` for the new `Response`. To change the values + * either modify the passed parameter(s) and return it, or return a totally + * new object. + * + * This method is intentionally limited to same-origin responses, regardless of + * whether CORS was used or not. + * + * @param {Response} response + * @param {Function} modifier + * @memberof workbox-core + */ + async function copyResponse(response, modifier) { + let origin = null; + // If response.url isn't set, assume it's cross-origin and keep origin null. + if (response.url) { + const responseURL = new URL(response.url); + origin = responseURL.origin; + } + if (origin !== self.location.origin) { + throw new WorkboxError('cross-origin-copy-response', { + origin + }); + } + const clonedResponse = response.clone(); + // Create a fresh `ResponseInit` object by cloning the headers. + const responseInit = { + headers: new Headers(clonedResponse.headers), + status: clonedResponse.status, + statusText: clonedResponse.statusText + }; + // Apply any user modifications. + const modifiedResponseInit = modifier ? modifier(responseInit) : responseInit; + // Create the new response from the body stream and `ResponseInit` + // modifications. Note: not all browsers support the Response.body stream, + // so fall back to reading the entire body into memory as a blob. + const body = canConstructResponseFromBodyStream() ? clonedResponse.body : await clonedResponse.blob(); + return new Response(body, modifiedResponseInit); + } + + /* + Copyright 2019 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. + */ + /** + * Claim any currently available clients once the service worker + * becomes active. This is normally used in conjunction with `skipWaiting()`. + * + * @memberof workbox-core + */ + function clientsClaim() { + self.addEventListener('activate', () => self.clients.claim()); + } + + /* + Copyright 2019 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. + */ + /** + * Modifies the default cache names used by the Workbox packages. + * Cache names are generated as `--`. + * + * @param {Object} details + * @param {Object} [details.prefix] The string to add to the beginning of + * the precache and runtime cache names. + * @param {Object} [details.suffix] The string to add to the end of + * the precache and runtime cache names. + * @param {Object} [details.precache] The cache name to use for precache + * caching. + * @param {Object} [details.runtime] The cache name to use for runtime caching. + * @param {Object} [details.googleAnalytics] The cache name to use for + * `workbox-google-analytics` caching. + * + * @memberof workbox-core + */ + function setCacheNameDetails(details) { + { + Object.keys(details).forEach(key => { + finalAssertExports.isType(details[key], 'string', { + moduleName: 'workbox-core', + funcName: 'setCacheNameDetails', + paramName: `details.${key}` + }); + }); + if ('precache' in details && details['precache'].length === 0) { + throw new WorkboxError('invalid-cache-name', { + cacheNameId: 'precache', + value: details['precache'] + }); + } + if ('runtime' in details && details['runtime'].length === 0) { + throw new WorkboxError('invalid-cache-name', { + cacheNameId: 'runtime', + value: details['runtime'] + }); + } + if ('googleAnalytics' in details && details['googleAnalytics'].length === 0) { + throw new WorkboxError('invalid-cache-name', { + cacheNameId: 'googleAnalytics', + value: details['googleAnalytics'] + }); + } + } + cacheNames$1.updateDetails(details); + } + + /* + Copyright 2019 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. + */ + /** + * This method is deprecated, and will be removed in Workbox v7. + * + * Calling self.skipWaiting() is equivalent, and should be used instead. + * + * @memberof workbox-core + */ + function skipWaiting() { + // Just call self.skipWaiting() directly. + // See https://github.com/GoogleChrome/workbox/issues/2525 + { + logger.warn(`skipWaiting() from workbox-core is no longer recommended ` + `and will be removed in Workbox v7. Using self.skipWaiting() instead ` + `is equivalent.`); + } + void self.skipWaiting(); + } + + exports._private = _private; + exports.cacheNames = cacheNames; + exports.clientsClaim = clientsClaim; + exports.copyResponse = copyResponse; + exports.registerQuotaErrorCallback = registerQuotaErrorCallback; + exports.setCacheNameDetails = setCacheNameDetails; + exports.skipWaiting = skipWaiting; + + return exports; + +})({}); +//# sourceMappingURL=workbox-core.dev.js.map diff --git a/workbox/workbox-core.prod.js b/workbox/workbox-core.prod.js new file mode 100644 index 0000000..fcd732a --- /dev/null +++ b/workbox/workbox-core.prod.js @@ -0,0 +1,2 @@ +this.workbox=this.workbox||{},this.workbox.core=function(t){"use strict";try{self["workbox:core:7.3.0"]&&_()}catch(t){}const e=(t,...e)=>{let n=t;return e.length>0&&(n+=` :: ${JSON.stringify(e)}`),n};class n extends Error{constructor(t,n){super(e(t,n)),this.name=t,this.details=n}}const r=new Set;const o={googleAnalytics:"googleAnalytics",precache:"precache-v2",prefix:"workbox",runtime:"runtime",suffix:"undefined"!=typeof registration?registration.scope:""},s=t=>[o.prefix,t,o.suffix].filter((t=>t&&t.length>0)).join("-"),i={updateDetails:t=>{(t=>{for(const e of Object.keys(o))t(e)})((e=>{"string"==typeof t[e]&&(o[e]=t[e])}))},getGoogleAnalyticsName:t=>t||s(o.googleAnalytics),getPrecacheName:t=>t||s(o.precache),getPrefix:()=>o.prefix,getRuntimeName:t=>t||s(o.runtime),getSuffix:()=>o.suffix};function c(t,e){const n=new URL(t);for(const t of e)n.searchParams.delete(t);return n.href}let a,u;function f(){if(void 0===u){const t=new Response("");if("body"in t)try{new Response(t.body),u=!0}catch(t){u=!1}u=!1}return u}function l(t){return new Promise((e=>setTimeout(e,t)))}var g=Object.freeze({__proto__:null,assert:null,cacheMatchIgnoreParams:async function(t,e,n,r){const o=c(e.url,n);if(e.url===o)return t.match(e,r);const s=Object.assign(Object.assign({},r),{ignoreSearch:!0}),i=await t.keys(e,s);for(const e of i){if(o===c(e.url,n))return t.match(e,r)}},cacheNames:i,canConstructReadableStream:function(){if(void 0===a)try{new ReadableStream({start(){}}),a=!0}catch(t){a=!1}return a},canConstructResponseFromBodyStream:f,dontWaitFor:function(t){t.then((()=>{}))},Deferred:class{constructor(){this.promise=new Promise(((t,e)=>{this.resolve=t,this.reject=e}))}},executeQuotaErrorCallbacks:async function(){for(const t of r)await t()},getFriendlyURL:t=>new URL(String(t),location.href).href.replace(new RegExp(`^${location.origin}`),""),logger:null,resultingClientExists:async function(t){if(!t)return;let e=await self.clients.matchAll({type:"window"});const n=new Set(e.map((t=>t.id)));let r;const o=performance.now();for(;performance.now()-o<2e3&&(e=await self.clients.matchAll({type:"window"}),r=e.find((e=>t?e.id===t:!n.has(e.id))),!r);)await l(100);return r},timeout:l,waitUntil:function(t,e){const n=e();return t.waitUntil(n),n},WorkboxError:n});const w={get googleAnalytics(){return i.getGoogleAnalyticsName()},get precache(){return i.getPrecacheName()},get prefix(){return i.getPrefix()},get runtime(){return i.getRuntimeName()},get suffix(){return i.getSuffix()}};return t._private=g,t.cacheNames=w,t.clientsClaim=function(){self.addEventListener("activate",(()=>self.clients.claim()))},t.copyResponse=async function(t,e){let r=null;if(t.url){r=new URL(t.url).origin}if(r!==self.location.origin)throw new n("cross-origin-copy-response",{origin:r});const o=t.clone(),s={headers:new Headers(o.headers),status:o.status,statusText:o.statusText},i=e?e(s):s,c=f()?o.body:await o.blob();return new Response(c,i)},t.registerQuotaErrorCallback=function(t){r.add(t)},t.setCacheNameDetails=function(t){i.updateDetails(t)},t.skipWaiting=function(){self.skipWaiting()},t}({}); +//# sourceMappingURL=workbox-core.prod.js.map diff --git a/workbox/workbox-precaching.dev.js b/workbox/workbox-precaching.dev.js new file mode 100644 index 0000000..bb3ca81 --- /dev/null +++ b/workbox/workbox-precaching.dev.js @@ -0,0 +1,1201 @@ +this.workbox = this.workbox || {}; +this.workbox.precaching = (function (exports, assert_js, cacheNames_js, logger_js, WorkboxError_js, waitUntil_js, copyResponse_js, getFriendlyURL_js, Strategy_js, registerRoute_js, Route_js) { + 'use strict'; + + // @ts-ignore + try { + self['workbox:precaching:7.3.0'] && _(); + } catch (e) {} + + /* + 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. + */ + // Name of the search parameter used to store revision info. + const REVISION_SEARCH_PARAM = '__WB_REVISION__'; + /** + * Converts a manifest entry into a versioned URL suitable for precaching. + * + * @param {Object|string} entry + * @return {string} A URL with versioning info. + * + * @private + * @memberof workbox-precaching + */ + function createCacheKey(entry) { + if (!entry) { + throw new WorkboxError_js.WorkboxError('add-to-cache-list-unexpected-type', { + entry + }); + } + // If a precache manifest entry is a string, it's assumed to be a versioned + // URL, like '/app.abcd1234.js'. Return as-is. + if (typeof entry === 'string') { + const urlObject = new URL(entry, location.href); + return { + cacheKey: urlObject.href, + url: urlObject.href + }; + } + const { + revision, + url + } = entry; + if (!url) { + throw new WorkboxError_js.WorkboxError('add-to-cache-list-unexpected-type', { + entry + }); + } + // If there's just a URL and no revision, then it's also assumed to be a + // versioned URL. + if (!revision) { + const urlObject = new URL(url, location.href); + return { + cacheKey: urlObject.href, + url: urlObject.href + }; + } + // Otherwise, construct a properly versioned URL using the custom Workbox + // search parameter along with the revision info. + const cacheKeyURL = new URL(url, location.href); + const originalURL = new URL(url, location.href); + cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision); + return { + cacheKey: cacheKeyURL.href, + url: originalURL.href + }; + } + + /* + Copyright 2020 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 plugin, designed to be used with PrecacheController, to determine the + * of assets that were updated (or not updated) during the install event. + * + * @private + */ + class PrecacheInstallReportPlugin { + constructor() { + this.updatedURLs = []; + this.notUpdatedURLs = []; + this.handlerWillStart = async ({ + request, + state + }) => { + // TODO: `state` should never be undefined... + if (state) { + state.originalRequest = request; + } + }; + this.cachedResponseWillBeUsed = async ({ + event, + state, + cachedResponse + }) => { + if (event.type === 'install') { + if (state && state.originalRequest && state.originalRequest instanceof Request) { + // TODO: `state` should never be undefined... + const url = state.originalRequest.url; + if (cachedResponse) { + this.notUpdatedURLs.push(url); + } else { + this.updatedURLs.push(url); + } + } + } + return cachedResponse; + }; + } + } + + /* + Copyright 2020 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 plugin, designed to be used with PrecacheController, to translate URLs into + * the corresponding cache key, based on the current revision info. + * + * @private + */ + class PrecacheCacheKeyPlugin { + constructor({ + precacheController + }) { + this.cacheKeyWillBeUsed = async ({ + request, + params + }) => { + // Params is type any, can't change right now. + /* eslint-disable */ + const cacheKey = (params === null || params === void 0 ? void 0 : params.cacheKey) || this._precacheController.getCacheKeyForURL(request.url); + /* eslint-enable */ + return cacheKey ? new Request(cacheKey, { + headers: request.headers + }) : request; + }; + this._precacheController = precacheController; + } + } + + /* + 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. + */ + /** + * @param {string} groupTitle + * @param {Array} deletedURLs + * + * @private + */ + const logGroup = (groupTitle, deletedURLs) => { + logger_js.logger.groupCollapsed(groupTitle); + for (const url of deletedURLs) { + logger_js.logger.log(url); + } + logger_js.logger.groupEnd(); + }; + /** + * @param {Array} deletedURLs + * + * @private + * @memberof workbox-precaching + */ + function printCleanupDetails(deletedURLs) { + const deletionCount = deletedURLs.length; + if (deletionCount > 0) { + logger_js.logger.groupCollapsed(`During precaching cleanup, ` + `${deletionCount} cached ` + `request${deletionCount === 1 ? ' was' : 's were'} deleted.`); + logGroup('Deleted Cache Requests', deletedURLs); + logger_js.logger.groupEnd(); + } + } + + /* + 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. + */ + /** + * @param {string} groupTitle + * @param {Array} urls + * + * @private + */ + function _nestedGroup(groupTitle, urls) { + if (urls.length === 0) { + return; + } + logger_js.logger.groupCollapsed(groupTitle); + for (const url of urls) { + logger_js.logger.log(url); + } + logger_js.logger.groupEnd(); + } + /** + * @param {Array} urlsToPrecache + * @param {Array} urlsAlreadyPrecached + * + * @private + * @memberof workbox-precaching + */ + function printInstallDetails(urlsToPrecache, urlsAlreadyPrecached) { + const precachedCount = urlsToPrecache.length; + const alreadyPrecachedCount = urlsAlreadyPrecached.length; + if (precachedCount || alreadyPrecachedCount) { + let message = `Precaching ${precachedCount} file${precachedCount === 1 ? '' : 's'}.`; + if (alreadyPrecachedCount > 0) { + message += ` ${alreadyPrecachedCount} ` + `file${alreadyPrecachedCount === 1 ? ' is' : 's are'} already cached.`; + } + logger_js.logger.groupCollapsed(message); + _nestedGroup(`View newly precached URLs.`, urlsToPrecache); + _nestedGroup(`View previously precached URLs.`, urlsAlreadyPrecached); + logger_js.logger.groupEnd(); + } + } + + /* + Copyright 2020 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 {@link workbox-strategies.Strategy} implementation + * specifically designed to work with + * {@link workbox-precaching.PrecacheController} + * to both cache and fetch precached assets. + * + * Note: an instance of this class is created automatically when creating a + * `PrecacheController`; it's generally not necessary to create this yourself. + * + * @extends workbox-strategies.Strategy + * @memberof workbox-precaching + */ + class PrecacheStrategy extends Strategy_js.Strategy { + /** + * + * @param {Object} [options] + * @param {string} [options.cacheName] Cache name to store and retrieve + * requests. Defaults to the cache names provided by + * {@link workbox-core.cacheNames}. + * @param {Array} [options.plugins] {@link https://developers.google.com/web/tools/workbox/guides/using-plugins|Plugins} + * to use in conjunction with this caching strategy. + * @param {Object} [options.fetchOptions] Values passed along to the + * {@link https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters|init} + * of all fetch() requests made by this strategy. + * @param {Object} [options.matchOptions] The + * {@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions|CacheQueryOptions} + * for any `cache.match()` or `cache.put()` calls made by this strategy. + * @param {boolean} [options.fallbackToNetwork=true] Whether to attempt to + * get the response from the network if there's a precache miss. + */ + constructor(options = {}) { + options.cacheName = cacheNames_js.cacheNames.getPrecacheName(options.cacheName); + super(options); + this._fallbackToNetwork = options.fallbackToNetwork === false ? false : true; + // Redirected responses cannot be used to satisfy a navigation request, so + // any redirected response must be "copied" rather than cloned, so the new + // response doesn't contain the `redirected` flag. See: + // https://bugs.chromium.org/p/chromium/issues/detail?id=669363&desc=2#c1 + this.plugins.push(PrecacheStrategy.copyRedirectedCacheableResponsesPlugin); + } + /** + * @private + * @param {Request|string} request A request to run this strategy for. + * @param {workbox-strategies.StrategyHandler} handler The event that + * triggered the request. + * @return {Promise} + */ + async _handle(request, handler) { + const response = await handler.cacheMatch(request); + if (response) { + return response; + } + // If this is an `install` event for an entry that isn't already cached, + // then populate the cache. + if (handler.event && handler.event.type === 'install') { + return await this._handleInstall(request, handler); + } + // Getting here means something went wrong. An entry that should have been + // precached wasn't found in the cache. + return await this._handleFetch(request, handler); + } + async _handleFetch(request, handler) { + let response; + const params = handler.params || {}; + // Fall back to the network if we're configured to do so. + if (this._fallbackToNetwork) { + { + logger_js.logger.warn(`The precached response for ` + `${getFriendlyURL_js.getFriendlyURL(request.url)} in ${this.cacheName} was not ` + `found. Falling back to the network.`); + } + const integrityInManifest = params.integrity; + const integrityInRequest = request.integrity; + const noIntegrityConflict = !integrityInRequest || integrityInRequest === integrityInManifest; + // Do not add integrity if the original request is no-cors + // See https://github.com/GoogleChrome/workbox/issues/3096 + response = await handler.fetch(new Request(request, { + integrity: request.mode !== 'no-cors' ? integrityInRequest || integrityInManifest : undefined + })); + // It's only "safe" to repair the cache if we're using SRI to guarantee + // that the response matches the precache manifest's expectations, + // and there's either a) no integrity property in the incoming request + // or b) there is an integrity, and it matches the precache manifest. + // See https://github.com/GoogleChrome/workbox/issues/2858 + // Also if the original request users no-cors we don't use integrity. + // See https://github.com/GoogleChrome/workbox/issues/3096 + if (integrityInManifest && noIntegrityConflict && request.mode !== 'no-cors') { + this._useDefaultCacheabilityPluginIfNeeded(); + const wasCached = await handler.cachePut(request, response.clone()); + { + if (wasCached) { + logger_js.logger.log(`A response for ${getFriendlyURL_js.getFriendlyURL(request.url)} ` + `was used to "repair" the precache.`); + } + } + } + } else { + // This shouldn't normally happen, but there are edge cases: + // https://github.com/GoogleChrome/workbox/issues/1441 + throw new WorkboxError_js.WorkboxError('missing-precache-entry', { + cacheName: this.cacheName, + url: request.url + }); + } + { + const cacheKey = params.cacheKey || (await handler.getCacheKey(request, 'read')); + // Workbox is going to handle the route. + // print the routing details to the console. + logger_js.logger.groupCollapsed(`Precaching is responding to: ` + getFriendlyURL_js.getFriendlyURL(request.url)); + logger_js.logger.log(`Serving the precached url: ${getFriendlyURL_js.getFriendlyURL(cacheKey instanceof Request ? cacheKey.url : cacheKey)}`); + logger_js.logger.groupCollapsed(`View request details here.`); + logger_js.logger.log(request); + logger_js.logger.groupEnd(); + logger_js.logger.groupCollapsed(`View response details here.`); + logger_js.logger.log(response); + logger_js.logger.groupEnd(); + logger_js.logger.groupEnd(); + } + return response; + } + async _handleInstall(request, handler) { + this._useDefaultCacheabilityPluginIfNeeded(); + const response = await handler.fetch(request); + // Make sure we defer cachePut() until after we know the response + // should be cached; see https://github.com/GoogleChrome/workbox/issues/2737 + const wasCached = await handler.cachePut(request, response.clone()); + if (!wasCached) { + // Throwing here will lead to the `install` handler failing, which + // we want to do if *any* of the responses aren't safe to cache. + throw new WorkboxError_js.WorkboxError('bad-precaching-response', { + url: request.url, + status: response.status + }); + } + return response; + } + /** + * This method is complex, as there a number of things to account for: + * + * The `plugins` array can be set at construction, and/or it might be added to + * to at any time before the strategy is used. + * + * At the time the strategy is used (i.e. during an `install` event), there + * needs to be at least one plugin that implements `cacheWillUpdate` in the + * array, other than `copyRedirectedCacheableResponsesPlugin`. + * + * - If this method is called and there are no suitable `cacheWillUpdate` + * plugins, we need to add `defaultPrecacheCacheabilityPlugin`. + * + * - If this method is called and there is exactly one `cacheWillUpdate`, then + * we don't have to do anything (this might be a previously added + * `defaultPrecacheCacheabilityPlugin`, or it might be a custom plugin). + * + * - If this method is called and there is more than one `cacheWillUpdate`, + * then we need to check if one is `defaultPrecacheCacheabilityPlugin`. If so, + * we need to remove it. (This situation is unlikely, but it could happen if + * the strategy is used multiple times, the first without a `cacheWillUpdate`, + * and then later on after manually adding a custom `cacheWillUpdate`.) + * + * See https://github.com/GoogleChrome/workbox/issues/2737 for more context. + * + * @private + */ + _useDefaultCacheabilityPluginIfNeeded() { + let defaultPluginIndex = null; + let cacheWillUpdatePluginCount = 0; + for (const [index, plugin] of this.plugins.entries()) { + // Ignore the copy redirected plugin when determining what to do. + if (plugin === PrecacheStrategy.copyRedirectedCacheableResponsesPlugin) { + continue; + } + // Save the default plugin's index, in case it needs to be removed. + if (plugin === PrecacheStrategy.defaultPrecacheCacheabilityPlugin) { + defaultPluginIndex = index; + } + if (plugin.cacheWillUpdate) { + cacheWillUpdatePluginCount++; + } + } + if (cacheWillUpdatePluginCount === 0) { + this.plugins.push(PrecacheStrategy.defaultPrecacheCacheabilityPlugin); + } else if (cacheWillUpdatePluginCount > 1 && defaultPluginIndex !== null) { + // Only remove the default plugin; multiple custom plugins are allowed. + this.plugins.splice(defaultPluginIndex, 1); + } + // Nothing needs to be done if cacheWillUpdatePluginCount is 1 + } + } + PrecacheStrategy.defaultPrecacheCacheabilityPlugin = { + async cacheWillUpdate({ + response + }) { + if (!response || response.status >= 400) { + return null; + } + return response; + } + }; + PrecacheStrategy.copyRedirectedCacheableResponsesPlugin = { + async cacheWillUpdate({ + response + }) { + return response.redirected ? await copyResponse_js.copyResponse(response) : response; + } + }; + + /* + Copyright 2019 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. + */ + /** + * Performs efficient precaching of assets. + * + * @memberof workbox-precaching + */ + class PrecacheController { + /** + * Create a new PrecacheController. + * + * @param {Object} [options] + * @param {string} [options.cacheName] The cache to use for precaching. + * @param {string} [options.plugins] Plugins to use when precaching as well + * as responding to fetch events for precached assets. + * @param {boolean} [options.fallbackToNetwork=true] Whether to attempt to + * get the response from the network if there's a precache miss. + */ + constructor({ + cacheName, + plugins = [], + fallbackToNetwork = true + } = {}) { + this._urlsToCacheKeys = new Map(); + this._urlsToCacheModes = new Map(); + this._cacheKeysToIntegrities = new Map(); + this._strategy = new PrecacheStrategy({ + cacheName: cacheNames_js.cacheNames.getPrecacheName(cacheName), + plugins: [...plugins, new PrecacheCacheKeyPlugin({ + precacheController: this + })], + fallbackToNetwork + }); + // Bind the install and activate methods to the instance. + this.install = this.install.bind(this); + this.activate = this.activate.bind(this); + } + /** + * @type {workbox-precaching.PrecacheStrategy} The strategy created by this controller and + * used to cache assets and respond to fetch events. + */ + get strategy() { + return this._strategy; + } + /** + * Adds items to the precache list, removing any duplicates and + * stores the files in the + * {@link workbox-core.cacheNames|"precache cache"} when the service + * worker installs. + * + * This method can be called multiple times. + * + * @param {Array} [entries=[]] Array of entries to precache. + */ + precache(entries) { + this.addToCacheList(entries); + if (!this._installAndActiveListenersAdded) { + self.addEventListener('install', this.install); + self.addEventListener('activate', this.activate); + this._installAndActiveListenersAdded = true; + } + } + /** + * This method will add items to the precache list, removing duplicates + * and ensuring the information is valid. + * + * @param {Array} entries + * Array of entries to precache. + */ + addToCacheList(entries) { + { + assert_js.assert.isArray(entries, { + moduleName: 'workbox-precaching', + className: 'PrecacheController', + funcName: 'addToCacheList', + paramName: 'entries' + }); + } + const urlsToWarnAbout = []; + for (const entry of entries) { + // See https://github.com/GoogleChrome/workbox/issues/2259 + if (typeof entry === 'string') { + urlsToWarnAbout.push(entry); + } else if (entry && entry.revision === undefined) { + urlsToWarnAbout.push(entry.url); + } + const { + cacheKey, + url + } = createCacheKey(entry); + const cacheMode = typeof entry !== 'string' && entry.revision ? 'reload' : 'default'; + if (this._urlsToCacheKeys.has(url) && this._urlsToCacheKeys.get(url) !== cacheKey) { + throw new WorkboxError_js.WorkboxError('add-to-cache-list-conflicting-entries', { + firstEntry: this._urlsToCacheKeys.get(url), + secondEntry: cacheKey + }); + } + if (typeof entry !== 'string' && entry.integrity) { + if (this._cacheKeysToIntegrities.has(cacheKey) && this._cacheKeysToIntegrities.get(cacheKey) !== entry.integrity) { + throw new WorkboxError_js.WorkboxError('add-to-cache-list-conflicting-integrities', { + url + }); + } + this._cacheKeysToIntegrities.set(cacheKey, entry.integrity); + } + this._urlsToCacheKeys.set(url, cacheKey); + this._urlsToCacheModes.set(url, cacheMode); + if (urlsToWarnAbout.length > 0) { + const warningMessage = `Workbox is precaching URLs without revision ` + `info: ${urlsToWarnAbout.join(', ')}\nThis is generally NOT safe. ` + `Learn more at https://bit.ly/wb-precache`; + { + logger_js.logger.warn(warningMessage); + } + } + } + } + /** + * Precaches new and updated assets. Call this method from the service worker + * install event. + * + * Note: this method calls `event.waitUntil()` for you, so you do not need + * to call it yourself in your event handlers. + * + * @param {ExtendableEvent} event + * @return {Promise} + */ + install(event) { + // waitUntil returns Promise + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return waitUntil_js.waitUntil(event, async () => { + const installReportPlugin = new PrecacheInstallReportPlugin(); + this.strategy.plugins.push(installReportPlugin); + // Cache entries one at a time. + // See https://github.com/GoogleChrome/workbox/issues/2528 + for (const [url, cacheKey] of this._urlsToCacheKeys) { + const integrity = this._cacheKeysToIntegrities.get(cacheKey); + const cacheMode = this._urlsToCacheModes.get(url); + const request = new Request(url, { + integrity, + cache: cacheMode, + credentials: 'same-origin' + }); + await Promise.all(this.strategy.handleAll({ + params: { + cacheKey + }, + request, + event + })); + } + const { + updatedURLs, + notUpdatedURLs + } = installReportPlugin; + { + printInstallDetails(updatedURLs, notUpdatedURLs); + } + return { + updatedURLs, + notUpdatedURLs + }; + }); + } + /** + * Deletes assets that are no longer present in the current precache manifest. + * Call this method from the service worker activate event. + * + * Note: this method calls `event.waitUntil()` for you, so you do not need + * to call it yourself in your event handlers. + * + * @param {ExtendableEvent} event + * @return {Promise} + */ + activate(event) { + // waitUntil returns Promise + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return waitUntil_js.waitUntil(event, async () => { + const cache = await self.caches.open(this.strategy.cacheName); + const currentlyCachedRequests = await cache.keys(); + const expectedCacheKeys = new Set(this._urlsToCacheKeys.values()); + const deletedURLs = []; + for (const request of currentlyCachedRequests) { + if (!expectedCacheKeys.has(request.url)) { + await cache.delete(request); + deletedURLs.push(request.url); + } + } + { + printCleanupDetails(deletedURLs); + } + return { + deletedURLs + }; + }); + } + /** + * Returns a mapping of a precached URL to the corresponding cache key, taking + * into account the revision information for the URL. + * + * @return {Map} A URL to cache key mapping. + */ + getURLsToCacheKeys() { + return this._urlsToCacheKeys; + } + /** + * Returns a list of all the URLs that have been precached by the current + * service worker. + * + * @return {Array} The precached URLs. + */ + getCachedURLs() { + return [...this._urlsToCacheKeys.keys()]; + } + /** + * Returns the cache key used for storing a given URL. If that URL is + * unversioned, like `/index.html', then the cache key will be the original + * URL with a search parameter appended to it. + * + * @param {string} url A URL whose cache key you want to look up. + * @return {string} The versioned URL that corresponds to a cache key + * for the original URL, or undefined if that URL isn't precached. + */ + getCacheKeyForURL(url) { + const urlObject = new URL(url, location.href); + return this._urlsToCacheKeys.get(urlObject.href); + } + /** + * @param {string} url A cache key whose SRI you want to look up. + * @return {string} The subresource integrity associated with the cache key, + * or undefined if it's not set. + */ + getIntegrityForCacheKey(cacheKey) { + return this._cacheKeysToIntegrities.get(cacheKey); + } + /** + * This acts as a drop-in replacement for + * [`cache.match()`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/match) + * with the following differences: + * + * - It knows what the name of the precache is, and only checks in that cache. + * - It allows you to pass in an "original" URL without versioning parameters, + * and it will automatically look up the correct cache key for the currently + * active revision of that URL. + * + * E.g., `matchPrecache('index.html')` will find the correct precached + * response for the currently active service worker, even if the actual cache + * key is `'/index.html?__WB_REVISION__=1234abcd'`. + * + * @param {string|Request} request The key (without revisioning parameters) + * to look up in the precache. + * @return {Promise} + */ + async matchPrecache(request) { + const url = request instanceof Request ? request.url : request; + const cacheKey = this.getCacheKeyForURL(url); + if (cacheKey) { + const cache = await self.caches.open(this.strategy.cacheName); + return cache.match(cacheKey); + } + return undefined; + } + /** + * Returns a function that looks up `url` in the precache (taking into + * account revision information), and returns the corresponding `Response`. + * + * @param {string} url The precached URL which will be used to lookup the + * `Response`. + * @return {workbox-routing~handlerCallback} + */ + createHandlerBoundToURL(url) { + const cacheKey = this.getCacheKeyForURL(url); + if (!cacheKey) { + throw new WorkboxError_js.WorkboxError('non-precached-url', { + url + }); + } + return options => { + options.request = new Request(url); + options.params = Object.assign({ + cacheKey + }, options.params); + return this.strategy.handle(options); + }; + } + } + + /* + Copyright 2019 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. + */ + let precacheController; + /** + * @return {PrecacheController} + * @private + */ + const getOrCreatePrecacheController = () => { + if (!precacheController) { + precacheController = new PrecacheController(); + } + return precacheController; + }; + + /* + Copyright 2019 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. + */ + /** + * Adds plugins to the precaching strategy. + * + * @param {Array} plugins + * + * @memberof workbox-precaching + */ + function addPlugins(plugins) { + const precacheController = getOrCreatePrecacheController(); + precacheController.strategy.plugins.push(...plugins); + } + + /* + 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. + */ + /** + * Removes any URL search parameters that should be ignored. + * + * @param {URL} urlObject The original URL. + * @param {Array} ignoreURLParametersMatching RegExps to test against + * each search parameter name. Matches mean that the search parameter should be + * ignored. + * @return {URL} The URL with any ignored search parameters removed. + * + * @private + * @memberof workbox-precaching + */ + function removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching = []) { + // Convert the iterable into an array at the start of the loop to make sure + // deletion doesn't mess up iteration. + for (const paramName of [...urlObject.searchParams.keys()]) { + if (ignoreURLParametersMatching.some(regExp => regExp.test(paramName))) { + urlObject.searchParams.delete(paramName); + } + } + return urlObject; + } + + /* + Copyright 2019 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. + */ + /** + * Generator function that yields possible variations on the original URL to + * check, one at a time. + * + * @param {string} url + * @param {Object} options + * + * @private + * @memberof workbox-precaching + */ + function* generateURLVariations(url, { + ignoreURLParametersMatching = [/^utm_/, /^fbclid$/], + directoryIndex = 'index.html', + cleanURLs = true, + urlManipulation + } = {}) { + const urlObject = new URL(url, location.href); + urlObject.hash = ''; + yield urlObject.href; + const urlWithoutIgnoredParams = removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching); + yield urlWithoutIgnoredParams.href; + if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith('/')) { + const directoryURL = new URL(urlWithoutIgnoredParams.href); + directoryURL.pathname += directoryIndex; + yield directoryURL.href; + } + if (cleanURLs) { + const cleanURL = new URL(urlWithoutIgnoredParams.href); + cleanURL.pathname += '.html'; + yield cleanURL.href; + } + if (urlManipulation) { + const additionalURLs = urlManipulation({ + url: urlObject + }); + for (const urlToAttempt of additionalURLs) { + yield urlToAttempt.href; + } + } + } + + /* + Copyright 2020 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 subclass of {@link workbox-routing.Route} that takes a + * {@link workbox-precaching.PrecacheController} + * instance and uses it to match incoming requests and handle fetching + * responses from the precache. + * + * @memberof workbox-precaching + * @extends workbox-routing.Route + */ + class PrecacheRoute extends Route_js.Route { + /** + * @param {PrecacheController} precacheController A `PrecacheController` + * instance used to both match requests and respond to fetch events. + * @param {Object} [options] Options to control how requests are matched + * against the list of precached URLs. + * @param {string} [options.directoryIndex=index.html] The `directoryIndex` will + * check cache entries for a URLs ending with '/' to see if there is a hit when + * appending the `directoryIndex` value. + * @param {Array} [options.ignoreURLParametersMatching=[/^utm_/, /^fbclid$/]] An + * array of regex's to remove search params when looking for a cache match. + * @param {boolean} [options.cleanURLs=true] The `cleanURLs` option will + * check the cache for the URL with a `.html` added to the end of the end. + * @param {workbox-precaching~urlManipulation} [options.urlManipulation] + * This is a function that should take a URL and return an array of + * alternative URLs that should be checked for precache matches. + */ + constructor(precacheController, options) { + const match = ({ + request + }) => { + const urlsToCacheKeys = precacheController.getURLsToCacheKeys(); + for (const possibleURL of generateURLVariations(request.url, options)) { + const cacheKey = urlsToCacheKeys.get(possibleURL); + if (cacheKey) { + const integrity = precacheController.getIntegrityForCacheKey(cacheKey); + return { + cacheKey, + integrity + }; + } + } + { + logger_js.logger.debug(`Precaching did not find a match for ` + getFriendlyURL_js.getFriendlyURL(request.url)); + } + return; + }; + super(match, precacheController.strategy); + } + } + + /* + Copyright 2019 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. + */ + /** + * Add a `fetch` listener to the service worker that will + * respond to + * [network requests]{@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests} + * with precached assets. + * + * Requests for assets that aren't precached, the `FetchEvent` will not be + * responded to, allowing the event to fall through to other `fetch` event + * listeners. + * + * @param {Object} [options] See the {@link workbox-precaching.PrecacheRoute} + * options. + * + * @memberof workbox-precaching + */ + function addRoute(options) { + const precacheController = getOrCreatePrecacheController(); + const precacheRoute = new PrecacheRoute(precacheController, options); + registerRoute_js.registerRoute(precacheRoute); + } + + /* + 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 SUBSTRING_TO_FIND = '-precache-'; + /** + * Cleans up incompatible precaches that were created by older versions of + * Workbox, by a service worker registered under the current scope. + * + * This is meant to be called as part of the `activate` event. + * + * This should be safe to use as long as you don't include `substringToFind` + * (defaulting to `-precache-`) in your non-precache cache names. + * + * @param {string} currentPrecacheName The cache name currently in use for + * precaching. This cache won't be deleted. + * @param {string} [substringToFind='-precache-'] Cache names which include this + * substring will be deleted (excluding `currentPrecacheName`). + * @return {Array} A list of all the cache names that were deleted. + * + * @private + * @memberof workbox-precaching + */ + const deleteOutdatedCaches = async (currentPrecacheName, substringToFind = SUBSTRING_TO_FIND) => { + const cacheNames = await self.caches.keys(); + const cacheNamesToDelete = cacheNames.filter(cacheName => { + return cacheName.includes(substringToFind) && cacheName.includes(self.registration.scope) && cacheName !== currentPrecacheName; + }); + await Promise.all(cacheNamesToDelete.map(cacheName => self.caches.delete(cacheName))); + return cacheNamesToDelete; + }; + + /* + Copyright 2019 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. + */ + /** + * Adds an `activate` event listener which will clean up incompatible + * precaches that were created by older versions of Workbox. + * + * @memberof workbox-precaching + */ + function cleanupOutdatedCaches() { + // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705 + self.addEventListener('activate', event => { + const cacheName = cacheNames_js.cacheNames.getPrecacheName(); + event.waitUntil(deleteOutdatedCaches(cacheName).then(cachesDeleted => { + { + if (cachesDeleted.length > 0) { + logger_js.logger.log(`The following out-of-date precaches were cleaned up ` + `automatically:`, cachesDeleted); + } + } + })); + }); + } + + /* + Copyright 2019 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. + */ + /** + * Helper function that calls + * {@link PrecacheController#createHandlerBoundToURL} on the default + * {@link PrecacheController} instance. + * + * If you are creating your own {@link PrecacheController}, then call the + * {@link PrecacheController#createHandlerBoundToURL} on that instance, + * instead of using this function. + * + * @param {string} url The precached URL which will be used to lookup the + * `Response`. + * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the + * response from the network if there's a precache miss. + * @return {workbox-routing~handlerCallback} + * + * @memberof workbox-precaching + */ + function createHandlerBoundToURL(url) { + const precacheController = getOrCreatePrecacheController(); + return precacheController.createHandlerBoundToURL(url); + } + + /* + Copyright 2019 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. + */ + /** + * Takes in a URL, and returns the corresponding URL that could be used to + * lookup the entry in the precache. + * + * If a relative URL is provided, the location of the service worker file will + * be used as the base. + * + * For precached entries without revision information, the cache key will be the + * same as the original URL. + * + * For precached entries with revision information, the cache key will be the + * original URL with the addition of a query parameter used for keeping track of + * the revision info. + * + * @param {string} url The URL whose cache key to look up. + * @return {string} The cache key that corresponds to that URL. + * + * @memberof workbox-precaching + */ + function getCacheKeyForURL(url) { + const precacheController = getOrCreatePrecacheController(); + return precacheController.getCacheKeyForURL(url); + } + + /* + Copyright 2019 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. + */ + /** + * Helper function that calls + * {@link PrecacheController#matchPrecache} on the default + * {@link PrecacheController} instance. + * + * If you are creating your own {@link PrecacheController}, then call + * {@link PrecacheController#matchPrecache} on that instance, + * instead of using this function. + * + * @param {string|Request} request The key (without revisioning parameters) + * to look up in the precache. + * @return {Promise} + * + * @memberof workbox-precaching + */ + function matchPrecache(request) { + const precacheController = getOrCreatePrecacheController(); + return precacheController.matchPrecache(request); + } + + /* + Copyright 2019 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. + */ + /** + * Adds items to the precache list, removing any duplicates and + * stores the files in the + * {@link workbox-core.cacheNames|"precache cache"} when the service + * worker installs. + * + * This method can be called multiple times. + * + * Please note: This method **will not** serve any of the cached files for you. + * It only precaches files. To respond to a network request you call + * {@link workbox-precaching.addRoute}. + * + * If you have a single array of files to precache, you can just call + * {@link workbox-precaching.precacheAndRoute}. + * + * @param {Array} [entries=[]] Array of entries to precache. + * + * @memberof workbox-precaching + */ + function precache(entries) { + const precacheController = getOrCreatePrecacheController(); + precacheController.precache(entries); + } + + /* + Copyright 2019 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. + */ + /** + * This method will add entries to the precache list and add a route to + * respond to fetch events. + * + * This is a convenience method that will call + * {@link workbox-precaching.precache} and + * {@link workbox-precaching.addRoute} in a single call. + * + * @param {Array} entries Array of entries to precache. + * @param {Object} [options] See the + * {@link workbox-precaching.PrecacheRoute} options. + * + * @memberof workbox-precaching + */ + function precacheAndRoute(entries, options) { + precache(entries); + addRoute(options); + } + + /* + Copyright 2020 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. + */ + /** + * `PrecacheFallbackPlugin` allows you to specify an "offline fallback" + * response to be used when a given strategy is unable to generate a response. + * + * It does this by intercepting the `handlerDidError` plugin callback + * and returning a precached response, taking the expected revision parameter + * into account automatically. + * + * Unless you explicitly pass in a `PrecacheController` instance to the + * constructor, the default instance will be used. Generally speaking, most + * developers will end up using the default. + * + * @memberof workbox-precaching + */ + class PrecacheFallbackPlugin { + /** + * Constructs a new PrecacheFallbackPlugin with the associated fallbackURL. + * + * @param {Object} config + * @param {string} config.fallbackURL A precached URL to use as the fallback + * if the associated strategy can't generate a response. + * @param {PrecacheController} [config.precacheController] An optional + * PrecacheController instance. If not provided, the default + * PrecacheController will be used. + */ + constructor({ + fallbackURL, + precacheController + }) { + /** + * @return {Promise} The precache response for the fallback URL. + * + * @private + */ + this.handlerDidError = () => this._precacheController.matchPrecache(this._fallbackURL); + this._fallbackURL = fallbackURL; + this._precacheController = precacheController || getOrCreatePrecacheController(); + } + } + + exports.PrecacheController = PrecacheController; + exports.PrecacheFallbackPlugin = PrecacheFallbackPlugin; + exports.PrecacheRoute = PrecacheRoute; + exports.PrecacheStrategy = PrecacheStrategy; + exports.addPlugins = addPlugins; + exports.addRoute = addRoute; + exports.cleanupOutdatedCaches = cleanupOutdatedCaches; + exports.createHandlerBoundToURL = createHandlerBoundToURL; + exports.getCacheKeyForURL = getCacheKeyForURL; + exports.matchPrecache = matchPrecache; + exports.precache = precache; + exports.precacheAndRoute = precacheAndRoute; + + return exports; + +})({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core, workbox.core._private, workbox.strategies, workbox.routing, workbox.routing); +//# sourceMappingURL=workbox-precaching.dev.js.map diff --git a/workbox/workbox-precaching.prod.js b/workbox/workbox-precaching.prod.js new file mode 100644 index 0000000..d0c5e79 --- /dev/null +++ b/workbox/workbox-precaching.prod.js @@ -0,0 +1,2 @@ +this.workbox=this.workbox||{},this.workbox.precaching=function(t,e,s,n,i,c,r,o){"use strict";try{self["workbox:precaching:7.3.0"]&&_()}catch(t){}function a(t){if(!t)throw new s.WorkboxError("add-to-cache-list-unexpected-type",{entry:t});if("string"==typeof t){const e=new URL(t,location.href);return{cacheKey:e.href,url:e.href}}const{revision:e,url:n}=t;if(!n)throw new s.WorkboxError("add-to-cache-list-unexpected-type",{entry:t});if(!e){const t=new URL(n,location.href);return{cacheKey:t.href,url:t.href}}const i=new URL(n,location.href),c=new URL(n,location.href);return i.searchParams.set("__WB_REVISION__",e),{cacheKey:i.href,url:c.href}}class h{constructor(){this.updatedURLs=[],this.notUpdatedURLs=[],this.handlerWillStart=async({request:t,state:e})=>{e&&(e.originalRequest=t)},this.cachedResponseWillBeUsed=async({event:t,state:e,cachedResponse:s})=>{if("install"===t.type&&e&&e.originalRequest&&e.originalRequest instanceof Request){const t=e.originalRequest.url;s?this.notUpdatedURLs.push(t):this.updatedURLs.push(t)}return s}}}class l{constructor({precacheController:t}){this.cacheKeyWillBeUsed=async({request:t,params:e})=>{const s=(null==e?void 0:e.cacheKey)||this.tt.getCacheKeyForURL(t.url);return s?new Request(s,{headers:t.headers}):t},this.tt=t}}class u extends c.Strategy{constructor(t={}){t.cacheName=e.cacheNames.getPrecacheName(t.cacheName),super(t),this.et=!1!==t.fallbackToNetwork,this.plugins.push(u.copyRedirectedCacheableResponsesPlugin)}async _handle(t,e){const s=await e.cacheMatch(t);return s||(e.event&&"install"===e.event.type?await this.st(t,e):await this.nt(t,e))}async nt(t,e){let n;const i=e.params||{};if(!this.et)throw new s.WorkboxError("missing-precache-entry",{cacheName:this.cacheName,url:t.url});{const s=i.integrity,c=t.integrity,r=!c||c===s;n=await e.fetch(new Request(t,{integrity:"no-cors"!==t.mode?c||s:void 0})),s&&r&&"no-cors"!==t.mode&&(this.it(),await e.cachePut(t,n.clone()))}return n}async st(t,e){this.it();const n=await e.fetch(t);if(!await e.cachePut(t,n.clone()))throw new s.WorkboxError("bad-precaching-response",{url:t.url,status:n.status});return n}it(){let t=null,e=0;for(const[s,n]of this.plugins.entries())n!==u.copyRedirectedCacheableResponsesPlugin&&(n===u.defaultPrecacheCacheabilityPlugin&&(t=s),n.cacheWillUpdate&&e++);0===e?this.plugins.push(u.defaultPrecacheCacheabilityPlugin):e>1&&null!==t&&this.plugins.splice(t,1)}}u.defaultPrecacheCacheabilityPlugin={cacheWillUpdate:async({response:t})=>!t||t.status>=400?null:t},u.copyRedirectedCacheableResponsesPlugin={cacheWillUpdate:async({response:t})=>t.redirected?await i.copyResponse(t):t};class f{constructor({cacheName:t,plugins:s=[],fallbackToNetwork:n=!0}={}){this.ct=new Map,this.rt=new Map,this.ot=new Map,this.ht=new u({cacheName:e.cacheNames.getPrecacheName(t),plugins:[...s,new l({precacheController:this})],fallbackToNetwork:n}),this.install=this.install.bind(this),this.activate=this.activate.bind(this)}get strategy(){return this.ht}precache(t){this.addToCacheList(t),this.lt||(self.addEventListener("install",this.install),self.addEventListener("activate",this.activate),this.lt=!0)}addToCacheList(t){const e=[];for(const n of t){"string"==typeof n?e.push(n):n&&void 0===n.revision&&e.push(n.url);const{cacheKey:t,url:i}=a(n),c="string"!=typeof n&&n.revision?"reload":"default";if(this.ct.has(i)&&this.ct.get(i)!==t)throw new s.WorkboxError("add-to-cache-list-conflicting-entries",{firstEntry:this.ct.get(i),secondEntry:t});if("string"!=typeof n&&n.integrity){if(this.ot.has(t)&&this.ot.get(t)!==n.integrity)throw new s.WorkboxError("add-to-cache-list-conflicting-integrities",{url:i});this.ot.set(t,n.integrity)}if(this.ct.set(i,t),this.rt.set(i,c),e.length>0){const t=`Workbox is precaching URLs without revision info: ${e.join(", ")}\nThis is generally NOT safe. Learn more at https://bit.ly/wb-precache`;console.warn(t)}}}install(t){return n.waitUntil(t,(async()=>{const e=new h;this.strategy.plugins.push(e);for(const[e,s]of this.ct){const n=this.ot.get(s),i=this.rt.get(e),c=new Request(e,{integrity:n,cache:i,credentials:"same-origin"});await Promise.all(this.strategy.handleAll({params:{cacheKey:s},request:c,event:t}))}const{updatedURLs:s,notUpdatedURLs:n}=e;return{updatedURLs:s,notUpdatedURLs:n}}))}activate(t){return n.waitUntil(t,(async()=>{const t=await self.caches.open(this.strategy.cacheName),e=await t.keys(),s=new Set(this.ct.values()),n=[];for(const i of e)s.has(i.url)||(await t.delete(i),n.push(i.url));return{deletedURLs:n}}))}getURLsToCacheKeys(){return this.ct}getCachedURLs(){return[...this.ct.keys()]}getCacheKeyForURL(t){const e=new URL(t,location.href);return this.ct.get(e.href)}getIntegrityForCacheKey(t){return this.ot.get(t)}async matchPrecache(t){const e=t instanceof Request?t.url:t,s=this.getCacheKeyForURL(e);if(s){return(await self.caches.open(this.strategy.cacheName)).match(s)}}createHandlerBoundToURL(t){const e=this.getCacheKeyForURL(t);if(!e)throw new s.WorkboxError("non-precached-url",{url:t});return s=>(s.request=new Request(t),s.params=Object.assign({cacheKey:e},s.params),this.strategy.handle(s))}}let w;const d=()=>(w||(w=new f),w);class y extends o.Route{constructor(t,e){super((({request:s})=>{const n=t.getURLsToCacheKeys();for(const i of function*(t,{ignoreURLParametersMatching:e=[/^utm_/,/^fbclid$/],directoryIndex:s="index.html",cleanURLs:n=!0,urlManipulation:i}={}){const c=new URL(t,location.href);c.hash="",yield c.href;const r=function(t,e=[]){for(const s of[...t.searchParams.keys()])e.some((t=>t.test(s)))&&t.searchParams.delete(s);return t}(c,e);if(yield r.href,s&&r.pathname.endsWith("/")){const t=new URL(r.href);t.pathname+=s,yield t.href}if(n){const t=new URL(r.href);t.pathname+=".html",yield t.href}if(i){const t=i({url:c});for(const e of t)yield e.href}}(s.url,e)){const e=n.get(i);if(e){return{cacheKey:e,integrity:t.getIntegrityForCacheKey(e)}}}}),t.strategy)}}function p(t){const e=d(),s=new y(e,t);r.registerRoute(s)}function R(t){d().precache(t)}return t.PrecacheController=f,t.PrecacheFallbackPlugin=class{constructor({fallbackURL:t,precacheController:e}){this.handlerDidError=()=>this.tt.matchPrecache(this.ut),this.ut=t,this.tt=e||d()}},t.PrecacheRoute=y,t.PrecacheStrategy=u,t.addPlugins=function(t){d().strategy.plugins.push(...t)},t.addRoute=p,t.cleanupOutdatedCaches=function(){self.addEventListener("activate",(t=>{const s=e.cacheNames.getPrecacheName();t.waitUntil((async(t,e="-precache-")=>{const s=(await self.caches.keys()).filter((s=>s.includes(e)&&s.includes(self.registration.scope)&&s!==t));return await Promise.all(s.map((t=>self.caches.delete(t)))),s})(s).then((t=>{})))}))},t.createHandlerBoundToURL=function(t){return d().createHandlerBoundToURL(t)},t.getCacheKeyForURL=function(t){return d().getCacheKeyForURL(t)},t.matchPrecache=function(t){return d().matchPrecache(t)},t.precache=R,t.precacheAndRoute=function(t,e){R(t),p(e)},t}({},workbox.core._private,workbox.core._private,workbox.core._private,workbox.core,workbox.strategies,workbox.routing,workbox.routing); +//# sourceMappingURL=workbox-precaching.prod.js.map diff --git a/workbox/workbox-range-requests.dev.js b/workbox/workbox-range-requests.dev.js new file mode 100644 index 0000000..b2071cc --- /dev/null +++ b/workbox/workbox-range-requests.dev.js @@ -0,0 +1,242 @@ +this.workbox = this.workbox || {}; +this.workbox.rangeRequests = (function (exports, WorkboxError_js, assert_js, logger_js) { + 'use strict'; + + // @ts-ignore + try { + self['workbox:range-requests:7.3.0'] && _(); + } catch (e) {} + + /* + 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. + */ + /** + * @param {Blob} blob A source blob. + * @param {number} [start] The offset to use as the start of the + * slice. + * @param {number} [end] The offset to use as the end of the slice. + * @return {Object} An object with `start` and `end` properties, reflecting + * the effective boundaries to use given the size of the blob. + * + * @private + */ + function calculateEffectiveBoundaries(blob, start, end) { + { + assert_js.assert.isInstance(blob, Blob, { + moduleName: 'workbox-range-requests', + funcName: 'calculateEffectiveBoundaries', + paramName: 'blob' + }); + } + const blobSize = blob.size; + if (start && start >= blobSize) { + throw new WorkboxError_js.WorkboxError('range-not-satisfiable', { + size: blobSize, + end, + start + }); + } + let effectiveStart; + let effectiveEnd; + if (start !== undefined && end !== undefined) { + effectiveStart = start; + // Range values are inclusive, so add 1 to the value. + effectiveEnd = end + 1; + } else if (start !== undefined && end === undefined) { + effectiveStart = start; + effectiveEnd = blobSize; + } else if (end !== undefined && start === undefined) { + effectiveStart = blobSize - end; + effectiveEnd = blobSize; + } + return { + start: effectiveStart, + end: effectiveEnd + }; + } + + /* + 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. + */ + /** + * @param {string} rangeHeader A Range: header value. + * @return {Object} An object with `start` and `end` properties, reflecting + * the parsed value of the Range: header. If either the `start` or `end` are + * omitted, then `null` will be returned. + * + * @private + */ + function parseRangeHeader(rangeHeader) { + { + assert_js.assert.isType(rangeHeader, 'string', { + moduleName: 'workbox-range-requests', + funcName: 'parseRangeHeader', + paramName: 'rangeHeader' + }); + } + const normalizedRangeHeader = rangeHeader.trim().toLowerCase(); + if (!normalizedRangeHeader.startsWith('bytes=')) { + throw new WorkboxError_js.WorkboxError('unit-must-be-bytes', { + normalizedRangeHeader + }); + } + // Specifying multiple ranges separate by commas is valid syntax, but this + // library only attempts to handle a single, contiguous sequence of bytes. + // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Range#Syntax + if (normalizedRangeHeader.includes(',')) { + throw new WorkboxError_js.WorkboxError('single-range-only', { + normalizedRangeHeader + }); + } + const rangeParts = /(\d*)-(\d*)/.exec(normalizedRangeHeader); + // We need either at least one of the start or end values. + if (!rangeParts || !(rangeParts[1] || rangeParts[2])) { + throw new WorkboxError_js.WorkboxError('invalid-range-values', { + normalizedRangeHeader + }); + } + return { + start: rangeParts[1] === '' ? undefined : Number(rangeParts[1]), + end: rangeParts[2] === '' ? undefined : Number(rangeParts[2]) + }; + } + + /* + 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. + */ + /** + * Given a `Request` and `Response` objects as input, this will return a + * promise for a new `Response`. + * + * If the original `Response` already contains partial content (i.e. it has + * a status of 206), then this assumes it already fulfills the `Range:` + * requirements, and will return it as-is. + * + * @param {Request} request A request, which should contain a Range: + * header. + * @param {Response} originalResponse A response. + * @return {Promise} Either a `206 Partial Content` response, with + * the response body set to the slice of content specified by the request's + * `Range:` header, or a `416 Range Not Satisfiable` response if the + * conditions of the `Range:` header can't be met. + * + * @memberof workbox-range-requests + */ + async function createPartialResponse(request, originalResponse) { + try { + if ("dev" !== 'production') { + assert_js.assert.isInstance(request, Request, { + moduleName: 'workbox-range-requests', + funcName: 'createPartialResponse', + paramName: 'request' + }); + assert_js.assert.isInstance(originalResponse, Response, { + moduleName: 'workbox-range-requests', + funcName: 'createPartialResponse', + paramName: 'originalResponse' + }); + } + if (originalResponse.status === 206) { + // If we already have a 206, then just pass it through as-is; + // see https://github.com/GoogleChrome/workbox/issues/1720 + return originalResponse; + } + const rangeHeader = request.headers.get('range'); + if (!rangeHeader) { + throw new WorkboxError_js.WorkboxError('no-range-header'); + } + const boundaries = parseRangeHeader(rangeHeader); + const originalBlob = await originalResponse.blob(); + const effectiveBoundaries = calculateEffectiveBoundaries(originalBlob, boundaries.start, boundaries.end); + const slicedBlob = originalBlob.slice(effectiveBoundaries.start, effectiveBoundaries.end); + const slicedBlobSize = slicedBlob.size; + const slicedResponse = new Response(slicedBlob, { + // Status code 206 is for a Partial Content response. + // See https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/206 + status: 206, + statusText: 'Partial Content', + headers: originalResponse.headers + }); + slicedResponse.headers.set('Content-Length', String(slicedBlobSize)); + slicedResponse.headers.set('Content-Range', `bytes ${effectiveBoundaries.start}-${effectiveBoundaries.end - 1}/` + `${originalBlob.size}`); + return slicedResponse; + } catch (error) { + { + logger_js.logger.warn(`Unable to construct a partial response; returning a ` + `416 Range Not Satisfiable response instead.`); + logger_js.logger.groupCollapsed(`View details here.`); + logger_js.logger.log(error); + logger_js.logger.log(request); + logger_js.logger.log(originalResponse); + logger_js.logger.groupEnd(); + } + return new Response('', { + status: 416, + statusText: 'Range Not Satisfiable' + }); + } + } + + /* + 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. + */ + /** + * The range request plugin makes it easy for a request with a 'Range' header to + * be fulfilled by a cached response. + * + * It does this by intercepting the `cachedResponseWillBeUsed` plugin callback + * and returning the appropriate subset of the cached response body. + * + * @memberof workbox-range-requests + */ + class RangeRequestsPlugin { + constructor() { + /** + * @param {Object} options + * @param {Request} options.request The original request, which may or may not + * contain a Range: header. + * @param {Response} options.cachedResponse The complete cached response. + * @return {Promise} If request contains a 'Range' header, then a + * new response with status 206 whose body is a subset of `cachedResponse` is + * returned. Otherwise, `cachedResponse` is returned as-is. + * + * @private + */ + this.cachedResponseWillBeUsed = async ({ + request, + cachedResponse + }) => { + // Only return a sliced response if there's something valid in the cache, + // and there's a Range: header in the request. + if (cachedResponse && request.headers.has('range')) { + return await createPartialResponse(request, cachedResponse); + } + // If there was no Range: header, or if cachedResponse wasn't valid, just + // pass it through as-is. + return cachedResponse; + }; + } + } + + exports.RangeRequestsPlugin = RangeRequestsPlugin; + exports.createPartialResponse = createPartialResponse; + + return exports; + +})({}, workbox.core._private, workbox.core._private, workbox.core._private); +//# sourceMappingURL=workbox-range-requests.dev.js.map diff --git a/workbox/workbox-range-requests.prod.js b/workbox/workbox-range-requests.prod.js new file mode 100644 index 0000000..115a7f0 --- /dev/null +++ b/workbox/workbox-range-requests.prod.js @@ -0,0 +1,2 @@ +this.workbox=this.workbox||{},this.workbox.rangeRequests=function(t,e,n){"use strict";try{self["workbox:range-requests:7.3.0"]&&_()}catch(t){}async function r(t,n){try{if(206===n.status)return n;const r=t.headers.get("range");if(!r)throw new e.WorkboxError("no-range-header");const s=function(t){const n=t.trim().toLowerCase();if(!n.startsWith("bytes="))throw new e.WorkboxError("unit-must-be-bytes",{normalizedRangeHeader:n});if(n.includes(","))throw new e.WorkboxError("single-range-only",{normalizedRangeHeader:n});const r=/(\d*)-(\d*)/.exec(n);if(!r||!r[1]&&!r[2])throw new e.WorkboxError("invalid-range-values",{normalizedRangeHeader:n});return{start:""===r[1]?void 0:Number(r[1]),end:""===r[2]?void 0:Number(r[2])}}(r),a=await n.blob(),o=function(t,n,r){const s=t.size;if(n&&n>=s)throw new e.WorkboxError("range-not-satisfiable",{size:s,end:r,start:n});let a,o;return void 0!==n&&void 0!==r?(a=n,o=r+1):void 0!==n&&void 0===r?(a=n,o=s):void 0!==r&&void 0===n&&(a=s-r,o=s),{start:a,end:o}}(a,s.start,s.end),i=a.slice(o.start,o.end),d=i.size,u=new Response(i,{status:206,statusText:"Partial Content",headers:n.headers});return u.headers.set("Content-Length",String(d)),u.headers.set("Content-Range",`bytes ${o.start}-${o.end-1}/${a.size}`),u}catch(t){return new Response("",{status:416,statusText:"Range Not Satisfiable"})}}return t.RangeRequestsPlugin=class{constructor(){this.cachedResponseWillBeUsed=async({request:t,cachedResponse:e})=>e&&t.headers.has("range")?await r(t,e):e}},t.createPartialResponse=r,t}({},workbox.core._private,workbox.core._private); +//# sourceMappingURL=workbox-range-requests.prod.js.map diff --git a/workbox/workbox-routing.dev.js b/workbox/workbox-routing.dev.js new file mode 100644 index 0000000..dd52447 --- /dev/null +++ b/workbox/workbox-routing.dev.js @@ -0,0 +1,884 @@ +this.workbox = this.workbox || {}; +this.workbox.routing = (function (exports, assert_js, logger_js, WorkboxError_js, getFriendlyURL_js) { + 'use strict'; + + // @ts-ignore + try { + self['workbox:routing:7.3.0'] && _(); + } catch (e) {} + + /* + 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. + */ + /** + * The default HTTP method, 'GET', used when there's no specific method + * configured for a route. + * + * @type {string} + * + * @private + */ + const defaultMethod = 'GET'; + /** + * The list of valid HTTP methods associated with requests that could be routed. + * + * @type {Array} + * + * @private + */ + const validMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT']; + + /* + 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. + */ + /** + * @param {function()|Object} handler Either a function, or an object with a + * 'handle' method. + * @return {Object} An object with a handle method. + * + * @private + */ + const normalizeHandler = handler => { + if (handler && typeof handler === 'object') { + { + assert_js.assert.hasMethod(handler, 'handle', { + moduleName: 'workbox-routing', + className: 'Route', + funcName: 'constructor', + paramName: 'handler' + }); + } + return handler; + } else { + { + assert_js.assert.isType(handler, 'function', { + moduleName: 'workbox-routing', + className: 'Route', + funcName: 'constructor', + paramName: 'handler' + }); + } + return { + handle: handler + }; + } + }; + + /* + 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 `Route` consists of a pair of callback functions, "match" and "handler". + * The "match" callback determine if a route should be used to "handle" a + * request by returning a non-falsy value if it can. The "handler" callback + * is called when there is a match and should return a Promise that resolves + * to a `Response`. + * + * @memberof workbox-routing + */ + class Route { + /** + * Constructor for Route class. + * + * @param {workbox-routing~matchCallback} match + * A callback function that determines whether the route matches a given + * `fetch` event by returning a non-falsy value. + * @param {workbox-routing~handlerCallback} handler A callback + * function that returns a Promise resolving to a Response. + * @param {string} [method='GET'] The HTTP method to match the Route + * against. + */ + constructor(match, handler, method = defaultMethod) { + { + assert_js.assert.isType(match, 'function', { + moduleName: 'workbox-routing', + className: 'Route', + funcName: 'constructor', + paramName: 'match' + }); + if (method) { + assert_js.assert.isOneOf(method, validMethods, { + paramName: 'method' + }); + } + } + // These values are referenced directly by Router so cannot be + // altered by minificaton. + this.handler = normalizeHandler(handler); + this.match = match; + this.method = method; + } + /** + * + * @param {workbox-routing-handlerCallback} handler A callback + * function that returns a Promise resolving to a Response + */ + setCatchHandler(handler) { + this.catchHandler = normalizeHandler(handler); + } + } + + /* + 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. + */ + /** + * NavigationRoute makes it easy to create a + * {@link workbox-routing.Route} that matches for browser + * [navigation requests]{@link https://developers.google.com/web/fundamentals/primers/service-workers/high-performance-loading#first_what_are_navigation_requests}. + * + * It will only match incoming Requests whose + * {@link https://fetch.spec.whatwg.org/#concept-request-mode|mode} + * is set to `navigate`. + * + * You can optionally only apply this route to a subset of navigation requests + * by using one or both of the `denylist` and `allowlist` parameters. + * + * @memberof workbox-routing + * @extends workbox-routing.Route + */ + class NavigationRoute extends Route { + /** + * If both `denylist` and `allowlist` are provided, the `denylist` will + * take precedence and the request will not match this route. + * + * The regular expressions in `allowlist` and `denylist` + * are matched against the concatenated + * [`pathname`]{@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/pathname} + * and [`search`]{@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/search} + * portions of the requested URL. + * + * *Note*: These RegExps may be evaluated against every destination URL during + * a navigation. Avoid using + * [complex RegExps](https://github.com/GoogleChrome/workbox/issues/3077), + * or else your users may see delays when navigating your site. + * + * @param {workbox-routing~handlerCallback} handler A callback + * function that returns a Promise resulting in a Response. + * @param {Object} options + * @param {Array} [options.denylist] If any of these patterns match, + * the route will not handle the request (even if a allowlist RegExp matches). + * @param {Array} [options.allowlist=[/./]] If any of these patterns + * match the URL's pathname and search parameter, the route will handle the + * request (assuming the denylist doesn't match). + */ + constructor(handler, { + allowlist = [/./], + denylist = [] + } = {}) { + { + assert_js.assert.isArrayOfClass(allowlist, RegExp, { + moduleName: 'workbox-routing', + className: 'NavigationRoute', + funcName: 'constructor', + paramName: 'options.allowlist' + }); + assert_js.assert.isArrayOfClass(denylist, RegExp, { + moduleName: 'workbox-routing', + className: 'NavigationRoute', + funcName: 'constructor', + paramName: 'options.denylist' + }); + } + super(options => this._match(options), handler); + this._allowlist = allowlist; + this._denylist = denylist; + } + /** + * Routes match handler. + * + * @param {Object} options + * @param {URL} options.url + * @param {Request} options.request + * @return {boolean} + * + * @private + */ + _match({ + url, + request + }) { + if (request && request.mode !== 'navigate') { + return false; + } + const pathnameAndSearch = url.pathname + url.search; + for (const regExp of this._denylist) { + if (regExp.test(pathnameAndSearch)) { + { + logger_js.logger.log(`The navigation route ${pathnameAndSearch} is not ` + `being used, since the URL matches this denylist pattern: ` + `${regExp.toString()}`); + } + return false; + } + } + if (this._allowlist.some(regExp => regExp.test(pathnameAndSearch))) { + { + logger_js.logger.debug(`The navigation route ${pathnameAndSearch} ` + `is being used.`); + } + return true; + } + { + logger_js.logger.log(`The navigation route ${pathnameAndSearch} is not ` + `being used, since the URL being navigated to doesn't ` + `match the allowlist.`); + } + return 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. + */ + /** + * RegExpRoute makes it easy to create a regular expression based + * {@link workbox-routing.Route}. + * + * For same-origin requests the RegExp only needs to match part of the URL. For + * requests against third-party servers, you must define a RegExp that matches + * the start of the URL. + * + * @memberof workbox-routing + * @extends workbox-routing.Route + */ + class RegExpRoute extends Route { + /** + * If the regular expression contains + * [capture groups]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#grouping-back-references}, + * the captured values will be passed to the + * {@link workbox-routing~handlerCallback} `params` + * argument. + * + * @param {RegExp} regExp The regular expression to match against URLs. + * @param {workbox-routing~handlerCallback} handler A callback + * function that returns a Promise resulting in a Response. + * @param {string} [method='GET'] The HTTP method to match the Route + * against. + */ + constructor(regExp, handler, method) { + { + assert_js.assert.isInstance(regExp, RegExp, { + moduleName: 'workbox-routing', + className: 'RegExpRoute', + funcName: 'constructor', + paramName: 'pattern' + }); + } + const match = ({ + url + }) => { + const result = regExp.exec(url.href); + // Return immediately if there's no match. + if (!result) { + return; + } + // Require that the match start at the first character in the URL string + // if it's a cross-origin request. + // See https://github.com/GoogleChrome/workbox/issues/281 for the context + // behind this behavior. + if (url.origin !== location.origin && result.index !== 0) { + { + logger_js.logger.debug(`The regular expression '${regExp.toString()}' only partially matched ` + `against the cross-origin URL '${url.toString()}'. RegExpRoute's will only ` + `handle cross-origin requests if they match the entire URL.`); + } + return; + } + // If the route matches, but there aren't any capture groups defined, then + // this will return [], which is truthy and therefore sufficient to + // indicate a match. + // If there are capture groups, then it will return their values. + return result.slice(1); + }; + super(match, handler, method); + } + } + + /* + 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. + */ + /** + * The Router can be used to process a `FetchEvent` using one or more + * {@link workbox-routing.Route}, responding with a `Response` if + * a matching route exists. + * + * If no route matches a given a request, the Router will use a "default" + * handler if one is defined. + * + * Should the matching Route throw an error, the Router will use a "catch" + * handler if one is defined to gracefully deal with issues and respond with a + * Request. + * + * If a request matches multiple routes, the **earliest** registered route will + * be used to respond to the request. + * + * @memberof workbox-routing + */ + class Router { + /** + * Initializes a new Router. + */ + constructor() { + this._routes = new Map(); + this._defaultHandlerMap = new Map(); + } + /** + * @return {Map>} routes A `Map` of HTTP + * method name ('GET', etc.) to an array of all the corresponding `Route` + * instances that are registered. + */ + get routes() { + return this._routes; + } + /** + * Adds a fetch event listener to respond to events when a route matches + * the event's request. + */ + addFetchListener() { + // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705 + self.addEventListener('fetch', event => { + const { + request + } = event; + const responsePromise = this.handleRequest({ + request, + event + }); + if (responsePromise) { + event.respondWith(responsePromise); + } + }); + } + /** + * Adds a message event listener for URLs to cache from the window. + * This is useful to cache resources loaded on the page prior to when the + * service worker started controlling it. + * + * The format of the message data sent from the window should be as follows. + * Where the `urlsToCache` array may consist of URL strings or an array of + * URL string + `requestInit` object (the same as you'd pass to `fetch()`). + * + * ``` + * { + * type: 'CACHE_URLS', + * payload: { + * urlsToCache: [ + * './script1.js', + * './script2.js', + * ['./script3.js', {mode: 'no-cors'}], + * ], + * }, + * } + * ``` + */ + addCacheListener() { + // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705 + self.addEventListener('message', event => { + // event.data is type 'any' + // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access + if (event.data && event.data.type === 'CACHE_URLS') { + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + const { + payload + } = event.data; + { + logger_js.logger.debug(`Caching URLs from the window`, payload.urlsToCache); + } + const requestPromises = Promise.all(payload.urlsToCache.map(entry => { + if (typeof entry === 'string') { + entry = [entry]; + } + const request = new Request(...entry); + return this.handleRequest({ + request, + event + }); + // TODO(philipwalton): TypeScript errors without this typecast for + // some reason (probably a bug). The real type here should work but + // doesn't: `Array | undefined>`. + })); // TypeScript + event.waitUntil(requestPromises); + // If a MessageChannel was used, reply to the message on success. + if (event.ports && event.ports[0]) { + void requestPromises.then(() => event.ports[0].postMessage(true)); + } + } + }); + } + /** + * Apply the routing rules to a FetchEvent object to get a Response from an + * appropriate Route's handler. + * + * @param {Object} options + * @param {Request} options.request The request to handle. + * @param {ExtendableEvent} options.event The event that triggered the + * request. + * @return {Promise|undefined} A promise is returned if a + * registered route can handle the request. If there is no matching + * route and there's no `defaultHandler`, `undefined` is returned. + */ + handleRequest({ + request, + event + }) { + { + assert_js.assert.isInstance(request, Request, { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'handleRequest', + paramName: 'options.request' + }); + } + const url = new URL(request.url, location.href); + if (!url.protocol.startsWith('http')) { + { + logger_js.logger.debug(`Workbox Router only supports URLs that start with 'http'.`); + } + return; + } + const sameOrigin = url.origin === location.origin; + const { + params, + route + } = this.findMatchingRoute({ + event, + request, + sameOrigin, + url + }); + let handler = route && route.handler; + const debugMessages = []; + { + if (handler) { + debugMessages.push([`Found a route to handle this request:`, route]); + if (params) { + debugMessages.push([`Passing the following params to the route's handler:`, params]); + } + } + } + // If we don't have a handler because there was no matching route, then + // fall back to defaultHandler if that's defined. + const method = request.method; + if (!handler && this._defaultHandlerMap.has(method)) { + { + debugMessages.push(`Failed to find a matching route. Falling ` + `back to the default handler for ${method}.`); + } + handler = this._defaultHandlerMap.get(method); + } + if (!handler) { + { + // No handler so Workbox will do nothing. If logs is set of debug + // i.e. verbose, we should print out this information. + logger_js.logger.debug(`No route found for: ${getFriendlyURL_js.getFriendlyURL(url)}`); + } + return; + } + { + // We have a handler, meaning Workbox is going to handle the route. + // print the routing details to the console. + logger_js.logger.groupCollapsed(`Router is responding to: ${getFriendlyURL_js.getFriendlyURL(url)}`); + debugMessages.forEach(msg => { + if (Array.isArray(msg)) { + logger_js.logger.log(...msg); + } else { + logger_js.logger.log(msg); + } + }); + logger_js.logger.groupEnd(); + } + // Wrap in try and catch in case the handle method throws a synchronous + // error. It should still callback to the catch handler. + let responsePromise; + try { + responsePromise = handler.handle({ + url, + request, + event, + params + }); + } catch (err) { + responsePromise = Promise.reject(err); + } + // Get route's catch handler, if it exists + const catchHandler = route && route.catchHandler; + if (responsePromise instanceof Promise && (this._catchHandler || catchHandler)) { + responsePromise = responsePromise.catch(async err => { + // If there's a route catch handler, process that first + if (catchHandler) { + { + // Still include URL here as it will be async from the console group + // and may not make sense without the URL + logger_js.logger.groupCollapsed(`Error thrown when responding to: ` + ` ${getFriendlyURL_js.getFriendlyURL(url)}. Falling back to route's Catch Handler.`); + logger_js.logger.error(`Error thrown by:`, route); + logger_js.logger.error(err); + logger_js.logger.groupEnd(); + } + try { + return await catchHandler.handle({ + url, + request, + event, + params + }); + } catch (catchErr) { + if (catchErr instanceof Error) { + err = catchErr; + } + } + } + if (this._catchHandler) { + { + // Still include URL here as it will be async from the console group + // and may not make sense without the URL + logger_js.logger.groupCollapsed(`Error thrown when responding to: ` + ` ${getFriendlyURL_js.getFriendlyURL(url)}. Falling back to global Catch Handler.`); + logger_js.logger.error(`Error thrown by:`, route); + logger_js.logger.error(err); + logger_js.logger.groupEnd(); + } + return this._catchHandler.handle({ + url, + request, + event + }); + } + throw err; + }); + } + return responsePromise; + } + /** + * Checks a request and URL (and optionally an event) against the list of + * registered routes, and if there's a match, returns the corresponding + * route along with any params generated by the match. + * + * @param {Object} options + * @param {URL} options.url + * @param {boolean} options.sameOrigin The result of comparing `url.origin` + * against the current origin. + * @param {Request} options.request The request to match. + * @param {Event} options.event The corresponding event. + * @return {Object} An object with `route` and `params` properties. + * They are populated if a matching route was found or `undefined` + * otherwise. + */ + findMatchingRoute({ + url, + sameOrigin, + request, + event + }) { + const routes = this._routes.get(request.method) || []; + for (const route of routes) { + let params; + // route.match returns type any, not possible to change right now. + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + const matchResult = route.match({ + url, + sameOrigin, + request, + event + }); + if (matchResult) { + { + // Warn developers that using an async matchCallback is almost always + // not the right thing to do. + if (matchResult instanceof Promise) { + logger_js.logger.warn(`While routing ${getFriendlyURL_js.getFriendlyURL(url)}, an async ` + `matchCallback function was used. Please convert the ` + `following route to use a synchronous matchCallback function:`, route); + } + } + // See https://github.com/GoogleChrome/workbox/issues/2079 + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + params = matchResult; + if (Array.isArray(params) && params.length === 0) { + // Instead of passing an empty array in as params, use undefined. + params = undefined; + } else if (matchResult.constructor === Object && + // eslint-disable-line + Object.keys(matchResult).length === 0) { + // Instead of passing an empty object in as params, use undefined. + params = undefined; + } else if (typeof matchResult === 'boolean') { + // For the boolean value true (rather than just something truth-y), + // don't set params. + // See https://github.com/GoogleChrome/workbox/pull/2134#issuecomment-513924353 + params = undefined; + } + // Return early if have a match. + return { + route, + params + }; + } + } + // If no match was found above, return and empty object. + return {}; + } + /** + * Define a default `handler` that's called when no routes explicitly + * match the incoming request. + * + * Each HTTP method ('GET', 'POST', etc.) gets its own default handler. + * + * Without a default handler, unmatched requests will go against the + * network as if there were no service worker present. + * + * @param {workbox-routing~handlerCallback} handler A callback + * function that returns a Promise resulting in a Response. + * @param {string} [method='GET'] The HTTP method to associate with this + * default handler. Each method has its own default. + */ + setDefaultHandler(handler, method = defaultMethod) { + this._defaultHandlerMap.set(method, normalizeHandler(handler)); + } + /** + * If a Route throws an error while handling a request, this `handler` + * will be called and given a chance to provide a response. + * + * @param {workbox-routing~handlerCallback} handler A callback + * function that returns a Promise resulting in a Response. + */ + setCatchHandler(handler) { + this._catchHandler = normalizeHandler(handler); + } + /** + * Registers a route with the router. + * + * @param {workbox-routing.Route} route The route to register. + */ + registerRoute(route) { + { + assert_js.assert.isType(route, 'object', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route' + }); + assert_js.assert.hasMethod(route, 'match', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route' + }); + assert_js.assert.isType(route.handler, 'object', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route' + }); + assert_js.assert.hasMethod(route.handler, 'handle', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route.handler' + }); + assert_js.assert.isType(route.method, 'string', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route.method' + }); + } + if (!this._routes.has(route.method)) { + this._routes.set(route.method, []); + } + // Give precedence to all of the earlier routes by adding this additional + // route to the end of the array. + this._routes.get(route.method).push(route); + } + /** + * Unregisters a route with the router. + * + * @param {workbox-routing.Route} route The route to unregister. + */ + unregisterRoute(route) { + if (!this._routes.has(route.method)) { + throw new WorkboxError_js.WorkboxError('unregister-route-but-not-found-with-method', { + method: route.method + }); + } + const routeIndex = this._routes.get(route.method).indexOf(route); + if (routeIndex > -1) { + this._routes.get(route.method).splice(routeIndex, 1); + } else { + throw new WorkboxError_js.WorkboxError('unregister-route-route-not-registered'); + } + } + } + + /* + Copyright 2019 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. + */ + let defaultRouter; + /** + * Creates a new, singleton Router instance if one does not exist. If one + * does already exist, that instance is returned. + * + * @private + * @return {Router} + */ + const getOrCreateDefaultRouter = () => { + if (!defaultRouter) { + defaultRouter = new Router(); + // The helpers that use the default Router assume these listeners exist. + defaultRouter.addFetchListener(); + defaultRouter.addCacheListener(); + } + return defaultRouter; + }; + + /* + Copyright 2019 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. + */ + /** + * Easily register a RegExp, string, or function with a caching + * strategy to a singleton Router instance. + * + * This method will generate a Route for you if needed and + * call {@link workbox-routing.Router#registerRoute}. + * + * @param {RegExp|string|workbox-routing.Route~matchCallback|workbox-routing.Route} capture + * If the capture param is a `Route`, all other arguments will be ignored. + * @param {workbox-routing~handlerCallback} [handler] A callback + * function that returns a Promise resulting in a Response. This parameter + * is required if `capture` is not a `Route` object. + * @param {string} [method='GET'] The HTTP method to match the Route + * against. + * @return {workbox-routing.Route} The generated `Route`. + * + * @memberof workbox-routing + */ + function registerRoute(capture, handler, method) { + let route; + if (typeof capture === 'string') { + const captureUrl = new URL(capture, location.href); + { + if (!(capture.startsWith('/') || capture.startsWith('http'))) { + throw new WorkboxError_js.WorkboxError('invalid-string', { + moduleName: 'workbox-routing', + funcName: 'registerRoute', + paramName: 'capture' + }); + } + // We want to check if Express-style wildcards are in the pathname only. + // TODO: Remove this log message in v4. + const valueToCheck = capture.startsWith('http') ? captureUrl.pathname : capture; + // See https://github.com/pillarjs/path-to-regexp#parameters + const wildcards = '[*:?+]'; + if (new RegExp(`${wildcards}`).exec(valueToCheck)) { + logger_js.logger.debug(`The '$capture' parameter contains an Express-style wildcard ` + `character (${wildcards}). Strings are now always interpreted as ` + `exact matches; use a RegExp for partial or wildcard matches.`); + } + } + const matchCallback = ({ + url + }) => { + { + if (url.pathname === captureUrl.pathname && url.origin !== captureUrl.origin) { + logger_js.logger.debug(`${capture} only partially matches the cross-origin URL ` + `${url.toString()}. This route will only handle cross-origin requests ` + `if they match the entire URL.`); + } + } + return url.href === captureUrl.href; + }; + // If `capture` is a string then `handler` and `method` must be present. + route = new Route(matchCallback, handler, method); + } else if (capture instanceof RegExp) { + // If `capture` is a `RegExp` then `handler` and `method` must be present. + route = new RegExpRoute(capture, handler, method); + } else if (typeof capture === 'function') { + // If `capture` is a function then `handler` and `method` must be present. + route = new Route(capture, handler, method); + } else if (capture instanceof Route) { + route = capture; + } else { + throw new WorkboxError_js.WorkboxError('unsupported-route-type', { + moduleName: 'workbox-routing', + funcName: 'registerRoute', + paramName: 'capture' + }); + } + const defaultRouter = getOrCreateDefaultRouter(); + defaultRouter.registerRoute(route); + return route; + } + + /* + Copyright 2019 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. + */ + /** + * If a Route throws an error while handling a request, this `handler` + * will be called and given a chance to provide a response. + * + * @param {workbox-routing~handlerCallback} handler A callback + * function that returns a Promise resulting in a Response. + * + * @memberof workbox-routing + */ + function setCatchHandler(handler) { + const defaultRouter = getOrCreateDefaultRouter(); + defaultRouter.setCatchHandler(handler); + } + + /* + Copyright 2019 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. + */ + /** + * Define a default `handler` that's called when no routes explicitly + * match the incoming request. + * + * Without a default handler, unmatched requests will go against the + * network as if there were no service worker present. + * + * @param {workbox-routing~handlerCallback} handler A callback + * function that returns a Promise resulting in a Response. + * + * @memberof workbox-routing + */ + function setDefaultHandler(handler) { + const defaultRouter = getOrCreateDefaultRouter(); + defaultRouter.setDefaultHandler(handler); + } + + exports.NavigationRoute = NavigationRoute; + exports.RegExpRoute = RegExpRoute; + exports.Route = Route; + exports.Router = Router; + exports.registerRoute = registerRoute; + exports.setCatchHandler = setCatchHandler; + exports.setDefaultHandler = setDefaultHandler; + + return exports; + +})({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private); +//# sourceMappingURL=workbox-routing.dev.js.map diff --git a/workbox/workbox-routing.prod.js b/workbox/workbox-routing.prod.js new file mode 100644 index 0000000..8b0a243 --- /dev/null +++ b/workbox/workbox-routing.prod.js @@ -0,0 +1,2 @@ +this.workbox=this.workbox||{},this.workbox.routing=function(t,e){"use strict";try{self["workbox:routing:7.3.0"]&&_()}catch(t){}const s=t=>t&&"object"==typeof t?t:{handle:t};class r{constructor(t,e,r="GET"){this.handler=s(e),this.match=t,this.method=r}setCatchHandler(t){this.catchHandler=s(t)}}class n extends r{constructor(t,e,s){super((({url:e})=>{const s=t.exec(e.href);if(s&&(e.origin===location.origin||0===s.index))return s.slice(1)}),e,s)}}class i{constructor(){this.ft=new Map,this.dt=new Map}get routes(){return this.ft}addFetchListener(){self.addEventListener("fetch",(t=>{const{request:e}=t,s=this.handleRequest({request:e,event:t});s&&t.respondWith(s)}))}addCacheListener(){self.addEventListener("message",(t=>{if(t.data&&"CACHE_URLS"===t.data.type){const{payload:e}=t.data,s=Promise.all(e.urlsToCache.map((e=>{"string"==typeof e&&(e=[e]);const s=new Request(...e);return this.handleRequest({request:s,event:t})})));t.waitUntil(s),t.ports&&t.ports[0]&&s.then((()=>t.ports[0].postMessage(!0)))}}))}handleRequest({request:t,event:e}){const s=new URL(t.url,location.href);if(!s.protocol.startsWith("http"))return;const r=s.origin===location.origin,{params:n,route:i}=this.findMatchingRoute({event:e,request:t,sameOrigin:r,url:s});let o=i&&i.handler;const u=t.method;if(!o&&this.dt.has(u)&&(o=this.dt.get(u)),!o)return;let c;try{c=o.handle({url:s,request:t,event:e,params:n})}catch(t){c=Promise.reject(t)}const a=i&&i.catchHandler;return c instanceof Promise&&(this.wt||a)&&(c=c.catch((async r=>{if(a)try{return await a.handle({url:s,request:t,event:e,params:n})}catch(t){t instanceof Error&&(r=t)}if(this.wt)return this.wt.handle({url:s,request:t,event:e});throw r}))),c}findMatchingRoute({url:t,sameOrigin:e,request:s,event:r}){const n=this.ft.get(s.method)||[];for(const i of n){let n;const o=i.match({url:t,sameOrigin:e,request:s,event:r});if(o)return n=o,(Array.isArray(n)&&0===n.length||o.constructor===Object&&0===Object.keys(o).length||"boolean"==typeof o)&&(n=void 0),{route:i,params:n}}return{}}setDefaultHandler(t,e="GET"){this.dt.set(e,s(t))}setCatchHandler(t){this.wt=s(t)}registerRoute(t){this.ft.has(t.method)||this.ft.set(t.method,[]),this.ft.get(t.method).push(t)}unregisterRoute(t){if(!this.ft.has(t.method))throw new e.WorkboxError("unregister-route-but-not-found-with-method",{method:t.method});const s=this.ft.get(t.method).indexOf(t);if(!(s>-1))throw new e.WorkboxError("unregister-route-route-not-registered");this.ft.get(t.method).splice(s,1)}}let o;const u=()=>(o||(o=new i,o.addFetchListener(),o.addCacheListener()),o);return t.NavigationRoute=class extends r{constructor(t,{allowlist:e=[/./],denylist:s=[]}={}){super((t=>this.gt(t)),t),this.qt=e,this.yt=s}gt({url:t,request:e}){if(e&&"navigate"!==e.mode)return!1;const s=t.pathname+t.search;for(const t of this.yt)if(t.test(s))return!1;return!!this.qt.some((t=>t.test(s)))}},t.RegExpRoute=n,t.Route=r,t.Router=i,t.registerRoute=function(t,s,i){let o;if("string"==typeof t){const e=new URL(t,location.href);o=new r((({url:t})=>t.href===e.href),s,i)}else if(t instanceof RegExp)o=new n(t,s,i);else if("function"==typeof t)o=new r(t,s,i);else{if(!(t instanceof r))throw new e.WorkboxError("unsupported-route-type",{moduleName:"workbox-routing",funcName:"registerRoute",paramName:"capture"});o=t}return u().registerRoute(o),o},t.setCatchHandler=function(t){u().setCatchHandler(t)},t.setDefaultHandler=function(t){u().setDefaultHandler(t)},t}({},workbox.core._private); +//# sourceMappingURL=workbox-routing.prod.js.map diff --git a/workbox/workbox-strategies.dev.js b/workbox/workbox-strategies.dev.js new file mode 100644 index 0000000..404e319 --- /dev/null +++ b/workbox/workbox-strategies.dev.js @@ -0,0 +1,1334 @@ +this.workbox = this.workbox || {}; +this.workbox.strategies = (function (exports, assert_js, logger_js, WorkboxError_js, cacheNames_js, getFriendlyURL_js, cacheMatchIgnoreParams_js, Deferred_js, executeQuotaErrorCallbacks_js, timeout_js) { + 'use strict'; + + // @ts-ignore + try { + self['workbox:strategies:7.3.0'] && _(); + } catch (e) {} + + /* + Copyright 2020 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. + */ + function toRequest(input) { + return typeof input === 'string' ? new Request(input) : input; + } + /** + * A class created every time a Strategy instance instance calls + * {@link workbox-strategies.Strategy~handle} or + * {@link workbox-strategies.Strategy~handleAll} that wraps all fetch and + * cache actions around plugin callbacks and keeps track of when the strategy + * is "done" (i.e. all added `event.waitUntil()` promises have resolved). + * + * @memberof workbox-strategies + */ + class StrategyHandler { + /** + * Creates a new instance associated with the passed strategy and event + * that's handling the request. + * + * The constructor also initializes the state that will be passed to each of + * the plugins handling this request. + * + * @param {workbox-strategies.Strategy} strategy + * @param {Object} options + * @param {Request|string} options.request A request to run this strategy for. + * @param {ExtendableEvent} options.event The event associated with the + * request. + * @param {URL} [options.url] + * @param {*} [options.params] The return value from the + * {@link workbox-routing~matchCallback} (if applicable). + */ + constructor(strategy, options) { + this._cacheKeys = {}; + /** + * The request the strategy is performing (passed to the strategy's + * `handle()` or `handleAll()` method). + * @name request + * @instance + * @type {Request} + * @memberof workbox-strategies.StrategyHandler + */ + /** + * The event associated with this request. + * @name event + * @instance + * @type {ExtendableEvent} + * @memberof workbox-strategies.StrategyHandler + */ + /** + * A `URL` instance of `request.url` (if passed to the strategy's + * `handle()` or `handleAll()` method). + * Note: the `url` param will be present if the strategy was invoked + * from a workbox `Route` object. + * @name url + * @instance + * @type {URL|undefined} + * @memberof workbox-strategies.StrategyHandler + */ + /** + * A `param` value (if passed to the strategy's + * `handle()` or `handleAll()` method). + * Note: the `param` param will be present if the strategy was invoked + * from a workbox `Route` object and the + * {@link workbox-routing~matchCallback} returned + * a truthy value (it will be that value). + * @name params + * @instance + * @type {*|undefined} + * @memberof workbox-strategies.StrategyHandler + */ + { + assert_js.assert.isInstance(options.event, ExtendableEvent, { + moduleName: 'workbox-strategies', + className: 'StrategyHandler', + funcName: 'constructor', + paramName: 'options.event' + }); + } + Object.assign(this, options); + this.event = options.event; + this._strategy = strategy; + this._handlerDeferred = new Deferred_js.Deferred(); + this._extendLifetimePromises = []; + // Copy the plugins list (since it's mutable on the strategy), + // so any mutations don't affect this handler instance. + this._plugins = [...strategy.plugins]; + this._pluginStateMap = new Map(); + for (const plugin of this._plugins) { + this._pluginStateMap.set(plugin, {}); + } + this.event.waitUntil(this._handlerDeferred.promise); + } + /** + * Fetches a given request (and invokes any applicable plugin callback + * methods) using the `fetchOptions` (for non-navigation requests) and + * `plugins` defined on the `Strategy` object. + * + * The following plugin lifecycle methods are invoked when using this method: + * - `requestWillFetch()` + * - `fetchDidSucceed()` + * - `fetchDidFail()` + * + * @param {Request|string} input The URL or request to fetch. + * @return {Promise} + */ + async fetch(input) { + const { + event + } = this; + let request = toRequest(input); + if (request.mode === 'navigate' && event instanceof FetchEvent && event.preloadResponse) { + const possiblePreloadResponse = await event.preloadResponse; + if (possiblePreloadResponse) { + { + logger_js.logger.log(`Using a preloaded navigation response for ` + `'${getFriendlyURL_js.getFriendlyURL(request.url)}'`); + } + return possiblePreloadResponse; + } + } + // If there is a fetchDidFail plugin, we need to save a clone of the + // original request before it's either modified by a requestWillFetch + // plugin or before the original request's body is consumed via fetch(). + const originalRequest = this.hasCallback('fetchDidFail') ? request.clone() : null; + try { + for (const cb of this.iterateCallbacks('requestWillFetch')) { + request = await cb({ + request: request.clone(), + event + }); + } + } catch (err) { + if (err instanceof Error) { + throw new WorkboxError_js.WorkboxError('plugin-error-request-will-fetch', { + thrownErrorMessage: err.message + }); + } + } + // The request can be altered by plugins with `requestWillFetch` making + // the original request (most likely from a `fetch` event) different + // from the Request we make. Pass both to `fetchDidFail` to aid debugging. + const pluginFilteredRequest = request.clone(); + try { + let fetchResponse; + // See https://github.com/GoogleChrome/workbox/issues/1796 + fetchResponse = await fetch(request, request.mode === 'navigate' ? undefined : this._strategy.fetchOptions); + if ("dev" !== 'production') { + logger_js.logger.debug(`Network request for ` + `'${getFriendlyURL_js.getFriendlyURL(request.url)}' returned a response with ` + `status '${fetchResponse.status}'.`); + } + for (const callback of this.iterateCallbacks('fetchDidSucceed')) { + fetchResponse = await callback({ + event, + request: pluginFilteredRequest, + response: fetchResponse + }); + } + return fetchResponse; + } catch (error) { + { + logger_js.logger.log(`Network request for ` + `'${getFriendlyURL_js.getFriendlyURL(request.url)}' threw an error.`, error); + } + // `originalRequest` will only exist if a `fetchDidFail` callback + // is being used (see above). + if (originalRequest) { + await this.runCallbacks('fetchDidFail', { + error: error, + event, + originalRequest: originalRequest.clone(), + request: pluginFilteredRequest.clone() + }); + } + throw error; + } + } + /** + * Calls `this.fetch()` and (in the background) runs `this.cachePut()` on + * the response generated by `this.fetch()`. + * + * The call to `this.cachePut()` automatically invokes `this.waitUntil()`, + * so you do not have to manually call `waitUntil()` on the event. + * + * @param {Request|string} input The request or URL to fetch and cache. + * @return {Promise} + */ + async fetchAndCachePut(input) { + const response = await this.fetch(input); + const responseClone = response.clone(); + void this.waitUntil(this.cachePut(input, responseClone)); + return response; + } + /** + * Matches a request from the cache (and invokes any applicable plugin + * callback methods) using the `cacheName`, `matchOptions`, and `plugins` + * defined on the strategy object. + * + * The following plugin lifecycle methods are invoked when using this method: + * - cacheKeyWillBeUsed() + * - cachedResponseWillBeUsed() + * + * @param {Request|string} key The Request or URL to use as the cache key. + * @return {Promise} A matching response, if found. + */ + async cacheMatch(key) { + const request = toRequest(key); + let cachedResponse; + const { + cacheName, + matchOptions + } = this._strategy; + const effectiveRequest = await this.getCacheKey(request, 'read'); + const multiMatchOptions = Object.assign(Object.assign({}, matchOptions), { + cacheName + }); + cachedResponse = await caches.match(effectiveRequest, multiMatchOptions); + { + if (cachedResponse) { + logger_js.logger.debug(`Found a cached response in '${cacheName}'.`); + } else { + logger_js.logger.debug(`No cached response found in '${cacheName}'.`); + } + } + for (const callback of this.iterateCallbacks('cachedResponseWillBeUsed')) { + cachedResponse = (await callback({ + cacheName, + matchOptions, + cachedResponse, + request: effectiveRequest, + event: this.event + })) || undefined; + } + return cachedResponse; + } + /** + * Puts a request/response pair in the cache (and invokes any applicable + * plugin callback methods) using the `cacheName` and `plugins` defined on + * the strategy object. + * + * The following plugin lifecycle methods are invoked when using this method: + * - cacheKeyWillBeUsed() + * - cacheWillUpdate() + * - cacheDidUpdate() + * + * @param {Request|string} key The request or URL to use as the cache key. + * @param {Response} response The response to cache. + * @return {Promise} `false` if a cacheWillUpdate caused the response + * not be cached, and `true` otherwise. + */ + async cachePut(key, response) { + const request = toRequest(key); + // Run in the next task to avoid blocking other cache reads. + // https://github.com/w3c/ServiceWorker/issues/1397 + await timeout_js.timeout(0); + const effectiveRequest = await this.getCacheKey(request, 'write'); + { + if (effectiveRequest.method && effectiveRequest.method !== 'GET') { + throw new WorkboxError_js.WorkboxError('attempt-to-cache-non-get-request', { + url: getFriendlyURL_js.getFriendlyURL(effectiveRequest.url), + method: effectiveRequest.method + }); + } + // See https://github.com/GoogleChrome/workbox/issues/2818 + const vary = response.headers.get('Vary'); + if (vary) { + logger_js.logger.debug(`The response for ${getFriendlyURL_js.getFriendlyURL(effectiveRequest.url)} ` + `has a 'Vary: ${vary}' header. ` + `Consider setting the {ignoreVary: true} option on your strategy ` + `to ensure cache matching and deletion works as expected.`); + } + } + if (!response) { + { + logger_js.logger.error(`Cannot cache non-existent response for ` + `'${getFriendlyURL_js.getFriendlyURL(effectiveRequest.url)}'.`); + } + throw new WorkboxError_js.WorkboxError('cache-put-with-no-response', { + url: getFriendlyURL_js.getFriendlyURL(effectiveRequest.url) + }); + } + const responseToCache = await this._ensureResponseSafeToCache(response); + if (!responseToCache) { + { + logger_js.logger.debug(`Response '${getFriendlyURL_js.getFriendlyURL(effectiveRequest.url)}' ` + `will not be cached.`, responseToCache); + } + return false; + } + const { + cacheName, + matchOptions + } = this._strategy; + const cache = await self.caches.open(cacheName); + const hasCacheUpdateCallback = this.hasCallback('cacheDidUpdate'); + const oldResponse = hasCacheUpdateCallback ? await cacheMatchIgnoreParams_js.cacheMatchIgnoreParams( + // TODO(philipwalton): the `__WB_REVISION__` param is a precaching + // feature. Consider into ways to only add this behavior if using + // precaching. + cache, effectiveRequest.clone(), ['__WB_REVISION__'], matchOptions) : null; + { + logger_js.logger.debug(`Updating the '${cacheName}' cache with a new Response ` + `for ${getFriendlyURL_js.getFriendlyURL(effectiveRequest.url)}.`); + } + try { + await cache.put(effectiveRequest, hasCacheUpdateCallback ? responseToCache.clone() : responseToCache); + } catch (error) { + if (error instanceof Error) { + // See https://developer.mozilla.org/en-US/docs/Web/API/DOMException#exception-QuotaExceededError + if (error.name === 'QuotaExceededError') { + await executeQuotaErrorCallbacks_js.executeQuotaErrorCallbacks(); + } + throw error; + } + } + for (const callback of this.iterateCallbacks('cacheDidUpdate')) { + await callback({ + cacheName, + oldResponse, + newResponse: responseToCache.clone(), + request: effectiveRequest, + event: this.event + }); + } + return true; + } + /** + * Checks the list of plugins for the `cacheKeyWillBeUsed` callback, and + * executes any of those callbacks found in sequence. The final `Request` + * object returned by the last plugin is treated as the cache key for cache + * reads and/or writes. If no `cacheKeyWillBeUsed` plugin callbacks have + * been registered, the passed request is returned unmodified + * + * @param {Request} request + * @param {string} mode + * @return {Promise} + */ + async getCacheKey(request, mode) { + const key = `${request.url} | ${mode}`; + if (!this._cacheKeys[key]) { + let effectiveRequest = request; + for (const callback of this.iterateCallbacks('cacheKeyWillBeUsed')) { + effectiveRequest = toRequest(await callback({ + mode, + request: effectiveRequest, + event: this.event, + // params has a type any can't change right now. + params: this.params // eslint-disable-line + })); + } + this._cacheKeys[key] = effectiveRequest; + } + return this._cacheKeys[key]; + } + /** + * Returns true if the strategy has at least one plugin with the given + * callback. + * + * @param {string} name The name of the callback to check for. + * @return {boolean} + */ + hasCallback(name) { + for (const plugin of this._strategy.plugins) { + if (name in plugin) { + return true; + } + } + return false; + } + /** + * Runs all plugin callbacks matching the given name, in order, passing the + * given param object (merged ith the current plugin state) as the only + * argument. + * + * Note: since this method runs all plugins, it's not suitable for cases + * where the return value of a callback needs to be applied prior to calling + * the next callback. See + * {@link workbox-strategies.StrategyHandler#iterateCallbacks} + * below for how to handle that case. + * + * @param {string} name The name of the callback to run within each plugin. + * @param {Object} param The object to pass as the first (and only) param + * when executing each callback. This object will be merged with the + * current plugin state prior to callback execution. + */ + async runCallbacks(name, param) { + for (const callback of this.iterateCallbacks(name)) { + // TODO(philipwalton): not sure why `any` is needed. It seems like + // this should work with `as WorkboxPluginCallbackParam[C]`. + await callback(param); + } + } + /** + * Accepts a callback and returns an iterable of matching plugin callbacks, + * where each callback is wrapped with the current handler state (i.e. when + * you call each callback, whatever object parameter you pass it will + * be merged with the plugin's current state). + * + * @param {string} name The name fo the callback to run + * @return {Array} + */ + *iterateCallbacks(name) { + for (const plugin of this._strategy.plugins) { + if (typeof plugin[name] === 'function') { + const state = this._pluginStateMap.get(plugin); + const statefulCallback = param => { + const statefulParam = Object.assign(Object.assign({}, param), { + state + }); + // TODO(philipwalton): not sure why `any` is needed. It seems like + // this should work with `as WorkboxPluginCallbackParam[C]`. + return plugin[name](statefulParam); + }; + yield statefulCallback; + } + } + } + /** + * Adds a promise to the + * [extend lifetime promises]{@link https://w3c.github.io/ServiceWorker/#extendableevent-extend-lifetime-promises} + * of the event event associated with the request being handled (usually a + * `FetchEvent`). + * + * Note: you can await + * {@link workbox-strategies.StrategyHandler~doneWaiting} + * to know when all added promises have settled. + * + * @param {Promise} promise A promise to add to the extend lifetime promises + * of the event that triggered the request. + */ + waitUntil(promise) { + this._extendLifetimePromises.push(promise); + return promise; + } + /** + * Returns a promise that resolves once all promises passed to + * {@link workbox-strategies.StrategyHandler~waitUntil} + * have settled. + * + * Note: any work done after `doneWaiting()` settles should be manually + * passed to an event's `waitUntil()` method (not this handler's + * `waitUntil()` method), otherwise the service worker thread my be killed + * prior to your work completing. + */ + async doneWaiting() { + let promise; + while (promise = this._extendLifetimePromises.shift()) { + await promise; + } + } + /** + * Stops running the strategy and immediately resolves any pending + * `waitUntil()` promises. + */ + destroy() { + this._handlerDeferred.resolve(null); + } + /** + * This method will call cacheWillUpdate on the available plugins (or use + * status === 200) to determine if the Response is safe and valid to cache. + * + * @param {Request} options.request + * @param {Response} options.response + * @return {Promise} + * + * @private + */ + async _ensureResponseSafeToCache(response) { + let responseToCache = response; + let pluginsUsed = false; + for (const callback of this.iterateCallbacks('cacheWillUpdate')) { + responseToCache = (await callback({ + request: this.request, + response: responseToCache, + event: this.event + })) || undefined; + pluginsUsed = true; + if (!responseToCache) { + break; + } + } + if (!pluginsUsed) { + if (responseToCache && responseToCache.status !== 200) { + responseToCache = undefined; + } + { + if (responseToCache) { + if (responseToCache.status !== 200) { + if (responseToCache.status === 0) { + logger_js.logger.warn(`The response for '${this.request.url}' ` + `is an opaque response. The caching strategy that you're ` + `using will not cache opaque responses by default.`); + } else { + logger_js.logger.debug(`The response for '${this.request.url}' ` + `returned a status code of '${response.status}' and won't ` + `be cached as a result.`); + } + } + } + } + } + return responseToCache; + } + } + + /* + Copyright 2020 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. + */ + /** + * An abstract base class that all other strategy classes must extend from: + * + * @memberof workbox-strategies + */ + class Strategy { + /** + * Creates a new instance of the strategy and sets all documented option + * properties as public instance properties. + * + * Note: if a custom strategy class extends the base Strategy class and does + * not need more than these properties, it does not need to define its own + * constructor. + * + * @param {Object} [options] + * @param {string} [options.cacheName] Cache name to store and retrieve + * requests. Defaults to the cache names provided by + * {@link workbox-core.cacheNames}. + * @param {Array} [options.plugins] [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins} + * to use in conjunction with this caching strategy. + * @param {Object} [options.fetchOptions] Values passed along to the + * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters) + * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796) + * `fetch()` requests made by this strategy. + * @param {Object} [options.matchOptions] The + * [`CacheQueryOptions`]{@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions} + * for any `cache.match()` or `cache.put()` calls made by this strategy. + */ + constructor(options = {}) { + /** + * Cache name to store and retrieve + * requests. Defaults to the cache names provided by + * {@link workbox-core.cacheNames}. + * + * @type {string} + */ + this.cacheName = cacheNames_js.cacheNames.getRuntimeName(options.cacheName); + /** + * The list + * [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins} + * used by this strategy. + * + * @type {Array} + */ + this.plugins = options.plugins || []; + /** + * Values passed along to the + * [`init`]{@link https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters} + * of all fetch() requests made by this strategy. + * + * @type {Object} + */ + this.fetchOptions = options.fetchOptions; + /** + * The + * [`CacheQueryOptions`]{@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions} + * for any `cache.match()` or `cache.put()` calls made by this strategy. + * + * @type {Object} + */ + this.matchOptions = options.matchOptions; + } + /** + * Perform a request strategy and returns a `Promise` that will resolve with + * a `Response`, invoking all relevant plugin callbacks. + * + * When a strategy instance is registered with a Workbox + * {@link workbox-routing.Route}, this method is automatically + * called when the route matches. + * + * Alternatively, this method can be used in a standalone `FetchEvent` + * listener by passing it to `event.respondWith()`. + * + * @param {FetchEvent|Object} options A `FetchEvent` or an object with the + * properties listed below. + * @param {Request|string} options.request A request to run this strategy for. + * @param {ExtendableEvent} options.event The event associated with the + * request. + * @param {URL} [options.url] + * @param {*} [options.params] + */ + handle(options) { + const [responseDone] = this.handleAll(options); + return responseDone; + } + /** + * Similar to {@link workbox-strategies.Strategy~handle}, but + * instead of just returning a `Promise` that resolves to a `Response` it + * it will return an tuple of `[response, done]` promises, where the former + * (`response`) is equivalent to what `handle()` returns, and the latter is a + * Promise that will resolve once any promises that were added to + * `event.waitUntil()` as part of performing the strategy have completed. + * + * You can await the `done` promise to ensure any extra work performed by + * the strategy (usually caching responses) completes successfully. + * + * @param {FetchEvent|Object} options A `FetchEvent` or an object with the + * properties listed below. + * @param {Request|string} options.request A request to run this strategy for. + * @param {ExtendableEvent} options.event The event associated with the + * request. + * @param {URL} [options.url] + * @param {*} [options.params] + * @return {Array} A tuple of [response, done] + * promises that can be used to determine when the response resolves as + * well as when the handler has completed all its work. + */ + handleAll(options) { + // Allow for flexible options to be passed. + if (options instanceof FetchEvent) { + options = { + event: options, + request: options.request + }; + } + const event = options.event; + const request = typeof options.request === 'string' ? new Request(options.request) : options.request; + const params = 'params' in options ? options.params : undefined; + const handler = new StrategyHandler(this, { + event, + request, + params + }); + const responseDone = this._getResponse(handler, request, event); + const handlerDone = this._awaitComplete(responseDone, handler, request, event); + // Return an array of promises, suitable for use with Promise.all(). + return [responseDone, handlerDone]; + } + async _getResponse(handler, request, event) { + await handler.runCallbacks('handlerWillStart', { + event, + request + }); + let response = undefined; + try { + response = await this._handle(request, handler); + // The "official" Strategy subclasses all throw this error automatically, + // but in case a third-party Strategy doesn't, ensure that we have a + // consistent failure when there's no response or an error response. + if (!response || response.type === 'error') { + throw new WorkboxError_js.WorkboxError('no-response', { + url: request.url + }); + } + } catch (error) { + if (error instanceof Error) { + for (const callback of handler.iterateCallbacks('handlerDidError')) { + response = await callback({ + error, + event, + request + }); + if (response) { + break; + } + } + } + if (!response) { + throw error; + } else { + logger_js.logger.log(`While responding to '${getFriendlyURL_js.getFriendlyURL(request.url)}', ` + `an ${error instanceof Error ? error.toString() : ''} error occurred. Using a fallback response provided by ` + `a handlerDidError plugin.`); + } + } + for (const callback of handler.iterateCallbacks('handlerWillRespond')) { + response = await callback({ + event, + request, + response + }); + } + return response; + } + async _awaitComplete(responseDone, handler, request, event) { + let response; + let error; + try { + response = await responseDone; + } catch (error) { + // Ignore errors, as response errors should be caught via the `response` + // promise above. The `done` promise will only throw for errors in + // promises passed to `handler.waitUntil()`. + } + try { + await handler.runCallbacks('handlerDidRespond', { + event, + request, + response + }); + await handler.doneWaiting(); + } catch (waitUntilError) { + if (waitUntilError instanceof Error) { + error = waitUntilError; + } + } + await handler.runCallbacks('handlerDidComplete', { + event, + request, + response, + error: error + }); + handler.destroy(); + if (error) { + throw error; + } + } + } + /** + * Classes extending the `Strategy` based class should implement this method, + * and leverage the {@link workbox-strategies.StrategyHandler} + * arg to perform all fetching and cache logic, which will ensure all relevant + * cache, cache options, fetch options and plugins are used (per the current + * strategy instance). + * + * @name _handle + * @instance + * @abstract + * @function + * @param {Request} request + * @param {workbox-strategies.StrategyHandler} handler + * @return {Promise} + * + * @memberof workbox-strategies.Strategy + */ + + /* + 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 messages = { + strategyStart: (strategyName, request) => `Using ${strategyName} to respond to '${getFriendlyURL_js.getFriendlyURL(request.url)}'`, + printFinalResponse: response => { + if (response) { + logger_js.logger.groupCollapsed(`View the final response here.`); + logger_js.logger.log(response || '[No response returned]'); + logger_js.logger.groupEnd(); + } + } + }; + + /* + 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. + */ + /** + * An implementation of a [cache-first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache-first-falling-back-to-network) + * request strategy. + * + * A cache first strategy is useful for assets that have been revisioned, + * such as URLs like `/styles/example.a8f5f1.css`, since they + * can be cached for long periods of time. + * + * If the network request fails, and there is no cache match, this will throw + * a `WorkboxError` exception. + * + * @extends workbox-strategies.Strategy + * @memberof workbox-strategies + */ + class CacheFirst extends Strategy { + /** + * @private + * @param {Request|string} request A request to run this strategy for. + * @param {workbox-strategies.StrategyHandler} handler The event that + * triggered the request. + * @return {Promise} + */ + async _handle(request, handler) { + const logs = []; + { + assert_js.assert.isInstance(request, Request, { + moduleName: 'workbox-strategies', + className: this.constructor.name, + funcName: 'makeRequest', + paramName: 'request' + }); + } + let response = await handler.cacheMatch(request); + let error = undefined; + if (!response) { + { + logs.push(`No response found in the '${this.cacheName}' cache. ` + `Will respond with a network request.`); + } + try { + response = await handler.fetchAndCachePut(request); + } catch (err) { + if (err instanceof Error) { + error = err; + } + } + { + if (response) { + logs.push(`Got response from network.`); + } else { + logs.push(`Unable to get a response from the network.`); + } + } + } else { + { + logs.push(`Found a cached response in the '${this.cacheName}' cache.`); + } + } + { + logger_js.logger.groupCollapsed(messages.strategyStart(this.constructor.name, request)); + for (const log of logs) { + logger_js.logger.log(log); + } + messages.printFinalResponse(response); + logger_js.logger.groupEnd(); + } + if (!response) { + throw new WorkboxError_js.WorkboxError('no-response', { + url: request.url, + error + }); + } + return response; + } + } + + /* + 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. + */ + /** + * An implementation of a [cache-only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#cache-only) + * request strategy. + * + * This class is useful if you want to take advantage of any + * [Workbox plugins](https://developer.chrome.com/docs/workbox/using-plugins/). + * + * If there is no cache match, this will throw a `WorkboxError` exception. + * + * @extends workbox-strategies.Strategy + * @memberof workbox-strategies + */ + class CacheOnly extends Strategy { + /** + * @private + * @param {Request|string} request A request to run this strategy for. + * @param {workbox-strategies.StrategyHandler} handler The event that + * triggered the request. + * @return {Promise} + */ + async _handle(request, handler) { + { + assert_js.assert.isInstance(request, Request, { + moduleName: 'workbox-strategies', + className: this.constructor.name, + funcName: 'makeRequest', + paramName: 'request' + }); + } + const response = await handler.cacheMatch(request); + { + logger_js.logger.groupCollapsed(messages.strategyStart(this.constructor.name, request)); + if (response) { + logger_js.logger.log(`Found a cached response in the '${this.cacheName}' ` + `cache.`); + messages.printFinalResponse(response); + } else { + logger_js.logger.log(`No response found in the '${this.cacheName}' cache.`); + } + logger_js.logger.groupEnd(); + } + if (!response) { + throw new WorkboxError_js.WorkboxError('no-response', { + url: request.url + }); + } + return response; + } + } + + /* + 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 cacheOkAndOpaquePlugin = { + /** + * Returns a valid response (to allow caching) if the status is 200 (OK) or + * 0 (opaque). + * + * @param {Object} options + * @param {Response} options.response + * @return {Response|null} + * + * @private + */ + cacheWillUpdate: async ({ + response + }) => { + if (response.status === 200 || response.status === 0) { + return response; + } + return null; + } + }; + + /* + 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. + */ + /** + * An implementation of a + * [network first](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network-first-falling-back-to-cache) + * request strategy. + * + * By default, this strategy will cache responses with a 200 status code as + * well as [opaque responses](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque-responses). + * Opaque responses are are cross-origin requests where the response doesn't + * support [CORS](https://enable-cors.org/). + * + * If the network request fails, and there is no cache match, this will throw + * a `WorkboxError` exception. + * + * @extends workbox-strategies.Strategy + * @memberof workbox-strategies + */ + class NetworkFirst extends Strategy { + /** + * @param {Object} [options] + * @param {string} [options.cacheName] Cache name to store and retrieve + * requests. Defaults to cache names provided by + * {@link workbox-core.cacheNames}. + * @param {Array} [options.plugins] [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins} + * to use in conjunction with this caching strategy. + * @param {Object} [options.fetchOptions] Values passed along to the + * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters) + * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796) + * `fetch()` requests made by this strategy. + * @param {Object} [options.matchOptions] [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions) + * @param {number} [options.networkTimeoutSeconds] If set, any network requests + * that fail to respond within the timeout will fallback to the cache. + * + * This option can be used to combat + * "[lie-fi]{@link https://developers.google.com/web/fundamentals/performance/poor-connectivity/#lie-fi}" + * scenarios. + */ + constructor(options = {}) { + super(options); + // If this instance contains no plugins with a 'cacheWillUpdate' callback, + // prepend the `cacheOkAndOpaquePlugin` plugin to the plugins list. + if (!this.plugins.some(p => 'cacheWillUpdate' in p)) { + this.plugins.unshift(cacheOkAndOpaquePlugin); + } + this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0; + { + if (this._networkTimeoutSeconds) { + assert_js.assert.isType(this._networkTimeoutSeconds, 'number', { + moduleName: 'workbox-strategies', + className: this.constructor.name, + funcName: 'constructor', + paramName: 'networkTimeoutSeconds' + }); + } + } + } + /** + * @private + * @param {Request|string} request A request to run this strategy for. + * @param {workbox-strategies.StrategyHandler} handler The event that + * triggered the request. + * @return {Promise} + */ + async _handle(request, handler) { + const logs = []; + { + assert_js.assert.isInstance(request, Request, { + moduleName: 'workbox-strategies', + className: this.constructor.name, + funcName: 'handle', + paramName: 'makeRequest' + }); + } + const promises = []; + let timeoutId; + if (this._networkTimeoutSeconds) { + const { + id, + promise + } = this._getTimeoutPromise({ + request, + logs, + handler + }); + timeoutId = id; + promises.push(promise); + } + const networkPromise = this._getNetworkPromise({ + timeoutId, + request, + logs, + handler + }); + promises.push(networkPromise); + const response = await handler.waitUntil((async () => { + // Promise.race() will resolve as soon as the first promise resolves. + return (await handler.waitUntil(Promise.race(promises))) || ( + // If Promise.race() resolved with null, it might be due to a network + // timeout + a cache miss. If that were to happen, we'd rather wait until + // the networkPromise resolves instead of returning null. + // Note that it's fine to await an already-resolved promise, so we don't + // have to check to see if it's still "in flight". + await networkPromise); + })()); + { + logger_js.logger.groupCollapsed(messages.strategyStart(this.constructor.name, request)); + for (const log of logs) { + logger_js.logger.log(log); + } + messages.printFinalResponse(response); + logger_js.logger.groupEnd(); + } + if (!response) { + throw new WorkboxError_js.WorkboxError('no-response', { + url: request.url + }); + } + return response; + } + /** + * @param {Object} options + * @param {Request} options.request + * @param {Array} options.logs A reference to the logs array + * @param {Event} options.event + * @return {Promise} + * + * @private + */ + _getTimeoutPromise({ + request, + logs, + handler + }) { + let timeoutId; + const timeoutPromise = new Promise(resolve => { + const onNetworkTimeout = async () => { + { + logs.push(`Timing out the network response at ` + `${this._networkTimeoutSeconds} seconds.`); + } + resolve(await handler.cacheMatch(request)); + }; + timeoutId = setTimeout(onNetworkTimeout, this._networkTimeoutSeconds * 1000); + }); + return { + promise: timeoutPromise, + id: timeoutId + }; + } + /** + * @param {Object} options + * @param {number|undefined} options.timeoutId + * @param {Request} options.request + * @param {Array} options.logs A reference to the logs Array. + * @param {Event} options.event + * @return {Promise} + * + * @private + */ + async _getNetworkPromise({ + timeoutId, + request, + logs, + handler + }) { + let error; + let response; + try { + response = await handler.fetchAndCachePut(request); + } catch (fetchError) { + if (fetchError instanceof Error) { + error = fetchError; + } + } + if (timeoutId) { + clearTimeout(timeoutId); + } + { + if (response) { + logs.push(`Got response from network.`); + } else { + logs.push(`Unable to get a response from the network. Will respond ` + `with a cached response.`); + } + } + if (error || !response) { + response = await handler.cacheMatch(request); + { + if (response) { + logs.push(`Found a cached response in the '${this.cacheName}'` + ` cache.`); + } else { + logs.push(`No response found in the '${this.cacheName}' cache.`); + } + } + } + return response; + } + } + + /* + 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. + */ + /** + * An implementation of a + * [network-only](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#network-only) + * request strategy. + * + * This class is useful if you want to take advantage of any + * [Workbox plugins](https://developer.chrome.com/docs/workbox/using-plugins/). + * + * If the network request fails, this will throw a `WorkboxError` exception. + * + * @extends workbox-strategies.Strategy + * @memberof workbox-strategies + */ + class NetworkOnly extends Strategy { + /** + * @param {Object} [options] + * @param {Array} [options.plugins] [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins} + * to use in conjunction with this caching strategy. + * @param {Object} [options.fetchOptions] Values passed along to the + * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters) + * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796) + * `fetch()` requests made by this strategy. + * @param {number} [options.networkTimeoutSeconds] If set, any network requests + * that fail to respond within the timeout will result in a network error. + */ + constructor(options = {}) { + super(options); + this._networkTimeoutSeconds = options.networkTimeoutSeconds || 0; + } + /** + * @private + * @param {Request|string} request A request to run this strategy for. + * @param {workbox-strategies.StrategyHandler} handler The event that + * triggered the request. + * @return {Promise} + */ + async _handle(request, handler) { + { + assert_js.assert.isInstance(request, Request, { + moduleName: 'workbox-strategies', + className: this.constructor.name, + funcName: '_handle', + paramName: 'request' + }); + } + let error = undefined; + let response; + try { + const promises = [handler.fetch(request)]; + if (this._networkTimeoutSeconds) { + const timeoutPromise = timeout_js.timeout(this._networkTimeoutSeconds * 1000); + promises.push(timeoutPromise); + } + response = await Promise.race(promises); + if (!response) { + throw new Error(`Timed out the network response after ` + `${this._networkTimeoutSeconds} seconds.`); + } + } catch (err) { + if (err instanceof Error) { + error = err; + } + } + { + logger_js.logger.groupCollapsed(messages.strategyStart(this.constructor.name, request)); + if (response) { + logger_js.logger.log(`Got response from network.`); + } else { + logger_js.logger.log(`Unable to get a response from the network.`); + } + messages.printFinalResponse(response); + logger_js.logger.groupEnd(); + } + if (!response) { + throw new WorkboxError_js.WorkboxError('no-response', { + url: request.url, + error + }); + } + return response; + } + } + + /* + 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. + */ + /** + * An implementation of a + * [stale-while-revalidate](https://developer.chrome.com/docs/workbox/caching-strategies-overview/#stale-while-revalidate) + * request strategy. + * + * Resources are requested from both the cache and the network in parallel. + * The strategy will respond with the cached version if available, otherwise + * wait for the network response. The cache is updated with the network response + * with each successful request. + * + * By default, this strategy will cache responses with a 200 status code as + * well as [opaque responses](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque-responses). + * Opaque responses are cross-origin requests where the response doesn't + * support [CORS](https://enable-cors.org/). + * + * If the network request fails, and there is no cache match, this will throw + * a `WorkboxError` exception. + * + * @extends workbox-strategies.Strategy + * @memberof workbox-strategies + */ + class StaleWhileRevalidate extends Strategy { + /** + * @param {Object} [options] + * @param {string} [options.cacheName] Cache name to store and retrieve + * requests. Defaults to cache names provided by + * {@link workbox-core.cacheNames}. + * @param {Array} [options.plugins] [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins} + * to use in conjunction with this caching strategy. + * @param {Object} [options.fetchOptions] Values passed along to the + * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters) + * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796) + * `fetch()` requests made by this strategy. + * @param {Object} [options.matchOptions] [`CacheQueryOptions`](https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions) + */ + constructor(options = {}) { + super(options); + // If this instance contains no plugins with a 'cacheWillUpdate' callback, + // prepend the `cacheOkAndOpaquePlugin` plugin to the plugins list. + if (!this.plugins.some(p => 'cacheWillUpdate' in p)) { + this.plugins.unshift(cacheOkAndOpaquePlugin); + } + } + /** + * @private + * @param {Request|string} request A request to run this strategy for. + * @param {workbox-strategies.StrategyHandler} handler The event that + * triggered the request. + * @return {Promise} + */ + async _handle(request, handler) { + const logs = []; + { + assert_js.assert.isInstance(request, Request, { + moduleName: 'workbox-strategies', + className: this.constructor.name, + funcName: 'handle', + paramName: 'request' + }); + } + const fetchAndCachePromise = handler.fetchAndCachePut(request).catch(() => { + // Swallow this error because a 'no-response' error will be thrown in + // main handler return flow. This will be in the `waitUntil()` flow. + }); + void handler.waitUntil(fetchAndCachePromise); + let response = await handler.cacheMatch(request); + let error; + if (response) { + { + logs.push(`Found a cached response in the '${this.cacheName}'` + ` cache. Will update with the network response in the background.`); + } + } else { + { + logs.push(`No response found in the '${this.cacheName}' cache. ` + `Will wait for the network response.`); + } + try { + // NOTE(philipwalton): Really annoying that we have to type cast here. + // https://github.com/microsoft/TypeScript/issues/20006 + response = await fetchAndCachePromise; + } catch (err) { + if (err instanceof Error) { + error = err; + } + } + } + { + logger_js.logger.groupCollapsed(messages.strategyStart(this.constructor.name, request)); + for (const log of logs) { + logger_js.logger.log(log); + } + messages.printFinalResponse(response); + logger_js.logger.groupEnd(); + } + if (!response) { + throw new WorkboxError_js.WorkboxError('no-response', { + url: request.url, + error + }); + } + return response; + } + } + + exports.CacheFirst = CacheFirst; + exports.CacheOnly = CacheOnly; + exports.NetworkFirst = NetworkFirst; + exports.NetworkOnly = NetworkOnly; + exports.StaleWhileRevalidate = StaleWhileRevalidate; + exports.Strategy = Strategy; + exports.StrategyHandler = StrategyHandler; + + return exports; + +})({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private); +//# sourceMappingURL=workbox-strategies.dev.js.map diff --git a/workbox/workbox-strategies.prod.js b/workbox/workbox-strategies.prod.js new file mode 100644 index 0000000..bb49ea1 --- /dev/null +++ b/workbox/workbox-strategies.prod.js @@ -0,0 +1,2 @@ +this.workbox=this.workbox||{},this.workbox.strategies=function(t,e,s,r,n,a,i,o,c){"use strict";try{self["workbox:strategies:7.3.0"]&&_()}catch(t){}function h(t){return"string"==typeof t?new Request(t):t}class l{constructor(t,e){this.vt={},Object.assign(this,e),this.event=e.event,this.ht=t,this.bt=new n.Deferred,this.Et=[],this._t=[...t.plugins],this.kt=new Map;for(const t of this._t)this.kt.set(t,{});this.event.waitUntil(this.bt.promise)}async fetch(t){const{event:s}=this;let r=h(t);if("navigate"===r.mode&&s instanceof FetchEvent&&s.preloadResponse){const t=await s.preloadResponse;if(t)return t}const n=this.hasCallback("fetchDidFail")?r.clone():null;try{for(const t of this.iterateCallbacks("requestWillFetch"))r=await t({request:r.clone(),event:s})}catch(t){if(t instanceof Error)throw new e.WorkboxError("plugin-error-request-will-fetch",{thrownErrorMessage:t.message})}const a=r.clone();try{let t;t=await fetch(r,"navigate"===r.mode?void 0:this.ht.fetchOptions);for(const e of this.iterateCallbacks("fetchDidSucceed"))t=await e({event:s,request:a,response:t});return t}catch(t){throw n&&await this.runCallbacks("fetchDidFail",{error:t,event:s,originalRequest:n.clone(),request:a.clone()}),t}}async fetchAndCachePut(t){const e=await this.fetch(t),s=e.clone();return this.waitUntil(this.cachePut(t,s)),e}async cacheMatch(t){const e=h(t);let s;const{cacheName:r,matchOptions:n}=this.ht,a=await this.getCacheKey(e,"read"),i=Object.assign(Object.assign({},n),{cacheName:r});s=await caches.match(a,i);for(const t of this.iterateCallbacks("cachedResponseWillBeUsed"))s=await t({cacheName:r,matchOptions:n,cachedResponse:s,request:a,event:this.event})||void 0;return s}async cachePut(t,s){const n=h(t);await c.timeout(0);const o=await this.getCacheKey(n,"write");if(!s)throw new e.WorkboxError("cache-put-with-no-response",{url:i.getFriendlyURL(o.url)});const l=await this.xt(s);if(!l)return!1;const{cacheName:w,matchOptions:u}=this.ht,f=await self.caches.open(w),d=this.hasCallback("cacheDidUpdate"),p=d?await r.cacheMatchIgnoreParams(f,o.clone(),["__WB_REVISION__"],u):null;try{await f.put(o,d?l.clone():l)}catch(t){if(t instanceof Error)throw"QuotaExceededError"===t.name&&await a.executeQuotaErrorCallbacks(),t}for(const t of this.iterateCallbacks("cacheDidUpdate"))await t({cacheName:w,oldResponse:p,newResponse:l.clone(),request:o,event:this.event});return!0}async getCacheKey(t,e){const s=`${t.url} | ${e}`;if(!this.vt[s]){let r=t;for(const t of this.iterateCallbacks("cacheKeyWillBeUsed"))r=h(await t({mode:e,request:r,event:this.event,params:this.params}));this.vt[s]=r}return this.vt[s]}hasCallback(t){for(const e of this.ht.plugins)if(t in e)return!0;return!1}async runCallbacks(t,e){for(const s of this.iterateCallbacks(t))await s(e)}*iterateCallbacks(t){for(const e of this.ht.plugins)if("function"==typeof e[t]){const s=this.kt.get(e),r=r=>{const n=Object.assign(Object.assign({},r),{state:s});return e[t](n)};yield r}}waitUntil(t){return this.Et.push(t),t}async doneWaiting(){let t;for(;t=this.Et.shift();)await t}destroy(){this.bt.resolve(null)}async xt(t){let e=t,s=!1;for(const t of this.iterateCallbacks("cacheWillUpdate"))if(e=await t({request:this.request,response:e,event:this.event})||void 0,s=!0,!e)break;return s||e&&200!==e.status&&(e=void 0),e}}class w{constructor(t={}){this.cacheName=s.cacheNames.getRuntimeName(t.cacheName),this.plugins=t.plugins||[],this.fetchOptions=t.fetchOptions,this.matchOptions=t.matchOptions}handle(t){const[e]=this.handleAll(t);return e}handleAll(t){t instanceof FetchEvent&&(t={event:t,request:t.request});const e=t.event,s="string"==typeof t.request?new Request(t.request):t.request,r="params"in t?t.params:void 0,n=new l(this,{event:e,request:s,params:r}),a=this.Rt(n,s,e);return[a,this.Wt(a,n,s,e)]}async Rt(t,s,r){let n;await t.runCallbacks("handlerWillStart",{event:r,request:s});try{if(n=await this._handle(s,t),!n||"error"===n.type)throw new e.WorkboxError("no-response",{url:s.url})}catch(e){if(e instanceof Error)for(const a of t.iterateCallbacks("handlerDidError"))if(n=await a({error:e,event:r,request:s}),n)break;if(!n)throw e}for(const e of t.iterateCallbacks("handlerWillRespond"))n=await e({event:r,request:s,response:n});return n}async Wt(t,e,s,r){let n,a;try{n=await t}catch(a){}try{await e.runCallbacks("handlerDidRespond",{event:r,request:s,response:n}),await e.doneWaiting()}catch(t){t instanceof Error&&(a=t)}if(await e.runCallbacks("handlerDidComplete",{event:r,request:s,response:n,error:a}),e.destroy(),a)throw a}}const u={cacheWillUpdate:async({response:t})=>200===t.status||0===t.status?t:null};return t.CacheFirst=class extends w{async _handle(t,s){let r,n=await s.cacheMatch(t);if(!n)try{n=await s.fetchAndCachePut(t)}catch(t){t instanceof Error&&(r=t)}if(!n)throw new e.WorkboxError("no-response",{url:t.url,error:r});return n}},t.CacheOnly=class extends w{async _handle(t,s){const r=await s.cacheMatch(t);if(!r)throw new e.WorkboxError("no-response",{url:t.url});return r}},t.NetworkFirst=class extends w{constructor(t={}){super(t),this.plugins.some((t=>"cacheWillUpdate"in t))||this.plugins.unshift(u),this.Ot=t.networkTimeoutSeconds||0}async _handle(t,s){const r=[],n=[];let a;if(this.Ot){const{id:e,promise:i}=this.Ut({request:t,logs:r,handler:s});a=e,n.push(i)}const i=this.Ct({timeoutId:a,request:t,logs:r,handler:s});n.push(i);const o=await s.waitUntil((async()=>await s.waitUntil(Promise.race(n))||await i)());if(!o)throw new e.WorkboxError("no-response",{url:t.url});return o}Ut({request:t,logs:e,handler:s}){let r;return{promise:new Promise((e=>{r=setTimeout((async()=>{e(await s.cacheMatch(t))}),1e3*this.Ot)})),id:r}}async Ct({timeoutId:t,request:e,logs:s,handler:r}){let n,a;try{a=await r.fetchAndCachePut(e)}catch(t){t instanceof Error&&(n=t)}return t&&clearTimeout(t),!n&&a||(a=await r.cacheMatch(e)),a}},t.NetworkOnly=class extends w{constructor(t={}){super(t),this.Ot=t.networkTimeoutSeconds||0}async _handle(t,s){let r,n;try{const e=[s.fetch(t)];if(this.Ot){const t=c.timeout(1e3*this.Ot);e.push(t)}if(n=await Promise.race(e),!n)throw new Error(`Timed out the network response after ${this.Ot} seconds.`)}catch(t){t instanceof Error&&(r=t)}if(!n)throw new e.WorkboxError("no-response",{url:t.url,error:r});return n}},t.StaleWhileRevalidate=class extends w{constructor(t={}){super(t),this.plugins.some((t=>"cacheWillUpdate"in t))||this.plugins.unshift(u)}async _handle(t,s){const r=s.fetchAndCachePut(t).catch((()=>{}));s.waitUntil(r);let n,a=await s.cacheMatch(t);if(a);else try{a=await r}catch(t){t instanceof Error&&(n=t)}if(!a)throw new e.WorkboxError("no-response",{url:t.url,error:n});return a}},t.Strategy=w,t.StrategyHandler=l,t}({},workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private,workbox.core._private); +//# sourceMappingURL=workbox-strategies.prod.js.map diff --git a/workbox/workbox-sw.js b/workbox/workbox-sw.js new file mode 100644 index 0000000..1b972a4 --- /dev/null +++ b/workbox/workbox-sw.js @@ -0,0 +1,2 @@ +!function(){"use strict";try{self["workbox:sw:7.3.0"]&&_()}catch(t){}const t={backgroundSync:"background-sync",broadcastUpdate:"broadcast-update",cacheableResponse:"cacheable-response",core:"core",expiration:"expiration",googleAnalytics:"offline-ga",navigationPreload:"navigation-preload",precaching:"precaching",rangeRequests:"range-requests",routing:"routing",strategies:"strategies",streams:"streams",recipes:"recipes"};self.workbox=new class{constructor(){return this.v={},this.Pt={debug:"localhost"===self.location.hostname,modulePathPrefix:null,modulePathCb:null},this.$t=this.Pt.debug?"dev":"prod",this.jt=!1,new Proxy(this,{get(e,s){if(e[s])return e[s];const o=t[s];return o&&e.loadModule(`workbox-${o}`),e[s]}})}setConfig(t={}){if(this.jt)throw new Error("Config must be set before accessing workbox.* modules");Object.assign(this.Pt,t),this.$t=this.Pt.debug?"dev":"prod"}loadModule(t){const e=this.St(t);try{importScripts(e),this.jt=!0}catch(s){throw console.error(`Unable to import module '${t}' from '${e}'.`),s}}St(t){if(this.Pt.modulePathCb)return this.Pt.modulePathCb(t,this.Pt.debug);let e=["https://storage.googleapis.com/workbox-cdn/releases/7.3.0"];const s=`${t}.${this.$t}.js`,o=this.Pt.modulePathPrefix;return o&&(e=o.split("/"),""===e[e.length-1]&&e.splice(e.length-1,1)),e.push(s),e.join("/")}}}(); +//# sourceMappingURL=workbox-sw.js.map