@schukai/monster 1.25.0 → 1.28.0

package/source/types/is.js

@@ -7,16 +7,18 @@
 import {assignToNamespace, Monster} from '../namespace.js';
 
 /**
- * With this function you can check if a value is iterable
+ * With this function you can check if a value is iterable.
+ * 
+ * This method is used in the library to have consistent names.
  *
  * You can call the method via the monster namespace `Monster.Types.isPrimitive()`.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(Monster.Types.isIterable(null)) // ↦ false
- * console.log(Monster.Types.isIterable('hello')) // ↦ true
- * console.log(Monster.Types.isIterable([])) // ↦ true
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/monster.js';
+ * Monster.Types.isIterable(null) // ↦ false
+ * Monster.Types.isIterable('hello') // ↦ true
+ * Monster.Types.isIterable([]) // ↦ true
  * </script>
  * ```
  *
@@ -24,7 +26,7 @@ import {assignToNamespace, Monster} from '../namespace.js';
  *
  * ```
  * <script type="module">
- * import {isIterable} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
+ * import {isIterable} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/modules/types/is.js';
  * isIterable(null)  // ↦ false
  * isIterable('hello')  // ↦ true
  * isIterable([])  // ↦ true
@@ -46,14 +48,16 @@ function isIterable(value) {
 
 /**
  * Checks whether the value passed is a primitive (string, number, boolean, NaN, undefined, null or symbol)
+ * 
+ * This method is used in the library to have consistent names.
  *
  * You can call the method via the monster namespace `Monster.Types.isPrimitive()`.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(Monster.Types.isPrimitive('2')) // ↦ false
- * console.log(Monster.Types.isPrimitive([])) // ↦ true
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/monster.js';
+ * Monster.Types.isPrimitive('2') // ↦ false
+ * Monster.Types.isPrimitive([]) // ↦ true
  * </script>
  * ```
  *
@@ -61,9 +65,9 @@ function isIterable(value) {
  *
  * ```
  * <script type="module">
- * import {isPrimitive} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(isPrimitive('2'))  // ↦ true
- * console.log(isPrimitive([]))  // ↦ false
+ * import {isPrimitive} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/modules/types/is.js';
+ * isPrimitive('2'))  // ↦ true
+ * isPrimitive([]))  // ↦ false
  * </script>
  * ```
  *
@@ -91,14 +95,16 @@ function isPrimitive(value) {
 
 /**
  * Checks whether the value passed is a symbol
+ * 
+ * This method is used in the library to have consistent names.
  *
  * You can call the method via the monster namespace `Monster.Types.isSymbol()`.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(Monster.Types.isSymbol('2')) // ↦ false
- * console.log(Monster.Types.isSymbol(Symbol('test')) // ↦ true
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/monster.js';
+ * Monster.Types.isSymbol('2') // ↦ false
+ * Monster.Types.isSymbol(Symbol('test') // ↦ true
  * </script>
  * ```
  *
@@ -106,9 +112,9 @@ function isPrimitive(value) {
  *
  * ```
  * <script type="module">
- * import {isSymbol} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(isSymbol(Symbol('a')))  // ↦ true
- * console.log(isSymbol([])  // ↦ false
+ * import {isSymbol} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/modules/types/is.js';
+ * isSymbol(Symbol('a')))  // ↦ true
+ * isSymbol([])  // ↦ false
  * </script>
  * ```
  *
@@ -123,16 +129,18 @@ function isSymbol(value) {
 }
 
 /**
- * Checks whether the value passed is a boolean
+ * Checks whether the value passed is a boolean.
+ * 
+ * This method is used in the library to have consistent names.
  *
  * You can call the method via the monster namespace `Monster.Types.isBoolean()`.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(Monster.Types.isBoolean('2')) // ↦ false
- * console.log(Monster.Types.isBoolean([])) // ↦ false
- * console.log(Monster.Types.isBoolean(true)) // ↦ true
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/monster.js';
+ * Monster.Types.isBoolean('2') // ↦ false
+ * Monster.Types.isBoolean([]) // ↦ false
+ * Monster.Types.isBoolean(true) // ↦ true
  * </script>
  * ```
  *
@@ -140,10 +148,10 @@ function isSymbol(value) {
  *
  * ```
  * <script type="module">
- * import {isBoolean} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(isBoolean('2'))  // ↦ false
- * console.log(isBoolean([]))  // ↦ false
- * console.log(isBoolean(2>4))  // ↦ true
+ * import {isBoolean} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/modules/types/is.js';
+ * isBoolean('2'))  // ↦ false
+ * isBoolean([]))  // ↦ false
+ * isBoolean(2>4))  // ↦ true
  * </script>
  * ```
  *
@@ -163,15 +171,17 @@ function isBoolean(value) {
 }
 
 /**
- * checks whether the value passed is a string
+ * Checks whether the value passed is a string
+ * 
+ * This method is used in the library to have consistent names.
  *
- * you can call the method via the monster namespace `Monster.Types.isString()`.
+ * You can call the method via the monster namespace `Monster.Types.isString()`.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(Monster.Types.isString('2')) // ↦ true
- * console.log(Monster.Types.isString([])) // ↦ false
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/monster.js';
+ * Monster.Types.isString('2') // ↦ true
+ * Monster.Types.isString([]) // ↦ false
  * </script>
  * ```
  *
@@ -179,9 +189,9 @@ function isBoolean(value) {
  *
  * ```
  * <script type="module">
- * import {isString} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(isString('2'))  // ↦ true
- * console.log(isString([]))  // ↦ false
+ * import {isString} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/modules/types/is.js';
+ * isString('2'))  // ↦ true
+ * isString([]))  // ↦ false
  * </script>
  * ```
  *
@@ -199,16 +209,18 @@ function isString(value) {
 }
 
 /**
- * checks whether the value passed is a object
+ * Checks whether the value passed is a object
+ * 
+ * This method is used in the library to have consistent names.
  *
- * you can call the method via the monster namespace `Monster.Types.isObject()`.
+ * You can call the method via the monster namespace `Monster.Types.isObject()`.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(Monster.Types.isObject('2')) // ↦ false
- * console.log(Monster.Types.isObject([])) // ↦ false
- * console.log(Monster.Types.isObject({})) // ↦ true
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/monster.js';
+ * Monster.Types.isObject('2') // ↦ false
+ * Monster.Types.isObject([]) // ↦ false
+ * Monster.Types.isObject({}) // ↦ true
  * </script>
  * ```
  *
@@ -216,9 +228,9 @@ function isString(value) {
  *
  * ```
  * <script type="module">
- * import {isObject} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(isObject('2'))  // ↦ false
- * console.log(isObject([]))  // ↦ false
+ * import {isObject} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/modules/types/is.js';
+ * isObject('2'))  // ↦ false
+ * isObject([]))  // ↦ false
  * </script>
  * ```
  *
@@ -241,16 +253,18 @@ function isObject(value) {
 }
 
 /**
- * checks whether the value passed is a object and instance of instance
+ * Checks whether the value passed is a object and instance of instance.
+ * 
+ * This method is used in the library to have consistent names.
  *
  * you can call the method via the monster namespace `Monster.Types.isInstance()`.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(Monster.Types.isInstance('2')) // ↦ false
- * console.log(Monster.Types.isInstance([])) // ↦ false
- * console.log(Monster.Types.isInstance({})) // ↦ true
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/monster.js';
+ * Monster.Types.isInstance('2') // ↦ false
+ * Monster.Types.isInstance([]) // ↦ false
+ * Monster.Types.isInstance({}) // ↦ true
  * </script>
  * ```
  *
@@ -258,9 +272,9 @@ function isObject(value) {
  *
  * ```
  * <script type="module">
- * import {isInstance} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(isInstance('2'))  // ↦ false
- * console.log(isInstance([]))  // ↦ false
+ * import {isInstance} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/modules/types/is.js';
+ * isInstance('2'))  // ↦ false
+ * isInstance([]))  // ↦ false
  * </script>
  * ```
  *
@@ -281,15 +295,17 @@ function isInstance(value, instance) {
 }
 
 /**
- * checks whether the value passed is a array
+ * Checks whether the value passed is a array
+ * 
+ * This method is used in the library to have consistent names. 
  *
  * you can call the method via the monster namespace `Monster.Types.isArray()`.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(Monster.Types.isArray('2')) // ↦ false
- * console.log(Monster.Types.isArray([])) // ↦ true
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/monster.js';
+ * Monster.Types.isArray('2') // ↦ false
+ * Monster.Types.isArray([]) // ↦ true
  * </script>
  * ```
  *
@@ -297,9 +313,9 @@ function isInstance(value, instance) {
  *
  * ```
  * <script type="module">
- * import {isArray} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(isArray('2'))  // ↦ false
- * console.log(isArray([]))  // ↦ true
+ * import {isArray} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/modules/types/is.js';
+ * isArray('2'))  // ↦ false
+ * isArray([]))  // ↦ true
  * </script>
  * ```
  *
@@ -308,25 +324,25 @@ function isInstance(value, instance) {
  * @since 1.0.0
  * @copyright schukai GmbH
  * @memberOf Monster.Types
+ * @see https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray
  */
 function isArray(value) {
-    if (Array.isArray(value)) {
-        return true;
-    }
-    return false;
+    return Array.isArray(value);
 }
 
 /**
- * checks whether the value passed is a function
+ * Checks whether the value passed is a function
+ * 
+ * This method is used in the library to have consistent names. 
  *
  * you can call the method via the monster namespace `Monster.Types.isFunction()`.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(Monster.Types.isFunction(()=>{})) // ↦ true
- * console.log(Monster.Types.isFunction('2')) // ↦ false
- * console.log(Monster.Types.isFunction([])) // ↦ false
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/monster.js';
+ * Monster.Types.isFunction(()=>{}) // ↦ true
+ * Monster.Types.isFunction('2') // ↦ false
+ * Monster.Types.isFunction([]) // ↦ false
  * </script>
  * ```
  *
@@ -334,10 +350,10 @@ function isArray(value) {
  *
  * ```
  * <script type="module">
- * import {isFunction} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(isFunction(()=>{})) // ↦ true
- * console.log(isFunction('2'))  // ↦ false
- * console.log(isFunction([]))  // ↦ false
+ * import {isFunction} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/modules/types/is.js';
+ * isFunction(()=>{}) // ↦ true
+ * isFunction('2'))  // ↦ false
+ * isFunction([]))  // ↦ false
  * </script>
  * ```
  *
@@ -360,16 +376,18 @@ function isFunction(value) {
 }
 
 /**
- * checks whether the value passed is an integer
+ * Checks whether the value passed is an integer.
+ * 
+ * This method is used in the library to have consistent names. 
  *
- * you can call the method via the monster namespace `Monster.Types.isFunction()`.
+ * You can call the method via the monster namespace `Monster.Types.isFunction()`.
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(Monster.Types.isInteger(()=>{})) // ↦ true
- * console.log(Monster.Types.isInteger('2')) // ↦ false
- * console.log(Monster.Types.isInteger(2)) // ↦ true
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/monster.js';
+ * Monster.Types.isInteger(()=>{}) // ↦ true
+ * Monster.Types.isInteger('2') // ↦ false
+ * Monster.Types.isInteger(2) // ↦ true
  * </script>
  * ```
  *
@@ -377,10 +395,10 @@ function isFunction(value) {
  *
  * ```
  * <script type="module">
- * import {isInteger} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/is.js';
- * console.log(isInteger(()=>{})) // ↦ true
- * console.log(isInteger('2'))  // ↦ false
- * console.log(isInteger(2))  // ↦ true
+ * import {isInteger} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/modules/types/is.js';
+ * isInteger(()=>{}) // ↦ true
+ * isInteger('2'))  // ↦ false
+ * isInteger(2))  // ↦ true
  * </script>
  * ```
  *

package/source/types/mediatype.js

@@ -28,7 +28,7 @@ const internal = Symbol('internal');
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/mediatype.js';
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/monster.js';
  * console.log(new Monster.Types.MediaType())
  * </script>
  * ```
@@ -37,7 +37,7 @@ const internal = Symbol('internal');
  *
  * ```
  * <script type="module">
- * import {MediaType} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/mediatype.js';
+ * import {MediaType} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/modules/types/mediatype.js';
  * console.log(new MediaType())
  * </script>
  * ```
@@ -137,7 +137,7 @@ class MediaType extends Base {
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/dataurl.js';
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/monster.js';
  * console.log(Monster.Types.parseMediaType())
  * </script>
  * ```
@@ -146,7 +146,7 @@ class MediaType extends Base {
  *
  * ```
  * <script type="module">
- * import {parseMediaType} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.25.0/dist/modules/types/dataurl.js';
+ * import {parseMediaType} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/modules/types/dataurl.js';
  * console.log(parseMediaType())
  * </script>
  * ```

package/source/types/node.js

@@ -0,0 +1,210 @@
+'use strict';
+
+/**
+ * @author schukai GmbH
+ */
+
+
+import {assignToNamespace, Monster} from '../namespace.js';
+import {Base} from './base.js';
+import {isPrimitive} from "./is.js";
+import {NodeList} from './nodelist.js';
+import {validateInstance} from './validate.js';
+
+/**
+ * @private
+ * @type {symbol}
+ */
+const internalValueSymbol = Symbol('internalData');
+
+/**
+ * @private
+ * @type {symbol}
+ */
+const treeStructureSymbol = Symbol('treeStructure');
+
+
+/**
+ * You can create the instance via the monster namespace `new Monster.Types.Node()`.
+ *
+ * ```
+ * <script type="module">
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/monster.js';
+ * new Monster.Types.Node()
+ * </script>
+ * ```
+ *
+ * Alternatively, you can also integrate this function individually.
+ *
+ * ```
+ * <script type="module">
+ * import {Node} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.28.0/dist/modules/types/node.js';
+ * new Node()
+ * </script>
+ * ```
+ *
+ * @since 1.26.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Types
+ * @summary A Node Class
+ * @see https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Iteration_protocols
+ */
+class Node extends Base {
+
+    /**
+     * @param {*} [value]
+     */
+    constructor(value) {
+        super();
+        this[internalValueSymbol] = value;
+
+        this[treeStructureSymbol] = {
+            parent: null,
+            childNodes: new NodeList,
+            level: 0
+        }
+
+    }
+
+    /**
+     * @property {*}
+     */
+    get value() {
+        return this[internalValueSymbol];
+    }
+
+    /**
+     * @property {*}
+     */
+    set value(value) {
+        this[internalValueSymbol] = value;
+    }
+
+    /**
+     * @property {Monster.Types.Node|null}
+     */
+    get parent() {
+        return this[treeStructureSymbol].parent;
+    }
+
+    /**
+     * @property {integer}
+     */
+    get level() {
+        return this[treeStructureSymbol].level;
+    }
+
+    /**
+     *
+     * @property {NodeList}
+     */
+    get childNodes() {
+        return this[treeStructureSymbol].childNodes;
+    }
+
+    /**
+     *
+     * @property {NodeList}
+     */
+    set childNodes(childNodes) {
+        this[treeStructureSymbol].childNodes = validateInstance(childNodes, NodeList);
+        setChildLevelAndParent.call(this, this, 1);
+    }
+
+    /**
+     * @return {Monster.Types.Node}
+     * @param {Node} node
+     */
+    appendChild(node) {
+        this[treeStructureSymbol].childNodes.add(validateInstance(node, Node));
+        node[treeStructureSymbol].parent = this;
+
+        node[treeStructureSymbol].level = this.level + 1;
+        setChildLevelAndParent.call(this, node, 1);
+        return this;
+    }
+
+    /**
+     * @return {Monster.Types.Node}
+     * @param {Node} node
+     */
+    removeChild(node) {
+        this[treeStructureSymbol].childNodes.remove(validateInstance(node, Node));
+        node[treeStructureSymbol].parent = null;
+
+        node[treeStructureSymbol].level = 0;
+        setChildLevelAndParent.call(this, node, -1);
+        return this;
+    }
+
+    /**
+     *
+     * @return {boolean}
+     */
+    hasChildNodes() {
+        return this[treeStructureSymbol].childNodes.length > 0;
+    }
+
+    /**
+     * @return {Monster.Types.Node}
+     * @param {Node} node
+     */
+    hasChild(node) {
+        return this[treeStructureSymbol].childNodes.has(validateInstance(node, Node));
+    }
+
+    /**
+     * @since 1.28.0
+     * @return {string}
+     */
+    toString() {
+
+        let parts = [];
+        if (this[internalValueSymbol]) {
+            let label = this[internalValueSymbol];
+            if (!isPrimitive(label)) label = JSON.stringify(this[internalValueSymbol])
+
+            parts.push( label);
+        }
+
+        if (!this.hasChildNodes()) {
+            return parts.join("\n");
+        }
+
+        let count = this.childNodes.length,
+            counter = 0;
+
+        for (const node of this.childNodes) {
+            counter++;
+            const prefix = (count === counter ? '└' : '├').padStart(2 * node.level, ' |');
+            parts.push(prefix + node.toString());
+        }
+
+        return parts.join("\n");
+    }
+
+}
+
+/**
+ * @private
+ * @param {Node} node
+ * @param {int} operand
+ * @return {setChildLevelAndParent}
+ */
+function setChildLevelAndParent(node, operand) {
+    const self = this;
+
+    if (node !== this) {
+        node[treeStructureSymbol].parent = this
+    }
+
+    node[treeStructureSymbol].childNodes.forEach(function (child) {
+        child[treeStructureSymbol].parent = node;
+        child[treeStructureSymbol].level = node[treeStructureSymbol].level + operand;
+        setChildLevelAndParent.call(self, child, operand);
+    });
+    return this;
+}
+
+assignToNamespace('Monster.Types', Node);
+export {Monster, Node}