@schukai/monster 2.2.1 → 3.1.0

package/README.md

@@ -73,7 +73,7 @@ We do try to work around some browser bugs, but on the whole we don't use polyfi
 However, many functions can be mapped via [polyfill.io](https://polyfill.io/) and thus the compatibility can be increased.
 
 ```html
-<script id="polyfill" src="https://polyfill.io/v3/polyfill.min.js?features=Array.from,Array.isArray,Array.prototype.entries,Array.prototype.fill,Array.prototype.filter,Array.prototype.forEach,Array.prototype.indexOf,Array.prototype.keys,Array.prototype.lastIndexOf,Array.prototype.map,Array.prototype.reduce,Array.prototype.sort,ArrayBuffer,atob,CustomEvent,DataView,document,Document,DocumentFragment,Element,Event,fetch,globalThis,HTMLDocument,HTMLTemplateElement,Intl,JSON,Map,Math.log2,Number.isInteger,Object.assign,Object.defineProperty,Object.entries,Object.freeze,Object.getOwnPropertyDescriptor,Object.getOwnPropertyNames,Object.getOwnPropertySymbols,Object.getPrototypeOf,Object.keys,Promise,Reflect,Reflect.defineProperty,Reflect.get,Reflect.getOwnPropertyDescriptor,Reflect.setPrototypeOf,Set,String.prototype.endsWith,String.prototype.matchAll,String.prototype.padStart,String.prototype.startsWith,String.prototype.trim,Symbol,Symbol.for,Symbol.hasInstance,Symbol.iterator,Uint16Array,Uint8Array,URL,WeakMap,WeakSet"
+<script id="polyfill" src="https://polyfill.io/v3/polyfill.min.js?features=Array.from,Array.isArray,Array.prototype.entries,Array.prototype.fill,Array.prototype.filter,Array.prototype.forEach,Array.prototype.indexOf,Array.prototype.keys,Array.prototype.lastIndexOf,Array.prototype.map,Array.prototype.reduce,Array.prototype.sort,ArrayBuffer,atob,CustomEvent,DataView,document,Document,DocumentFragment,Element,Event,fetch,globalThis,HTMLDocument,HTMLTemplateElement,Intl,JSON,Map,Math.log2,Number.isInteger,Object.assign,Object.defineProperty,Object.entries,Object.freeze,Object.getOwnPropertyDescriptor,Object.getOwnPropertyNames,Object.getPrototypeOf,Object.keys,Promise,Reflect,Reflect.defineProperty,Reflect.get,Reflect.getOwnPropertyDescriptor,Reflect.setPrototypeOf,Set,String.prototype.endsWith,String.prototype.matchAll,String.prototype.padStart,String.prototype.startsWith,String.prototype.trim,Symbol,Symbol.for,Symbol.hasInstance,Symbol.iterator,Uint16Array,Uint8Array,URL,WeakMap,WeakSet"
        crossorigin="anonymous"
        referrerpolicy="no-referrer"></script>
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schukai/monster",
-  "version": "2.2.1",
+  "version": "3.1.0",
   "description": "Monster is a simple library for creating fast, robust and lightweight websites.",
   "keywords": [
     "framework",

package/source/data/datasource/restapi.mjs

@@ -22,7 +22,7 @@ export {RestAPI}
  * @since 1.22.0
  * @copyright schukai GmbH
  * @memberOf Monster.Data.Datasource
- * @summary The LocalStorage class encapsulates the access to data objects.
+ * @summary The RestAPI is a class that binds a REST API server.
  */
 class RestAPI extends Datasource {
 
@@ -30,7 +30,6 @@ class RestAPI extends Datasource {
      *
      * @param {Object} [readDefinition] An options object containing any custom settings that you want to apply to the read request.
      * @param {Object} [writeDefinition] An options object containing any custom settings that you want to apply to the write request.
-     * @throws {TypeError} value is not a string
      */
     constructor(readDefinition, writeDefinition) {
         super();
@@ -54,17 +53,21 @@ class RestAPI extends Datasource {
     }    
     
     /**
-     * @property {string} url=undefined Defines the resource that you wish to fetch.
      * @property {Object} write={} Options
      * @property {Object} write.init={} An options object containing any custom settings that you want to apply to the request. The parameters are identical to those of the {@link https://developer.mozilla.org/en-US/docs/Web/API/Request/Request|Request constructor}
      * @property {string} write.init.method=POST
+     * @property {Object} write.init.headers Object containing any custom headers that you want to apply to the request.
      * @property {string} write.acceptedStatus=[200,201]
      * @property {string} write.url URL
      * @property {Object} write.mapping the mapping is applied before writing.
      * @property {String} write.mapping.transformer Transformer to select the appropriate entries
+     * @property {Monster.Data.Datasource~exampleCallback[]} write.mapping.callback with the help of the callback, the structures can be adjusted before writing.
      * @property {Object} write.report
      * @property {String} write.report.path Path to validations
-     * @property {Monster.Data.Datasource~exampleCallback[]} write.mapping.callback with the help of the callback, the structures can be adjusted before writing.
+     * @property {Object} write.sheathing 
+     * @property {Object} write.sheathing.object Object to be wrapped
+     * @property {string} write.sheathing.path Path to the data 
+     * @property {Object} read={} Options
      * @property {Object} read.init={} An options object containing any custom settings that you want to apply to the request. The parameters are identical to those of the {@link https://developer.mozilla.org/en-US/docs/Web/API/Request/Request|Request constructor}
      * @property {string} read.init.method=GET
      * @property {string} read.acceptedStatus=[200]
@@ -85,6 +88,10 @@ class RestAPI extends Datasource {
                     transformer: undefined,
                     callbacks: []
                 },
+                sheathing: {
+                    object: undefined,
+                    path: undefined,
+                },
                 report: {
                     path: undefined
                 }
@@ -146,6 +153,11 @@ class RestAPI extends Datasource {
             let transformation = self.getOption('read.mapping.transformer');
             if (transformation !== undefined) {
                 const pipe = new Pipe(transformation);
+
+                for (const callback of self.getOption('read.mapping.callbacks')) {
+                    pipe.setCallback(callback.constructor.name, callback);
+                }                
+                
                 obj = pipe.run(obj);
             }
 
@@ -174,6 +186,11 @@ class RestAPI extends Datasource {
         let transformation = self.getOption('write.mapping.transformer');
         if (transformation !== undefined) {
             const pipe = new Pipe(transformation);
+
+            for (const callback of self.getOption('write.mapping.callbacks')) {
+                pipe.setCallback(callback.constructor.name, callback);
+            }
+            
             obj = pipe.run(obj);
         }
 
@@ -234,12 +251,3 @@ class RestAPI extends Datasource {
 }
 
 
-/**
- * This callback can be passed to a datasource and is used to adapt data structures.
- *
- * @callback Monster.Data.Datasource~exampleCallback
- * @param {*} value Value
- * @param {string} key  Key
- * @memberOf Monster.Data
- * @see Monster.Data.Datasource
- */

package/source/data/datasource/websocket.mjs

@@ -0,0 +1,337 @@
+/**
+ * Copyright schukai GmbH and contributors 2022. All Rights Reserved.
+ * Node module: @schukai/monster
+ * This file is licensed under the AGPLv3 License.
+ * License text available at https://www.gnu.org/licenses/agpl-3.0.en.html
+ */
+
+import {internalSymbol, instanceSymbol} from "../../constants.mjs";
+import {isInteger, isString, isObject} from "../../types/is.mjs";
+import {Queue} from "../../types/queue.mjs";
+import {Datasource} from "../datasource.mjs";
+import {Pathfinder} from "../pathfinder.mjs";
+import {Pipe} from "../pipe.mjs";
+
+export {WebSocketDatasource}
+
+/**
+ * @private
+ * @type {symbol}
+ */
+const receiveQueueSymbol = Symbol("queue");
+
+
+/**
+ * @private
+ * @type {symbol}
+ * 
+ * hint: this name is used in the tests. if you want to change it, please change it in the tests as well.
+ */
+const connectionSymbol = Symbol("connection");
+
+/**
+ * @private
+ * @type {symbol}
+ */
+const manualCloseSymbol = Symbol("manualClose");
+
+/**
+ * @see https://www.rfc-editor.org/rfc/rfc6455.html#section-7.4.1
+ * @type {{"1000": string, "1011": string, "1010": string, "1008": string, "1007": string, "1006": string, "1005": string, "1004": string, "1015": string, "1003": string, "1002": string, "1001": string, "1009": string}}
+ */
+const connectionStatusCode = {
+    1000: "Normal closure",
+    1001: "Going away",
+    1002: "Protocol error",
+    1003: "Unsupported data",
+    1004: "Reserved",
+    1005: "No status code",
+    1006: "Connection closed abnormally",
+    1007: "Invalid frame payload data",
+    1008: "Policy violation",
+    1009: "Message too big",
+    1010: "Mandatory extension",
+    1011: "Internal server error",
+    1015: "TLS handshake"
+};
+
+/**
+ * The RestAPI is a class that enables a REST API server.
+ *
+ * @externalExample ../../../example/data/storage/restapi.mjs
+ * @license AGPLv3
+ * @since 3.1.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Data.Datasource
+ * @summary The LocalStorage class encapsulates the access to data objects.
+ */
+class WebSocketDatasource extends Datasource {
+
+    /**
+     *
+     * @param {Object} [options] options contains definitions for the datasource.
+     */
+    constructor(options) {
+        super();
+
+        if (isString(options)) {
+            options = {url: options};
+        }
+
+        if (!isObject(options)) options = {};
+        this.setOptions(options);
+        this[receiveQueueSymbol] = new Queue();
+
+        this[connectionSymbol] = {};
+        this[connectionSymbol].socket = null;
+        this[connectionSymbol].reconnectCounter = 0;
+        this[manualCloseSymbol]=false;
+    }
+
+    /**
+     *
+     * @returns {Websocketdatasource}
+     * @throws {Error} No url defined for websocket datasource.
+     */
+    connect() {
+        const self = this;
+
+        let connected = false;
+        let reconnectTimeout = self.getOption('reconnect.timeout');
+        if (!isInteger(reconnectTimeout) || reconnectTimeout < 1000) reconnectTimeout = 1000;
+        let reconnectAttempts = self.getOption('reconnect.attempts');
+        if (!isInteger(reconnectAttempts) || reconnectAttempts < 1) reconnectAttempts = 1;
+        let reconnectEnabled = self.getOption('reconnect.enabled');
+        if (reconnectEnabled !== true) reconnectEnabled = false;
+
+        self[manualCloseSymbol] = false;
+        self[connectionSymbol].reconnectCounter++;
+
+        if (self[connectionSymbol].socket && self[connectionSymbol].socket.readyState < 2) {
+            self[connectionSymbol].socket.close();
+        }
+        self[connectionSymbol].socket = null;
+
+        const url = self.getOption('url');
+        if (!url) throw new Error('No url defined for websocket datasource.');
+
+        self[connectionSymbol].socket = new WebSocket(url);
+
+        self[connectionSymbol].socket.onmessage = function (event) {
+            self[receiveQueueSymbol].add(event);
+            setTimeout(function () {
+                self.read();
+            }, 0);
+        };
+
+        self[connectionSymbol].socket.onopen = function () {
+            connected = true;
+            self[connectionSymbol].reconnectCounter = 0;
+        };
+
+        self[connectionSymbol].socket.close = function (event) {
+            
+            if (self[manualCloseSymbol]) {
+                self[manualCloseSymbol] = false;
+                return;
+            }
+
+            if (reconnectEnabled && this[connectionSymbol].reconnectCounter < reconnectAttempts) {
+                setTimeout(() => {
+                    self.connect();
+                }, reconnectTimeout * this[connectionSymbol].reconnectCounter);
+            }
+
+        };
+
+        self[connectionSymbol].socket.onerror = (error) => {
+
+            if (reconnectEnabled && self[connectionSymbol].reconnectCounter < reconnectAttempts) {
+                setTimeout(() => {
+                    self.connect();
+                }, reconnectTimeout * this[connectionSymbol].reconnectCounter);
+            }
+
+        };
+    }
+
+    isConnected() {
+        return this[connectionSymbol].socket && this[connectionSymbol].socket.readyState === 1;
+    }
+
+    /**
+     * This method is called by the `instanceof` operator.
+     * @returns {symbol}
+     */
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/data/datasource/websocket");
+    }
+
+    /**
+     * @property {string} url=undefined Defines the resource that you wish to fetch.
+     * @property {Number} reconnect.timeout The timeout in milliseconds for the reconnect.
+     * @property {Number} reconnect.attempts The maximum number of reconnects.
+     * @property {Bool} reconnect.enabled If the reconnect is enabled.
+     * @property {Object} write={} Options
+     * @property {Object} write.mapping the mapping is applied before writing.
+     * @property {String} write.mapping.transformer Transformer to select the appropriate entries
+     * @property {Monster.Data.Datasource~exampleCallback[]} write.mapping.callback with the help of the callback, the structures can be adjusted before writing.
+     * @property {Object} write.report
+     * @property {String} write.report.path Path to validations
+     * @property {Object} write.sheathing
+     * @property {Object} write.sheathing.object Object to be wrapped
+     * @property {string} write.sheathing.path Path to the data
+     * @property {Object} read={} Options
+     * @property {Object} read.mapping the mapping is applied after reading.
+     * @property {String} read.mapping.transformer Transformer to select the appropriate entries
+     * @property {Monster.Data.Datasource~exampleCallback[]} read.mapping.callback with the help of the callback, the structures can be adjusted after reading.
+     */
+    get defaults() {
+        return Object.assign({}, super.defaults, {
+            url: undefined,
+            write: {
+                mapping: {
+                    transformer: undefined,
+                    callbacks: []
+                },
+                report: {
+                    path: undefined
+                },
+                sheathing: {
+                    object: undefined,
+                    path: undefined,
+                },
+            },
+            read: {
+                mapping: {
+                    transformer: undefined,
+                    callbacks: []
+                },
+            },
+            reconnect: {
+                timeout: 1000,
+                attempts: 10,
+                enabled: true
+            }
+        });
+    }
+
+    /**
+     * This method closes the connection.
+     * 
+     * @returns {Promise}
+     */
+    close() {
+        this[manualCloseSymbol]=true;
+        if (this[connectionSymbol].socket) {
+            this[connectionSymbol].socket.close();
+        }
+        return this;
+    }
+
+    /**
+     * @return {Promise}
+     * @throws {Error} the options does not contain a valid json definition
+     * @throws {Error} the data cannot be read
+     * @throws {TypeError} value is not an object
+     */
+    read() {
+        const self = this;
+        let response;
+
+        return new Promise((resolve, reject) => {
+            if (self[receiveQueueSymbol].isEmpty()) {
+                resolve();
+            }
+
+            while (!self[receiveQueueSymbol].isEmpty()) {
+                
+                const event = self[receiveQueueSymbol].poll();
+                const body = event?.data;
+                if (!body) continue;
+
+                let obj;
+                try {
+                    obj = JSON.parse(body);
+                } catch (e) {
+
+                    let msg = 'the response does not contain a valid json (actual: ';
+
+                    if (body.length > 100) {
+                        msg += body.substring(0, 97) + '...';
+                    } else {
+                        msg += body;
+                    }
+
+                    msg += "; " + e.message + ')';
+
+                    reject(msg);
+                }
+
+                let transformation = self.getOption('read.mapping.transformer');
+                if (transformation !== undefined) {
+                    const pipe = new Pipe(transformation);
+
+                    for (const callback of self.getOption('read.mapping.callbacks')) {
+                        pipe.setCallback(callback.constructor.name, callback);
+                    }
+
+                    obj = pipe.run(obj);
+                }
+
+                self.set(obj);
+                return response;
+            }
+        })
+    }
+
+    /**
+     * @return {Promise}
+     */
+    write() {
+        const self = this;
+
+        let obj = self.get();
+        let transformation = self.getOption('write.mapping.transformer');
+        if (transformation !== undefined) {
+            const pipe = new Pipe(transformation);
+
+            for (const callback of self.getOption('write.mapping.callbacks')) {
+                pipe.setCallback(callback.constructor.name, callback);
+            }
+
+            obj = pipe.run(obj);
+        }
+
+        let sheathingObject = self.getOption('write.sheathing.object');
+        let sheathingPath = self.getOption('write.sheathing.path');
+        let reportPath = self.getOption('write.report.path');
+
+        if (sheathingObject && sheathingPath) {
+            const sub = obj;
+            obj = sheathingObject;
+            (new Pathfinder(obj)).setVia(sheathingPath, sub);
+        }
+
+        return new Promise((resolve, reject) => {
+            
+            if (self[connectionSymbol].socket.readyState !== 1) {
+                reject('the socket is not ready');
+            }
+
+            self[connectionSymbol].socket.send(JSON.stringify(obj))
+            resolve();
+        });
+    }
+
+
+    /**
+     * @return {RestAPI}
+     */
+    getClone() {
+        const self = this;
+        return new Websocketdatasource(self[internalSymbol].getRealSubject()['options']);
+    }
+
+}
+

package/source/data/datasource.mjs

@@ -17,6 +17,18 @@ import {Pathfinder} from "./pathfinder.mjs";
 
 export {Datasource}
 
+
+/**
+ * This callback can be passed to a datasource and is used to adapt data structures.
+ *
+ * @callback Monster.Data.Datasource~exampleCallback
+ * @param {*} value Value
+ * @param {string} key  Key
+ * @memberOf Monster.Data
+ * @see Monster.Data.Datasource
+ */
+
+
 /**
  * @private
  * @type {symbol}

package/source/dom/constants.mjs

@@ -59,6 +59,7 @@ export {
     ATTRIBUTE_EXPORTPARTS,
     ATTRIBUTE_HIDDEN,
     objectUpdaterLinkSymbol,
+    customElementUpdaterLinkSymbol
 
 }
 
@@ -223,6 +224,14 @@ const ATTRIBUTE_ERRORMESSAGE = ATTRIBUTE_PREFIX + 'error';
  */
 const objectUpdaterLinkSymbol = Symbol.for('@schukai/monster/dom/@@object-updater-link');
 
+/**
+ * @memberOf Monster.DOM
+ * @type {symbol}
+ * @license AGPLv3
+ * @since 1.24.0
+ */
+const customElementUpdaterLinkSymbol = Symbol.for('@schukai/monster/dom/custom-element@@options-updater-link');
+
 /**
  * @memberOf Monster.DOM
  * @type {string}

package/source/dom/customelement.mjs

@@ -16,19 +16,26 @@ import {Observer} from "../types/observer.mjs";
 import {ProxyObserver} from "../types/proxyobserver.mjs";
 import {validateFunction, validateInstance, validateObject, validateString} from "../types/validate.mjs";
 import {clone} from "../util/clone.mjs";
-import {addAttributeToken, addToObjectLink, getLinkedObjects, hasObjectLink} from "./attributes.mjs";
+import {addAttributeToken, getLinkedObjects, hasObjectLink} from "./attributes.mjs";
 import {
     ATTRIBUTE_DISABLED,
     ATTRIBUTE_ERRORMESSAGE,
     ATTRIBUTE_OPTIONS,
     ATTRIBUTE_OPTIONS_SELECTOR,
-    objectUpdaterLinkSymbol
+    customElementUpdaterLinkSymbol
 } from "./constants.mjs";
 import {findDocumentTemplate, Template} from "./template.mjs";
-import {Updater} from "./updater.mjs";
+import {addObjectWithUpdaterToElement} from "./updater.mjs";
 import {instanceSymbol} from '../constants.mjs';
 
-export {CustomElement, initMethodSymbol, assembleMethodSymbol, attributeObserverSymbol, registerCustomElement, assignUpdaterToElement, getSlottedElements}
+export {
+    CustomElement,
+    initMethodSymbol,
+    assembleMethodSymbol,
+    attributeObserverSymbol,
+    registerCustomElement,
+    getSlottedElements
+}
 
 /**
  * @memberOf Monster.DOM
@@ -460,7 +467,7 @@ class CustomElement extends HTMLElement {
             nodeList = elements
         }
 
-        assignUpdaterToElement.call(self, nodeList, clone(self[internalSymbol].getRealSubject()['options']));
+        addObjectWithUpdaterToElement.call(self, nodeList, customElementUpdaterLinkSymbol, clone(self[internalSymbol].getRealSubject()['options']))
         return self;
     }
 
@@ -473,7 +480,7 @@ class CustomElement extends HTMLElement {
      */
     connectedCallback() {
         let self = this;
-        if (!hasObjectLink(self, objectUpdaterLinkSymbol)) {
+        if (!hasObjectLink(self, customElementUpdaterLinkSymbol)) {
             self[assembleMethodSymbol]()
         }
     }
@@ -673,11 +680,11 @@ function initOptionObserver() {
     self.attachObserver(new Observer(function () {
 
         // not initialised
-        if (!hasObjectLink(self, objectUpdaterLinkSymbol)) {
+        if (!hasObjectLink(self, customElementUpdaterLinkSymbol)) {
             return;
         }
         // inform every element
-        const updaters = getLinkedObjects(self, objectUpdaterLinkSymbol);
+        const updaters = getLinkedObjects(self, customElementUpdaterLinkSymbol);
 
         for (const list of updaters) {
             for (const updater of list) {
@@ -935,44 +942,3 @@ function registerCustomElement(element) {
     getGlobalObject('customElements').define(element.getTag(), element);
 }
 
-
-/**
- *
- * @param element
- * @param object
- * @return {Promise[]}
- * @license AGPLv3
- * @since 1.23.0
- * @memberOf Monster.DOM
- */
-function assignUpdaterToElement(elements, object) {
-
-    const updaters = new Set;
-
-    if (elements instanceof NodeList) {
-        elements = new Set([
-            ...elements
-        ])
-    }
-
-    let result = [];
-
-    elements.forEach((element) => {
-        if (!(element instanceof HTMLElement)) return;
-        if ((element instanceof HTMLTemplateElement)) return;
-
-        const u = new Updater(element, object)
-        updaters.add(u);
-
-        result.push(u.run().then(() => {
-            return u.enableEventProcessing();
-        }));
-
-    });
-
-    if (updaters.size > 0) {
-        addToObjectLink(this, objectUpdaterLinkSymbol, updaters);
-    }
-
-    return result;
-}