@schukai/monster 1.21.1 → 1.25.0

package/source/data/datasource/storage/sessionstorage.js

@@ -0,0 +1,61 @@
+'use strict';
+
+/**
+ * @author schukai GmbH
+ */
+
+import {internalSymbol} from "../../../constants.js";
+import {assignToNamespace, Monster} from '../../../namespace.js';
+import {getGlobalObject} from "../../../types/global.js";
+import {Datasource} from "../../datasource.js";
+import {Storage, storageObjectSymbol} from "../storage.js";
+
+/**
+ * You can create an object of this class using the monster namespace `Monster.Data.Datasource.Storage.SessionStorage()`.
+ *
+ * ```
+ * <script type="module">
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/datasource/storage/sessionstorage.js';
+ * Monster.Data.Datasource.Storage.SessionStorage()
+ * </script>
+ * ```
+ *
+ * Alternatively you can import the class directly
+ *
+ * ```
+ * <script type="module">
+ * import {SessionStorage} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/datasource/storage/sessionstorage.js';
+ * new SessionStorage()
+ * </script>
+ * ```
+ *
+ * @since 1.22.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Data.Datasource.Storage
+ * @summary The LocalStorage class encapsulates the access to data objects.
+ */
+class SessionStorage extends Storage {
+
+    /**
+     * @throws {Error} this method must be implemented by derived classes.
+     * @return {external:sessionStorage}
+     * @private
+     */
+    [storageObjectSymbol]() {
+        return getGlobalObject('sessionStorage');
+    }
+
+    /**
+     * Create Clone
+     * 
+     * @return {SessionStorage}
+     */
+    getClone() {
+        const self = this;
+        return new SessionStorage(self[internalSymbol].getRealSubject()['options'].key);
+    }
+
+}
+
+assignToNamespace('Monster.Data.Datasource.Storage', SessionStorage);
+export {Monster, SessionStorage}

package/source/data/datasource/storage.js

@@ -0,0 +1,131 @@
+'use strict';
+
+/**
+ * @author schukai GmbH
+ */
+
+import {internalSymbol} from "../../constants.js";
+import {assignToNamespace, Monster} from '../../namespace.js';
+import {validateString} from "../../types/validate.js";
+import {Datasource} from "../datasource.js";
+
+/**
+ * @private
+ * @type {symbol}
+ */
+const storageObjectSymbol = Symbol('storageObject');
+
+/**
+ * You can create an object of this class using the monster namespace `Monster.Data.Datasource.Storage()`.
+ *
+ * ```
+ * <script type="module">
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/datasource/storage.js';
+ * Monster.Data.Datasource.Storage()
+ * </script>
+ * ```
+ *
+ * Alternatively you can import the class directly
+ *
+ * ```
+ * <script type="module">
+ * import {Storage} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/datasource/storage.js';
+ * new Storage()
+ * </script>
+ * ```
+ *
+ * @example
+ *
+ * import {Storage} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/datasource/storage.js';
+ *
+ * new Datasource();
+ *
+ * @since 1.22.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Data.Datasource
+ * @summary The Storage class encapsulates the access to data objects over WebStorageAPI.
+ */
+class Storage extends Datasource {
+
+    /**
+     *
+     * @param {string} key LocalStorage Key
+     * @throws {TypeError} value is not a string
+     */
+    constructor(key) {
+        super();
+        this.setOption('key', validateString(key));
+    }
+
+    /**
+     * @property {string} key=undefined LocalStorage Key
+     */
+    get defaults() {
+        return Object.assign({}, super.defaults, {
+            key: undefined,
+        });
+    }
+
+    /**
+     * @throws {Error} this method must be implemented by derived classes.
+     * @return {external:Storage}
+     * @private
+     */
+    [storageObjectSymbol]() {
+        throw new Error("this method must be implemented by derived classes")
+    }
+
+    /**
+     * @return {Promise}
+     * @throws {Error} the options does not contain a valid json definition
+     * @throws {TypeError} value is not a object
+     * @throws {Error} the data cannot be read
+     */
+    read() {
+        const self = this;
+
+        const storage = self[storageObjectSymbol]();
+
+        return new Promise(function (resolve) {
+            const data = JSON.parse(storage.getItem(self.getOption('key')));
+            self.set(data??{});
+            resolve();
+        })
+
+    }
+
+    /**
+     * @return {Storage}
+     * @throws {Error} the data cannot be written
+     */
+    write() {
+        const self = this;
+
+        const storage = self[storageObjectSymbol]();
+
+        return new Promise(function (resolve) {
+
+            const data = self.get();
+            if (data === undefined) {
+                storage.removeItem(self.getOption('key'));
+            } else {
+                storage.setItem(self.getOption('key'), JSON.stringify(data));
+            }
+
+            resolve();
+        })
+    }
+
+    /**
+     * @return {Storage}
+     */
+    getClone() {
+        const self=this;
+        return new Storage(self[internalSymbol].getRealSubject()['options'].key);
+    } 
+    
+}
+
+
+assignToNamespace('Monster.Data.Datasource', Storage);
+export {Monster, Storage, storageObjectSymbol}

