neo.mjs 3.2.5 → 3.2.8

package/apps/ServiceWorker.mjs

@@ -0,0 +1,36 @@
+import Neo         from '../src/Neo.mjs';
+import * as core   from '../src/core/_export.mjs';
+import ServiceBase from '../src/worker/ServiceBase.mjs';
+
+/**
+ * @class Neo.ServiceWorker
+ * @extends Neo.worker.ServiceBase
+ * @singleton
+ */
+class ServiceWorker extends ServiceBase {
+    static getConfig() {return {
+        /**
+         * @member {String} className='Neo.ServiceWorker'
+         * @protected
+         */
+        className: 'Neo.ServiceWorker',
+        /**
+         * @member {Boolean} singleton=true
+         * @protected
+         */
+        singleton: true,
+        /**
+         * @member {String} workerId='service'
+         * @protected
+         */
+        workerId: 'service'
+    }}
+}
+
+Neo.applyClassConfig(ServiceWorker);
+
+let instance = Neo.create(ServiceWorker);
+
+Neo.applyToGlobalNs(instance);
+
+export default instance;

package/buildScripts/webpack/buildThreads.mjs

@@ -61,7 +61,7 @@ if (programOpts.info) {
                 type   : 'list',
                 name   : 'threads',
                 message: 'Please choose the threads to build:',
-                choices: ['all', 'app', 'canvas', 'data', 'main', 'vdom'],
+                choices: ['all', 'app', 'canvas', 'data', 'main', 'service', 'vdom'],
                 default: 'all'
             });
         }
@@ -88,11 +88,12 @@ if (programOpts.info) {
         }
 
         function parseThreads(tPath) {
-            (threads === 'all' || threads === 'main')   && spawnSync(webpack, ['--config', `${tPath}.main.mjs`],                                                    cpOpts);
-            (threads === 'all' || threads === 'app')    && spawnSync(webpack, ['--config', `${tPath}.appworker.mjs`, `--env insideNeo=${insideNeo}`],               cpOpts);
-            (threads === 'all' || threads === 'canvas') && spawnSync(webpack, ['--config', `${tPath}.worker.mjs`,    `--env insideNeo=${insideNeo} worker=canvas`], cpOpts);
-            (threads === 'all' || threads === 'data')   && spawnSync(webpack, ['--config', `${tPath}.worker.mjs`,    `--env insideNeo=${insideNeo} worker=data`],   cpOpts);
-            (threads === 'all' || threads === 'vdom')   && spawnSync(webpack, ['--config', `${tPath}.worker.mjs`,    `--env insideNeo=${insideNeo} worker=vdom`],   cpOpts);
+            (threads === 'all' || threads === 'main')    && spawnSync(webpack, ['--config', `${tPath}.main.mjs`],                                                     cpOpts);
+            (threads === 'all' || threads === 'app')     && spawnSync(webpack, ['--config', `${tPath}.appworker.mjs`, `--env insideNeo=${insideNeo}`],                cpOpts);
+            (threads === 'all' || threads === 'canvas')  && spawnSync(webpack, ['--config', `${tPath}.worker.mjs`,    `--env insideNeo=${insideNeo} worker=canvas`],  cpOpts);
+            (threads === 'all' || threads === 'data')    && spawnSync(webpack, ['--config', `${tPath}.worker.mjs`,    `--env insideNeo=${insideNeo} worker=data`],    cpOpts);
+            (threads === 'all' || threads === 'service') && spawnSync(webpack, ['--config', `${tPath}.worker.mjs`,    `--env insideNeo=${insideNeo} worker=service`], cpOpts);
+            (threads === 'all' || threads === 'vdom')    && spawnSync(webpack, ['--config', `${tPath}.worker.mjs`,    `--env insideNeo=${insideNeo} worker=vdom`],    cpOpts);
         }
 
         // dist/development

package/buildScripts/webpack/json/build.json

@@ -14,6 +14,10 @@
             "input": "./src/worker/Data.mjs",
             "output": "dataworker.js"
         },
