@schukai/monster 1.22.0 → 1.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schukai/monster",
-  "version": "1.22.0",
+  "version": "1.26.0",
   "types": "./source/types/package.d.ts",
   "description": "Monster is a simple library for creating fast, robust and lightweight websites.",
   "keywords": [
@@ -17,7 +17,18 @@
     "core",
     "shopcloud",
     "alvine",
-    "monster"
+    "monster",
+    "buildmap",
+    "stack",
+    "observer",
+    "observable",
+    "uuid",
+    "node",
+    "nodelist",
+    "css-in-js",
+    "logger",
+    "log",
+    "theme"
   ],
   "type": "module",
   "homepage": "https://monsterjs.org",

package/source/constants.js

@@ -7,16 +7,25 @@ import {Monster} from './namespace.js';
  */
 
 /**
- * formerly known as PROPERTY_KEY_OPTIONS
- *
+ * @private
+ * @type {symbol}
  * @memberOf Monster
- * @type {string}
- * @since 1.15.0
+ * @since 1.24.0
  */
-const PROPERTY_KEY_INTERNALDATA = 'monsterInternalData';
+const internalSymbol = Symbol('internalData');
+
+/**
+ * @private
+ * @type {symbol}
+ * @memberOf Monster
+ * @since 1.25.0
+ */
+const internalStateSymbol = Symbol('state');
 
 
 export {
     Monster,
-    PROPERTY_KEY_INTERNALDATA
-}
+    internalSymbol,
+    internalStateSymbol
+}
+

package/source/constraints/abstract.js