package/source/data/datasource.js

@@ -0,0 +1,246 @@
+'use strict';
+
+/**
+ * @author schukai GmbH
+ */
+
+import {internalSymbol} from "../constants.js";
+import {assignToNamespace, Monster} from '../namespace.js';
+import {Base} from "../types/base.js";
+import {parseDataURL} from "../types/dataurl.js";
+import {isString} from "../types/is.js";
+import {ProxyObserver} from "../types/proxyobserver.js";
+import {validateObject} from "../types/validate.js";
+import {extend} from "./extend.js";
+import {Pathfinder} from "./pathfinder.js";
+
+
+/**
+ * @private
+ * @type {symbol}
+ * @memberOf Monster.Data
+ * @since 1.24.0
+ */
+const internalDataSymbol = Symbol('internalData');
+
+/**
+ * The datasource class is the basis for dealing with different data sources.
+ * It provides a unified interface for accessing data
+ *
+ * You can create an object of this class using the monster namespace `Monster.Data.Datasource()`.
+ *
+ * ```
+ * <script type="module">
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/datasource.js';
+ * Monster.Data.Datasource()
+ * </script>
+ * ```
+ *
+ * Alternatively you can import the class directly
+ *
+ * ```
+ * <script type="module">
+ * import {Datasource} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/datasource.js';
+ * new Datasource()
+ * </script>
+ * ```
+ *
+ * @example
+ *
+ * import {Datasource} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/datasource.js'
+ *
+ * class MyDatasource extends Datasource {
+ *  
+ * }
+ *
+ * const ds = new MyDatasource();
+ *
+ * @since 1.22.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Data
+ * @summary The datasource class encapsulates the access to data objects.
+ */
+class Datasource extends Base {
+
+    /**
+     *
+     */
+    constructor() {
+        super();
+        this[internalSymbol] = new ProxyObserver({
+            'options': extend({}, this.defaults)
+        });
+        
+        this[internalDataSymbol] = new ProxyObserver({
+
+        });
+        
+    
+    }
+
+    /**
+     * attach a new observer
+     *
+     * @param {Observer} observer
+     * @returns {Datasource}
+     */
+    attachObserver(observer) {
+        this[internalDataSymbol].attachObserver(observer)
+        return this;
+    }
+
+    /**
+     * detach a observer
+     *
+     * @param {Observer} observer
+     * @returns {Datasource}
+     */
+    detachObserver(observer) {
+        this[internalDataSymbol].detachObserver(observer)
+        return this;
+    }
+
+    /**
+     * @param {Observer} observer
+     * @returns {boolean}
+     */
+    containsObserver(observer) {
+        return this[internalDataSymbol].containsObserver(observer);
+    }
+
+    /**
+     * Derived classes can override and extend this method as follows.
+     *
+     * ```
+     * get defaults() {
+     *    return Object.assign({}, super.defaults, {
+     *        myValue:true
+     *    });
+     * }
+     * ```
+     */
+    get defaults() {
+        return {};
+    }
+
+    /**
+     * Set option
+     *
+     * @param {string} path
+     * @param {*} value
+     * @return {Datasource}
+     */
+    setOption(path, value) {
+        new Pathfinder(this[internalSymbol].getSubject()['options']).setVia(path, value);
+        return this;
+    }
+
+    /**
+     * @param {string|object} options
+     * @return {Datasource}
+     * @throws {Error} the options does not contain a valid json definition
+     */
+    setOptions(options) {
+
+        if (isString(options)) {
+            options = parseOptionsJSON(options)
+        }
+
+        const self = this;
+        extend(self[internalSymbol].getSubject()['options'], self.defaults, options);
+
+        return self;
+    }
+
+    /**
+     * nested options can be specified by path `a.b.c`
+     *
+     * @param {string} path
+     * @param {*} defaultValue
+     * @return {*}
+     */
+    getOption(path, defaultValue) {
+        let value;
+
+        try {
+            value = new Pathfinder(this[internalSymbol].getRealSubject()['options']).getVia(path);
+        } catch (e) {
+
+        }
+
+        if (value === undefined) return defaultValue;
+        return value;
+    }
+
+    /**
+     * @throws {Error} this method must be implemented by derived classes.
+     * @return {Promise}
+     */
+    read() {
+        throw new Error("this method must be implemented by derived classes")
+    }
+
+    /**
+     * @throws {Error} this method must be implemented by derived classes.
+     * @return {Promise}
+     */
+    write() {
+        throw new Error("this method must be implemented by derived classes")
+    }
+
+
+    /**
+     * Returns real object
+     * 
+     * @return {Object|Array}
+     */
+    get() {
+        const self = this;
+        return self[internalDataSymbol].getRealSubject();
+    }
+
+    /**
+     * @param {Object|Array} data
+     * @return {Datasource}
+     */
+    set(data) {
+        const self = this;
+        self[internalDataSymbol].setSubject(data);
+        return self;
+    }
+
+}
+
+/**
+ * @private
+ * @param data
+ * @return {Object}
+ * @throws {Error} the options does not contain a valid json definition
+ */
+function parseOptionsJSON(data) {
+    if (isString(data)) {
+
+        // the configuration can be specified as a data url.
+        try {
+            let dataUrl = parseDataURL(data);
+            data = dataUrl.content;
+        } catch (e) {
+
+        }
+
+
+        try {
+            let obj = JSON.parse(data);
+            validateObject(obj);
+            return obj;
+        } catch (e) {
+            throw new Error('the options does not contain a valid json definition (actual: ' + data + ').');
+        }
+    }
+
+    return {};
+}
+
+
+assignToNamespace('Monster.Data', Datasource);
+export {Monster, Datasource}

