3.0.51

.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,154 @@
+# Changelog
+
+## 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,19 +1,20 @@
 {
   "name": "@api.global/typedserver",
-  "version": "3.0.34",
+  "version": "3.0.51",
   "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"
+    "./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/",
-    "build": "tsbuild tsfolders --web --allowimplicitany --skiplibcheck && tsbundle --from ./ts_web_inject/index.ts --to ./dist_ts_web_inject/bundle.js",
+    "build": "tsbuild tsfolders --web --allowimplicitany && npm run bundle",
+    "bundle": "tsbundle --from ./ts_web_inject/index.ts --to ./dist_ts_web_inject/bundle.js && tsbundle --from ./ts_web_serviceworker/index.ts --to ./dist_ts_web_serviceworker/serviceworker.bundle.js",
     "interfaces": "tsbuild interfaces --web --allowimplicitany --skiplibcheck",
     "docs": "tsdoc aidoc"
   },
@@ -56,50 +57,51 @@
   ],
   "homepage": "https://github.com/pushrocks/easyserve",
   "dependencies": {
-    "@api.global/typedrequest": "^3.0.23",
+    "@api.global/typedrequest": "^3.0.30",
     "@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",
+    "@cloudflare/workers-types": "^4.20240821.1",
+    "@design.estate/dees-comms": "^1.0.27",
     "@push.rocks/lik": "^6.0.15",
     "@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.21",
+    "@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/smartmime": "^2.0.2",
+    "@push.rocks/smartntml": "^2.0.4",
     "@push.rocks/smartopen": "^2.0.0",
     "@push.rocks/smartpath": "^5.0.18",
-    "@push.rocks/smartpromise": "^4.0.2",
+    "@push.rocks/smartpromise": "^4.0.4",
     "@push.rocks/smartrequest": "^2.0.22",
     "@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.0.44",
+    "@push.rocks/smarttime": "^4.0.8",
     "@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.1.2",
     "@types/express": "^4.17.21",
     "body-parser": "^1.20.2",
     "cors": "^2.8.5",
     "express": "^4.19.2",
     "express-force-ssl": "^0.3.2",
-    "lit": "^3.1.3"
+    "lit": "^3.2.0"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.76",
+    "@git.zone/tsbuild": "^2.1.84",
     "@git.zone/tsbundle": "^2.0.15",
-    "@git.zone/tsrun": "^1.2.44",
+    "@git.zone/tsrun": "^1.2.49",
     "@git.zone/tstest": "^1.0.90",
-    "@push.rocks/tapbundle": "^5.0.23",
-    "@types/node": "^20.12.11"
+    "@push.rocks/tapbundle": "^5.0.24",
+    "@types/node": "^22.5.0"
   },
   "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.34',
+  version: '3.0.51',
   description: 'A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.'
 }

ts/classes.typedserver.ts

@@ -1,5 +1,5 @@
 import * as plugins from './plugins.js';
-import * as paths from './typedserver.paths.js';
+import * as paths from './paths.js';
 import * as interfaces from '../dist_ts_interfaces/index.js';
 import * as servertools from './servertools/index.js';
 import { type TCompressionMethod } from './servertools/classes.compressor.js';
@@ -103,7 +103,7 @@ export class TypedServer {
           case 'devtools':
             res.setHeader('Content-Type', 'text/javascript');
             res.status(200);
-            res.write(plugins.smartfile.fs.toStringSync(paths.bundlePath));
+            res.write(plugins.smartfile.fs.toStringSync(paths.injectBundlePath));
             res.end();
             break;
           case 'reloadcheck':

ts/index.ts

@@ -4,7 +4,12 @@ import * as servertools from './servertools/index.js';
 
 export { servertools };
 
-export * from './typedserver.classes.typedserver.js';
+export * from './classes.typedserver.js';
 // Type helpers
 export type Request = plugins.express.Request;
 export type Response = plugins.express.Response;
+
+
+// lets export utilityservers
+import * as utilityservers from './utilityservers/index.js';
+export { utilityservers };

ts/infohtml/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@losslessone_private/lole-infohtml',
+  version: '1.0.39',
+  description: 'html for displaying infos at lossless'
+}

ts/infohtml/index.ts

