-
Notifications
You must be signed in to change notification settings - Fork 24
/
ngsw-worker.js
3224 lines (3185 loc) · 152 KB
/
ngsw-worker.js
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
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
(function() {
"use strict";
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
/**
* Adapts the service worker to its runtime environment.
*
* Mostly, this is used to mock out identifiers which are otherwise read
* from the global scope.
*/
class Adapter {
constructor(scopeUrl) {
this.scopeUrl = scopeUrl;
const parsedScopeUrl = this.parseUrl(this.scopeUrl);
// Determine the origin from the registration scope. This is used to differentiate between
// relative and absolute URLs.
this.origin = parsedScopeUrl.origin;
// Suffixing `ngsw` with the baseHref to avoid clash of cache names for SWs with different
// scopes on the same domain.
this.cacheNamePrefix = "ngsw:" + parsedScopeUrl.path;
}
/**
* Wrapper around the `Request` constructor.
*/
newRequest(input, init) {
return new Request(input, init);
}
/**
* Wrapper around the `Response` constructor.
*/
newResponse(body, init) {
return new Response(body, init);
}
/**
* Wrapper around the `Headers` constructor.
*/
newHeaders(headers) {
return new Headers(headers);
}
/**
* Test if a given object is an instance of `Client`.
*/
isClient(source) {
return source instanceof Client;
}
/**
* Read the current UNIX time in milliseconds.
*/
get time() {
return Date.now();
}
/**
* Get a normalized representation of a URL such as those found in the ServiceWorker's `ngsw.json`
* configuration.
*
* More specifically:
* 1. Resolve the URL relative to the ServiceWorker's scope.
* 2. If the URL is relative to the ServiceWorker's own origin, then only return the path part.
* Otherwise, return the full URL.
*
* @param url The raw request URL.
* @return A normalized representation of the URL.
*/
normalizeUrl(url) {
// Check the URL's origin against the ServiceWorker's.
const parsed = this.parseUrl(url, this.scopeUrl);
return parsed.origin === this.origin ? parsed.path : url;
}
/**
* Parse a URL into its different parts, such as `origin`, `path` and `search`.
*/
parseUrl(url, relativeTo) {
// Workaround a Safari bug, see
// https://github.com/angular/angular/issues/31061#issuecomment-503637978
const parsed = !relativeTo ? new URL(url) : new URL(url, relativeTo);
return {
origin: parsed.origin,
path: parsed.pathname,
search: parsed.search,
};
}
/**
* Wait for a given amount of time before completing a Promise.
*/
timeout(ms) {
return new Promise((resolve) => {
setTimeout(() => resolve(), ms);
});
}
}
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
/**
* An error returned in rejected promises if the given key is not found in the table.
*/
class NotFound {
constructor(table, key) {
this.table = table;
this.key = key;
}
}
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
/**
* An implementation of a `Database` that uses the `CacheStorage` API to serialize
* state within mock `Response` objects.
*/
class CacheDatabase {
constructor(scope, adapter) {
this.scope = scope;
this.adapter = adapter;
this.tables = new Map();
}
delete(name) {
if (this.tables.has(name)) {
this.tables.delete(name);
}
return this.scope.caches.delete(
`${this.adapter.cacheNamePrefix}:db:${name}`
);
}
list() {
return this.scope.caches
.keys()
.then((keys) =>
keys.filter((key) =>
key.startsWith(`${this.adapter.cacheNamePrefix}:db:`)
)
);
}
open(name, cacheQueryOptions) {
if (!this.tables.has(name)) {
const table = this.scope.caches
.open(`${this.adapter.cacheNamePrefix}:db:${name}`)
.then(
(cache) =>
new CacheTable(name, cache, this.adapter, cacheQueryOptions)
);
this.tables.set(name, table);
}
return this.tables.get(name);
}
}
/**
* A `Table` backed by a `Cache`.
*/
class CacheTable {
constructor(table, cache, adapter, cacheQueryOptions) {
this.table = table;
this.cache = cache;
this.adapter = adapter;
this.cacheQueryOptions = cacheQueryOptions;
}
request(key) {
return this.adapter.newRequest("/" + key);
}
delete(key) {
return this.cache.delete(this.request(key), this.cacheQueryOptions);
}
keys() {
return this.cache
.keys()
.then((requests) => requests.map((req) => req.url.substr(1)));
}
read(key) {
return this.cache
.match(this.request(key), this.cacheQueryOptions)
.then((res) => {
if (res === undefined) {
return Promise.reject(new NotFound(this.table, key));
}
return res.json();
});
}
write(key, value) {
return this.cache.put(
this.request(key),
this.adapter.newResponse(JSON.stringify(value))
);
}
}
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P ?
value :
new P(function(resolve) {
resolve(value);
});
}
return new(P || (P = Promise))(function(resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done ?
resolve(result.value) :
adopt(result.value).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
const UpdateCacheStatus = /*@__PURE__*/ (function(UpdateCacheStatus) {
UpdateCacheStatus[(UpdateCacheStatus["NOT_CACHED"] = 0)] = "NOT_CACHED";
UpdateCacheStatus[(UpdateCacheStatus["CACHED_BUT_UNUSED"] = 1)] =
"CACHED_BUT_UNUSED";
UpdateCacheStatus[(UpdateCacheStatus["CACHED"] = 2)] = "CACHED";
return UpdateCacheStatus;
})({});
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
class SwCriticalError extends Error {
constructor() {
super(...arguments);
this.isCritical = true;
}
}
function errorToString(error) {
if (error instanceof Error) {
return `${error.message}\n${error.stack}`;
} else {
return `${error}`;
}
}
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
/**
* Compute the SHA1 of the given string
*
* see http://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf
*
* WARNING: this function has not been designed not tested with security in mind.
* DO NOT USE IT IN A SECURITY SENSITIVE CONTEXT.
*
* Borrowed from @angular/compiler/src/i18n/digest.ts
*/
function sha1(str) {
const utf8 = str;
const words32 = stringToWords32(utf8, Endian.Big);
return _sha1(words32, utf8.length * 8);
}
function sha1Binary(buffer) {
const words32 = arrayBufferToWords32(buffer, Endian.Big);
return _sha1(words32, buffer.byteLength * 8);
}
function _sha1(words32, len) {
const w = [];
let [a, b, c, d, e] = [
0x67452301,
0xefcdab89,
0x98badcfe,
0x10325476,
0xc3d2e1f0,
];
words32[len >> 5] |= 0x80 << (24 - (len % 32));
words32[(((len + 64) >> 9) << 4) + 15] = len;
for (let i = 0; i < words32.length; i += 16) {
const [h0, h1, h2, h3, h4] = [a, b, c, d, e];
for (let j = 0; j < 80; j++) {
if (j < 16) {
w[j] = words32[i + j];
} else {
w[j] = rol32(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
}
const [f, k] = fk(j, b, c, d);
const temp = [rol32(a, 5), f, e, k, w[j]].reduce(add32);
[e, d, c, b, a] = [d, c, rol32(b, 30), a, temp];
}
[a, b, c, d, e] = [
add32(a, h0),
add32(b, h1),
add32(c, h2),
add32(d, h3),
add32(e, h4),
];
}
return byteStringToHexString(words32ToByteString([a, b, c, d, e]));
}
function add32(a, b) {
return add32to64(a, b)[1];
}
function add32to64(a, b) {
const low = (a & 0xffff) + (b & 0xffff);
const high = (a >>> 16) + (b >>> 16) + (low >>> 16);
return [high >>> 16, (high << 16) | (low & 0xffff)];
}
// Rotate a 32b number left `count` position
function rol32(a, count) {
return (a << count) | (a >>> (32 - count));
}
const Endian = /*@__PURE__*/ (function(Endian) {
Endian[(Endian["Little"] = 0)] = "Little";
Endian[(Endian["Big"] = 1)] = "Big";
return Endian;
})({});
function fk(index, b, c, d) {
if (index < 20) {
return [(b & c) | (~b & d), 0x5a827999];
}
if (index < 40) {
return [b ^ c ^ d, 0x6ed9eba1];
}
if (index < 60) {
return [(b & c) | (b & d) | (c & d), 0x8f1bbcdc];
}
return [b ^ c ^ d, 0xca62c1d6];
}
function stringToWords32(str, endian) {
const size = (str.length + 3) >>> 2;
const words32 = [];
for (let i = 0; i < size; i++) {
words32[i] = wordAt(str, i * 4, endian);
}
return words32;
}
function arrayBufferToWords32(buffer, endian) {
const size = (buffer.byteLength + 3) >>> 2;
const words32 = [];
const view = new Uint8Array(buffer);
for (let i = 0; i < size; i++) {
words32[i] = wordAt(view, i * 4, endian);
}
return words32;
}
function byteAt(str, index) {
if (typeof str === "string") {
return index >= str.length ? 0 : str.charCodeAt(index) & 0xff;
} else {
return index >= str.byteLength ? 0 : str[index] & 0xff;
}
}
function wordAt(str, index, endian) {
let word = 0;
if (endian === Endian.Big) {
for (let i = 0; i < 4; i++) {
word += byteAt(str, index + i) << (24 - 8 * i);
}
} else {
for (let i = 0; i < 4; i++) {
word += byteAt(str, index + i) << (8 * i);
}
}
return word;
}
function words32ToByteString(words32) {
return words32.reduce((str, word) => str + word32ToByteString(word), "");
}
function word32ToByteString(word) {
let str = "";
for (let i = 0; i < 4; i++) {
str += String.fromCharCode((word >>> (8 * (3 - i))) & 0xff);
}
return str;
}
function byteStringToHexString(str) {
let hex = "";
for (let i = 0; i < str.length; i++) {
const b = byteAt(str, i);
hex += (b >>> 4).toString(16) + (b & 0x0f).toString(16);
}
return hex.toLowerCase();
}
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
/**
* A group of assets that are cached in a `Cache` and managed by a given policy.
*
* Concrete classes derive from this base and specify the exact caching policy.
*/
class AssetGroup {
constructor(scope, adapter, idle, config, hashes, db, prefix) {
this.scope = scope;
this.adapter = adapter;
this.idle = idle;
this.config = config;
this.hashes = hashes;
this.db = db;
this.prefix = prefix;
/**
* A deduplication cache, to make sure the SW never makes two network requests
* for the same resource at once. Managed by `fetchAndCacheOnce`.
*/
this.inFlightRequests = new Map();
/**
* Normalized resource URLs.
*/
this.urls = [];
/**
* Regular expression patterns.
*/
this.patterns = [];
this.name = config.name;
// Normalize the config's URLs to take the ServiceWorker's scope into account.
this.urls = config.urls.map((url) => adapter.normalizeUrl(url));
// Patterns in the config are regular expressions disguised as strings. Breathe life into them.
this.patterns = config.patterns.map((pattern) => new RegExp(pattern));
// This is the primary cache, which holds all of the cached requests for this group. If a
// resource
// isn't in this cache, it hasn't been fetched yet.
this.cache = scope.caches.open(`${this.prefix}:${config.name}:cache`);
// This is the metadata table, which holds specific information for each cached URL, such as
// the timestamp of when it was added to the cache.
this.metadata = this.db.open(
`${this.prefix}:${config.name}:meta`,
config.cacheQueryOptions
);
}
cacheStatus(url) {
return __awaiter(this, void 0, void 0, function*() {
const cache = yield this.cache;
const meta = yield this.metadata;
const req = this.adapter.newRequest(url);
const res = yield cache.match(req, this.config.cacheQueryOptions);
if (res === undefined) {
return UpdateCacheStatus.NOT_CACHED;
}
try {
const data = yield meta.read(req.url);
if (!data.used) {
return UpdateCacheStatus.CACHED_BUT_UNUSED;
}
} catch (_) {
// Error on the side of safety and assume cached.
}
return UpdateCacheStatus.CACHED;
});
}
/**
* Clean up all the cached data for this group.
*/
cleanup() {
return __awaiter(this, void 0, void 0, function*() {
yield this.scope.caches.delete(
`${this.prefix}:${this.config.name}:cache`
);
yield this.db.delete(`${this.prefix}:${this.config.name}:meta`);
});
}
/**
* Process a request for a given resource and return it, or return null if it's not available.
*/
handleFetch(req, ctx) {
return __awaiter(this, void 0, void 0, function*() {
const url = this.adapter.normalizeUrl(req.url);
// Either the request matches one of the known resource URLs, one of the patterns for
// dynamically matched URLs, or neither. Determine which is the case for this request in
// order to decide how to handle it.
if (
this.urls.indexOf(url) !== -1 ||
this.patterns.some((pattern) => pattern.test(url))
) {
// This URL matches a known resource. Either it's been cached already or it's missing, in
// which case it needs to be loaded from the network.
// Open the cache to check whether this resource is present.
const cache = yield this.cache;
// Look for a cached response. If one exists, it can be used to resolve the fetch
// operation.
const cachedResponse = yield cache.match(
req,
this.config.cacheQueryOptions
);
if (cachedResponse !== undefined) {
// A response has already been cached (which presumably matches the hash for this
// resource). Check whether it's safe to serve this resource from cache.
if (this.hashes.has(url)) {
// This resource has a hash, and thus is versioned by the manifest. It's safe to return
// the response.
return cachedResponse;
} else {
// This resource has no hash, and yet exists in the cache. Check how old this request is
// to make sure it's still usable.
if (yield this.needToRevalidate(req, cachedResponse)) {
this.idle.schedule(
`revalidate(${this.prefix}, ${this.config.name}): ${req.url}`,
() =>
__awaiter(this, void 0, void 0, function*() {
yield this.fetchAndCacheOnce(req);
})
);
}
// In either case (revalidation or not), the cached response must be good.
return cachedResponse;
}
}
// No already-cached response exists, so attempt a fetch/cache operation. The original request
// may specify things like credential inclusion, but for assets these are not honored in order
// to avoid issues with opaque responses. The SW requests the data itself.
const res = yield this.fetchAndCacheOnce(
this.adapter.newRequest(req.url)
);
// If this is successful, the response needs to be cloned as it might be used to respond to
// multiple fetch operations at the same time.
return res.clone();
} else {
return null;
}
});
}
/**
* Some resources are cached without a hash, meaning that their expiration is controlled
* by HTTP caching headers. Check whether the given request/response pair is still valid
* per the caching headers.
*/
needToRevalidate(req, res) {
return __awaiter(this, void 0, void 0, function*() {
// Three different strategies apply here:
// 1) The request has a Cache-Control header, and thus expiration needs to be based on its age.
// 2) The request has an Expires header, and expiration is based on the current timestamp.
// 3) The request has no applicable caching headers, and must be revalidated.
if (res.headers.has("Cache-Control")) {
// Figure out if there is a max-age directive in the Cache-Control header.
const cacheControl = res.headers.get("Cache-Control");
const cacheDirectives = cacheControl
// Directives are comma-separated within the Cache-Control header value.
.split(",")
// Make sure each directive doesn't have extraneous whitespace.
.map((v) => v.trim())
// Some directives have values (like maxage and s-maxage)
.map((v) => v.split("="));
// Lowercase all the directive names.
cacheDirectives.forEach((v) => (v[0] = v[0].toLowerCase()));
// Find the max-age directive, if one exists.
const maxAgeDirective = cacheDirectives.find(
(v) => v[0] === "max-age"
);
const cacheAge = maxAgeDirective ? maxAgeDirective[1] : undefined;
if (!cacheAge) {
// No usable TTL defined. Must assume that the response is stale.
return true;
}
try {
const maxAge = 1000 * parseInt(cacheAge);
// Determine the origin time of this request. If the SW has metadata on the request (which
// it
// should), it will have the time the request was added to the cache. If it doesn't for some
// reason, the request may have a Date header which will serve the same purpose.
let ts;
try {
// Check the metadata table. If a timestamp is there, use it.
const metaTable = yield this.metadata;
ts = (yield metaTable.read(req.url)).ts;
} catch (_a) {
// Otherwise, look for a Date header.
const date = res.headers.get("Date");
if (date === null) {
// Unable to determine when this response was created. Assume that it's stale, and
// revalidate it.
return true;
}
ts = Date.parse(date);
}
const age = this.adapter.time - ts;
return age < 0 || age > maxAge;
} catch (_b) {
// Assume stale.
return true;
}
} else if (res.headers.has("Expires")) {
// Determine if the expiration time has passed.
const expiresStr = res.headers.get("Expires");
try {
// The request needs to be revalidated if the current time is later than the expiration
// time, if it parses correctly.
return this.adapter.time > Date.parse(expiresStr);
} catch (_c) {
// The expiration date failed to parse, so revalidate as a precaution.
return true;
}
} else {
// No way to evaluate staleness, so assume the response is already stale.
return true;
}
});
}
/**
* Fetch the complete state of a cached resource, or return null if it's not found.
*/
fetchFromCacheOnly(url) {
return __awaiter(this, void 0, void 0, function*() {
const cache = yield this.cache;
const metaTable = yield this.metadata;
// Lookup the response in the cache.
const request = this.adapter.newRequest(url);
const response = yield cache.match(
request,
this.config.cacheQueryOptions
);
if (response === undefined) {
// It's not found, return null.
return null;
}
// Next, lookup the cached metadata.
let metadata = undefined;
try {
metadata = yield metaTable.read(request.url);
} catch (_a) {
// Do nothing, not found. This shouldn't happen, but it can be handled.
}
// Return both the response and any available metadata.
return { response, metadata };
});
}
/**
* Lookup all resources currently stored in the cache which have no associated hash.
*/
unhashedResources() {
return __awaiter(this, void 0, void 0, function*() {
const cache = yield this.cache;
// Start with the set of all cached requests.
return (
(yield cache.keys())
// Normalize their URLs.
.map((request) => this.adapter.normalizeUrl(request.url))
// Exclude the URLs which have hashes.
.filter((url) => !this.hashes.has(url))
);
});
}
/**
* Fetch the given resource from the network, and cache it if able.
*/
fetchAndCacheOnce(req, used = true) {
return __awaiter(this, void 0, void 0, function*() {
// The `inFlightRequests` map holds information about which caching operations are currently
// underway for known resources. If this request appears there, another "thread" is already
// in the process of caching it, and this work should not be duplicated.
if (this.inFlightRequests.has(req.url)) {
// There is a caching operation already in progress for this request. Wait for it to
// complete, and hopefully it will have yielded a useful response.
return this.inFlightRequests.get(req.url);
}
// No other caching operation is being attempted for this resource, so it will be owned here.
// Go to the network and get the correct version.
const fetchOp = this.fetchFromNetwork(req);
// Save this operation in `inFlightRequests` so any other "thread" attempting to cache it
// will block on this chain instead of duplicating effort.
this.inFlightRequests.set(req.url, fetchOp);
// Make sure this attempt is cleaned up properly on failure.
try {
// Wait for a response. If this fails, the request will remain in `inFlightRequests`
// indefinitely.
const res = yield fetchOp;
// It's very important that only successful responses are cached. Unsuccessful responses
// should never be cached as this can completely break applications.
if (!res.ok) {
throw new Error(
`Response not Ok (fetchAndCacheOnce): request for ${req.url} returned response ${res.status} ${res.statusText}`
);
}
try {
// This response is safe to cache (as long as it's cloned). Wait until the cache operation
// is complete.
const cache = yield this.scope.caches.open(
`${this.prefix}:${this.config.name}:cache`
);
yield cache.put(req, res.clone());
// If the request is not hashed, update its metadata, especially the timestamp. This is
// needed for future determination of whether this cached response is stale or not.
if (!this.hashes.has(this.adapter.normalizeUrl(req.url))) {
// Metadata is tracked for requests that are unhashed.
const meta = { ts: this.adapter.time, used };
const metaTable = yield this.metadata;
yield metaTable.write(req.url, meta);
}
return res;
} catch (err) {
// Among other cases, this can happen when the user clears all data through the DevTools,
// but the SW is still running and serving another tab. In that case, trying to write to the
// caches throws an `Entry was not found` error.
// If this happens the SW can no longer work correctly. This situation is unrecoverable.
throw new SwCriticalError(
`Failed to update the caches for request to '${
req.url
}' (fetchAndCacheOnce): ${errorToString(err)}`
);
}
} finally {
// Finally, it can be removed from `inFlightRequests`. This might result in a double-remove
// if some other chain was already making this request too, but that won't hurt anything.
this.inFlightRequests.delete(req.url);
}
});
}
fetchFromNetwork(req, redirectLimit = 3) {
return __awaiter(this, void 0, void 0, function*() {
// Make a cache-busted request for the resource.
const res = yield this.cacheBustedFetchFromNetwork(req);
// Check for redirected responses, and follow the redirects.
if (res["redirected"] && !!res.url) {
// If the redirect limit is exhausted, fail with an error.
if (redirectLimit === 0) {
throw new SwCriticalError(
`Response hit redirect limit (fetchFromNetwork): request redirected too many times, next is ${res.url}`
);
}
// Unwrap the redirect directly.
return this.fetchFromNetwork(
this.adapter.newRequest(res.url),
redirectLimit - 1
);
}
return res;
});
}
/**
* Load a particular asset from the network, accounting for hash validation.
*/
cacheBustedFetchFromNetwork(req) {
return __awaiter(this, void 0, void 0, function*() {
const url = this.adapter.normalizeUrl(req.url);
// If a hash is available for this resource, then compare the fetched version with the
// canonical hash. Otherwise, the network version will have to be trusted.
if (this.hashes.has(url)) {
// It turns out this resource does have a hash. Look it up. Unless the fetched version
// matches this hash, it's invalid and the whole manifest may need to be thrown out.
const canonicalHash = this.hashes.get(url);
// Ideally, the resource would be requested with cache-busting to guarantee the SW gets
// the freshest version. However, doing this would eliminate any chance of the response
// being in the HTTP cache. Given that the browser has recently actively loaded the page,
// it's likely that many of the responses the SW needs to cache are in the HTTP cache and
// are fresh enough to use. In the future, this could be done by setting cacheMode to
// *only* check the browser cache for a cached version of the resource, when cacheMode is
// fully supported. For now, the resource is fetched directly, without cache-busting, and
// if the hash test fails a cache-busted request is tried before concluding that the
// resource isn't correct. This gives the benefit of acceleration via the HTTP cache
// without the risk of stale data, at the expense of a duplicate request in the event of
// a stale response.
// Fetch the resource from the network (possibly hitting the HTTP cache).
const networkResult = yield this.safeFetch(req);
// Decide whether a cache-busted request is necessary. It might be for two independent
// reasons: either the non-cache-busted request failed (hopefully transiently) or if the
// hash of the content retrieved does not match the canonical hash from the manifest. It's
// only valid to access the content of the first response if the request was successful.
let makeCacheBustedRequest = networkResult.ok;
if (makeCacheBustedRequest) {
// The request was successful. A cache-busted request is only necessary if the hashes
// don't match. Compare them, making sure to clone the response so it can be used later
// if it proves to be valid.
const fetchedHash = sha1Binary(
yield networkResult.clone().arrayBuffer()
);
makeCacheBustedRequest = fetchedHash !== canonicalHash;
}
// Make a cache busted request to the network, if necessary.
if (makeCacheBustedRequest) {
// Hash failure, the version that was retrieved under the default URL did not have the
// hash expected. This could be because the HTTP cache got in the way and returned stale
// data, or because the version on the server really doesn't match. A cache-busting
// request will differentiate these two situations.
const cacheBustReq = this.adapter.newRequest(
this.cacheBust(req.url)
);
const cacheBustedResult = yield this.safeFetch(cacheBustReq);
// If the response was unsuccessful, there's nothing more that can be done.
if (!cacheBustedResult.ok) {
throw new SwCriticalError(
`Response not Ok (cacheBustedFetchFromNetwork): cache busted request for ${req.url} returned response ${cacheBustedResult.status} ${cacheBustedResult.statusText}`
);
}
// Hash the contents.
const cacheBustedHash = sha1Binary(
yield cacheBustedResult.clone().arrayBuffer()
);
// If the cache-busted version doesn't match, then the manifest is not an accurate
// representation of the server's current set of files, and the SW should give up.
if (canonicalHash !== cacheBustedHash) {
throw new SwCriticalError(
`Hash mismatch (cacheBustedFetchFromNetwork): ${req.url}: expected ${canonicalHash}, got ${cacheBustedHash} (after cache busting)`
);
}
// If it does match, then use the cache-busted result.
return cacheBustedResult;
}
// Excellent, the version from the network matched on the first try, with no need for
// cache-busting. Use it.
return networkResult;
} else {
// This URL doesn't exist in our hash database, so it must be requested directly.
return this.safeFetch(req);
}
});
}
/**
* Possibly update a resource, if it's expired and needs to be updated. A no-op otherwise.
*/
maybeUpdate(updateFrom, req, cache) {
return __awaiter(this, void 0, void 0, function*() {
const url = this.adapter.normalizeUrl(req.url);
const meta = yield this.metadata;
// Check if this resource is hashed and already exists in the cache of a prior version.
if (this.hashes.has(url)) {
const hash = this.hashes.get(url);
// Check the caches of prior versions, using the hash to ensure the correct version of
// the resource is loaded.
const res = yield updateFrom.lookupResourceWithHash(url, hash);
// If a previously cached version was available, copy it over to this cache.
if (res !== null) {
// Copy to this cache.
yield cache.put(req, res);
yield meta.write(req.url, { ts: this.adapter.time, used: false });
// No need to do anything further with this resource, it's now cached properly.
return true;
}
}
// No up-to-date version of this resource could be found.
return false;
});
}
/**
* Construct a cache-busting URL for a given URL.
*/
cacheBust(url) {
return (
url +
(url.indexOf("?") === -1 ? "?" : "&") +
"ngsw-cache-bust=" +
Math.random()
);
}
safeFetch(req) {
return __awaiter(this, void 0, void 0, function*() {
try {
return yield this.scope.fetch(req);
} catch (_a) {
return this.adapter.newResponse("", {
status: 504,
statusText: "Gateway Timeout",
});
}
});
}
}
/**
* An `AssetGroup` that prefetches all of its resources during initialization.
*/
class PrefetchAssetGroup extends AssetGroup {
initializeFully(updateFrom) {
return __awaiter(this, void 0, void 0, function*() {
// Open the cache which actually holds requests.
const cache = yield this.cache;
// Cache all known resources serially. As this reduce proceeds, each Promise waits
// on the last before starting the fetch/cache operation for the next request. Any
// errors cause fall-through to the final Promise which rejects.
yield this.urls.reduce(
(previous, url) =>
__awaiter(this, void 0, void 0, function*() {
// Wait on all previous operations to complete.
yield previous;
// Construct the Request for this url.
const req = this.adapter.newRequest(url);
// First, check the cache to see if there is already a copy of this resource.
const alreadyCached =
(yield cache.match(req, this.config.cacheQueryOptions)) !==
undefined;
// If the resource is in the cache already, it can be skipped.
if (alreadyCached) {
return;
}
// If an update source is available.
if (
updateFrom !== undefined &&
(yield this.maybeUpdate(updateFrom, req, cache))
) {
return;
}
// Otherwise, go to the network and hopefully cache the response (if successful).
yield this.fetchAndCacheOnce(req, false);
}),
Promise.resolve()
);
// Handle updating of unknown (unhashed) resources. This is only possible if there's
// a source to update from.
if (updateFrom !== undefined) {
const metaTable = yield this.metadata;
// Select all of the previously cached resources. These are cached unhashed resources
// from previous versions of the app, in any asset group.
yield(yield updateFrom.previouslyCachedResources())
// First, narrow down the set of resources to those which are handled by this group.
// Either it's a known URL, or it matches a given pattern.
.filter(
(url) =>
this.urls.indexOf(url) !== -1 ||
this.patterns.some((pattern) => pattern.test(url))
)
// Finally, process each resource in turn.
.reduce(
(previous, url) =>
__awaiter(this, void 0, void 0, function*() {
yield previous;
const req = this.adapter.newRequest(url);
// It's possible that the resource in question is already cached. If so,
// continue to the next one.
const alreadyCached =
(yield cache.match(req, this.config.cacheQueryOptions)) !==
undefined;
if (alreadyCached) {
return;
}
// Get the most recent old version of the resource.
const res = yield updateFrom.lookupResourceWithoutHash(url);
if (res === null || res.metadata === undefined) {
// Unexpected, but not harmful.
return;
}
// Write it into the cache. It may already be expired, but it can still serve
// traffic until it's updated (stale-while-revalidate approach).
yield cache.put(req, res.response);
yield metaTable.write(
req.url,
Object.assign(Object.assign({}, res.metadata), {
used: false,
})
);
}),
Promise.resolve()
);