package/source/data/diff.js

@@ -17,8 +17,8 @@ import {typeOf} from "../types/typeof.js";
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.21.1/dist/modules/data/diff.js';
- * console.log(Monster.Data.Diff(a, b))
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/diff.js';
+ * Monster.Data.Diff(a, b)
  * </script>
  * ```
  *
@@ -26,14 +26,14 @@ import {typeOf} from "../types/typeof.js";
  *
  * ```
  * <script type="module">
- * import {Diff} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.21.1/dist/modules/data/diff.js';
- * console.log(Diff(a, b))
+ * import {Diff} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/diff.js';
+ * Diff(a, b)
  * </script>
  * ```
  *
  * @example
  *
- * import {Diff} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.21.1/dist/modules/data/diff.js';
+ * import {Diff} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/diff.js';
  *
  * // given are two objects x and y.
  *
@@ -80,7 +80,7 @@ import {typeOf} from "../types/typeof.js";
  * @copyright schukai GmbH
  * @memberOf Monster.Data
  */
-function Diff(first, second) {
+function diff(first, second) {
     return doDiff(first, second)
 }
 
@@ -245,5 +245,5 @@ function getOperator(a, b) {
 
 }
 
-assignToNamespace('Monster.Data', Diff);
-export {Monster, Diff}
+assignToNamespace('Monster.Data', diff);
+export {Monster, diff}

package/source/data/extend.js

@@ -8,15 +8,15 @@ import {isArray, isObject} from "../types/is.js";
 import {typeOf} from "../types/typeof.js";
 
 /**
- * extend copies all enumerable own properties from one or
+ * Extend copies all enumerable own properties from one or
  * more source objects to a target object. It returns the modified target object.
  *
  * You can call the method via the monster namespace `Monster.Data.extend()`.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.21.1/dist/modules/data/extend.js';
- * console.log(Monster.Data.extend(a, b))
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/extend.js';
+ * Monster.Data.extend(a, b)
  * </script>
  * ```
  *