@@ -0,0 +1,44 @@
+import * as plugins from './infohtml.plugins.js';
+
+import { simpleInfo } from './template.js';
+
+export interface IHtmlInfoOptions {
+  text: string;
+  heading?: string;
+  title?: string;
+  sentryMessage?: string;
+  sentryDsn?: string;
+  redirectTo?: string;
+}
+
+export class InfoHtml {
+  // STATIC
+  public static async fromSimpleText(textArg: string) {
+    const infohtmlInstance = new InfoHtml({
+      text: textArg,
+      heading: null,
+    });
+    await infohtmlInstance.init();
+    return infohtmlInstance;
+  }
+
+  public static async fromOptions(optionsArg: IHtmlInfoOptions) {
+    const infohtmlInstance = new InfoHtml(optionsArg);
+    await infohtmlInstance.init();
+    return infohtmlInstance;
+  }
+
+  // INSTANCE
+  public options: IHtmlInfoOptions;
+  public smartntmlInstance: plugins.smartntml.Smartntml;
+  public htmlString: string;
+  constructor(optionsArg: IHtmlInfoOptions) {
+    this.options = optionsArg;
+  }
+
+  public async init() {
+    this.smartntmlInstance = new plugins.smartntml.Smartntml();
+    this.htmlString = await simpleInfo(this.smartntmlInstance, this.options);
+    return this.htmlString;
+  }
+}

ts/infohtml/infohtml.plugins.ts

@@ -0,0 +1,3 @@
+import * as smartntml from '@push.rocks/smartntml';
+
+export { smartntml };

ts/infohtml/template.ts

