3.0.64

.gitlab-ci.yml

@@ -1,128 +0,0 @@
-# gitzone ci_default
-image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-
-cache:
-  paths:
-    - .npmci_cache/
-  key: '$CI_BUILD_STAGE'
-
-stages:
-  - security
-  - test
-  - release
-  - metadata
-
-before_script:
-  - pnpm install -g pnpm
-  - pnpm install -g @shipzone/npmci
-  - npmci npm prepare
-
-# ====================
-# security stage
-# ====================
-# ====================
-# security stage
-# ====================
-auditProductionDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-     - npmci command npm config set registry https://registry.npmjs.org
-     - npmci command pnpm audit --audit-level=high --prod
-  tags:
-    - lossless
-    - docker
-  allow_failure: true
-
-auditDevDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command pnpm audit --audit-level=high --dev
-  tags:
-    - lossless
-    - docker
-  allow_failure: true
-
-# ====================
-# test stage
-# ====================
-
-testStable:
-  stage: test
-  script:
-    - npmci node install stable
-    - npmci npm install
-    - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-testBuild:
-  stage: test
-  script:
-    - npmci node install stable
-    - npmci npm install
-    - npmci npm build
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-release:
-  stage: release
-  script:
-    - npmci node install stable
-    - npmci npm publish
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  allow_failure: true
-  only:
-    - tags
-  script:
-    - npmci command npm install -g typescript
-    - npmci npm prepare
-    - npmci npm install
-  tags:
-    - lossless
-    - docker
-    - priv
-
-trigger:
-  stage: metadata
-  script:
-    - npmci trigger
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-pages:
-  stage: metadata
-  script:
-    - npmci node install stable
-    - npmci npm install
-    - npmci command npm run buildDocs
-  tags:
-    - lossless
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-      - public
-  allow_failure: true

changelog.md

@@ -0,0 +1,267 @@
+# Changelog
+
+## 2025-02-04 - 3.0.64 - fix(serviceworker)
+Improve cache handling and response header management in service worker.
+
+- Addressed issue preventing caching of certain responses due to missing CORS headers.
+- Added 'Vary: Origin' header to ensure proper response handling.
+- Included 'Access-Control-Expose-Headers' for better CORS support.
+
+## 2025-02-04 - 3.0.63 - fix(core)
+Refactored caching strategy for service worker to improve compatibility and performance.
+
+- Removed hard and soft caching distinctions.
+- Simplified cache setup process.
+- Improved browser caching control headers.
+
+## 2025-02-04 - 3.0.62 - fix(Service Worker)
+Refactor and clean up the cache logic in the Service Worker to improve maintainability and handle Safari-specific cache behavior.
+
+- Refactored logic for determining cached domains, enhancing the readability and maintainability of the code.
+- Improved handling of CORS settings in caching requests, notably bypassing caching for soft cached domains in Safari to avoid CORS issues.
+- Enhanced error response creation for failed resource fetching, maintaining clarity on why and how certain resources were not fetched or cached.
+- Revised the structure of the caching logic to ensure consistent behavior across all supported browsers.
+
+## 2025-02-04 - 3.0.61 - fix(ServiceWorkerCacheManager)
+Fixed caching mechanism to better support Safari's handling of soft-cached domains.
+
+- Added logic to differentiate between hard and soft cached domains.
+- Implemented special handling for soft cached domains on Safari by bypassing caching.
+- Ensured appropriate CORS headers are present in cached responses.
+- Improved error handling with informative 500 error responses.
+- Optimized caching logic to prevent redundant caching and potential issues with locked streams on Safari.
+
+## 2025-02-04 - 3.0.61 - fix(ServiceWorkerCacheManager)
+Fixed caching mechanism to better support Safari's handling of soft-cached domains.
+
+- Added logic to differentiate between hard and soft cached domains.
+- Implemented special handling for soft cached domains on Safari by bypassing caching.
+- Ensured appropriate CORS headers are present in cached responses.
+- Improved error handling with informative 500 error responses.
+- Optimized caching logic to prevent redundant caching and potential issues with locked streams on Safari.
+
+## 2025-02-04 - 3.0.61 - fix(ServiceWorkerCacheManager)
+Fixed caching mechanism to better support Safari's handling of soft-cached domains.
+
+- Added logic to differentiate between hard and soft cached domains.
+- Implemented special handling for soft cached domains on Safari by bypassing caching.
+- Ensured appropriate CORS headers are present in cached responses.
+- Improved error handling with informative 500 error responses.
+- Optimized caching logic to prevent redundant caching and potential issues with locked streams on Safari.
+
+## 2025-02-04 - 3.0.60 - fix(cachemanager)
+Improve cache management and error handling
+
+- Updated comments for clarity and consistency.
+- Enhanced error handling in `fetch` event listener.
+- Optimized cache key management and cleanup process.
+- Ensured CORS headers are set for cached responses.
+- Improved logging for caching operations.
+
+## 2025-02-03 - 3.0.59 - fix(serviceworker)
+Fixed CORS and Cache Control handling for Service Worker
+
+- Improved handling of CORS settings for external requests.
+- Preserved important headers while excluding caching headers.
+- Ensured the presence of CORS headers in cached responses.
+- Adjusted Cache-Control headers to prevent browser caching but allow service worker caching.
+
+## 2025-02-03 - 3.0.58 - fix(network-manager)
+Refined network management logic for better offline handling.
+
+- Improved logic to handle missing connections more gracefully.
+- Added detailed online/offline connection status logging.
+- Implemented a check for stale cache with a grace period for offline scenarios.
+- Network requests now use optimized retries and timeouts.
+
+## 2025-02-03 - 3.0.57 - fix(updateManager)
+Refine cache management for service worker updates.
+
+- Ensured cache is forcibly updated if older than defined maximum age.
+- Implemented interval checks and forced updates for cache staleness.
+- Updated version information and cache timestamps upon forced updates or validations.
+
+## 2025-02-03 - 3.0.56 - fix(cachemanager)
+Adjust cache control headers and fix redundant code
+
+- Remove duplicate assetbroker URLs in the cache evaluation logic.
+- Update cache control headers to improve caching behavior.
+- Increase the timeout for fetch operations to improve compatibility.
+
+## 2025-01-28 - 3.0.55 - fix(server)
+Fix response content manipulation for HTML files with injectReload
+
+- Moved fileString declaration inside HTML file handling block to prevent unnecessary string conversion for non-HTML files.
+- Corrected responseContent assignment to ensure modified HTML strings are converted back to Buffer format.
+
+## 2025-01-28 - 3.0.54 - fix(servertools)
+Fixed an issue with compression results handling in HandlerStatic where content was always being written even if not compressed.
+
+- Corrected the double writing of response in HandlerStatic.
+- Ensured that file buffers are only conditionally written based on compression availability.
+
+## 2024-12-26 - 3.0.53 - fix(infohtml)
+Remove Sentry script and logo from HTML template
+
+- Removed Sentry script from the HTML template.
+- Removed Lossless GmbH logo and contact info.
+- Updated footer link to point to foss.global.
+
+## 2024-12-25 - 3.0.52 - fix(dependencies)
+Bump package versions in dependencies and exports.
+
+- Updated package dependencies to their latest versions.
+- Added './infohtml' in package exports.
+
+## 2024-08-27 - 3.0.51 - fix(core)
+Update dependencies and fix service worker cache manager and task manager functionalities
+
+- Updated dependencies in package.json to their latest versions
+- Enhanced service worker cache manager to include additional scoped URLs
+- Fixed task manager to start the task manager and added update task functionality
+- Removed .gitlab-ci.yml from the repository as part of the cleanup
+
+## 2024-05-25 - 3.0.43 to 3.0.50 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.43 to 3.0.50
+
+## 2024-05-23 - 3.0.37 to 3.0.42 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.37 to 3.0.42
+
+## 2024-05-17 - 3.0.37 - Core
+Routine update and bug fix
+
+- Updated core functionalities
+
+## 2024-05-14 - 3.0.33 to 3.0.36 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.33 to 3.0.36
+
+## 2024-05-13 - 3.0.31 to 3.0.32 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.31 to 3.0.32
+
+## 2024-05-11 - 3.0.29 to 3.0.31 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.29 to 3.0.31
+
+## 2024-04-19 - 3.0.27 to 3.0.28 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.27 to 3.0.28
+
+## 2024-04-14 - 3.0.27 - Documentation
+Updated Documentation
+
+- Improved and updated documentation
+
+## 2024-03-01 - 3.0.25 to 3.0.26 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.25 to 3.0.26
+
+## 2024-02-21 - 3.0.20 to 3.0.24 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.20 to 3.0.24
+
+## 2024-01-19 - 3.0.19 to 3.0.20 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.19 to 3.0.20
+
+## 2024-01-09 - 3.0.14 to 3.0.18 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.14 to 3.0.18
+
+## 2024-01-08 - 3.0.11 to 3.0.13 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.11 to 3.0.13
+
+## 2024-01-07 - 3.0.9 to 3.0.10 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.9 to 3.0.10
+
+## 2023-11-06 - 3.0.8 to 3.0.9 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.8 to 3.0.9
+
+## 2023-10-23 - 3.0.6 to 3.0.7 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.6 to 3.0.7
+
+## 2023-10-20 - 3.0.5 to 3.0.6 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.5 to 3.0.6
+
+## 2023-09-21 - 3.0.4 to 3.0.5 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.4 to 3.0.5
+
+## 2023-08-06 - 3.0.2 to 3.0.3 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.2 to 3.0.3
+
+## 2023-08-03 - 3.0.1 to 3.0.0 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 3.0.1 to 3.0.0
+
+## 2023-08-03 - 2.0.65 - Core
+Breaking change in core update
+
+- Introduced breaking changes updating core functionalities
+
+## 2023-07-02 - 2.0.59 to 2.0.64 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.59 to 2.0.64
+
+## 2023-07-01 - 2.0.54 to 2.0.58 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.54 to 2.0.58
+
+## 2023-06-12 - 2.0.53 - Core
+Routine update and bug fix
+
+- Updated core functionalities
+
+## 2023-04-10 - 2.0.52 to 2.0.53 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.52 to 2.0.53
+
+## 2023-04-04 - 2.0.49 to 2.0.51 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.49 to 2.0.51
+
+## 2023-03-31 - 2.0.45 to 2.0.48 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.45 to 2.0.48
+
+## 2023-03-30 - 2.0.37 to 2.0.44 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.37 to 2.0.44
+
+## 2023-03-29 - 2.0.33 to 2.0.36 - Core
+Routine updates and bug fixes
+
+- Updated core functionalities for better performance and stability in versions 2.0.33 to 2.0.36