@@ -24,8 +24,8 @@ import {typeOf} from "../types/typeof.js";
  *
  * ```
  * <script type="module">
- * import {extend} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.21.1/dist/modules/data/extend.js';
- * console.log(extend(a, b))
+ * import {extend} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/extend.js';
+ * extend(a, b)
  * </script>
  * ```
  *

package/source/data/pathfinder.js

@@ -27,7 +27,7 @@ export const WILDCARD = '*';
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.21.1/dist/modules/data/pathfinder.js';
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/pathfinder.js';
  * console.log(new Monster.Data.Pathfinder())
  * </script>
  * ```
@@ -36,7 +36,7 @@ export const WILDCARD = '*';
  *
  * ```
  * <script type="module">
- * import {Pathfinder} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.21.1/dist/modules/data/pathfinder.js';
+ * import {Pathfinder} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/pathfinder.js';
  * console.log(new Pathfinder())
  * </script>
  * ```
@@ -78,7 +78,7 @@ export const WILDCARD = '*';
  *
  * @example
  *
- * import {Pathfinder} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.21.1/dist/modules/data/pathfinder.js';
+ * import {Pathfinder} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/pathfinder.js';
  *
  * let value = new Pathfinder({
  * a: {
@@ -104,7 +104,7 @@ export const WILDCARD = '*';
  *
  * @example
  *
- * import {Pathfinder} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.21.1/dist/modules/data/pathfinder.js';
+ * import {Pathfinder} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/pathfinder.js';
  *
  * let p = new Pathfinder({
  *                a: {
@@ -317,8 +317,14 @@ function getValueViaPath(subject, path, check) {
             throw Error("the journey is not at its end (" + parts.join(DELIMITER) + ")");
         }
 
-        if (check === true && !subject.hasOwnProperty(current)) {
-            throw Error('unknown value');
+
+        if (check === true) {
+            const descriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(subject), current);
+
+            if (!subject.hasOwnProperty(current) && descriptor === undefined) {
+                throw Error('unknown value');
+            }
+
         }
 
         return anchor;

package/source/data/pipe.js

@@ -19,8 +19,8 @@ const DELIMITER = '|';
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.21.1/dist/modules/data/pipe.js';
- * console.log(new Monster.Data.Pipe())
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/pipe.js';
+ * new Monster.Data.Pipe()
  * </script>
  * ```
  *
@@ -28,8 +28,8 @@ const DELIMITER = '|';
  *
  * ```
  * <script type="module">
- * import {Pipe} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.21.1/dist/modules/data/pipe.js';
- * console.log(new Pipe())
+ * import {Pipe} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/pipe.js';
+ * new Pipe()
  * </script>
  * ```
  *
@@ -39,7 +39,7 @@ const DELIMITER = '|';
  * the word is then converted to uppercase letters and a prefix Hello is added. the two backslash safe the space char.
  *
  * @example
- * import {Pipe} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.21.1/dist/modules/data/pipe.js';
+ * import {Pipe} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/data/pipe.js';
  *
  * let obj = {
  *    a: {
@@ -68,6 +68,7 @@ class Pipe extends Base {
     constructor(pipe) {
         super();
         validateString(pipe);
+        
         this.pipe = pipe.split(DELIMITER).map((v) => {
             return new Transformer(v);
         });