@@ -9,6 +9,10 @@ import {Base} from '../types/base.js';
 
 
 /**
+ * Constraints are used to define conditions that must be met by the value of a variable.
+ *
+ * The uniform API of the constraints allows chains to be formed.
+ * 
  * The abstract constraint defines the api for all constraints. mainly the method isValid() is defined.
  *
  * derived classes must implement the method isValid().
@@ -16,6 +20,7 @@ import {Base} from '../types/base.js';
  * @since 1.3.0
  * @copyright schukai GmbH
  * @memberOf Monster.Constraints
+ * @summary The abstract constraint
  */
 class AbstractConstraint extends Base {
 

package/source/constraints/abstractoperator.js

@@ -7,11 +7,16 @@ import {assignToNamespace, Monster} from '../namespace.js';
 import {AbstractConstraint} from "./abstract.js";
 
 /**
+ * Constraints are used to define conditions that must be met by the value of a variable.
+ *
+ * The uniform API of the constraints allows chains to be formed.
+ *
  * Operators allow you to link constraints together. for example, you can check whether a value is an object or an array. each operator has two operands that are linked together.
  *
  * @since 1.3.0
  * @copyright schukai GmbH
  * @memberOf Monster.Constraints
+ * @summary The abstract operator constraint
  */
 class AbstractOperator extends AbstractConstraint {
 

package/source/constraints/andoperator.js

@@ -8,11 +8,15 @@ import {assignToNamespace, Monster} from '../namespace.js';
 import {AbstractOperator} from "./abstractoperator.js";
 
 /**
+ * Constraints are used to define conditions that must be met by the value of a variable.
+ *
+ * The uniform API of the constraints allows chains to be formed.
+ *
  * The AndOperator is used to link several contraints. The constraint is fulfilled if all constraints of the operators are fulfilled.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/andoperator.js';
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/monster.js';
  * new Monster.Constraint.AndOperator();
  * </script>
  * ```
@@ -21,16 +25,16 @@ import {AbstractOperator} from "./abstractoperator.js";
  *
  * ```
  * <script type="module">
- * import {AndOperator} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/andoperator.js';
+ * import {AndOperator} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/constraints/andoperator.js';
  * new AndOperator();
  * </script>
  * ```
  *
  * @example
  *
- * import {Valid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/valid.js';
- * import {Invalid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/invalid.js';
- * import {AndOperator} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/andoperator.js';
+ * import {Valid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/constraints/valid.js';
+ * import {Invalid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/constraints/invalid.js';
+ * import {AndOperator} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/constraints/andoperator.js';
  *
  * new AndOperator(
  * new Valid(), new Valid()).isValid()
@@ -47,6 +51,7 @@ import {AbstractOperator} from "./abstractoperator.js";
  * @since 1.3.0
  * @copyright schukai GmbH
  * @memberOf Monster.Constraints
+ * @summary A and operator constraint
  */
 class AndOperator extends AbstractOperator {
 

package/source/constraints/invalid.js

@@ -7,13 +7,17 @@ import {assignToNamespace, Monster} from '../namespace.js';
 import {AbstractConstraint} from "./abstract.js";
 
 /**
+ * Constraints are used to define conditions that must be met by the value of a variable.
+ *
+ * The uniform API of the constraints allows chains to be formed.
+ *
  * The invalid constraint allows an always invalid query to be performed. this constraint is mainly intended for testing.
  *
  * You can call the method via the monster namespace `new Monster.Constraint.Invalid()`.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/invalid.js';
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/monster.js';
  * new Monster.Constraint.Invalid();
  * </script>
  * ```
@@ -22,14 +26,14 @@ import {AbstractConstraint} from "./abstract.js";
  *
  * ```
  * <script type="module">
- * import {Invalid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/invalid.js';
+ * import {Invalid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/constraints/invalid.js';
  * new Invalid();
  * </script>
  * ```
  *
  * @example
  *
- * import {Invalid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/invalid.js';
+ * import {Invalid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/constraints/invalid.js';
  *
  * new Invalid().isValid()
  * .then(()=>console.log(true))
@@ -39,6 +43,7 @@ import {AbstractConstraint} from "./abstract.js";
  * @since 1.3.0
  * @copyright schukai GmbH
  * @memberOf Monster.Constraints
+ * @summary A constraint that always invalid
  */
 class Invalid extends AbstractConstraint {
 

package/source/constraints/isarray.js

@@ -8,12 +8,16 @@ import {isArray} from "../types/is.js";
 import {AbstractConstraint} from "./abstract.js";
 
 /**
+ * Constraints are used to define conditions that must be met by the value of a variable.
+ * 
+ * The uniform API of the constraints allows chains to be formed.
+ * 
  * You can call the method via the monster namespace `new Monster.Constraint.IsObject()`.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/isarray.js';
- * console.log(new Monster.Constraint.IsArray())
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/monster.js';
+ * new Monster.Constraint.IsArray()
  * </script>
  * ```
  *
@@ -21,14 +25,14 @@ import {AbstractConstraint} from "./abstract.js";
  *
  * ```
  * <script type="module">
- * import {IsArray} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/isarray.js';
+ * import {IsArray} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/constraints/isarray.js';
  * console.log(new IsArray())
  * </script>
  * ```
  *
  * @example
  *
- * import {IsArray} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/isarray.js';
+ * import {IsArray} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/constraints/isarray.js';
  *
  * new IsArray()
  * .isValid([])
@@ -43,6 +47,7 @@ import {AbstractConstraint} from "./abstract.js";
  * @since 1.3.0
  * @copyright schukai GmbH
  * @memberOf Monster.Constraints
+ * @summary A constraint to check if a value is an array
  */
 class IsArray extends AbstractConstraint {
 

package/source/constraints/isobject.js

@@ -8,11 +8,15 @@ import {isObject} from "../types/is.js";
 import {AbstractConstraint} from "./abstract.js";
 
 /**
+ * Constraints are used to define conditions that must be met by the value of a variable.
+ *
+ * The uniform API of the constraints allows chains to be formed.
+ *
  * You can call the method via the monster namespace `new Monster.Constraint.IsObject()`.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/isobject.js';
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/monster.js';
  * console.log(new Monster.Constraint.IsObject())
  * </script>
  * ```
@@ -21,14 +25,14 @@ import {AbstractConstraint} from "./abstract.js";
  *
  * ```
  * <script type="module">
- * import {IsObject} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/isobject.js';
+ * import {IsObject} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/constraints/isobject.js';
  * console.log(new IsObject())
  * </script>
  * ```
  *
  * @example
  *
- * import {IsObject} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/isobject.js';
+ * import {IsObject} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/constraints/isobject.js';
  *
  * new IsObject()
  * .isValid({})
@@ -44,6 +48,7 @@ import {AbstractConstraint} from "./abstract.js";
  * @since 1.3.0
  * @copyright schukai GmbH
  * @memberOf Monster.Constraints
+ * @summary A constraint to check if a value is an object
  */
 class IsObject extends AbstractConstraint {
 

package/source/constraints/oroperator.js

@@ -7,11 +7,15 @@ import {assignToNamespace, Monster} from '../namespace.js';
 import {AbstractOperator} from "./abstractoperator.js";
 
 /**
+ * Constraints are used to define conditions that must be met by the value of a variable.
+ *
+ * The uniform API of the constraints allows chains to be formed.
+ *
  * The OrOperator is used to link several constraints. The constraint is fulfilled if one of the constraints is fulfilled.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraint/oroperator.js';
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/monster.js';
  * new Monster.Constraint.OrOperator();
  * </script>
  * ```
@@ -20,16 +24,16 @@ import {AbstractOperator} from "./abstractoperator.js";
  *
  * ```
  * <script type="module">
- * import {OrOperator} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraint/oroperator.js';
+ * import {OrOperator} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/constraint/oroperator.js';
  * new OrOperator();
  * </script>
  * ```
  *
  * @example
  *
- * import {Valid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/valid.js';
- * import {Invalid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/invalid.js';
- * import {OrOperator} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/oroperator.js';
+ * import {Valid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/constraints/valid.js';
+ * import {Invalid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/constraints/invalid.js';
+ * import {OrOperator} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/constraints/oroperator.js';
  *
  * new OrOperator(
  * new Valid(), new Invalid()).isValid()
@@ -46,6 +50,7 @@ import {AbstractOperator} from "./abstractoperator.js";
  * @since 1.3.0
  * @copyright schukai GmbH
  * @memberOf Monster.Constraints
+ * @summary A or operator 
  */
 class OrOperator extends AbstractOperator {
 

package/source/constraints/valid.js

@@ -7,13 +7,17 @@ import {assignToNamespace, Monster} from '../namespace.js';
 import {AbstractConstraint} from "./abstract.js";
 
 /**
+ * Constraints are used to define conditions that must be met by the value of a variable.
+ *
+ * The uniform API of the constraints allows chains to be formed.
+ *
  * The valid constraint allows an always valid query to be performed. this constraint is mainly intended for testing.
  *
  * You can call the method via the monster namespace `new Monster.Constraint.Valid()`.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/valid.js';
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/monster.js';
  * new Monster.Constraint.Valid();
  * </script>
  * ```
@@ -22,14 +26,14 @@ import {AbstractConstraint} from "./abstract.js";
  *
  * ```
  * <script type="module">
- * import {Valid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/valid.js';
+ * import {Valid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/constraints/valid.js';
  * new Valid();
  * </script>
  * ```
  *
  * @example
  *
- * import {Valid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/constraints/valid.js';
+ * import {Valid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/constraints/valid.js';
  *
  * new Valid().isValid()
  * .then(()=>console.log(true))
@@ -39,6 +43,7 @@ import {AbstractConstraint} from "./abstract.js";
  * @since 1.3.0
  * @copyright schukai GmbH
  * @memberOf Monster.Constraints
+ * @summary A constraint that always valid
  */
 class Valid extends AbstractConstraint {
 

package/source/data/buildmap.js

@@ -20,7 +20,7 @@ import {DELIMITER, Pathfinder, WILDCARD} from "./pathfinder.js";
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/data/buildmap.js';
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/monster.js';
  * console.log(Monster.Data.buildMap())
  * </script>
  * ```
@@ -29,18 +29,18 @@ import {DELIMITER, Pathfinder, WILDCARD} from "./pathfinder.js";
  *
  * ```
  * <script type="module">
- * import {buildMap} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/data/buildmap.js';
+ * import {buildMap} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/data/buildmap.js';
  * console.log(buildMap())
  * </script>
  * ```
- * 
+ *
  * The templates determine the appearance of the keys and the value of the map. Either a single value `id` can be taken or a composite key `${id} ${name}` can be used.
- * 
+ *
  * If you want to access values of the parent data set, you have to use the `^` character `${id} ${^.name}`.
  *
  * @example
  *
- * import {buildMap} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/data/buildmap.js';
+ * import {buildMap} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/data/buildmap.js';
  * // a typical data structure as reported by an api
  *
  * let map;
@@ -119,8 +119,25 @@ import {DELIMITER, Pathfinder, WILDCARD} from "./pathfinder.js";
  * @throws {TypeError} the selector callback must return a map
  */
 function buildMap(subject, selector, valueTemplate, keyTemplate, filter) {
+    return assembleParts(subject, selector, filter, function (v, k, m) {
+        k = build(v, keyTemplate, k);
+        v = build(v, valueTemplate);
+        this.set(k, v);
+    });
+
+}
+
+/**
+ * @private
+ * @param {*} subject
+ * @param {string|Monster.Data~exampleSelectorCallback} selector
+ * @param {Monster.Data~exampleFilterCallback} [filter]
+ * @param {function} callback
+ * @return {*}
+ */
+function assembleParts(subject, selector, filter, callback) {
 
-    const result = new Map
+    const result = new Map();
 
     let map;
     if (isFunction(selector)) {
@@ -145,10 +162,9 @@ function buildMap(subject, selector, valueTemplate, keyTemplate, filter) {
             if (filter.call(m, v, k) !== true) return;
         }
 
-        k = build(v, keyTemplate, k);
-        v = build(v, valueTemplate);
+        callback.call(result, v, k, m);
+
 
-        result.set(k, v);
     });
 
     return result;
@@ -239,7 +255,7 @@ function buildFlatMap(subject, selector, key, parentMap) {
  * Alternatively to a string selector a callback can be specified. this must return a map.
  *
  * @example
- * import {buildMap} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.22.0/dist/modules/data/buildmap.js';
+ * import {buildMap} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/data/buildmap.js';
  *
  * let obj = {
  *                "data": [
@@ -408,4 +424,4 @@ function build(subject, definition, defaultValue) {
 
 
 assignToNamespace('Monster.Data', buildMap);
-export {Monster, buildMap}
+export {Monster, buildMap, assembleParts}

package/source/data/buildtree.js

@@ -0,0 +1,95 @@
+'use strict';
+
+/**
+ * @author schukai GmbH
+ */
+
+import {assignToNamespace, Monster} from '../namespace.js';
+import {Node} from "../types/node.js";
+import {NodeList} from "../types/nodelist.js";
+import {assembleParts} from "./buildmap.js";
+
+
+/**
+ * @private
+ * @type {symbol}
+ */
+const parentSymbol = Symbol('parent');
+
+/**
+ * @private
+ * @type {symbol}
+ */
+const rootSymbol = Symbol('root');
+
+/**
+ * With the help of the function `buildTree()`, nodes can be easily created from data objects.
+ *
+ * You can call the method via the monster namespace `Monster.Data.buildTree()`.
+ *
+ * ```
+ * <script type="module">
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/buildtree.js';
+ * console.log(Monster.Data.buildTree())
+ * </script>
+ * ```
+ *
+ * Alternatively, you can also integrate this function individually.
+ *
+ * ```
+ * <script type="module">
+ * import {buildTree} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.0/dist/modules/data/buildtree.js';
+ * console.log(buildTree())
+ * </script>
+ * ```
+ *
+ * @param {*} subject
+ * @param {string|Monster.Data~exampleSelectorCallback} selector
+ * @param {string} id
+ * @param {string} parentID
+ * @param {Monster.Data~exampleFilterCallback} [filter]
+ * @return {*}
+ * @memberOf Monster.Data
+ * @throws {TypeError} value is neither a string nor a function
+ * @throws {TypeError} the selector callback must return a map
+ * @throws {Error} the object has no value for the specified id
+ */
+function buildTree(subject, selector, id, parentID, filter) {
+
+    const nodes = new Map;
+
+    const childMap = assembleParts(subject, selector, filter, function (o, k, m) {
+
+        const key = o?.[id]
+        let ref = o?.[parentID]
+        if (ref === null|| ref===undefined) ref = rootSymbol;
+
+        if (key === undefined) {
+            throw new Error('the object has no value for the specified id')
+        }
+
+        o[parentSymbol] = ref;
+        
+        const node = new Node(o);
+        this.has(ref) ? this.get(ref).add(node) : this.set(ref, new NodeList().add(node));
+        nodes.set(key, node);
+
+    })
+
+    nodes.forEach(node => {
+
+        if (childMap.has(node.value.id)) {
+            node.childNodes = childMap.get(node.value.id);
+        }
+    })
+
+    const r = childMap.get(rootSymbol);
+    
+    return new NodeList(childMap.get(rootSymbol));
+
+
+}
+
+
+assignToNamespace('Monster.Data', buildTree);
+export {Monster, buildTree}

package/source/data/datasource/restapi/writeerror.js

@@ -0,0 +1,49 @@
+'use strict';
+
+/**
+ * @author schukai GmbH
+ */
+
+import {internalSymbol} from "../../../constants.js";
+import {assignToNamespace, Monster} from '../../../namespace.js';
+
+/**
+ * Error message for API requests with extension of request and validation.
+ * 
+ * @since 1.24.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Data.Datasource.RestAPI
+ * @summary the error is thrown by the rest api in case of error
+ */
+class WriteError extends Error {
+    /**
+     *
+     * @param {string} message
+     * @param {Response} response
+     */
+    constructor(message, response, validation) {
+        super(message);
+        this[internalSymbol] = {
+            response: response,
+            validation: validation
+        };
+    }
+
+    /**
+     * @return {Response}
+     */
+    getResponse() {
+        return this[internalSymbol]['response']
+    }
+
+    /**
+     * @return {Object}
+     */
+    getValidation() {
+        return this[internalSymbol]['validation']
+    }
+}
+
+
+assignToNamespace('Monster.Data.Datasource.RestAPI', WriteError);
+export {Monster, WriteError}