1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
/// <reference lib="webworker" />
const sw = (self as typeof globalThis) as unknown as ServiceWorkerGlobalScope;
const CACHE_PREFIX = 'epube';
const CACHE_VERSION = BUILD_CACHE_VERSION;
const CACHE_NAME = CACHE_PREFIX + "-" + CACHE_VERSION;
const MANIFEST_ASSETS = BUILD_MANIFEST_ASSETS;
function fetchWithTimeout(request: Request, timeoutMs = 2500): Promise<Response> {
return new Promise((resolve, reject) => {
// Create an abort controller to stop the native network request if the timer fires first
const controller = new AbortController();
const timeoutId = setTimeout(() => {
controller.abort();
reject(new Error("Network timeout: DNS resolution took too long."));
}, timeoutMs);
fetch(request, { signal: controller.signal })
.then((response) => {
clearTimeout(timeoutId);
resolve(response);
})
.catch((err) => {
clearTimeout(timeoutId);
reject(err);
});
});
}
// Install: precache all assets from manifest
sw.addEventListener('install', (event) => {
(event as any).waitUntil((async () => {
console.log('[worker] install started', CACHE_NAME);
const cache = await caches.open(CACHE_NAME);
try {
// 1. Fetch all assets concurrently with version parameters
const fetchPromises = MANIFEST_ASSETS.map(async (url) => {
const cleanUrl = new URL(url, location.href);
// normalize = strip CACHE_VERSION suffix from pathname
cleanUrl.pathname = cleanUrl.pathname.replace("_" + CACHE_VERSION, "");
// this is our original URL from manifest (with suffix if set)
const networkUrl = new URL(url, location.href);
const response = await fetch(networkUrl.toString(), { cache: 'reload' });
// Emulate cache.addAll behavior: fail if any status is not 200-299
if (!response.ok) {
throw new Error(`Failed to fetch ${cleanUrl} (Status: ${response.status})`);
}
return {
cleanUrlStr: cleanUrl.toString(),
response: response.clone()
};
});
const results = await Promise.all(fetchPromises);
await Promise.all(results.map(({ cleanUrlStr, response }) => cache.put(cleanUrlStr, response)));
console.log('[worker] all assets cached successfully');
// Only skip waiting if the entire cache was successfully built
(sw as any).skipWaiting();
}
catch (err) {
console.error('[worker] Critical precache failed! Critical asset missing:', err);
// Do NOT call skipWaiting(). Let this installation fail so the old worker stays safe.
// we need to tell the browser the install failed so it throws away this worker, otherwise it gets stuck in waiting
throw err;
}
})());
});
sw.addEventListener('message', (event) => {
if (event.data && event.data.type === 'GET_CACHE_NAME') {
// Respond directly to the specific frontend window/tab that asked
event.ports[0].postMessage({ cacheName: CACHE_NAME });
} else if (event.data && event.data.type === 'GET_CACHE_VERSION') {
// Respond directly to the specific frontend window/tab that asked
event.ports[0].postMessage({ cacheName: CACHE_VERSION });
}
});
// Activate: clean up old caches and take control of all pages
sw.addEventListener('activate', (event) => {
console.log('[worker] activate');
// Create the async task block
const activationTask = async () => {
// await loadConfig();
const keyList = await caches.keys();
for (const key of keyList) {
if (key.includes(CACHE_PREFIX) && key !== CACHE_NAME) {
/* eslint-disable no-await-in-loop */
await caches.delete(key);
}
}
await sw.clients.claim();
};
// Hand the executed promise directly to the event
(event as any).waitUntil(activationTask());
});
// Fetch: cache-first for static assets, network-first for API
sw.addEventListener('fetch', (event) => {
const url = new URL((event as any).request.url);
// console.log('[fetch]', url);
// /assets/ belong to android app
if (url.pathname.startsWith('/assets/'))
return;
// request API endpoints from the network if possible and cache them locally
if (url.pathname.match('backend.php')) {
(event as any).respondWith((async () => {
try {
const networkResp = await fetchWithTimeout((event as any).request);
if (networkResp.ok) {
const cache = await caches.open(CACHE_NAME);
await cache.put(networkResp.url, networkResp.clone());
}
return networkResp;
}
catch (err) {
// Network failed, try to get the cached API response
const cachedResp = await caches.match((event as any).request);
if (cachedResp)
return cachedResp;
}
})());
return;
}
/**
index & read UI: online first; if offline, map index pages to offline.html & map all read.html?* to offline read.html
note that instead of hardcoding specific URLs, we handle all user-initiated explicit page navigation requests,
everything else falls back to the next block with cache-first-online-fallback logic
@todo potentially we could rewrite this to be offline-first as all entrypoints are cached, but we need to
somehow deal with substituting index.html with offline.html if network is unavailable without flapping
the UI repeatedly between online & offline indexes
*/
if (event.request.mode === 'navigate') {
(event as any).respondWith((async () => {
try {
const networkResp = await fetchWithTimeout((event as any).request);
if (networkResp.ok) {
const cache = await caches.open(CACHE_NAME);
await cache.put(networkResp.url, networkResp.clone());
}
return networkResp;
}
catch (err) {
// i.e. read.html?id=1234&b=1234
if (url.pathname.includes("read.html")) {
return caches.match("/read.html", { ignoreSearch: true });
}
else {
return caches.match('/offline.html');
}
}
})());
return;
}
// everything else: cache-first with network fallback
(event as any).respondWith((async () => {
const cache = await caches.open(CACHE_NAME);
const cached = await cache.match((event as any).request);
if (cached) {
// if cached, try to update: fire background network check without waiting for it (no await)
fetch((event as any).request)
.then((networkResp) => {
if (networkResp.ok)
cache.put((event as any).request, networkResp.clone());
})
.catch((e) => console.warn('[worker] Background update failed:', e));
// Return cached asset immediately
return cached;
}
// Cache miss: fetch from network and cache it
const networkResp = await fetch((event as any).request);
/* if (networkResp.ok) { -- we don't cache all responses
await cache.put(event.request, networkResp.clone());
} */
return networkResp;
})());
});
|