@@ -0,0 +1,160 @@
+import * as plugins from './infohtml.plugins.js';
+import { type IHtmlInfoOptions } from './index.js';
+
+export const simpleInfo = async (
+  smartntmlInstanceArg: plugins.smartntml.Smartntml,
+  optionsArg: IHtmlInfoOptions
+) => {
+  const html = plugins.smartntml.deesElement.html;
+  const htmlTemplate = await plugins.smartntml.deesElement.html`
+    <html lang="en">
+      <head>
+        <title>${optionsArg.title}</title>
+        <script>
+          setTimeout(() => {
+            const redirectUrl = '${optionsArg.redirectTo}';
+            if (redirectUrl) {
+              window.location = redirectUrl;
+            }
+          }, 5000);
+        </script>
+        <style>
+          body {
+            margin: 0px;
+            background: #000000;
+            font-family: 'Roboto Mono', monospace;
+            min-height: 100vh;
+            min-width: 100vw;
+            border: 1px solid #e4002b;
+          }
+
+          * {
+            box-sizing: border-box;
+          }
+
+          .logo {
+            width: 150px;
+            padding-top: 70px;
+            margin: 0px auto 30px auto;
+          }
+
+          .content {
+            text-align: center;
+            max-width: 800px;
+            margin: auto;
+          }
+
+          .content .maintext {
+            margin: 10px;
+            color: #ffffff;
+            background: #333;
+            display: block;
+            border-radius: 3px;
+            box-shadow: 0px 0px 5px rgba(0, 0, 0, 0.3);
+            padding: 20px;
+          }
+
+          .content .maintext h1 {
+            margin: 0px;
+          }
+
+          .content .addontext {
+            margin: 10px;
+            color: #ffffff;
+            background: #222;
+            display: block;
+            padding: 10px 15px;
+            border-radius: 3px;
+            box-shadow: 0px 0px 5px rgba(0, 0, 0, 0.3);
+            padding: 10px;
+          }
+
+          .content .text h1 {
+            margin: 0px;
+            font-weight: 100;
+            font-size: 40px;
+          }
+
+          .content .text ul {
+            text-align: left;
+          }
+
+          a {
+            color: #ffffff;
+          }
+
+          .legal {
+            color: #fff;
+            position: fixed;
+            bottom: 0px;
+            width: 100vw;
+            text-align: center;
+            padding: 10px;
+          }
+        </style>
+        <meta
+          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[] = [];
+            if (optionsArg.heading) {
+              returnArray.push(html`
+                <div class="maintext">
+                  <h1>${optionsArg.heading}</h1>
+                  ${optionsArg.text}
+                </div>
+              `);
+            } 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">
+                  We will redirect you to ${optionsArg.redirectTo} in a few seconds.
+                </div>`
+              );
+            }
+            return returnArray;
+          })()}
+        </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>
+        </div>
+      </body>
+    </html>
+  `;
+  return smartntmlInstanceArg.renderTemplateResult(htmlTemplate);
+};

ts/paths.ts

@@ -4,4 +4,8 @@ export const packageDir = plugins.path.join(
   plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
   '../'
 );
-export const distBundleDir = plugins.path.join(packageDir, './dist_bundle');
+
+export const injectBundleDir = plugins.path.join(packageDir, './dist_ts_web_inject');
+export const injectBundlePath = plugins.path.join(injectBundleDir, './bundle.js');
+
+export const serviceworkerBundleDir = plugins.path.join(packageDir, './dist_ts_web_serviceworker');

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

@@ -9,7 +9,7 @@ import { setupRobots } from './tools.robots.js';
 import { setupManifest } from './tools.manifest.js';
 import { Sitemap } from './classes.sitemap.js';
 import { Feed } from './classes.feed.js';
-import { type IServerOptions } from '../typedserver.classes.typedserver.js';
+import { type IServerOptions } from '../classes.typedserver.js';
 export type TServerStatus = 'initiated' | 'running' | 'stopped';
 
 /**
@@ -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/index.ts

@@ -4,3 +4,9 @@ export * from './classes.handler.js';
 export * from './classes.handlerstatic.js';
 export * from './classes.handlerproxy.js';
 export * from './classes.handlertypedrouter.js';
+export * from './classes.compressor.js';
+import * as serviceworker from './tools.serviceworker.js';
+
+export {
+  serviceworker,
+}

ts/servertools/tools.serviceworker.ts

@@ -3,28 +3,28 @@ import * as paths from '../paths.js';
 
 import * as interfaces from '../../dist_ts_interfaces/index.js'
 import { Handler } from './classes.handler.js';
-import type { TypedServer } from '../typedserver.classes.typedserver.js';
+import type { TypedServer } from '../classes.typedserver.js';
 import { HandlerTypedRouter } from './classes.handlertypedrouter.js';
 
-const lswJS: string = plugins.smartfile.fs.toStringSync(
-  plugins.path.join(paths.distBundleDir, './lsw.js')
+const swBundleJs: string = plugins.smartfile.fs.toStringSync(
+  plugins.path.join(paths.serviceworkerBundleDir, './serviceworker.bundle.js')
 );
-const lswJSMeta: string = plugins.smartfile.fs.toStringSync(
-  plugins.path.join(paths.distBundleDir, './lsw.js.map')
+const swBundleJsMap: string = plugins.smartfile.fs.toStringSync(
+  plugins.path.join(paths.serviceworkerBundleDir, './serviceworker.bundle.js.map')
 );
-let lswVersionInfo: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'] =
+let swVersionInfo: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'] =
   null;
 const serviceworkerHandler = new Handler(
   'GET',
   async (req, res) => {
-    if (req.path === '/lsw.js') {
+    if (req.path === '/serviceworker.bundle.js') {
       res.status(200);
       res.set('Content-Type', 'text/javascript');
-      res.write(lswJS + '\n' + `/** appSemVer: ${lswVersionInfo?.appSemVer || 'not set'} */`);
-    } else if (req.path === '/lsw.js.map') {
+      res.write(swBundleJs + '\n' + `/** appSemVer: ${swVersionInfo?.appSemVer || 'not set'} */`);
+    } else if (req.path === '/serviceworker.bundle.js.map') {
       res.status(200);
       res.set('Content-Type', 'application/json');
-      res.write(lswJSMeta);
+      res.write(swBundleJsMap);
     }
     res.end();
   }
@@ -32,13 +32,13 @@ const serviceworkerHandler = new Handler(
 
 export const addServiceWorkerRoute = (
   typedserverInstance: TypedServer,
-  lswData: () => interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response']
+  swDataFunc: () => interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response']
 ) => {
   // lets the version info as unique string;
-  lswVersionInfo = lswData();
+  swVersionInfo = swDataFunc();
 
   // the basic stuff
-  typedserverInstance.server.addRoute('/lsw.js*', serviceworkerHandler);
+  typedserverInstance.server.addRoute('/serviceworker.*', serviceworkerHandler);
 
   // the typed stuff
   const typedrouter = new plugins.typedrequest.TypedRouter();
@@ -47,14 +47,14 @@ export const addServiceWorkerRoute = (
     new plugins.typedrequest.TypedHandler<interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo>(
       'serviceworker_versionInfo',
       async (req) => {
-        const versionInfoResponse = lswData();
+        const versionInfoResponse = swDataFunc();
         return versionInfoResponse;
       }
     )
   );
 
   typedserverInstance.server.addRoute(
-    '/lsw-typedrequest',
+    '/sw-typedrequest',
     new HandlerTypedRouter(typedrouter)
   );
 };

ts/typedserver.paths.ts

@@ -1,8 +0,0 @@
-import * as plugins from './plugins.js';
-
-export const packageDir = plugins.path.join(
-  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
-  '../'
-);
-
-export const bundlePath = plugins.path.join(packageDir, './dist_ts_web_inject/bundle.js');

ts/utilityservers/classes.serviceserver.ts

@@ -0,0 +1,51 @@
+import { TypedServer } from '../classes.typedserver.js';
+import * as servertools from '../servertools/index.js';
+import * as plugins from '../plugins.js';
+
+export interface ILoleServiceServerConstructorOptions {
+  addCustomRoutes?: (serverArg: servertools.Server) => Promise<any>;
+  serviceName: string;
+  serviceVersion: string;
+  serviceDomain: string;
+  port?: number;
+}
+
+// the main service server
+export class UtilityServiceServer {
+  public options: ILoleServiceServerConstructorOptions;
+  public typedServer: TypedServer;
+
+  constructor(optionsArg: ILoleServiceServerConstructorOptions) {
+    this.options = optionsArg;
+  }
+
+  public async start() {
+    console.log('starting lole-serviceserver...')
+    this.typedServer = new TypedServer({
+      cors: true,
+      domain: this.options.serviceDomain,
+      forceSsl: false,
+      port: this.options.port || 3000,
+      robots: true,
+      defaultAnswer: async () => {
+        const InfoHtml = (await import('../infohtml/index.js')).InfoHtml;
+        return (
+          await InfoHtml.fromSimpleText(
+            `${this.options.serviceName} (version ${this.options.serviceVersion})`
+          )
+        ).htmlString;
+      },
+    });
+
+    // lets add any custom routes
+    if (this.options.addCustomRoutes) {
+      await this.options.addCustomRoutes(this.typedServer.server);
+    }
+
+    await this.typedServer.start();
+  }
+
+  public async stop() {
+    await this.typedServer.stop();
+  }
+}

ts/utilityservers/classes.websiteserver.ts

@@ -0,0 +1,137 @@
+import * as interfaces from '../../dist_ts_interfaces/index.js';
+import { type IServerOptions, TypedServer } from '../classes.typedserver.js';
+import type { Request, Response } from '../index.js';
+import * as plugins from '../plugins.js';
+import * as servertools from '../servertools/index.js';
+
+export interface IUtilityWebsiteServerConstructorOptions {
+  addCustomRoutes?: (serverArg: servertools.Server) => Promise<any>;
+  appSemVer?: string;
+  domain: string;
+  serveDir: string;
+  feedMetadata: IServerOptions['feedMetadata'];
+}
+
+/**
+ * the utility website server implements a best practice server for websites
+ * It supports:
+ *  * live reload
+ *  * compression
+ *  * serviceworker
+ *  * pwa manifest
+ */
+export class UtilityWebsiteServer {
+  public options: IUtilityWebsiteServerConstructorOptions;
+  public typedserver: TypedServer;
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+
+  constructor(optionsArg: IUtilityWebsiteServerConstructorOptions) {
+    this.options = optionsArg;
+  }
+
+  /**
+   *
+   */
+  public async start(portArg = 3000) {
+    this.typedserver = new TypedServer({
+      cors: true,
+      injectReload: true,
+      watch: true,
+      serveDir: this.options.serveDir,
+      enableCompression: true,
+      preferredCompressionMethod: 'gzip',
+      domain: this.options.domain,
+      forceSsl: false,
+      manifest: {
+        name: this.options.domain,
+        short_name: this.options.domain,
+        start_url: '/',
+        display_override: ['window-controls-overlay'],
+        lang: 'en',
+        background_color: '#000000',
+        scope: '/',
+      },
+      port: portArg,
+
+      // features
+      robots: true,
+      sitemap: true,
+    });
+
+    let lswData: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'] =
+      {
+        appHash: 'xxxxxx',
+        appSemVer: this.options.appSemVer || 'x.x.x',
+      };
+
+    // -> /lsw* - anything regarding serviceworker
+    servertools.serviceworker.addServiceWorkerRoute(this.typedserver, () => {
+      return lswData;
+    });
+
+    // lets add ads.txt
+    this.typedserver.server.addRoute(
+      '/ads.txt',
+      new servertools.Handler('GET', async (req, res) => {
+        res.type('txt/plain');
+        const adsTxt =
+          ['google.com, pub-4104137977476459, DIRECT, f08c47fec0942fa0'].join('\n') + '\n';
+        res.write(adsTxt);
+        res.end();
+      })
+    );
+
+    this.typedserver.server.addRoute(
+      '/assetbroker/manifest/:manifestAsset',
+      new servertools.Handler('GET', async (req, res) => {
+        let manifestAssetName = req.params.manifestAsset;
+        if (manifestAssetName === 'favicon.png') {
+          manifestAssetName = `favicon_${this.options.domain
+            .replace('.', '')
+            .replace('losslesscom', 'lossless')}@2x_transparent.png`;
+        }
+        const fullOriginAssetUrl = `https://assetbroker.lossless.one/brandfiles/00general/${manifestAssetName}`;
+        console.log(`Getting ${manifestAssetName} from ${fullOriginAssetUrl}`);
+        const dataBuffer: Buffer = (await plugins.smartrequest.getBinary(fullOriginAssetUrl)).body;
+        res.type('.png');
+        res.write(dataBuffer);
+        res.end();
+      })
+    );
+
+    // lets add any custom routes
+    if (this.options.addCustomRoutes) {
+      await this.options.addCustomRoutes(this.typedserver.server);
+    }
+
+    // -> /*  - serve the files
+    this.typedserver.serveDirHashSubject.subscribe((appHash: string) => {
+      lswData = {
+        appHash,
+        appSemVer: '1.0.0',
+      };
+    });
+
+    // lets setup the typedrouter chain
+    this.typedserver.typedrouter.addTypedRouter(this.typedrouter);
+
+    // lets start everything
+    console.log('routes are all set. Startin up now!');
+    await this.typedserver.start();
+    console.log('typedserver started!');
+  }
+
+  public async stop() {
+    await this.typedserver.stop();
+  }
+
+  /**
+   * allows you to hanlde requests from other server instances without the need to listen for yourself
+   * note smartexpress allows you start the instance wuith passing >>false<< as second parameter to .start();
+   * @param req
+   * @param res
+   */
+  public async handleRequest(req: Request, res: Response) {
+    await this.typedserver.server.handleReqRes(req, res);
+  }
+}

