@schukai/monster 3.2.0 → 3.4.0

package/source/net/webconnect/message.mjs

@@ -0,0 +1,55 @@
+/**
+ * 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 {Base} from "../../types/base.mjs";
+import {validateObject, validateString} from "../../types/validate.mjs";
+
+export {Message}
+
+const dataSymbol = Symbol("@@data");
+
+/**
+ * This class represents a WebSocket message.
+ */
+class Message extends Base {
+
+    /**
+     * @param {Object} data
+     * @throws {TypeError} value is not a object
+     */
+    constructor(data) {
+        super();
+        this[dataSymbol] = validateObject(data);
+    }
+    
+    /**
+     * Returns the raw message.
+     * 
+     * @returns {object}
+     */
+    getData() {
+        return this[dataSymbol];
+    }
+
+    /**
+     * @returns {*}
+     */
+    toJSON() {
+        return this[dataSymbol];
+    }
+
+    /**
+     * @param {string} json
+     * @returns {Message}
+     * @throws {TypeError} value is not a string
+     */
+    static fromJSON(json) {
+        validateString(json);
+        return new Message(JSON.parse(json));
+    }
+
+}

package/source/{data/datasource/websocket.mjs → net/webconnect.mjs}

@@ -5,21 +5,25 @@
  * 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";
+import {instanceSymbol} from "../constants.mjs";
+import {isInteger, isString, isObject} from "../types/is.mjs";
+import {BaseWithOptions} from "../types/basewithoptions.mjs";
+import {ObservableQueue} from "../types/observablequeue.mjs";
+import {Message} from "./webconnect/message.mjs";
 
-export {WebSocketDatasource}
+
+export {WebConnect}
 
 /**
  * @private
  * @type {Symbol}
  */
-const receiveQueueSymbol = Symbol("queue");
-
+const receiveQueueSymbol = Symbol("receiveQueue");
+/**
+ * @private
+ * @type {Symbol}
+ */
+const sendQueueSymbol = Symbol("sendQueue");
 
 /**
  * @private
@@ -36,6 +40,7 @@ const connectionSymbol = Symbol("connection");
 const manualCloseSymbol = Symbol("manualClose");
 
 /**
+ * @private
  * @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}}
  */