+        "service": {
+            "input": "./apps/ServiceWorker.mjs",
+            "output": "serviceworker.js"
+        },
         "vdom": {
             "input": "./src/worker/VDom.mjs",
             "output": "vdomworker.js"

package/buildScripts/webpack/json/myApps.template.json

@@ -13,23 +13,5 @@
         "SharedDialog",
         "SharedDialog2",
         "Website"
-    ],
-    "workers": {
-        "app": {
-            "input": "./src/worker/App.mjs",
-            "output": "appworker.js"
-        },
-        "canvas": {
-            "input": "./src/worker/Canvas.mjs",
-            "output": "canvasworker.js"
-        },
-        "data": {
-            "input": "./src/worker/Data.mjs",
-            "output": "dataworker.js"
-        },
-        "vdom": {
-            "input": "./src/worker/VDom.mjs",
-            "output": "vdomworker.js"
-        }
-    }
+    ]
 }

package/examples/ServiceWorker.mjs

@@ -0,0 +1,36 @@
+import Neo         from '../src/Neo.mjs';
+import * as core   from '../src/core/_export.mjs';
+import ServiceBase from '../src/worker/ServiceBase.mjs';
+
+/**
+ * @class Neo.ServiceWorker
+ * @extends Neo.worker.ServiceBase
+ * @singleton
+ */
+class ServiceWorker extends ServiceBase {
+    static getConfig() {return {
+        /**
+         * @member {String} className='Neo.ServiceWorker'
+         * @protected
+         */
+        className: 'Neo.ServiceWorker',
+        /**
+         * @member {Boolean} singleton=true
+         * @protected
+         */
+        singleton: true,
+        /**
+         * @member {String} workerId='service'
+         * @protected
+         */
+        workerId: 'service'
+    }}
+}
+
+Neo.applyClassConfig(ServiceWorker);
+
+let instance = Neo.create(ServiceWorker);
+
+Neo.applyToGlobalNs(instance);
+
+export default instance;

package/examples/component/helix/neo-config.json

@@ -4,5 +4,6 @@
     "environment"      : "development",
     "mainPath"         : "./Main.mjs",
     "renderCountDeltas": true,
-    "themes"           : ["neo-theme-dark"]
+    "themes"           : ["neo-theme-dark"],
+    "useServiceWorker" : true
 }

package/examples/preloadingAssets/app.mjs

@@ -0,0 +1,6 @@
+import MainContainer from './view/MainContainer.mjs';
+
+export const onStart = () => Neo.app({
+    mainView: MainContainer,
+    name    : 'MyApp'
+});

package/examples/preloadingAssets/index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta charset="UTF-8">
+    <title>Preloading Assets</title>
+</head>
+<body>
+    <script src="../../src/MicroLoader.mjs" type="module"></script>
+</body>
+</html>

package/examples/preloadingAssets/neo-config.json

@@ -0,0 +1,7 @@
+{
+    "appPath": "examples/preloadingAssets/app.mjs",
+    "basePath": "../../",
+    "environment": "development",
+    "mainPath": "./Main.mjs",
+    "useServiceWorker": true
+}

package/examples/preloadingAssets/view/MainContainer.mjs

@@ -0,0 +1,60 @@
+import Component               from '../../../src/component/Base.mjs';
+import MainContainerController from './MainContainerController.mjs'
+import TabContainer            from '../../../src/tab/Container.mjs';
+import Viewport                from '../../../src/container/Viewport.mjs';
+
+/**
+ * @class Neo.examples.preloadingAssets.view.MainContainer
+ * @extends Neo.container.Viewport
+ */
+class MainContainer extends Viewport {
+    static getConfig() {return {
+        className: 'Neo.examples.preloadingAssets.view.MainContainer',
+        autoMount: true,
+        controller: MainContainerController,
+        layout   : {ntype: 'fit'},
+
+        items: [{
+            module: TabContainer,
+            height: 300,
+            width : 500,
+            style : {flex: 'none', margin: '20px'},
+
+            itemDefaults: {
+                module: Component,
+                style : {flex: 'none', padding: '20px'}
+            },
+
+            items: [{
+                tabButtonConfig: {
+                    iconCls: 'fa fa-user-astronaut',
+                    text   : 'Bob'
+                },
+
+                vdom: {
+                    tag: 'img',
+                    src: '../../resources/examples/ai_images/000150.jpg'
+                }
+            }, {
+                tabButtonConfig: {
+                    iconCls: 'fa fa-user-ninja',
+                    text   : 'Alice'
+                },
+
+                vdom: {
+                    tag: 'img',
+                    src: '../../resources/examples/ai_images/000074.jpg'
+                }
+            }],
+
+            listeners: {
+                activeIndexChange: 'onActiveIndexChange',
+                mounted          : 'onMounted'
+            }
+        }]
+    }}
+}
+
+Neo.applyClassConfig(MainContainer);
+
+export default MainContainer;