package.json

@@ -1,15 +1,16 @@
 {
   "name": "@api.global/typedserver",
-  "version": "3.0.38",
+  "version": "3.0.64",
   "description": "A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.",
   "type": "module",
   "exports": {
     ".": "./dist_ts/index.js",
-    "./ts": "./dist_ts/index.js",
-    "./ts_edgeworker": "./dist_ts_edgeworker",
-    "./ts_web_inject": "./dist_ts_web_inject/index.js",
-    "./ts_web_serviceworker": "./dist_ts_web_serviceworker",
-    "./ts_web_serviceworker_client": "./dist_ts_web_serviceworker_client"
+    "./infohtml": "./dist_ts/infohtml/index.js",
+    "./backend": "./dist_ts/index.js",
+    "./edgeworker": "./dist_ts_edgeworker/index.js",
+    "./web_inject": "./dist_ts_web_inject/index.js",
+    "./web_serviceworker": "./dist_ts_web_serviceworker/index.js",
+    "./web_serviceworker_client": "./dist_ts_web_serviceworker_client/index.js"
   },
   "scripts": {
     "test": "npm run build && tstest test/",
@@ -57,51 +58,51 @@
   ],
   "homepage": "https://github.com/pushrocks/easyserve",
   "dependencies": {
-    "@api.global/typedrequest": "^3.0.23",
+    "@api.global/typedrequest": "^3.1.10",
     "@api.global/typedrequest-interfaces": "^3.0.19",
     "@api.global/typedsocket": "^3.0.1",
-    "@cloudflare/workers-types": "^4.20240512.0",
-    "@design.estate/dees-comms": "^1.0.24",
-    "@push.rocks/lik": "^6.0.15",
+    "@cloudflare/workers-types": "^4.20241224.0",
+    "@design.estate/dees-comms": "^1.0.27",
+    "@push.rocks/lik": "^6.1.0",
     "@push.rocks/smartchok": "^1.0.34",
     "@push.rocks/smartdelay": "^3.0.5",
     "@push.rocks/smartenv": "^5.0.12",
     "@push.rocks/smartfeed": "^1.0.11",
-    "@push.rocks/smartfile": "^11.0.14",
-    "@push.rocks/smartjson": "^5.0.19",
-    "@push.rocks/smartlog": "^3.0.3",
-    "@push.rocks/smartlog-destination-devtools": "^1.0.10",
-    "@push.rocks/smartlog-interfaces": "^3.0.0",
+    "@push.rocks/smartfile": "^11.0.23",
+    "@push.rocks/smartjson": "^5.0.20",
+    "@push.rocks/smartlog": "^3.0.7",
+    "@push.rocks/smartlog-destination-devtools": "^1.0.12",
+    "@push.rocks/smartlog-interfaces": "^3.0.2",
     "@push.rocks/smartmanifest": "^2.0.2",
     "@push.rocks/smartmatch": "^2.0.0",
-    "@push.rocks/smartmime": "^1.0.5",
-    "@push.rocks/smartntml": "^2.0.4",
+    "@push.rocks/smartmime": "^2.0.4",
+    "@push.rocks/smartntml": "^2.0.8",
     "@push.rocks/smartopen": "^2.0.0",
     "@push.rocks/smartpath": "^5.0.18",
-    "@push.rocks/smartpromise": "^4.0.2",
-    "@push.rocks/smartrequest": "^2.0.22",
+    "@push.rocks/smartpromise": "^4.0.4",
+    "@push.rocks/smartrequest": "^2.0.23",
     "@push.rocks/smartrx": "^3.0.7",
     "@push.rocks/smartsitemap": "^2.0.3",
-    "@push.rocks/smartstream": "^3.0.35",
-    "@push.rocks/smarttime": "^4.0.6",
+    "@push.rocks/smartstream": "^3.2.5",
+    "@push.rocks/smarttime": "^4.1.1",
     "@push.rocks/taskbuffer": "^3.1.7",
     "@push.rocks/webrequest": "^3.0.37",
-    "@push.rocks/webstore": "^2.0.14",
-    "@tsclass/tsclass": "^4.0.54",
+    "@push.rocks/webstore": "^2.0.20",
+    "@tsclass/tsclass": "^4.2.0",
     "@types/express": "^4.17.21",
-    "body-parser": "^1.20.2",
+    "body-parser": "^1.20.3",
     "cors": "^2.8.5",
-    "express": "^4.19.2",
+    "express": "^4.21.2",
     "express-force-ssl": "^0.3.2",
-    "lit": "^3.1.3"
+    "lit": "^3.2.1"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.76",
-    "@git.zone/tsbundle": "^2.0.15",
-    "@git.zone/tsrun": "^1.2.44",
+    "@git.zone/tsbuild": "^2.2.0",
+    "@git.zone/tsbundle": "^2.1.0",
+    "@git.zone/tsrun": "^1.3.3",
     "@git.zone/tstest": "^1.0.90",
-    "@push.rocks/tapbundle": "^5.0.23",
-    "@types/node": "^20.12.11"
+    "@push.rocks/tapbundle": "^5.5.3",
+    "@types/node": "^22.10.2"
   },
   "private": false,
   "browserslist": [

ts/00_commitinfo_data.ts

@@ -1,8 +1,8 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
   name: '@api.global/typedserver',
-  version: '3.0.38',
+  version: '3.0.64',
   description: 'A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.'
 }

ts/classes.typedserver.ts

@@ -135,8 +135,8 @@ export class TypedServer {
         '/*',
         new servertools.HandlerStatic(this.options.serveDir, {
           responseModifier: async (responseArg) => {
-            let fileString = responseArg.responseContent.toString();
             if (plugins.path.parse(responseArg.path).ext === '.html') {
+              let fileString = responseArg.responseContent.toString();
               const fileStringArray = fileString.split('<head>');
               if (this.options.injectReload && fileStringArray.length === 2) {
                 fileStringArray[0] = `${fileStringArray[0]}<head>
@@ -152,6 +152,7 @@ export class TypedServer {
                 `;
                 fileString = fileStringArray.join('');
                 console.log('injected typedserver script.');
+                responseArg.responseContent = Buffer.from(fileString);
               } else if (this.options.injectReload) {
                 console.log('Could not insert typedserver script');
               }
@@ -164,7 +165,7 @@ export class TypedServer {
             return {
               headers,
               path: responseArg.path,
-              responseContent: Buffer.from(fileString),
+              responseContent: responseArg.responseContent,
             };
           },
           serveIndexHtmlDefault: true,

ts/infohtml/template.ts

@@ -96,26 +96,9 @@ export const simpleInfo = async (
           name="viewport"
           content="user-scalable=no, initial-scale=1, maximum-scale=1, minimum-scale=1, width=device-width, height=device-height, target-densitydpi=device-dpi"
         />
-        <script
-          src="https://browser.sentry-cdn.com/5.4.0/bundle.min.js"
-          crossorigin="anonymous"
-        ></script>
-        <script>
-          if (optionsArg.sentryDsn && optionsArg.sentryMessage) {
-            Sentry.init({
-              dsn: '${optionsArg.sentryDsn}',
-              // ...
-            });
-            Sentry.setExtra('location', window.location.href);
-            Sentry.captureMessage('${optionsArg.sentryMessage} @ ' + window.location.host);
-          }
-        </script>
         <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
       </head>
       <body>
-        <div class="logo">
-          <img src="https://assetbroker.lossless.one/brandfiles/lossless/svg-minimal-bright.svg" />
-        </div>
         <div class="content">
           ${(() => {
             const returnArray: plugins.smartntml.deesElement.TemplateResult[] = [];
@@ -129,15 +112,6 @@ export const simpleInfo = async (
             } else {
               returnArray.push(html` <div class="maintext">${optionsArg.text}</div> `);
             }
-            if (optionsArg.sentryDsn && optionsArg.sentryMessage) {
-              returnArray.push(
-                html`<div class="addontext">
-                  We recorded this event. Should you continue to see this page against your
-                  expectations, feel free to mail us at
-                  <a href="mailto:hello@lossless.com">hello@lossless.com</a>
-                </div>`
-              );
-            }
             if (optionsArg.redirectTo) {
               returnArray.push(
                 html`<div class="addontext">
@@ -149,9 +123,7 @@ export const simpleInfo = async (
           })()}
         </div>
         <div class="legal">
-          <a href="https://lossless.com">Lossless GmbH</a> / &copy 2014-${new Date().getFullYear()}
-          / <a href="https://lossless.gmbh">Legal Info</a> /
-          <a href="https://lossless.gmbh">Privacy Policy</a>
+          <a href="https://foss.global">learn more about foss.global</a> / &copy 2014-${new Date().getFullYear()} Task Venture Capital GmbH
         </div>
       </body>
     </html>

ts/servertools/classes.handlerstatic.ts

@@ -134,8 +134,10 @@ export class HandlerStatic extends Handler {
       res.status(200);
       if (compressionResult?.compressionMethod) {
         res.header('Content-Encoding', compressionResult.compressionMethod);
+        res.write(compressionResult.result);
+      } else {
+        res.write(fileBuffer);
       }
-      res.write(compressionResult.result);
       res.end();
     });
   }

ts/servertools/classes.route.ts

@@ -6,7 +6,13 @@ import { type IRoute as IExpressRoute } from 'express';
 
 export class Route {
   public routeString: string;
+
+  /**
+   * an object map of handlers
+   * Why multiple? Because GET, POST, PUT, DELETE, etc. can all have different handlers
+   */
   public handlerObjectMap = new plugins.lik.ObjectMap<Handler>();
+  
   public expressMiddlewareObjectMap = new plugins.lik.ObjectMap<any>();
   public expressRoute: IExpressRoute; // will be set to server route on server start
   constructor(ServerArg: Server, routeStringArg: string) {

ts/servertools/classes.server.ts

@@ -77,6 +77,11 @@ export class Server {
     return route;
   }
 
+  /**
+   * starts the server and sets up the routes
+   * @param portArg
+   * @param doListen
+   */
   public async start(portArg: number | string = this.options.port, doListen = true) {
     const done = plugins.smartpromise.defer();
 

ts/servertools/tools.serviceworker.ts

@@ -38,7 +38,7 @@ export const addServiceWorkerRoute = (
   swVersionInfo = swDataFunc();
 
   // the basic stuff
-  typedserverInstance.server.addRoute('/serviceworker.js*', serviceworkerHandler);
+  typedserverInstance.server.addRoute('/serviceworker.*', serviceworkerHandler);
 
   // the typed stuff
   const typedrouter = new plugins.typedrequest.TypedRouter();

ts/utilityservers/classes.serviceserver.ts

@@ -11,7 +11,7 @@ export interface ILoleServiceServerConstructorOptions {
 }
 
 // the main service server
-export class ServiceServer {
+export class UtilityServiceServer {
   public options: ILoleServiceServerConstructorOptions;
   public typedServer: TypedServer;
 

ts_web_serviceworker/classes.cachemanager.ts

@@ -0,0 +1,230 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './env.js';
+import { logger } from './logging.js';
+import { ServiceWorker } from './classes.serviceworker.js';
+
+export class CacheManager {
+  public losslessServiceWorkerRef: ServiceWorker;
+
+  public usedCacheNames = {
+    runtimeCacheName: 'runtime'
+  };
+
+  constructor(losslessServiceWorkerRefArg: ServiceWorker) {
+    this.losslessServiceWorkerRef = losslessServiceWorkerRefArg;
+    this._setupCache();
+  }
+
+  private _setupCache = () => {
+    const createMatchRequest = (requestArg: Request): Request => {
+      // Create a matchRequest based on whether the request is internal or external.
+      let matchRequest: Request;
+      if (requestArg.url.startsWith(this.losslessServiceWorkerRef.serviceWindowRef.location.origin)) {
+        // Internal request; use the original.
+        matchRequest = requestArg;
+      } else {
+        // External request; create a new Request with appropriate CORS settings.
+        matchRequest = new Request(requestArg.url, {
+          method: requestArg.method,
+          headers: requestArg.headers,
+          mode: 'cors',
+          credentials: 'same-origin',
+          redirect: 'follow'
+        });
+      }
+      return matchRequest;
+    };
+
+    /**
+     * Creates a 500 error response.
+     */
+    const create500Response = async (requestArg: Request, responseArg: Response): Promise<Response> => {
+      return new Response(
+        `
+        <html>
+          <head>
+            <style>
+              .note {
+                padding: 10px;
+                color: #fff;
+                background: #000;
+                border-bottom: 1px solid #e4002b;
+                margin-bottom: 20px;
+              }
+            </style>
+          </head>
+          <body>
+            <div class="note">
+              <strong>serviceworker running, but status 500</strong><br>
+            </div>
+            serviceworker is unable to fetch this request<br>
+            Here is some info about the request/response pair:<br>
+            <br>
+            requestUrl: ${requestArg.url}<br>
+            responseType: ${responseArg.type}<br>
+            responseBody: ${await responseArg.clone().text()}<br>
+          </body>
+        </html>
+      `,
+        {
+          headers: {
+            "Content-Type": "text/html"
+          },
+          status: 500
+        }
+      );
+    };
+
+    // Listen for fetch events.
+    this.losslessServiceWorkerRef.serviceWindowRef.addEventListener('fetch', async (fetchEventArg: any) => {
+      // Block specific scopes.
+      const originalRequest: Request = fetchEventArg.request;
+      const parsedUrl = new URL(originalRequest.url);
+      if (
+        parsedUrl.hostname.includes('paddle.com') ||
+        parsedUrl.hostname.includes('paypal.com') ||
+        parsedUrl.hostname.includes('reception.lossless.one') ||
+        parsedUrl.pathname.startsWith('/socket.io') ||
+        originalRequest.url.startsWith('https://umami.')
+      ) {
+        logger.log('note', `serviceworker not active for ${parsedUrl.toString()}`);
+        return;
+      }
+
+      // Create a deferred response.
+      const done = plugins.smartpromise.defer<Response>();
+      fetchEventArg.respondWith(done.promise);
+
+      if (
+        (originalRequest.method === 'GET' &&
+         (originalRequest.url.startsWith(this.losslessServiceWorkerRef.serviceWindowRef.location.origin) &&
+          !originalRequest.url.includes('/api/') &&
+          !originalRequest.url.includes('smartserve/reloadcheck'))) ||
+        originalRequest.url.includes('https://assetbroker.') ||
+        originalRequest.url.includes('https://unpkg.com') ||
+        originalRequest.url.includes('https://fonts.googleapis.com') ||
+        originalRequest.url.includes('https://fonts.gstatic.com')
+      ) {
+        // Check for updates asynchronously.
+        this.losslessServiceWorkerRef.updateManager.checkUpdate(this);
+
+        // Try to serve from cache.
+        const matchRequest = createMatchRequest(originalRequest);
+        const cachedResponse = await caches.match(matchRequest);
+        if (cachedResponse) {
+          logger.log('ok', `CACHED: found cached response for ${matchRequest.url}`);
+          done.resolve(cachedResponse);
+          return;
+        }
+
+        // In case there is no cached response, fetch from the network.
+        logger.log('info', `NOTYETCACHED: trying to cache ${matchRequest.url}`);
+        const newResponse: Response = await fetch(matchRequest).catch(async err => {
+          return await create500Response(matchRequest, new Response(err.message));
+        });
+
+        // If the response status is an error or the response is opaque, do not cache it.
+        if (newResponse.status > 299 || newResponse.type === 'opaque' || (newResponse.headers.get('access-control-allow-origin') === null && !matchRequest.url.startsWith(this.losslessServiceWorkerRef.serviceWindowRef.location.origin))) {
+          logger.log(
+            'error',
+            `NOTCACHED: not caching response for ${matchRequest.url} due to status ${newResponse.status} and type ${newResponse.type}`
+          );
+          // Simply return the network response without caching.
+          done.resolve(newResponse);
+          return;
+        } else {
+          // Cache the response.
+          const cache = await caches.open(this.usedCacheNames.runtimeCacheName);
+          const responseToPutToCache = newResponse.clone();
+          const headers = new Headers();
+          responseToPutToCache.headers.forEach((value, key) => {
+            // Preserve all headers except caching-related ones.
+            if (![
+              'Cache-Control',
+              'cache-control',
+              'Expires',
+              'expires',
+              'Pragma',
+              'pragma'
+            ].includes(key)) {
+              headers.set(key, value);
+            }
+          });
+
+          // Ensure CORS headers are present.
+          if (!headers.has('Access-Control-Allow-Origin')) {
+            headers.set('Access-Control-Allow-Origin', '*');
+          }
+          headers.set('Vary', 'Origin');
+          if (!headers.has('Access-Control-Expose-Headers')) {
+            headers.set('Access-Control-Expose-Headers', '*')
+          }
+          if (!headers.has('Access-Control-Allow-Methods')) {
+            headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+          }
+          if (!headers.has('Access-Control-Allow-Headers')) {
+            headers.set('Access-Control-Allow-Headers', 'Content-Type');
+          }
+          // Prevent browser caching while allowing service worker caching.
+          headers.set('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate');
+          headers.set('Pragma', 'no-cache');
+          headers.set('Expires', '0');
+          headers.set('Surrogate-Control', 'no-store');
+
+          await cache.put(matchRequest, new Response(responseToPutToCache.body, {
+            ...responseToPutToCache,
+            headers
+          }));
+          logger.log('ok', `NOWCACHED: cached response for ${matchRequest.url} for subsequent requests!`);
+          done.resolve(newResponse);
+        }
+      } else {
+        // For remote requests not intended for caching, fetch directly from the origin.
+        logger.log(
+          'ok',
+          `NOTCACHED: not caching any responses for ${originalRequest.url}. Fetching from origin now...`
+        );
+        done.resolve(
+          await fetch(originalRequest).catch(async err => {
+            return await create500Response(originalRequest, new Response(err.message));
+          })
+        );
+      }
+    });
+  }
+
+  /**
+   * Cleans all caches.
+   * Should only be run when a new service worker is activated.
+   */
+  public cleanCaches = async (reasonArg = 'no reason given') => {
+    logger.log('info', `MAJOR CACHEEVENT: cleaning caches now! Reason: ${reasonArg}`);
+    const cacheNames = await caches.keys();
+
+    const deletePromises = cacheNames.map(cacheToDelete => {
+      const deletePromise = caches.delete(cacheToDelete);
+      deletePromise.then(() => {
+        logger.log('ok', `Deleted cache ${cacheToDelete}`);
+      });
+      return deletePromise;
+    });
+    await Promise.all(deletePromises);
+  }
+
+  /**
+   * Revalidates the runtime cache.
+   */
+  public async revalidateCache() {
+    const runtimeCache = await caches.open(this.usedCacheNames.runtimeCacheName);
+    const cacheKeys = await runtimeCache.keys();
+    for (const requestArg of cacheKeys) {
+      // Fetch a new response for comparison.
+      const clonedRequest = requestArg.clone();
+      const response = await plugins.smartpromise.timeoutWrap(fetch(clonedRequest), 5000); // Increased timeout for better mobile compatibility
+      if (response && response.status >= 200 && response.status < 300) {
+        await runtimeCache.delete(requestArg);
+        await runtimeCache.put(requestArg, response);
+      }
+    }
+  }
+}

ts_web_serviceworker/classes.networkmanager.ts

@@ -0,0 +1,127 @@
+import * as plugins from './plugins.js';
+import { ServiceWorker } from './classes.serviceworker.js';
+import { logger } from './logging.js';
+
+export class NetworkManager {
+  public serviceWorkerRef: ServiceWorker;
+  public webRequest: plugins.webrequest.WebRequest;
+  private isOffline: boolean = false;
+  private lastOnlineCheck: number = 0;
+  private readonly ONLINE_CHECK_INTERVAL = 30000; // 30 seconds
+
+  public previousState: string;
+
+  constructor(serviceWorkerRefArg: ServiceWorker) {
+    this.serviceWorkerRef = serviceWorkerRefArg;
+    this.webRequest = new plugins.webrequest.WebRequest();
+    
+    // Listen for connection changes
+    this.getConnection()?.addEventListener('change', () => {
+      this.updateConnectionStatus();
+    });
+
+    // Listen for online/offline events
+    self.addEventListener('online', () => {
+      this.isOffline = false;
+      logger.log('info', 'Device is now online');
+      this.updateConnectionStatus();
+    });
+
+    self.addEventListener('offline', () => {
+      this.isOffline = true;
+      logger.log('warn', 'Device is now offline');
+      this.updateConnectionStatus();
+    });
+  }
+
+  /**
+   * gets the connection
+   */
+  public getConnection() {
+    const navigatorLocal: any = self.navigator;
+    return navigatorLocal?.connection;
+  }
+
+  public getEffectiveType() {
+    return this.getConnection()?.effectiveType || '4g';
+  }
+
+  public updateConnectionStatus() {
+    const currentType = this.getEffectiveType();
+    logger.log('info', `Connection type changed from ${this.previousState} to ${currentType}`);
+    this.previousState = currentType;
+  }
+
+  /**
+   * Checks if the device is currently online by attempting to contact the server
+   * @returns Promise<boolean> true if online, false if offline
+   */
+  public async checkOnlineStatus(): Promise<boolean> {
+    const now = Date.now();
+    // Only check if enough time has passed since last check
+    if (now - this.lastOnlineCheck < this.ONLINE_CHECK_INTERVAL) {
+      return !this.isOffline;
+    }
+
+    try {
+      const response = await fetch('/sw-typedrequest', {
+        method: 'HEAD',
+        cache: 'no-cache'
+      });
+      this.isOffline = false;
+      this.lastOnlineCheck = now;
+      return true;
+    } catch (error) {
+      this.isOffline = true;
+      this.lastOnlineCheck = now;
+      logger.log('warn', 'Device appears to be offline');
+      return false;
+    }
+  }
+
+  /**
+   * Makes a network request with offline handling
+   * @param request The request to make
+   * @param options Additional options
+   * @returns Promise<Response>
+   */
+  public async makeRequest<T>(request: Request | string, options: {
+    timeoutMs?: number;
+    retries?: number;
+    backoffMs?: number;
+  } = {}): Promise<Response> {
+    const {
+      timeoutMs = 5000,
+      retries = 1,
+      backoffMs = 1000
+    } = options;
+
+    let lastError: Error;
+    for (let i = 0; i <= retries; i++) {
+      try {
+        const isOnline = await this.checkOnlineStatus();
+        if (!isOnline) {
+          throw new Error('Device is offline');
+        }
+
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+        const response = await fetch(request, {
+          ...typeof request === 'string' ? {} : request,
+          signal: controller.signal
+        });
+
+        clearTimeout(timeoutId);
+        return response;
+      } catch (error) {
+        lastError = error;
+        if (i < retries) {
+          await new Promise(resolve => setTimeout(resolve, backoffMs * (i + 1)));
+        }
+      }
+    }
+
+    throw lastError;
+  }
+}

ts_web_serviceworker/classes.serviceworker.ts

@@ -2,18 +2,18 @@ import * as plugins from './plugins.js';
 import * as interfaces from './env.js';
 
 // imports
-import { CacheManager } from './serviceworker.classes.cachemanager.js';
+import { CacheManager } from './classes.cachemanager.js';
 import { Deferred } from '@push.rocks/smartpromise';
 
-import { logger } from './serviceworker.logging.js';
+import { logger } from './logging.js';
 
 // imported classes
-import { UpdateManager } from './serviceworker.classes.updatemanager.js';
-import { NetworkManager } from './serviceworker.classes.networkmanager.js';
-import { TaskManager } from './serviceworker.classes.taskmanager.js';
+import { UpdateManager } from './classes.updatemanager.js';
+import { NetworkManager } from './classes.networkmanager.js';
+import { TaskManager } from './classes.taskmanager.js';
 import { ServiceworkerBackend } from './classes.backend.js';
 
-export class LosslessServiceWorker {
+export class ServiceWorker {
   // STATIC
 
   // INSTANCE

ts_web_serviceworker/classes.taskmanager.ts

@@ -0,0 +1,24 @@
+import * as plugins from './plugins.js';
+import { ServiceWorker } from './classes.serviceworker.js';
+
+/**
+ * Taskmanager
+ * should use times allocated by browser
+ */
+export class TaskManager {
+  public serviceworkerRef: ServiceWorker;
+  public taskmanager = new plugins.taskbuffer.TaskManager();
+
+  constructor(serviceWorkerRefArg: ServiceWorker) {
+    this.serviceworkerRef = serviceWorkerRefArg;
+    this.taskmanager.start();
+  }
+
+  public updateTask = new plugins.taskbuffer.Task({
+    name: 'updateTask',
+    taskFunction: async () => {
+      await this.serviceworkerRef.cacheManager.cleanCaches('a new app version has been communicated by the server.');
+    }
+  })
+
+}

ts_web_serviceworker/classes.updatemanager.ts

@@ -0,0 +1,162 @@
+import * as plugins from './plugins.js';
+import * as interfaces from '../dist_ts_interfaces/index.js';
+import { ServiceWorker } from './classes.serviceworker.js';
+import { logger } from './logging.js';
+import { CacheManager } from './classes.cachemanager.js';
+
+export class UpdateManager {
+  public lastUpdateCheck: number = 0;
+  public lastVersionInfo: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'];
+
+  public serviceworkerRef: ServiceWorker;
+
+  constructor(serviceWorkerRefArg: ServiceWorker) {
+    this.serviceworkerRef = serviceWorkerRefArg;
+  }
+
+  /**
+   * checks wether an update is needed
+   */
+  private readonly MAX_CACHE_AGE = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
+  private readonly MIN_CHECK_INTERVAL = 100000; // 100 seconds in milliseconds
+  private readonly OFFLINE_GRACE_PERIOD = 7 * 24 * 60 * 60 * 1000; // 7 days grace period when offline
+  private lastCacheTimestamp: number = 0;
+
+  public async checkUpdate(cacheManager: CacheManager): Promise<boolean> {
+    const lswVersionInfoKey = 'versionInfo';
+    const cacheTimestampKey = 'cacheTimestamp';
+
+    // Initialize or load version info
+    if (!this.lastVersionInfo && !(await this.serviceworkerRef.store.check(lswVersionInfoKey))) {
+      this.lastVersionInfo = {
+        appHash: '',
+        appSemVer: 'v0.0.0',
+      };
+    } else if (!this.lastVersionInfo && (await this.serviceworkerRef.store.check(lswVersionInfoKey))) {
+      this.lastVersionInfo = await this.serviceworkerRef.store.get(lswVersionInfoKey);
+    }
+
+    // Load or initialize cache timestamp
+    if (await this.serviceworkerRef.store.check(cacheTimestampKey)) {
+      this.lastCacheTimestamp = await this.serviceworkerRef.store.get(cacheTimestampKey);
+    }
+
+    const now = Date.now();
+    const millisSinceLastCheck = now - this.lastUpdateCheck;
+    const cacheAge = now - this.lastCacheTimestamp;
+
+    // Check if we need to handle stale cache
+    if (cacheAge > this.MAX_CACHE_AGE) {
+      const isOnline = await this.serviceworkerRef.networkManager.checkOnlineStatus();
+      
+      if (isOnline) {
+        logger.log('info', `Cache is older than ${this.MAX_CACHE_AGE}ms, forcing update...`);
+        await this.forceUpdate(cacheManager);
+        return true;
+      } else if (cacheAge > this.OFFLINE_GRACE_PERIOD) {
+        // If we're offline and beyond grace period, warn but continue serving cached content
+        logger.log('warn', `Cache is stale and device is offline. Cache age: ${cacheAge}ms. Using cached content with warning.`);
+        // We could potentially show a warning to the user here
+        return false;
+      } else {
+        logger.log('info', `Cache is stale but device is offline. Within grace period. Using cached content.`);
+        return false;
+      }
+    }
+
+    // Regular update check interval
+    if (millisSinceLastCheck < this.MIN_CHECK_INTERVAL && cacheAge < this.MAX_CACHE_AGE) {
+      return false;
+    }
+    logger.log('info', 'checking for update of the app by comparing app hashes...');
+    this.lastUpdateCheck = now;
+    const currentVersionInfo = await this.getVersionInfoFromServer();
+    logger.log('info', `old versionInfo: ${JSON.stringify(this.lastVersionInfo)}`);
+    logger.log('info', `current versionInfo: ${JSON.stringify(currentVersionInfo)}`);
+    const needsUpdate = this.lastVersionInfo.appHash !== currentVersionInfo.appHash ? true : false;
+    if (needsUpdate) {
+      logger.log('info', 'Caches need to be updated');
+      logger.log('info', 'starting a debounced update task');
+      this.performAsyncUpdateDebouncedTask.trigger();
+      this.lastVersionInfo = currentVersionInfo;
+      await this.serviceworkerRef.store.set(lswVersionInfoKey, this.lastVersionInfo);
+      
+      // Update cache timestamp
+      this.lastCacheTimestamp = now;
+      await this.serviceworkerRef.store.set('cacheTimestamp', now);
+    } else {
+      logger.log('ok', 'caches are still valid, performing revalidation in a bit...');
+      this.performAsyncCacheRevalidationDebouncedTask.trigger();
+      
+      // Update cache timestamp after successful revalidation
+      this.lastCacheTimestamp = now;
+      await this.serviceworkerRef.store.set('cacheTimestamp', now);
+    }
+  }
+
+  /**
+   * gets the apphash from the server
+   */
+  public async getVersionInfoFromServer() {
+    try {
+      const getAppHashRequest = new plugins.typedrequest.TypedRequest<
+        interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo
+      >('/sw-typedrequest', 'serviceworker_versionInfo');
+      
+      // Use networkManager for the request with retries and timeout
+      const response = await this.serviceworkerRef.networkManager.makeRequest('/sw-typedrequest', {
+        timeoutMs: 5000,
+        retries: 2,
+        backoffMs: 1000
+      });
+      
+      const result = await response.json();
+      return result;
+    } catch (error) {
+      logger.log('warn', `Failed to get version info from server: ${error.message}`);
+      throw error;
+    }
+  }
+
+  // tasks
+  /**
+   * this task is executed once we know that there is a new version available
+   */
+  private async forceUpdate(cacheManager: CacheManager) {
+    try {
+      logger.log('info', 'Forcing cache update due to staleness');
+      const currentVersionInfo = await this.getVersionInfoFromServer();
+      
+      // Only proceed with cache cleaning if we successfully got new version info
+      await this.serviceworkerRef.cacheManager.cleanCaches('Cache is stale, forcing update.');
+      this.lastVersionInfo = currentVersionInfo;
+      await this.serviceworkerRef.store.set('versionInfo', this.lastVersionInfo);
+      this.lastCacheTimestamp = Date.now();
+      await this.serviceworkerRef.store.set('cacheTimestamp', this.lastCacheTimestamp);
+      await this.serviceworkerRef.leleServiceWorkerBackend.triggerReloadAll();
+    } catch (error) {
+      logger.log('error', `Failed to force update: ${error.message}. Keeping existing cache.`);
+      // If update fails, we'll keep using the existing cache
+      throw error;
+    }
+  }
+
+  public performAsyncUpdateDebouncedTask = new plugins.taskbuffer.TaskDebounced({
+    name: 'performAsyncUpdate',
+    taskFunction: async () => {
+      logger.log('info', 'trying to update PWA with serviceworker');
+      await this.serviceworkerRef.cacheManager.cleanCaches('a new app version has been communicated by the server.');
+      // lets notify all current clients about the update
+      await this.serviceworkerRef.leleServiceWorkerBackend.triggerReloadAll();
+    },
+    debounceTimeInMillis: 2000,
+  });
+
+  public performAsyncCacheRevalidationDebouncedTask = new plugins.taskbuffer.TaskDebounced({
+    name: 'performAsyncCacheRevalidation',
+    taskFunction: async () => {
+      await this.serviceworkerRef.cacheManager.revalidateCache();
+    },
+    debounceTimeInMillis: 6000
+  });
+}

ts_web_serviceworker/index.ts

@@ -2,7 +2,6 @@
 import * as env from './env.js';
 declare var self: env.ServiceWindow;
 
-import { LosslessServiceWorker } from './serviceworker.classes.serviceworker.js';
-
-const losslessServiceWorkerInstance = new LosslessServiceWorker(self);
+import { ServiceWorker } from './classes.serviceworker.js';
 
+const sw = new ServiceWorker(self);

ts_web_serviceworker/serviceworker.classes.cachemanager.ts

@@ -1,224 +0,0 @@
-import * as plugins from './plugins.js';
-import * as interfaces from './env.js';
-import { logger } from './serviceworker.logging.js';
-import { LosslessServiceWorker } from './serviceworker.classes.serviceworker.js';
-
-export class CacheManager {
-  public losslessServiceWorkerRef: LosslessServiceWorker;
-
-  public usedCacheNames = {
-    runtimeCacheName: 'runtime'
-  };
-
-  constructor(losslessServiceWorkerRefArg: LosslessServiceWorker) {
-    this.losslessServiceWorkerRef = losslessServiceWorkerRefArg;
-    this._setupCache();
-  }
-
-  private _setupCache = () => {
-    const createMatchRequest = (requestArg: Request) => {
-      // lets create a matchRequest
-      let matchRequest: Request;
-      if (requestArg.url.startsWith(this.losslessServiceWorkerRef.serviceWindowRef.location.origin)) {
-        // internal request
-        matchRequest = requestArg;
-      } else {
-        matchRequest = new Request(requestArg.url, {
-          ...requestArg.clone(),
-          mode: 'cors'
-        });
-      }
-      return matchRequest;
-    };
-  
-    /**
-     * creates a 500 response
-     */
-    const create500Response = async (requestArg: Request, responseArg: Response) => {
-      return new Response(
-        `
-        <html>
-          <head>
-            <style>
-              .note {
-                padding: 10px;
-                color: #fff;
-                background: #000;
-                border-bottom: 1px solid #e4002b;
-                margin-bottom: 20px;
-              }
-            </style>
-          </head>
-          <body>
-          
-          <div class="note">
-            <strong>serviceworker running, but status 500</strong><br>
-          </div>
-          serviceworker is unable to fetch this request<br>
-          Here is some info about the request/response pair:<br>
-          <br>
-          requestUrl: ${requestArg.url}<br>
-          responseType: ${responseArg.type}<br>
-          responseBody: ${await responseArg.clone().text()}<br>
-          </body>
-        </html>
-      `,
-        {
-          headers: {
-            "Content-Type": "text/html"
-          },
-          status: 500
-        }
-      );
-    };
-  
-    // A list of local resources we always want to be cached.
-    this.losslessServiceWorkerRef.serviceWindowRef.addEventListener('fetch', async (fetchEventArg: any) => {
-      // Lets block scopes we don't want to be passing through the serviceworker
-      const parsedUrl = new URL(fetchEventArg.request.url)
-      if (
-        parsedUrl.hostname.includes('paddle.com')
-        || parsedUrl.hostname.includes('paypal.com')
-        || parsedUrl.hostname.includes('reception.lossless.one')
-        || parsedUrl.pathname.startsWith('/socket.io')
-      ) {
-        logger.log('note',`serviceworker not active for ${parsedUrl.toString()}`);
-        return;
-      }
-      
-      // lets continue for the rest
-      const done = plugins.smartpromise.defer<Response>();
-      fetchEventArg.respondWith(done.promise);
-      const originalRequest: Request = fetchEventArg.request;
-  
-      if (
-        (originalRequest.method === 'GET' &&
-          (originalRequest.url.startsWith(this.losslessServiceWorkerRef.serviceWindowRef.location.origin) &&
-            !originalRequest.url.includes('/api/') &&
-            !originalRequest.url.includes('smartserve/reloadcheck'))) ||
-        originalRequest.url.includes('https://assetbroker.lossless.one/public') ||
-        originalRequest.url.includes('https://assetbroker.lossless.one/brandfiles') ||
-        originalRequest.url.includes('https://assetbroker.lossless.one/websites') ||
-        originalRequest.url.includes('https://unpkg.com') ||
-        originalRequest.url.includes('https://fonts.googleapis.com') ||
-        originalRequest.url.includes('https://fonts.gstatic.com')
-      ) {
-  
-        // lets see if things need to be updated
-        // not waiting here
-        this.losslessServiceWorkerRef.updateManager.checkUpdate(this);
-  
-        // this code block is executed for local requests
-        const matchRequest = createMatchRequest(originalRequest);
-        const cachedResponse = await caches.match(matchRequest);
-        if (cachedResponse) {
-          logger.log('ok', `CACHED: found cached response for ${matchRequest.url}`);
-          done.resolve(cachedResponse);
-          return;
-        }
-  
-        // in case there is no cached response
-        logger.log('info', `NOTYETCACHED: trying to cache ${matchRequest.url}`);
-        const newResponse: Response = await fetch(matchRequest).catch(async err => {
-          return await create500Response(matchRequest, new Response(err.message));
-        });
-  
-        // fill cache
-        // Put a copy of the response in the runtime cache.
-        if (newResponse.status > 299 || newResponse.type === 'opaque') {
-          logger.log(
-            'error',
-            `NOTCACHED: can't cache response for ${matchRequest.url} due to status ${
-              newResponse.status
-            } and type ${newResponse.type}`
-          );
-          done.resolve(await create500Response(matchRequest, newResponse));
-        } else {
-          const cache = await caches.open(this.usedCacheNames.runtimeCacheName);
-          const responseToPutToCache = newResponse.clone();
-          const headers = new Headers();
-          responseToPutToCache.headers.forEach((value, key) => {
-            if (
-              value !== 'Cache-Control'
-              && value !== 'cache-control'
-              && value !== 'Expires'
-              && value !== 'expires'
-              && value !== 'Pragma'
-              && value !== 'pragma'
-            ) {
-              headers.set(key, value);
-            }
-          });
-          headers.set('Cache-Control', 'no-cache, no-store, must-revalidate');
-          headers.set('Pragma', 'no-cache');
-          headers.set('Expires', '0');
-          await cache.put(matchRequest, new Response(responseToPutToCache.body, {
-            ...responseToPutToCache,
-            headers
-          }));
-          logger.log(
-            'ok',
-            `NOWCACHED: cached response for ${matchRequest.url} for subsequent requests!`
-          );
-          done.resolve(newResponse);
-        }
-      } else {
-        // this code block is executed for remote requests
-        logger.log(
-          'ok',
-          `NOTCACHED: not caching any responses for ${
-            originalRequest.url
-          }. Fetching from origin now...`
-        );
-        done.resolve(
-          await fetch(originalRequest).catch(async err => {
-            return await create500Response(originalRequest, new Response(err.message));
-          })
-        );
-      }
-    });
-  }
-
-  /**
-   * update caches
-   * @param reasonArg
-   */
-
-  /**
-   * cleans all caches
-   * should only be run when running a new service worker
-   * @param reasonArg
-   */
-  public cleanCaches = async (reasonArg = 'no reason given') => {
-    logger.log('info', `MAJOR CACHEEVENT: cleaning caches now! Reason: ${reasonArg}`);
-    const cacheNames = await caches.keys();
-    
-    const deletePromises = cacheNames.map(cacheToDelete => {
-        const deletePromise = caches.delete(cacheToDelete);
-        deletePromise.then(() => {
-          logger.log('ok', `Deleted cache ${cacheToDelete}`);
-        });
-        return deletePromise;
-      });
-    await Promise.all(deletePromises);
-  }
-
-  /**
-   * revalidate cache
-   */
-  public async revalidateCache() {
-    const runtimeCache = await caches.open(this.usedCacheNames.runtimeCacheName);
-    const cacheKeys = await runtimeCache.keys();
-    for (const requestArg of cacheKeys) {
-      const cachedResponse = runtimeCache.match(requestArg);
-
-      // lets get a new response for comparison
-      const clonedRequest = requestArg.clone();
-      const response = await plugins.smartpromise.timeoutWrap(fetch(clonedRequest), 1000);
-      if (response && response.status >= 200 && response.status < 300) {
-        await runtimeCache.delete(requestArg);
-        await runtimeCache.put(requestArg, response);
-      }
-    }
-  }
-}

ts_web_serviceworker/serviceworker.classes.networkmanager.ts

@@ -1,33 +0,0 @@
-import * as plugins from './plugins.js';
-import { LosslessServiceWorker } from './serviceworker.classes.serviceworker.js';
-
-export class NetworkManager {
-  public serviceWorkerRef: LosslessServiceWorker;
-  public webRequest: plugins.webrequest.WebRequest;
-
-  public previousState: string;
-
-  constructor(serviceWorkerRefArg: LosslessServiceWorker) {
-    this.serviceWorkerRef = serviceWorkerRefArg;
-    this.webRequest = new plugins.webrequest.WebRequest();
-    this.getConnection()?.addEventListener('change', () => {
-      this.updateConnectionStatus();
-    });
-  }
-
-  /**
-   * gets the connection
-   */
-  public getConnection() {
-    const navigatorLocal: any = self.navigator;
-    return navigatorLocal?.connection;
-  }
-
-  public getEffectiveType() {
-    return this.getConnection()?.effectiveType || '4g';
-  }
-
-  public updateConnectionStatus() {
-    console.log(`Connection type changed from ${this.previousState} to ${this.getEffectiveType()}`);
-  }
-}

ts_web_serviceworker/serviceworker.classes.taskmanager.ts

@@ -1,15 +0,0 @@
-import * as plugins from './plugins.js';
-import { LosslessServiceWorker } from './serviceworker.classes.serviceworker.js';
-
-/**
- * Taskmanager
- * should use times allocated by browser
- */
-export class TaskManager {
-  public serviceworkerRef: LosslessServiceWorker;
-
-  constructor(serviceWorkerRefArg: LosslessServiceWorker) {
-    this.serviceworkerRef = serviceWorkerRefArg;
-  }
-
-}

ts_web_serviceworker/serviceworker.classes.updatemanager.ts

@@ -1,91 +0,0 @@
-import * as plugins from './plugins.js';
-import * as interfaces from '../dist_ts_interfaces/index.js';
-import { LosslessServiceWorker } from './serviceworker.classes.serviceworker.js';
-import { logger } from './serviceworker.logging.js';
-import { CacheManager } from './serviceworker.classes.cachemanager.js';
-
-export class UpdateManager {
-  public lastUpdateCheck: number = 0;
-  public lastVersionInfo: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'];
-
-  public serviceworkerRef: LosslessServiceWorker;
-
-  constructor(serviceWorkerRefArg: LosslessServiceWorker) {
-    this.serviceworkerRef = serviceWorkerRefArg;
-  }
-
-  /**
-   * checks wether an update is needed
-   */
-  public async checkUpdate(cacheManager: CacheManager): Promise<boolean> {
-    const lswVersionInfoKey = 'versionInfo';
-    if (!this.lastVersionInfo && !(await this.serviceworkerRef.store.check(lswVersionInfoKey))) {
-      this.lastVersionInfo = {
-        appHash: '',
-        appSemVer: 'v0.0.0',
-      };
-    } else if (
-      !this.lastVersionInfo &&
-      (await this.serviceworkerRef.store.check(lswVersionInfoKey))
-    ) {
-      this.lastVersionInfo = await this.serviceworkerRef.store.get(lswVersionInfoKey);
-    }
-
-    const now = Date.now();
-    const millisSinceLastCheck = now - this.lastUpdateCheck;
-    if (millisSinceLastCheck < 100000) {
-      // TODO account for being offline
-      return false;
-    }
-    logger.log('info', 'checking for update of the app by comparing app hashes...');
-    this.lastUpdateCheck = now;
-    const currentVersionInfo = await this.getVersionInfoFromServer();
-    logger.log('info', `old versionInfo: ${JSON.stringify(this.lastVersionInfo)}`);
-    logger.log('info', `current versionInfo: ${JSON.stringify(currentVersionInfo)}`);
-    const needsUpdate = this.lastVersionInfo.appHash !== currentVersionInfo.appHash ? true : false;
-    if (needsUpdate) {
-      logger.log('info', 'Caches need to be updated');
-      logger.log('info', 'starting a debounced update task');
-      this.performAsyncUpdateDebouncedTask.trigger();
-      this.lastVersionInfo = currentVersionInfo;
-      await this.serviceworkerRef.store.set(lswVersionInfoKey, this.lastVersionInfo);
-    } else {
-      logger.log('ok', 'caches are still valid, performing revalidation in a bit...');
-      this.performAsyncCacheRevalidationDebouncedTask.trigger();
-    }
-  }
-
-  /**
-   * gets the apphash from the server
-   */
-  public async getVersionInfoFromServer() {
-    const getAppHashRequest = new plugins.typedrequest.TypedRequest<
-      interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo
-    >('/sw-typedrequest', 'serviceworker_versionInfo');
-    const result = await getAppHashRequest.fire({});
-    return result;
-  }
-
-  // tasks
-  /**
-   * this task is executed once we know that there is a new version available
-   */
-  public performAsyncUpdateDebouncedTask = new plugins.taskbuffer.TaskDebounced({
-    name: 'performAsyncUpdate',
-    taskFunction: async () => {
-      logger.log('info', 'trying to update PWA with serviceworker');
-      await this.serviceworkerRef.cacheManager.cleanCaches('a new app version has been communicated by the server.');
-      // lets notify all current clients about the update
-      await this.serviceworkerRef.leleServiceWorkerBackend.triggerReloadAll();
-    },
-    debounceTimeInMillis: 2000,
-  });
-
-  public performAsyncCacheRevalidationDebouncedTask = new plugins.taskbuffer.TaskDebounced({
-    name: 'performAsyncCacheRevalidation',
-    taskFunction: async () => {
-      await this.serviceworkerRef.cacheManager.revalidateCache();
-    },
-    debounceTimeInMillis: 6000
-  });
-}

ts_web_serviceworker_client/classes.actionmanager.ts

@@ -1,6 +1,6 @@
-import * as plugins from './lele-serviceworker.plugins.js';
+import * as plugins from './plugins.js';
 import * as interfaces from '../dist_ts_interfaces/index.js';
-import { logger } from './serviceworker.logging.js';
+import { logger } from './logging.js';
 
 /**
  * MessageManager implements two ways of serviceworker communication

ts_web_serviceworker_client/classes.globalsw.ts

@@ -1,9 +1,9 @@
-import * as plugins from './lele-serviceworker.plugins.js';
-import { LosslessServiceworker } from './lele-serviceworker.classes.serviceworker.js';
+import * as plugins from './plugins.js';
+import { ServiceworkerClient } from './classes.serviceworkerclient.js';
 
 export class GlobalSW {
-  losslessSw: LosslessServiceworker;
-  constructor(losslessServiceWorkerInstanceArg: LosslessServiceworker) {
+  losslessSw: ServiceworkerClient;
+  constructor(losslessServiceWorkerInstanceArg: ServiceworkerClient) {
     this.losslessSw = losslessServiceWorkerInstanceArg;
     globalThis.globalSw = this;
   };

ts_web_serviceworker_client/classes.notificationmanager.ts

@@ -1,6 +1,6 @@
-import * as plugins from './lele-serviceworker.plugins.js';
+import * as plugins from './plugins.js';
 import * as interfaces from '../dist_ts_interfaces/index.js';
-import { logger } from "./serviceworker.logging.js";
+import { logger } from "./logging.js";
 
 export class NotificationManager {
 

ts_web_serviceworker_client/classes.serviceworkerclient.ts

@@ -1,19 +1,19 @@
-import * as plugins from './lele-serviceworker.plugins.js';
+import * as plugins from './plugins.js';
 import * as interfaces from '../dist_ts_interfaces/index.js';
-import { logger } from "./serviceworker.logging.js";
-import { NotificationManager } from './lele-serviceworker.classes.notificationmanager.js';
-import { ActionManager } from './lele-serviceworker.classes.actionmanager.js';
-import { GlobalSW } from './lele-serviceworker.classes.globalsw.js'
+import { logger } from "./logging.js";
+import { NotificationManager } from './classes.notificationmanager.js';
+import { ActionManager } from './classes.actionmanager.js';
+import { GlobalSW } from './classes.globalsw.js'
 
-export class LosslessServiceworker {
+export class ServiceworkerClient {
   // STATIC
-  public static async createServiceWorker(): Promise<LosslessServiceworker> {
+  public static async createServiceWorker(): Promise<ServiceworkerClient> {
     if ('serviceWorker' in navigator) {
       try {
         logger.log('info', 'trying to register serviceworker');
         // this is some magic for Parcel to not pick up the serviceworker
         const serviceworkerInNavigator: ServiceWorkerContainer = navigator.serviceWorker;
-        const swRegistration: ServiceWorkerRegistration = await serviceworkerInNavigator.register('/lsw.js', {
+        const swRegistration: ServiceWorkerRegistration = await serviceworkerInNavigator.register('/serviceworker.bundle.js', {
           scope: '/',
           updateViaCache: 'none'
         });
@@ -31,7 +31,7 @@ export class LosslessServiceworker {
         await navigator.serviceWorker.ready;
         logger.log('ok', 'serviceworker is ready!');
         await this.waitForController();
-        const losslessServiceWorkerInstance = new LosslessServiceworker();
+        const losslessServiceWorkerInstance = new ServiceworkerClient();
         return losslessServiceWorkerInstance;
       } catch (err) {
         // sentry integration here

ts_web_serviceworker_client/index.ts

@@ -8,17 +8,17 @@ export type {
 // imports
 // ====================================
 
-import { logger } from './serviceworker.logging.js';
+import { logger } from './logging.js';
 logger.log('note', 'mainthread console initialized!');
 
-import { LosslessServiceworker } from './lele-serviceworker.classes.serviceworker.js';
+import { ServiceworkerClient } from './classes.serviceworkerclient.js';
 
 export type {
-  LosslessServiceworker
+  ServiceworkerClient
 }
 
-export const getServiceWorker = async () => {
-  const losslessServiceWorkerInstance = await LosslessServiceworker.createServiceWorker(); // lets setup the service worker
+export const getServiceworkerClient = async () => {
+  const swClient = await ServiceworkerClient.createServiceWorker(); // lets setup the service worker
   logger.log('ok', 'service worker ready!'); // and wait for it to be ready
-  return losslessServiceWorkerInstance;
+  return swClient;
 };