PageSourceSearch

https://szs.org.pl/OneSignalSDKUpdaterWorker.js

js szs.org.pl collected 2026-10-09 01:39:26 UTC 26,503 bytes, 692 lines download raw bytes

1importScripts('https://cdn.onesignal.com/sdks/OneSignalSDKWorker.js');const CACHE_VERSION = '1.7.60.24';
2
3const BASE_CACHE_FILES = [
4    'https://szs.org.pl/wp-content/uploads/2023/07/slzszach-app-icon-pwa.png',
5'https://szs.org.pl/wp-content/uploads/2023/05/cropped-slaski-zwiazek-szachowy.jpg',
6'https://szs.org.pl/wp-content/uploads/2023/05/cropped-slaski-zwiazek-szachowy.jpg',
7
8];
9
10const OFFLINE_CACHE_FILES = [
11     'https://szs.org.pl/',
12];
13
14const NOT_FOUND_CACHE_FILES = [
15    'https://szs.org.pl/',
16];
17
18const OFFLINE_PAGE = 'https://szs.org.pl/';
19const NOT_FOUND_PAGE = 'https://szs.org.pl/';
20
21const CACHE_VERSIONS = {
22    content: 'content-v' + CACHE_VERSION,
23    notFound: '404-v' + CACHE_VERSION,
24    offline: 'offline-v' + CACHE_VERSION,
25};
26
27// Define MAX_TTL's in SECONDS for specific file extensions
28const MAX_TTL = {
29    '/': 3600,
30    html: 3600,
31    json: 86400,
32    js: 86400,
33    css: 86400,
34    png: 86400,
35    jpg: 86400,
36};
37
38const CACHE_STRATEGY = {
39    default: 'cacheFirst',
40    css_js: 'cacheFirst',
41    images: 'cacheFirst',
42    fonts: 'cacheFirst',
43};
44
45const CACHE_BLACKLIST =  [
46//    (str) => {
47//        return !str.includes('/wp-admin/') || !str.startsWith('https://szs.org.pl//wp-admin/');
48//    },
49];
50const neverCacheUrls = [/\/wp-admin/,/\/wp-login/,/preview=true/,/\/cart/,/ajax/,/login/,];
51
52
53const SUPPORTED_METHODS = [
54    'GET',
55];
56// Check if current url is in the neverCacheUrls list
57function pwaForWpcheckNeverCacheList(url) {
58    if ( this.match(url) ) {
59        return false;
60    }
61    return true;
62}
63/**
64 * pwaForWpisBlackListed
65 * @param {string} url
66 * @returns {boolean}
67 */
68function pwaForWpisBlackListed(url) {
69    return (CACHE_BLACKLIST.length > 0) ? !CACHE_BLACKLIST.filter((rule) => {
70        if(typeof rule === 'function') {
71            return !rule(url);
72        } else {
73            return false;
74        }
75    }).length : false
76}
77
78/**
79 * pwaForWpgetFileExtension
80 * @param {string} url
81 * @returns {string}
82 */
83function pwaForWpgetFileExtension(url) {
84    
85    if (typeof url === 'string') {
86     
87        let split_two = url.split('?');
88        let split_url = split_two[0];
89
90        let extension = split_url.split('.').reverse()[0].split('?')[0];		
91        return (extension.endsWith('/')) ? '/' : extension;
92        
93    }else{
94        return null;
95    }            
96}
97/**
98 * pwaForWpgetTTL
99 * @param {string} url
100 */
101function pwaForWpgetTTL(url) {
102    if (typeof url === 'string') {
103        let extension = pwaForWpgetFileExtension(url);
104        if (typeof MAX_TTL[extension] === 'number') {
105            return MAX_TTL[extension];
106        } else {
107            return MAX_TTL["/"];
108        }
109    } else {
110        return MAX_TTL["/"];
111    }
112}
113
114/**
115 * pwaForWpinstallServiceWorker
116 * @returns {Promise}
117 */
118function pwaForWpinstallServiceWorker() {
119    return Promise.all(
120        [
121            caches.open(CACHE_VERSIONS.content)
122                .then(
123                    (cache) => {
124                        
125                        if(BASE_CACHE_FILES.length >0){
126                        
127                            for (var i = 0; i < BASE_CACHE_FILES.length; i++) {
128                            
129                             pwaForWpprecacheUrl(BASE_CACHE_FILES[i]) 
130                       
131                            }
132                            
133                        }
134                        
135                        //return cache.addAll(BASE_CACHE_FILES);
136                    }
137                ),
138            caches.open(CACHE_VERSIONS.offline)
139                .then(
140                    (cache) => {
141                        return cache.addAll(OFFLINE_CACHE_FILES);
142                    }
143                ),
144            caches.open(CACHE_VERSIONS.notFound)
145                .then(
146                    (cache) => {
147                        return cache.addAll(NOT_FOUND_CACHE_FILES);
148                    }
149                )
150        ]
151    )
152        .then(() => {
153            return self.skipWaiting();
154        });
155}
156
157/**
158 * pwaForWpcleanupLegacyCache
159 * @returns {Promise}
160 */
161function pwaForWpcleanupLegacyCache() {
162
163    let currentCaches = Object.keys(CACHE_VERSIONS)
164        .map(
165            (key) => {
166                return CACHE_VERSIONS[key];
167            }
168        );
169
170    return new Promise(
171        (resolve, reject) => {
172
173            caches.keys()
174                .then(
175                    (keys) => {
176                        return legacyKeys = keys.filter(
177                            (key) => {
178                                return !~currentCaches.indexOf(key);
179                            }
180                        );
181                    }
182                )
183                .then(
184                    (legacy) => {
185                        if (legacy.length) {
186                            Promise.all(
187                                legacy.map(
188                                    (legacyKey) => {
189                                        return caches.delete(legacyKey)
190                                    }
191                                )
192                            )
193                                .then(
194                                    () => {
195                                        resolve()
196                                    }
197                                )
198                                .catch(
199                                    (err) => {
200                                        reject(err);
201                                    }
202                                );
203                        } else {
204                            resolve();
205                        }
206                    }
207                )
208                .catch(
209                    () => {
210                        reject();
211                    }
212                );
213
214        }
215    );
216}
217
218function pwaForWpprecacheUrl(url) {
219
220    if(!pwaForWpisBlackListed(url)) {
221        caches.open(CACHE_VERSIONS.content)
222            .then((cache) => {
223                cache.match(url)
224                    .then((response) => {
225                        if(!response) {
226                            return fetch(url)
227                        } else {
228                            // already in cache, nothing to do.
229                            return null
230                        }
231                    })
232                    .then((response) => {
233                        if(response) {						                                                     
234                             fetch(url).then(dataWrappedByPromise => dataWrappedByPromise.text())									
235                             .then(data => {
236							 if(data){
237                                const regex = /<img[^>]+src="(https:\/\/[^">]+)"/g;
238                                let m;
239                                while ((m = regex.exec(data)) !== null) {
240                                    if (m.index === regex.lastIndex) {
241                                            regex.lastIndex++;
242                                    }
243                                    m.forEach((match, groupIndex) => {
244                                            if(groupIndex == 1){
245                                                if(new URL(match).origin == location.origin){
246                                                    fetch(match).
247                                                            then((imagedata) => {
248                                                                    //console.log(imagedata);
249                                                                    cache.put(match, imagedata.clone());
250
251                                                    });
252                                                }
253                                            }
254                                    });
255                                }
256
257
258                            }
259
260
261					});
262											                                                                                						
263                            return cache.put(url, response.clone());
264                        } else {
265                            return null;
266                        }
267                    });
268            })
269    }
270}
271
272var fetchRengeData = function(event){
273    var pos = Number(/^bytes\=(\d+)\-$/g.exec(event.request.headers.get('range'))[1]);
274            console.log('Range request for', event.request.url, ', starting position:', pos);
275            event.respondWith(
276              caches.open(CACHE_VERSIONS.content)
277              .then(function(cache) {
278                return cache.match(event.request.url);
279              }).then(function(res) {
280                if (!res) {
281                  return fetch(event.request)
282                  .then(res => {
283                    return res.arrayBuffer();
284                  });
285                }
286                return res.arrayBuffer();
287              }).then(function(ab) {
288                return new Response(
289                  ab.slice(pos),
290                  {
291                    status: 206,
292                    statusText: 'Partial Content',
293                    headers: [
294                      // ['Content-Type', 'video/webm'],
295                      ['Content-Range', 'bytes ' + pos + '-' +
296                        (ab.byteLength - 1) + '/' + ab.byteLength]]
297                  });
298              }));
299}
300
301let cachingStrategy = {
302        notGetMethods: function(event){
303            // If non-GET request, try the network first, fall back to the offline page
304            if (event.request.method !== 'GET') {
305                event.respondWith(
306                    fetch(event.request)
307                        .catch(error => {
308                            return caches.match(offlinePage);
309                        })
310                );
311                return false;
312            }
313        },
314
315        fetchFromCache: function(event){
316           /* return new Promise(
317                            (resolve) => {*/
318                return caches.open(CACHE_VERSIONS.content)
319                    .then(
320                        (cache) => {
321
322                            return cache.match(event.request)
323                                .then(
324                                    (response) => {
325
326                                        if (response) {
327
328                                            let headers = response.headers.entries();
329                                            let date = null;
330
331                                            for (let pair of headers) {
332                                                if (pair[0] === 'date') {
333                                                    date = new Date(pair[1]);
334                                                }
335                                            }
336
337                                            if (date) {
338                                                let age = parseInt((new Date().getTime() - date.getTime())/1000);
339                                                let ttl = pwaForWpgetTTL(event.request.url);
340
341                                                if (age > ttl) {
342
343                                                    return new Promise(
344                                                        (resolve) => {
345
346                                                            return fetch(event.request.clone())
347                                                                .then(
348                                                                    (updatedResponse) => {
349                                                                        if (updatedResponse) {
350                                                                            cache.put(event.request, updatedResponse.clone());
351                                                                            resolve(updatedResponse);
352                                                                        } else {
353                                                                            resolve(response)
354                                                                        }
355                                                                    }
356                                                                )
357                                                                .catch(
358                                                                    () => {
359                                                                        resolve(response);
360                                                                    }
361                                                                );
362
363                                                        }
364                                                    )
365                                                        .catch(
366                                                            (err) => {
367                                                                return response;
368                                                            }
369                                                        );
370                                                } else {
371                                                    return response;
372                                                }
373
374                                            } else {
375                                                return response;
376                                            }
377
378                                        } else {
379                                            return null;
380                                        }
381                                    }
382                                )
383                                .then(
384                                    (response) => {
385                                        if (response) {
386                                            return response;
387                                        } else {
388                                            return fetch(event.request.clone(), {cache: "no-store"})
389                                                .then(
390                                                    (response) => {
391
392                                                        if(response.status < 300) {
393                                                            if (~SUPPORTED_METHODS.indexOf(event.request.method) && !pwaForWpisBlackListed(event.request.url)) {
394                                                                cache.put(event.request, response.clone());
395                                                            }
396                                                                return response;
397                                                        } else {
398                                                            return caches.open(CACHE_VERSIONS.notFound).then((cache) => {
399                                                                return cache.match(NOT_FOUND_PAGE);
400                                                            })
401                                                        }
402                                                    }
403                                                )
404                                                .then((response) => {
405                                                    if(response) {
406                                                        return response;
407                                                    }
408                                                })
409                                                .catch(
410                                                    () => {
411
412                                                        return caches.open(CACHE_VERSIONS.offline)
413                                                            .then(
414                                                                (offlineCache) => {
415                                                                    return offlineCache.match(OFFLINE_PAGE)
416                                                                }
417                                                            )
418
419                                                    }
420                                                );
421                                        }
422                                    }
423                                )
424                                .catch(
425                                    (error) => {
426                                        console.error('  Error in fetch handler:', error);
427                                        throw error;
428                                    }
429                                );
430                        }
431                    )
432            /*})*/
433
434        },
435        fetchnetwork: function(event){
436            return caches.open(CACHE_VERSIONS.content)
437                    .then(
438                        (cache) => {
439                           return fetch(event.request.clone()).then(function (response) {
440
441                                if(response.status < 300) {
442                                    if (~SUPPORTED_METHODS.indexOf(event.request.method) && !pwaForWpisBlackListed(event.request.url)) {
443                                        cache.put(event.request, response.clone());
444                                    }
445                                        return response;
446                                }else if(response.status==404){
447                                    return cachingStrategy.Notfoundpage();
448                                } else if( cache.match(event.request) ){
449                                    return cache.match(event.request);
450                                }else {
451                                    return cachingStrategy.Offlinepage();
452                                }
453                              }).catch(
454                                   (err) => {
455                                        return cache.match(event.request)
456                                    }
457                              ).catch(
458                                (err) => {
459                                        return cachingStrategy.Offlinepage();
460                                    }
461                              )
462                        }
463                    ).catch(
464                           (err) => {
465                                return cachingStrategy.Offlinepage();
466                            }
467                      )
468        },
469        addCache: function(event,updatedResponse){
470            cache.put(event.request, updatedResponse.clone());
471             resolve(updatedResponse);
472        },
473        Offlinepage: function(){
474            return caches.open(CACHE_VERSIONS.offline).then((cache) => {
475                return cache.match(OFFLINE_PAGE);
476            })
477        },
478        Notfoundpage: function(){
479            return caches.open(CACHE_VERSIONS.notFound).then((cache) => {
480                return cache.match(NOT_FOUND_PAGE);
481            })
482        },
483        /*Strategies*/
484        networkOnlyStrategy: function(event){
485            return caches.open(CACHE_VERSIONS.content)
486                    .then(
487                        (cache) => {
488                           return fetch(event.request.clone()).then(function (response) {
489                                if(response.status < 300) {
490                                    if (~SUPPORTED_METHODS.indexOf(event.request.method) && !pwaForWpisBlackListed(event.request.url)) {
491                                        cache.put(event.request, response.clone());
492                                    }
493                                    return response;
494                                }else if(response.status==404){
495                                    return cachingStrategy.Notfoundpage();
496                                } else if(cache.match(event.request)){
497                                    return cache.match(event.request)
498                                } else {
499                                    return cachingStrategy.Offlinepage();
500                                }
501                              }).catch(
502                                (err) => {
503                                        return cachingStrategy.Offlinepage();
504                                    }
505                              )
506                        }
507                    ).catch(
508                        (err) => {
509                           return cachingStrategy.Offlinepage()
510                        }
511                    );
512        },
513        cacheFirstStrategy: function(events){
514            return cachingStrategy.fetchFromCache(events).catch(
515                        (err) => {
516                           return cachingStrategy.Offlinepage()
517                        }
518                    );
519        },
520        NeworkFirstStrategy: function(events){
521            return cachingStrategy.fetchnetwork(events).catch(
522                        (err) => {
523                            return cachingStrategy.fetchFromCache(events)
524                        }
525                    ).catch(
526                        (err) => {
527                           return cachingStrategy.Offlinepage()
528                        }
529                    );
530        }
531
532
533}
534
535
536self.addEventListener(
537    'install', event => {
538        event.waitUntil(
539            Promise.all([
540                pwaForWpinstallServiceWorker(),
541                self.skipWaiting(),
542            ])
543        );
544    }
545);
546
547// The activate handler takes care of cleaning up old caches.
548self.addEventListener(
549    'activate', event => {
550        event.waitUntil(
551            Promise.all(
552                [
553                    pwaForWpcleanupLegacyCache(),
554                    self.clients.claim(),
555                    self.skipWaiting(),
556                ]
557            )
558                .catch(
559                    (err) => {
560                        self.skipWaiting();
561                    }
562                )
563        );
564    }
565);
566self.addEventListener('online', event => {
567    if (navigator.onLine && navigator.standalone === true) {
568        isReachable(event.request.url).then(function(online) {
569          if (online) {
570            //handle online status
571            caches.delete(event.request.url);
572            console.log('online');
573          } else {
574            console.log('no connectivity');
575          }
576        });
577    } else {
578        //handle offline status
579        console.log('offline');
580    }
581});
582
583function isReachable(url) {
584  /**
585   * Note: fetch() still "succeeds" for 404s on subdirectories,
586   * which is ok when only testing for domain reachability.
587   */
588  return fetch(url, { method: 'HEAD', mode: 'no-cors' })
589    .then(function(resp) {
590      return resp && (resp.ok || resp.type === 'opaque');
591    })
592    .catch(function(err) {
593      console.warn('[conn test failure]:', err);
594    });
595}
596
597self.addEventListener(
598    'fetch', event => {
599        // Return if the current request url is in the never cache list
600        if ( ! neverCacheUrls.every(pwaForWpcheckNeverCacheList, event.request.url) ) {
601           //console.log( 'PWA ServiceWorker: URL exists in excluded list of cache.' + event.request.url);
602          return;
603        }
604        if(! neverCacheUrls.every(pwaForWpcheckNeverCacheList, event.request.referrer) ){
605           //console.log( 'PWA ServiceWorker: Ref-URL exists in excluded list of cache.' + event.request.referrer);
606            return;
607        }
608        if(pwaForWpisBlackListed(event.request.url)){
609            return;   
610        }
611        
612        // Return if request url protocal isn't http or https
613        if ( ! event.request.url.match(/^(http|https):\/\//i) )
614            return;
615        if ( event.request.referrer.match(/^(wp-admin):\/\//i) )
616            return;
617                       
618        if ( new URL(event.request.url).origin !== location.origin )
619                            return;
620
621        if(event.request.method !== 'GET' ){
622            event.respondWith(
623                fetch(event.request)
624                    .catch(error => {
625                        return caches.open(CACHE_VERSIONS.offline).then(function(cache) {
626                                        return cache.match(OFFLINE_PAGE);
627                                      });
628                    })
629            );
630            return false;
631        }
632        const destination = event.request.destination;
633        switch (destination) {
634            case 'style':
635            case 'script':
636              cachingStrategyType = CACHE_STRATEGY.css_js;
637              break;
638            case 'document':
639              cachingStrategyType = CACHE_STRATEGY.default
640              break;
641            case 'image': 
642                cachingStrategyType = CACHE_STRATEGY.images;
643              break;
644            case 'font': 
645                cachingStrategyType = CACHE_STRATEGY.fonts;
646            break;
647            // All `XMLHttpRequest` or `fetch()` calls where
648            // `Request.destination` is the empty string default value
649            default: 
650              cachingStrategyType = CACHE_STRATEGY.default
651        }
652        var cache = null;
653        switch(cachingStrategyType){
654            case "networkFirst":
655               cache = cachingStrategy.NeworkFirstStrategy(event)
656            break;
657            case "networkOnly":
658               cache = cachingStrategy.networkOnlyStrategy(event)
659            break;
660            //break;
661            case "cacheFirst":
662            case "staleWhileRevalidate": 
663            default:
664               cache = cachingStrategy.cacheFirstStrategy(event)
665            break;
666        }
667        event.respondWith(cache);
668
669    }
670);
671
672
673self.addEventListener('message', (event) => {
674
675    if(
676        typeof event.data === 'object' &&
677        typeof event.data.action === 'string'
678    ) {
679        switch(event.data.action) {
680            case 'cache' :               
681                pwaForWpprecacheUrl(event.data.url);
682                break;
683            
684            default :
685                console.log('Unknown action: ' + event.data.action);
686                break;
687        }
688    }
689
690});
691
692

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.