@@ -57,13 +62,20 @@ const connectionStatusCode = {
 
 /**
  * @private
- * @this {WebSocketDatasource}
+ * @this {WebConnect}
  * @throws {Error} No url defined for websocket datasource.
  */
 function connectServer(resolve, reject) {
     const self = this;
 
+    const url = self.getOption('url');
+    if (!url) {
+        reject('No url defined for webconnect.');
+        return;
+    }
+
     let promiseAllredyResolved = false;
+
     let connectionTimeout = self.getOption('connection.timeout');
     if (!isInteger(connectionTimeout) || connectionTimeout < 100) {
         connectionTimeout = 5000;
@@ -90,20 +102,18 @@ function connectServer(resolve, reject) {
         self[connectionSymbol].socket.close();
     }
     self[connectionSymbol].socket = null;
-
-    const url = self.getOption('url');
-    if (!url) {
-        reject('No url defined for websocket datasource.');
-        return;
-    }
-
     self[connectionSymbol].socket = new WebSocket(url);
 
     self[connectionSymbol].socket.onmessage = function (event) {
-        self[receiveQueueSymbol].add(event);
-        setTimeout(function () {
-            self.read();
-        }, 1);
+        if (event.data instanceof Blob) {
+            const reader = new FileReader();
+            reader.addEventListener("loadend", function () {
+                self[receiveQueueSymbol].add(new Message(reader.result))
+            });
+            reader.readAsText(new Message(event.data));
+        } else {
+            self[receiveQueueSymbol].add(Message.fromJSON(event.data));
+        }
     };
 
     self[connectionSymbol].socket.onopen = function () {
@@ -155,22 +165,22 @@ function connectServer(resolve, reject) {
  * @memberOf Monster.Data.Datasource
  * @summary The LocalStorage class encapsulates the access to data objects.
  */
-class WebSocketDatasource extends Datasource {
+class WebConnect extends BaseWithOptions {
 
     /**
      *
      * @param {Object} [options] options contains definitions for the datasource.
      */
     constructor(options) {
-        super();
 
         if (isString(options)) {
             options = {url: options};
         }
+        
+        super(options);
 
-        if (!isObject(options)) options = {};
-        this.setOptions(options);
-        this[receiveQueueSymbol] = new Queue();
+        this[receiveQueueSymbol] = new ObservableQueue();
+        this[sendQueueSymbol] = new ObservableQueue();
 
         this[connectionSymbol] = {};
         this[connectionSymbol].socket = null;
@@ -194,7 +204,7 @@ class WebSocketDatasource extends Datasource {
      * @returns {boolean}
      */
     isConnected() {
-      return this[connectionSymbol]?.socket?.readyState === 1;
+        return this[connectionSymbol]?.socket?.readyState === 1;
     }
 
     /**
@@ -202,7 +212,7 @@ class WebSocketDatasource extends Datasource {
      * @returns {symbol}
      */
     static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/data/datasource/websocket");
+        return Symbol.for("@schukai/monster/net/webconnect");
     }
 
     /**
@@ -212,42 +222,10 @@ class WebSocketDatasource extends Datasource {
      * @property {Number} connection.reconnect.timeout The timeout in milliseconds for the reconnect.
      * @property {Number} connection.reconnect.attempts The maximum number of reconnects.
      * @property {Bool} connection.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: []
-                },
-            },
             connection: {
                 timeout: 5000,
                 reconnect: {
@@ -262,124 +240,107 @@ class WebSocketDatasource extends Datasource {
     /**
      * This method closes the connection.
      *
+     * @param {Number} [code=1000] The close code.
+     * @param {String} [reason=""] The close reason.
      * @returns {Promise}
+     * @see https://www.rfc-editor.org/rfc/rfc6455.html#section-7.4.1
      */
-    close() {
-        this[manualCloseSymbol] = true;
-        if (this[connectionSymbol].socket) {
-            this[connectionSymbol].socket.close();
+    close(statusCode, reason ) {
+        if (!isInteger(statusCode) || statusCode < 1000 || statusCode > 4999) {
+            statusCode = 1000;
         }
-        return this;
-    }
-
-    /**
-     * @return {Promise}
-     */
-    read() {
-        const self = this;
-        let response;
-
-        if (self[connectionSymbol]?.socket?.readyState !== 1) {
-            return Promise.reject('The connection is not established.');
+        if (!isString(reason)) {
+            reason = '';
         }
 
         return new Promise((resolve, reject) => {
-            if (self[receiveQueueSymbol].isEmpty()) {
-                resolve();
+            try {
+                this[manualCloseSymbol] = true;
+                if (this[connectionSymbol].socket) {
+                    this[connectionSymbol].socket.close(statusCode, reason);
+                }
+            } catch (error) {
+                reject(error);
             }
+            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 + ')';
+    /**
+     * Polls the receive queue for new messages.
+     * 
+     * @returns {Message}
+     */
+    poll() {
+        return this[receiveQueueSymbol].poll();
+    }
 
-                    reject(msg);
-                }
+    /**
+     * Are there any messages in the receive queue? 
+     * 
+     * @returns {boolean}
+     */
+    dataReceived() {
+        return !this[receiveQueueSymbol].isEmpty();
+    }
 
-                let transformation = self.getOption('read.mapping.transformer');
-                if (transformation !== undefined) {
-                    const pipe = new Pipe(transformation);
+    /**
+     * Get Message from the receive queue, but do not remove it.
+     * 
+     * @returns {Object}
+     */
+    peek() {
+        return this[receiveQueueSymbol].peek();
+    }
 
-                    for (const callback of self.getOption('read.mapping.callbacks')) {
-                        pipe.setCallback(callback.constructor.name, callback);
-                    }
+    /**
+     * Attach a new observer
+     *
+     * @param {Observer} observer
+     * @returns {ProxyObserver}
+     */
+    attachObserver(observer) {
+        this[receiveQueueSymbol].attachObserver(observer);
+        return this;
+    }
 
-                    obj = pipe.run(obj);
-                }
+    /**
+     * Detach a observer
+     *
+     * @param {Observer} observer
+     * @returns {ProxyObserver}
+     */
+    detachObserver(observer) {
+        this[receiveQueueSymbol].detachObserver(observer);
+        return this;
+    }
 
-                self.set(obj);
-                return response;
-            }
-        })
+    /**
+     * @param {Observer} observer
+     * @returns {boolean}
+     */
+    containsObserver(observer) {
+        return this[receiveQueueSymbol].containsObserver(observer);
     }
 
     /**
+     * @param {Message|Object} message
      * @return {Promise}
      */
-    write() {
+    send(message) {
         const self = this;
 
-        if (self[connectionSymbol]?.socket?.readyState !== 1) {
-            return Promise.reject('The connection is not established.');
-        }
-
-        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))
+            self[connectionSymbol].socket.send(JSON.stringify(message))
             resolve();
         });
     }
 
-
-    /**
-     * @return {RestAPI}
-     */
-    getClone() {
-        const self = this;
-        return new WebSocketDatasource(self[internalSymbol].getRealSubject()['options']);
-    }
-
 }
 

package/source/types/global.mjs

@@ -84,7 +84,7 @@ function getGlobal() {
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.0/dist/monster.mjs';
+ * import {Monster} from '@schukai/monster/source/monster.mjs';
  * Monster.Types.getGlobalObject('document')
  * // ↦ { }
  * </script>
@@ -124,7 +124,7 @@ function getGlobalObject(name) {
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.0/dist/monster.mjs';
+ * import {Monster} from '@schukai/monster/source/monster.mjs';
  * console.log(Monster.Types.getGlobalFunction('parseInt')) // ↦ f parseInt() { }
  * </script>
  * ```

package/source/types/mediatype.mjs

@@ -134,7 +134,7 @@ class MediaType extends Base {
  *
  * ```
  * <script type="module">
- * import {Monster} from '@schukai/monster/source//monster.mjs';
+ * import {Monster} from '@schukai/monster/source/monster.mjs';
  * console.log(Monster.Types.parseMediaType())
  * </script>
  * ```

package/source/types/observablequeue.mjs

@@ -0,0 +1,110 @@
+/**
+ * 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 {Queue} from './queue.mjs';
+import {instanceSymbol, internalSymbol} from '../constants.mjs';
+import {ObserverList} from "./observerlist.mjs";
+
+export {ObservableQueue};
+
+/**
+ * An observable queue is a list of items that are processed one after another (first in, first out).
+ * 
+ * `Queue.add()` and `Queue.clear()` notify all observers.
+ * 
+ * @externalExample ../../example/types/queue.mjs
+ * @license AGPLv3
+ * @since 3.3.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Types
+ * @summary An observable Queue (Fifo)
+ */
+class ObservableQueue extends Queue {
+
+    /**
+     *
+     */
+    constructor() {
+        super();
+        this[internalSymbol]= {
+            observers: new ObserverList()
+        };
+    }
+
+    /**
+     * This method is called by the `instanceof` operator.
+     * @returns {symbol}
+     * @since 2.1.0
+     */
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/types/observablequeue");
+    }
+    
+    /**
+     * Add a new element to the end of the queue.
+     *
+     * @param {*} value
+     * @returns {Queue}
+     */
+    add(value) {
+        super.add(value);
+        this.notifyObservers();
+        return this;
+    }
+
+    /**
+     * remove all entries
+     *
+     * @returns {Queue}
+     */
+    clear() {
+        super.clear();
+        this.notifyObservers();
+        return this;
+    }
+
+    /**
+     * Attach a new observer
+     *
+     * @param {Observer} observer
+     * @returns {ProxyObserver}
+     */
+    attachObserver(observer) {
+        this[internalSymbol].observers.attach(observer)
+        return this;
+    }
+
+    /**
+     * Detach a observer
+     *
+     * @param {Observer} observer
+     * @returns {ProxyObserver}
+     */
+    detachObserver(observer) {
+        this[internalSymbol].observers.detach(observer)
+        return this;
+    }
+
+    /**
+     * Notify all observer
+     *
+     * @returns {Promise}
+     */
+    notifyObservers() {
+        return this[internalSymbol].observers.notify(this);
+    }
+
+    /**
+     * @param {Observer} observer
+     * @returns {boolean}
+     */
+    containsObserver(observer) {
+        return this[internalSymbol].observers.contains(observer)
+    }    
+
+
+}

package/source/types/proxyobserver.mjs

@@ -61,9 +61,9 @@ export {ProxyObserver}
 
 
     /**
-     * get the real object
+     * Get the real object
      *
-     * changes to this object are not noticed by the observers, so you can make a large number of changes and inform the observers later.
+     * Changes to this object are not noticed by the observers, so you can make a large number of changes and inform the observers later.
      *
      * @returns {object}
      */

package/source/types/uniquequeue.mjs

@@ -6,12 +6,13 @@
  */
 
 import {Queue} from "./queue.mjs";
+import {internalSymbol} from "../constants.mjs";
 import {validateObject} from "./validate.mjs";
 
 export {UniqueQueue}
 
 /**
- * A UniqueQueue is a queue that contains items only once.
+ * An UniqueQueue is a queue that contains items only once.
  *
  * @license AGPLv3
  * @since 1.4.0
@@ -26,7 +27,9 @@ export {UniqueQueue}
      */
     constructor() {
         super();
-        this.unique = new WeakSet();
+        this[internalSymbol]={
+            unique : new WeakSet()
+        };
     }
 
     /**
@@ -40,8 +43,8 @@ export {UniqueQueue}
 
         validateObject(value);
 
-        if (!this.unique.has(value)) {
-            this.unique.add(value);
+        if (!this[internalSymbol].unique.has(value)) {
+            this[internalSymbol].unique.add(value);
             super.add(value);
         }
 
@@ -55,7 +58,7 @@ export {UniqueQueue}
      */
     clear() {
         super.clear();
-        this.unique = new WeakSet;
+        this[internalSymbol].unique = new WeakSet;
         return this;
     }
 
@@ -71,7 +74,7 @@ export {UniqueQueue}
             return undefined;
         }
         let value = this.data.shift();
-        this.unique.delete(value);
+        this[internalSymbol].unique.delete(value);
         return value;
     }
 

package/source/types/version.mjs

@@ -149,7 +149,7 @@ function getMonsterVersion() {
     }
 
     /** don't touch, replaced by make with package.json version */
-    monsterVersion = new Version('3.2.0')
+    monsterVersion = new Version('3.4.0')
 
     return monsterVersion;