package/examples/preloadingAssets/view/MainContainerController.mjs

@@ -0,0 +1,41 @@
+import Component from '../../../src/controller/Component.mjs';
+
+/**
+ * @class Neo.examples.preloadingAssets.view.MainContainerController
+ * @extends Neo.controller.Component
+ */
+class MainContainerController extends Component {
+    static getConfig() {return {
+        /**
+         * @member {String} className='Neo.examples.preloadingAssets.view.MainContainerController'
+         * @protected
+         */
+        className: 'Neo.examples.preloadingAssets.view.MainContainerController'
+    }}
+
+    /**
+     * @param {Object} data
+     */
+    onActiveIndexChange(data) {
+        console.log('onActiveIndexChange', data);
+    }
+
+    /**
+     * @param {String} id
+     */
+    onMounted(id) {
+        console.log('onMounted', id);
+
+        setTimeout(() => {
+            Neo.ServiceWorker.preloadAssets({
+                files: ['../resources/examples/ai_images/000074.jpg']
+            }).then(data => {
+                console.log(data);
+            });
+        }, 3000)
+    }
+}
+
+Neo.applyClassConfig(MainContainerController);
+
+export default MainContainerController;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "neo.mjs",
-    "version": "3.2.5",
+    "version": "3.2.8",
     "description": "The webworkers driven UI framework",
     "type": "module",
     "repository": {
@@ -41,16 +41,16 @@
         "chalk": "^5.0.0",
         "clean-webpack-plugin": "^4.0.0",
         "commander": "^9.0.0",
-        "cssnano": "^5.0.17",
+        "cssnano": "^5.1.0",
         "envinfo": "^7.8.1",
-        "fs-extra": "^10.0.0",
+        "fs-extra": "^10.0.1",
         "highlightjs-line-numbers.js": "^2.8.0",
         "inquirer": "^8.1.5",
         "neo-jsdoc": "^1.0.1",
         "neo-jsdoc-x": "^1.0.4",
-        "postcss": "^8.4.6",
-        "sass": "^1.49.8",
-        "webpack": "^5.69.1",
+        "postcss": "^8.4.7",
+        "sass": "^1.49.9",
+        "webpack": "^5.70.0",
         "webpack-cli": "^4.9.2",
         "webpack-dev-server": "4.7.4",
         "webpack-hook-plugin": "^1.0.7",

package/src/DefaultConfig.mjs

@@ -134,7 +134,7 @@ const DefaultConfig = {
      * Experimental flag if an offscreen canvas worker should get created.
      * @default false
      * @memberOf! module:Neo
-     * @name config.useCssVars
+     * @name config.useCanvasWorker
      * @type Boolean
      */
     useCanvasWorker: false,
@@ -163,6 +163,15 @@ const DefaultConfig = {
      * @type Boolean
      */
     useGoogleAnalytics: false,
+    /**
+     * True will add the ServiceWorker main thread addon to support caching of assets (PWA)
+     * See: https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
+     * @default false
+     * @memberOf! module:Neo
+     * @name config.useServiceWorker
+     * @type Boolean
+     */
+    useServiceWorker: false,
     /**
      * Creates App, Data & VDom as SharedWorkers.
      * Set this one to true in case you want to connect multiple main threads.

package/src/Main.mjs

@@ -188,9 +188,11 @@ class Main extends core.Base {
      *
      */
     async onDomContentLoaded() {
-        let me      = this,
-            config  = Neo.config,
-            imports = [];
+        let me               = this,
+            config           = Neo.config,
+            mainThreadAddons = config.mainThreadAddons,
+            imports          = [],
+            modules;
 
         DomAccess.onDomContentLoaded();
 
@@ -203,18 +205,20 @@ class Main extends core.Base {
             __webpack_require__.p = config.basePath.substring(6);
         }
 
-        config.mainThreadAddons.forEach(addon => {
-            if (addon !== 'AnalyticsByGoogle') {
-                imports.push(import(`./main/addon/${addon}.mjs`));
-            }
-        });
-
         // intended for the online examples where we need an easy way to add GA to every generated app
-        if (config.useGoogleAnalytics || config.mainThreadAddons.includes('AnalyticsByGoogle')) {
-            imports.push(import('./main/addon/AnalyticsByGoogle.mjs'));
+        if (config.useGoogleAnalytics && !mainThreadAddons.includes('AnalyticsByGoogle')) {
+            mainThreadAddons.push('AnalyticsByGoogle');
         }
 
-        const modules = await Promise.all(imports);
+        if (config.useServiceWorker && !mainThreadAddons.includes('ServiceWorker')) {
+            mainThreadAddons.push('ServiceWorker');
+        }
+
+        mainThreadAddons.forEach(addon => {
+            imports.push(import(`./main/addon/${addon}.mjs`));
+        });
+
+        modules = await Promise.all(imports);
 
         me.addon = {};
 

package/src/calendar/README.md

@@ -1,2 +1,2 @@
 # Development in progress
-Currently, scheduled for the v2.4 release
+Currently, scheduled for the v4.x release

package/src/calendar/view/EditEventContainer.mjs

@@ -92,10 +92,7 @@ class EditEventContainer extends FormContainer {
      */
     afterSetMounted(value, oldValue) {
         super.afterSetMounted(value, oldValue);
-
-        if (value) {
-            this.getField('title').focus();
-        }
+        value && this.getField('title').focus();
     }
 
     /**

package/src/calendar/view/MainContainer.mjs

@@ -310,7 +310,7 @@ class MainContainer extends Container {
                     style  : {marginLeft: '10px'}
                 });
             }, 10);
-        } else if (value === false && oldValue) {
+        } else if (!value && oldValue) {
             // we only need this logic in case we dynamically change the config from true to false
             me.items[1]         .removeLast();
             me.items[0].items[1].removeLast();
@@ -652,9 +652,7 @@ class MainContainer extends Container {
 
         map[me.activeView]();
 
-        me.model.setData({
-            currentDate: currentDate
-        });
+        me.model.setData({currentDate});
     }
 }
 

package/src/layout/HBox.mjs

@@ -29,9 +29,7 @@ class HBox extends Flexbox {
      */
     applyChildAttributes(item) {
         // Do not apply flex if fixed width
-        if (!item.width) {
-            super.applyChildAttributes(item);
-        }
+        !item.width && super.applyChildAttributes(item);
     }
 }
 

package/src/layout/VBox.mjs

@@ -29,9 +29,7 @@ class VBox extends Flexbox {
      */
     applyChildAttributes(item) {
         // Do not apply flex if fixed height
-        if (!item.height) {
-            super.applyChildAttributes(item);
-        }
+        !item.height && super.applyChildAttributes(item);
     }
 }
 

package/src/main/addon/ServiceWorker.mjs

@@ -0,0 +1,71 @@
+import Base               from '../../core/Base.mjs';
+import RemoteMethodAccess from '../../worker/mixin/RemoteMethodAccess.mjs';
+import WorkerManager      from '../../worker/Manager.mjs';
+
+/**
+ * Creates a ServiceWorker instance, in case Neo.config.useServiceWorker is set to true
+ * @class Neo.main.addon.ServiceWorker
+ * @extends Neo.core.Base
+ * @singleton
+ */
+class ServiceWorker extends Base {
+    static getConfig() {return {
+        /**
+         * @member {String} className='Neo.main.addon.ServiceWorker'
+         * @protected
+         */
+        className: 'Neo.main.addon.ServiceWorker',
+        /**
+         * @member {String[]|Neo.core.Base[]|null} mixins=[RemoteMethodAccess]
+         */
+        mixins: [RemoteMethodAccess],
+        /**
+         * @member {ServiceWorkerRegistration|null} registration=null
+         * @protected
+         */
+        registration: null,
+        /**
+         * @member {Boolean} singleton=true
+         * @protected
+         */
+        singleton: true
+    }}
+
+    /**
+     * @param {Object} config
+     */
+    construct(config) {
+        if ('serviceWorker' in navigator) {
+            let me            = this,
+                config        = Neo.config,
+                devMode       = config.environment === 'development',
+                fileName      = devMode ? 'ServiceWorker.mjs' : 'serviceworker.js',
+                folder        = window.location.pathname.includes('/examples/') ? 'examples/' : 'apps/',
+                opts          = devMode ? {type: 'module'} : {},
+                serviceWorker = navigator.serviceWorker;
+
+            serviceWorker.register(config.basePath + folder + fileName, opts)
+                .then(registration => {
+                    me.registration = registration;
+
+                    serviceWorker.ready.then(() => {
+                        serviceWorker.onmessage = WorkerManager.onWorkerMessage.bind(WorkerManager);
+
+                        WorkerManager.sendMessage('service', {
+                            action     : 'registerNeoConfig',
+                            channelPort: registration.active,
+                            data       : config
+                        });
+                    });
+                })
+        }
+    }
+}
+
+Neo.applyClassConfig(ServiceWorker);
+
+let instance = Neo.create(ServiceWorker);
+
+Neo.applyToGlobalNs(instance);
+
+export default instance;

package/src/main/addon/Stylesheet.mjs

@@ -53,7 +53,6 @@ class Stylesheet extends Base {
 
         if (Neo.config.themes.length > 0 && Neo.config.themes[0] !== '') {
             this.addGlobalCss();
-            // this.insertTheme();
         }
     }
 

package/src/tab/Container.mjs

@@ -139,9 +139,9 @@ class Container extends BaseContainer {
                     me.updateTabButtons();
 
                     me.fire('activeIndexChange', {
-                        item    : me.getActiveCard(),
-                        oldValue: oldValue,
-                        value   : value
+                        item: me.getActiveCard(),
+                        oldValue,
+                        value
                     });
                 }
             }
@@ -245,7 +245,7 @@ class Container extends BaseContainer {
             tabButtons.push(me.getTabButtonConfig(item.tabButtonConfig, index));
 
             if (!(item instanceof Neo.component.Base)) {
-                item = {...me.itemDefaults, flex: 1, isTab:true, ...item};
+                item = {flex: 1, ...me.itemDefaults, isTab: true, ...item};
             }
 
             tabComponents.push(item);

package/src/worker/App.mjs

@@ -72,7 +72,7 @@ class App extends Base {
     }
 
     /**
-     * @param {JSON} data
+     * @param {Object} data
      */
     createThemeMap(data) {
         Neo.ns('Neo.cssMap.fileInfo', true);
@@ -265,7 +265,7 @@ class App extends Base {
         this.onRegisterApp({ appName });
 
         this.sendMessage('main', {
-            action:'registerAppName',
+            action: 'registerAppName',
             appName
         });
     }

package/src/worker/Manager.mjs

@@ -218,6 +218,10 @@ class Manager extends Base {
      * @returns {Worker}
      */
     getWorker(name) {
+        if (name === 'service') {
+            return navigator.serviceWorker?.controller;
+        }
+
         return name instanceof Worker ? name : this.workers[name].worker;
     }
 
@@ -386,7 +390,12 @@ class Manager extends Base {
             message, worker;
 
         if (!me.stopCommunication) {
-            worker = me.getWorker(dest);
+            if (opts.channelPort) {
+                worker = opts.channelPort;
+                delete opts.channelPort;
+            } else {
+                worker = me.getWorker(dest);
+            }
 
             if (!worker) {
                 throw new Error('Called sendMessage for a worker that does not exist: ' + dest);
@@ -396,7 +405,7 @@ class Manager extends Base {
 
             message = new Message(opts);
 
-            (me.sharedWorkersEnabled && NeoConfig.useSharedWorkers ? worker.port : worker).postMessage(message, transfer);
+            (worker.port ? worker.port : worker).postMessage(message, transfer);
             return message;
         }
     }

package/src/worker/ServiceBase.mjs

@@ -0,0 +1,336 @@
+import Base               from '../core/Base.mjs';
+import Message            from './Message.mjs';
+import RemoteMethodAccess from './mixin/RemoteMethodAccess.mjs';
+
+/**
+ * @class Neo.worker.ServiceBase
+ * @extends Neo.core.Base
+ * @abstract
+ */
+class ServiceBase extends Base {
+    /**
+     * @member {Object[]|null} channelPorts=null
+     * @protected
+     */
+    channelPorts = null
+    /**
+     * @member {Client|null} lastClient=null
+     * @protected
+     */
+    lastClient = null
+    /**
+     * @member {Object[]} promises=[]
+     * @protected
+     */
+    promises = []
+    /**
+     * @member {String[]} remotes=[]
+     * @protected
+     */
+    remotes = []
+
+    static getConfig() {return {
+        /**
+         * @member {String} className='Neo.worker.ServiceBase'
+         * @protected
+         */
+        className: 'Neo.worker.ServiceBase',
+        /**
+         * @member {String} cacheName='neo-runtime'
+         */
+        cacheName: 'neo-runtime',
+        /**
+         * @member {String[]|null} cachePaths
+         */
+        cachePaths: [
+            'raw.githubusercontent.com/',
+            '/dist/production/',
+            '/fontawesome',
+            '/resources/'
+        ],
+        /**
+         * @member {String[]|Neo.core.Base[]|null} mixins=[RemoteMethodAccess]
+         */
+        mixins: [RemoteMethodAccess],
+        /**
+         * Remote method access for other workers
+         * @member {Object} remote={app: [//...]}
+         * @protected
+         */
+        remote: {
+            app: [
+                'clearCache',
+                'clearCaches',
+                'preloadAssets'
+            ]
+        },
+        /**
+         * @member {String|null} workerId=null
+         * @protected
+         */
+        workerId: null
+    }}
+
+    /**
+     * @param {Object} config
+     */
+    construct(config) {
+        super.construct(config);
+
+        let me   = this,
+            bind = name => me[name].bind(me);
+
+        me.channelPorts = [];
+
+        Object.assign(globalThis, {
+            onactivate: bind('onActivate'),
+            onfetch   : bind('onFetch'),
+            oninstall : bind('onInstall'),
+            onmessage : bind('onMessage')
+        });
+
+        Neo.currentWorker = me;
+        Neo.workerId      = me.workerId;
+    }
+
+    /**
+     * @param {String} name=this.cacheName
+     */
+    clearCache(name=this.cacheName) {
+        caches.keys()
+            .then(cacheNames     => cacheNames.filter(cacheName => cacheName === name))
+            .then(cachesToDelete => Promise.all(cachesToDelete.map(cacheToDelete => caches.delete(cacheToDelete))))
+    }
+
+    /**
+     *
+     */
+    clearCaches() {
+        caches.keys()
+            .then(cachesToDelete => Promise.all(cachesToDelete.map(cacheToDelete => caches.delete(cacheToDelete))))
+    }
+
+    /**
+     * @param {Client} client
+     */
+    createMessageChannel(client) {
+        let me      = this,
+            channel = new MessageChannel(),
+            port    = channel.port2;
+
+        channel.port1.onmessage = me.onMessage.bind(me);
+
+        me.sendMessage('app', {action: 'registerPort', transfer: port}, [port]);
+
+        me.channelPorts.push({
+            clientId   : client.id,
+            destination: 'app',
+            port       : channel.port1
+        });
+    }
+
+    /**
+     *
+     * @param {String} destination
+     * @param {String} clientId=this.lastClient.id
+     * @returns {MessagePort|null}
+     */
+    getPort(destination, clientId=this.lastClient?.id) {
+        for (let port of this.channelPorts) {
+            if (clientId === port.clientId && destination === port.destination) {
+                return port.port;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Ignore the call in case there is no connected client in place yet
+     */
+    initRemote() {
+        let me           = this,
+            lastClientId = me.lastClient?.id;
+
+        if (lastClientId && !me.remotes.includes(lastClientId)) {
+            me.remotes.push(lastClientId);
+            super.initRemote();
+        }
+    }
+
+    /**
+     * @param {ExtendableMessageEvent} event
+     */
+    onActivate(event) {
+        console.log('onActivate', event);
+    }
+
+    /**
+     * @param {Client} source
+     */
+    onConnect(source) {
+        console.log('onConnect', source);
+
+        this.createMessageChannel(source);
+        this.initRemote();
+    }
+
+    /**
+     * @param {ExtendableMessageEvent} event
+     */
+    onFetch(event) {
+        let hasMatch = false,
+            request  = event.request,
+            key;
+
+        for (key of this.cachePaths) {
+            if (request.url.includes(key)) {
+                hasMatch = true;
+                break;
+            }
+        }
+
+        hasMatch && event.respondWith(
+            caches.match(request)
+                .then(cachedResponse => cachedResponse || caches.open(this.cacheName)
+                .then(cache          => fetch(request)
+                .then(response       => cache.put(request, response.clone())
+                .then(()             => response)
+            )))
+        );
+    }
+
+    /**
+     * @param {ExtendableMessageEvent} event
+     */
+    onInstall(event) {
+        console.log('onInstall', event);
+        globalThis.skipWaiting();
+    }
+
+    /**
+     * For a client based message we receive an ExtendableMessageEvent,
+     * for a MessageChannel based message a MessageEvent
+     * @param {ExtendableMessageEvent|MessageEvent} event
+     */
+    onMessage(event) {
+        let me      = this,
+            data    = event.data,
+            action  = data.action,
+            replyId = data.replyId,
+            promise;
+
+        if (event.source) { // ExtendableMessageEvent
+            me.lastClient = event.source;
+        }
+
+        if (!action) {
+            throw new Error('Message action is missing: ' + data.id);
+        }
+
+        if (action !== 'reply') {
+            me['on' + Neo.capitalize(action)](data, event);
+        } else if (promise = action === 'reply' && me.promises[replyId]) {
+            promise[data.reject ? 'reject' : 'resolve'](data.data);
+            delete me.promises[replyId];
+        }
+    }
+
+    /**
+     * @param {Object} msg
+     * @param {ExtendableMessageEvent} event
+     */
+    onPing(msg, event) {
+        this.resolve(msg, {originMsg: msg});
+    }
+
+    /**
+     * @param {Object} msg
+     * @param {ExtendableMessageEvent} event
+     */
+    onRegisterNeoConfig(msg, event) {
+        Neo.config = Neo.config || {};
+        Object.assign(Neo.config, msg.data);
+
+        this.onConnect(event.source);
+    }
+
+    /**
+     * @param {Object} data
+     * @param {String} [data.cacheName=this.cacheName]
+     * @param {String[]|String} data.files
+     * @param {Boolean} [data.foreReload=false]
+     */
+    async preloadAssets(data) {
+        let cacheName = data.cacheName || this.cacheName,
+            cache     = await caches.open(cacheName),
+            files     = data.files,
+            items     = [],
+            asset, hasMatch, item;
+
+        if (!Array.isArray(files)) {
+            files = [files];
+        }
+
+        for (item of files) {
+            hasMatch = false;
+
+            if (!data.forceReload) {
+                asset    = await cache.match(item);
+                hasMatch = !!asset;
+            }
+
+            if (!hasMatch) {
+                items.push(item);
+            }
+        }
+
+        if (items.length > 0) {
+            await cache.addAll(items);
+        }
+
+        return {success: true};
+    }
+
+    /**
+     * @param {String} dest app, data, main or vdom (excluding the current worker)
+     * @param {Object} opts configs for Neo.worker.Message
+     * @param {Array} [transfer] An optional array of Transferable objects to transfer ownership of.
+     * If the ownership of an object is transferred, it becomes unusable (neutered) in the context it was sent from
+     * and becomes available only to the worker it was sent to.
+     * @returns {Promise<any>}
+     */
+    promiseMessage(dest, opts, transfer) {
+        let me = this;
+
+        return new Promise(function(resolve, reject) {
+            let message = me.sendMessage(dest, opts, transfer),
+                msgId   = message.id;
+
+            me.promises[msgId] = {reject, resolve};
+        });
+    }
+
+    /**
+     * @param {String} dest app, data, main or vdom (excluding the current worker)
+     * @param {Object} opts configs for Neo.worker.Message
+     * @param {Array} [transfer] An optional array of Transferable objects to transfer ownership of.
+     * If the ownership of an object is transferred, it becomes unusable (neutered) in the context it was sent from
+     * and becomes available only to the worker it was sent to.
+     * @returns {Neo.worker.Message}
+     * @protected
+     */
+    sendMessage(dest, opts, transfer) {
+        opts.destination = dest;
+
+        let message = new Message(opts),
+            port    = this.getPort(dest) || this.lastClient;
+
+        port.postMessage(message, transfer);
+        return message;
+    }
+}
+
+Neo.applyClassConfig(ServiceBase);
+
+export default ServiceBase;

package/src/worker/mixin/RemoteMethodAccess.mjs

@@ -56,7 +56,7 @@ class RemoteMethodAccess extends Base {
                 methods   = remote.methods,
                 pkg       = Neo.ns(className, true);
 
-            methods.forEach(function(method) {
+            methods.forEach(method => {
                 if (remote.origin !== 'main' && pkg[method]) {
                     throw new Error('Duplicate remote method definition ' + className + '.' + method);
                 }