ts/utilityservers/index.ts

@@ -0,0 +1,2 @@
+export * from './classes.serviceserver.js';
+export * from './classes.websiteserver.js';

ts_web_serviceworker/classes.cachemanager.ts

@@ -1,16 +1,16 @@
 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';
+import { logger } from './logging.js';
+import { ServiceWorker } from './classes.serviceworker.js';
 
 export class CacheManager {
-  public losslessServiceWorkerRef: LosslessServiceWorker;
+  public losslessServiceWorkerRef: ServiceWorker;
 
   public usedCacheNames = {
     runtimeCacheName: 'runtime'
   };
 
-  constructor(losslessServiceWorkerRefArg: LosslessServiceWorker) {
+  constructor(losslessServiceWorkerRefArg: ServiceWorker) {
     this.losslessServiceWorkerRef = losslessServiceWorkerRefArg;
     this._setupCache();
   }
@@ -75,12 +75,14 @@ export class CacheManager {
     // 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)
+      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;
@@ -89,16 +91,15 @@ export class CacheManager {
       // 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://assetbroker.') ||
+        originalRequest.url.includes('https://assetbroker.') ||
+        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')

ts_web_serviceworker/classes.networkmanager.ts

@@ -1,13 +1,13 @@
 import * as plugins from './plugins.js';
-import { LosslessServiceWorker } from './serviceworker.classes.serviceworker.js';
+import { ServiceWorker } from './classes.serviceworker.js';
 
 export class NetworkManager {
-  public serviceWorkerRef: LosslessServiceWorker;
+  public serviceWorkerRef: ServiceWorker;
   public webRequest: plugins.webrequest.WebRequest;
 
   public previousState: string;
 
-  constructor(serviceWorkerRefArg: LosslessServiceWorker) {
+  constructor(serviceWorkerRefArg: ServiceWorker) {
     this.serviceWorkerRef = serviceWorkerRefArg;
     this.webRequest = new plugins.webrequest.WebRequest();
     this.getConnection()?.addEventListener('change', () => {

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

@@ -1,16 +1,16 @@
 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';
+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: LosslessServiceWorker;
+  public serviceworkerRef: ServiceWorker;
 
-  constructor(serviceWorkerRefArg: LosslessServiceWorker) {
+  constructor(serviceWorkerRefArg: ServiceWorker) {
     this.serviceworkerRef = serviceWorkerRefArg;
   }
 
@@ -61,7 +61,7 @@ export class UpdateManager {
   public async getVersionInfoFromServer() {
     const getAppHashRequest = new plugins.typedrequest.TypedRequest<
       interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo
-    >('/lsw-typedrequest', 'serviceworker_versionInfo');
+    >('/sw-typedrequest', 'serviceworker_versionInfo');
     const result = await getAppHashRequest.fire({});
     return result;
   }

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.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_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;
 };