@schukai/monster 1.31.0 → 2.0.2

package/source/types/{id.js → id.mjs}

@@ -1,11 +1,14 @@
-'use strict';
-
 /**
- * @author schukai GmbH
+ * 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 {assignToNamespace, Monster} from '../namespace.js';
-import {Base} from './base.js';
-import {validateString} from "./validate.js";
+
+import {Base} from './base.mjs';
+import {validateString} from "./validate.mjs";
+
+export {ID}
 
 /**
  * @private
@@ -20,26 +23,9 @@ let internalCounter = new Map;
  *
  * So the ids can also be used for navigation. you just have to take care that the order stays the same.
  *
- * You can call the method via the monster namespace `new Monster.Types.ID()`.
- *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.31.0/dist/monster.js';
- * console.log(new Monster.Types.ID())
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {ID} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.31.0/dist/modules/types/id.js';
- * console.log(new ID())
- * </script>
- * ```
- *
  * As of version 1.6.0 there is the new RandomID. this ID class is continuous from now on.
  *
+ * @license AGPLv3
  * @since 1.0.0
  * @copyright schukai GmbH
  * @memberOf Monster.Types
@@ -79,6 +65,3 @@ class ID extends Base {
     }
 
 }
-
-assignToNamespace('Monster.Types', ID);
-export {Monster, ID}

package/source/types/is.mjs

@@ -0,0 +1,225 @@
+/**
+ * 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
+ */
+
+export {isIterable, isPrimitive, isSymbol, isBoolean, isString, isObject, isInstance, isArray, isFunction, isInteger}
+
+/**
+ * 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()`.
+ *
+ * @externalExample ../../example/types/is-1.mjs
+ * @param {*} value
+ * @returns {boolean}
+ * @license AGPLv3
+ * @since 1.2.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Types
+ */
+function isIterable(value) {
+    if (value === undefined) return false;
+    if (value === null) return false;
+    return typeof value?.[Symbol.iterator] === 'function';
+}
+
+
+/**
+ * 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.
+ *
+ * @externalExample ../../example/types/is-2.mjs
+ * @param {*} value
+ * @returns {boolean}
+ * @license AGPLv3
+ * @since 1.0.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Types
+ */
+function isPrimitive(value) {
+    var type;
+
+    if (value === undefined || value === null) {
+        return true;
+    }
+
+    type = typeof value;
+
+    if (type === 'string' || type === 'number' || type === 'boolean' || type === 'symbol') {
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Checks whether the value passed is a symbol
+ *
+ * This method is used in the library to have consistent names.
+ *
+ * @externalExample ../../example/types/is-3.mjs
+ * @param {*} value
+ * @returns {boolean}
+ * @license AGPLv3
+ * @since 1.9.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Types
+ */
+function isSymbol(value) {
+    return ('symbol' === typeof value) ? true : false;
+}
+
+/**
+ * Checks whether the value passed is a boolean.
+ *
+ * This method is used in the library to have consistent names.
+ *
+ * @externalExample ../../example/types/is-4.mjs
+ * @param {*} value
+ * @returns {boolean}
+ * @license AGPLv3
+ * @since 1.0.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Types
+ */
+function isBoolean(value) {
+
+    if (value === true || value === false) {
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Checks whether the value passed is a string
+ *
+ * This method is used in the library to have consistent names.
+ *
+ * @externalExample ../../example/types/is-5.mjs
+ * @param {*} value
+ * @returns {boolean}
+ * @license AGPLv3
+ * @since 1.0.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Types
+ */
+function isString(value) {
+    if (value === undefined || typeof value !== 'string') {
+        return false;
+    }
+    return true;
+}
+
+/**
+ * Checks whether the value passed is a object
+ *
+ * This method is used in the library to have consistent names.
+ *
+ * @externalExample ../../example/types/is-6.mjs
+ * @param {*} value
+ * @returns {boolean}
+ * @license AGPLv3
+ * @since 1.0.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Types
+ */
+function isObject(value) {
+
+    if (isArray(value)) return false;
+    if (isPrimitive(value)) return false;
+
+    if (typeof value === 'object') {
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Checks whether the value passed is a object and instance of instance.
+ *
+ * This method is used in the library to have consistent names.
+ * 
+ * @externalExample ../../example/types/is-7.mjs
+ * @param {*} value
+ * @param {*} instance
+ * @returns {boolean}
+ * @license AGPLv3
+ * @since 1.5.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Types
+ */
+function isInstance(value, instance) {
+    if (!isObject(value)) return false;
+    if (!isFunction(instance)) return false;
+    if (!instance.hasOwnProperty('prototype')) return false;
+    return (value instanceof instance) ? true : false;
+}
+
+/**
+ * Checks whether the value passed is a array
+ *
+ * This method is used in the library to have consistent names.
+ *
+ * @externalExample ../../example/types/is-8.mjs
+ * @param {*} value
+ * @returns {boolean}
+ * @license AGPLv3
+ * @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) {
+    return Array.isArray(value);
+}
+
+/**
+ * Checks whether the value passed is a function
+ *
+ * This method is used in the library to have consistent names.
+ * 
+ * @externalExample ../../example/types/is-9.mjs
+ * @param {*} value
+ * @returns {boolean}
+ * @license AGPLv3
+ * @since 1.0.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Types
+ */
+function isFunction(value) {
+    if (isArray(value)) return false;
+    if (isPrimitive(value)) return false;
+
+    if (typeof value === 'function') {
+        return true;
+    }
+
+    return false;
+
+}
+
+/**
+ * Checks whether the value passed is an integer.
+ *
+ * This method is used in the library to have consistent names.
+ *
+ * @externalExample ../../example/types/is-10.mjs
+ * @param {*} value
+ * @returns {boolean}
+ * @license AGPLv3
+ * @since 1.4.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Types
+ */
+function isInteger(value) {
+    return Number.isInteger(value);
+}
+

package/source/types/{mediatype.js → mediatype.mjs}

@@ -1,13 +1,15 @@
-'use strict';
-
-import {assignToNamespace} from "../namespace.js";
 /**
- * @author schukai GmbH
+ * 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, Monster} from "./base.js";
-import {isString} from "./is.js";
-import {validateArray, validateString} from "./validate.js";
 
+import {Base} from "./base.mjs";
+import {isString} from "./is.mjs";
+import {validateArray, validateString} from "./validate.mjs";
+
+export {MediaType, parseMediaType}
 
 /**
  * @private
@@ -26,22 +28,7 @@ const internal = Symbol('internal');
 /**
  * You can create an object via the monster namespace `new Monster.Types.MediaType()`.
  *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.31.0/dist/monster.js';
- * console.log(new Monster.Types.MediaType())
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {MediaType} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.31.0/dist/modules/types/mediatype.js';
- * console.log(new MediaType())
- * </script>
- * ```
- *
+ * @license AGPLv3
  * @since 1.8.0
  * @copyright schukai GmbH
  * @memberOf Monster.Types
@@ -137,7 +124,7 @@ class MediaType extends Base {
  *
  * ```
  * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.31.0/dist/monster.js';
+ * import {Monster} from '@schukai/monster/source//monster.mjs';
  * console.log(Monster.Types.parseMediaType())
  * </script>
  * ```
@@ -146,7 +133,7 @@ class MediaType extends Base {
  *
  * ```
  * <script type="module">
- * import {parseMediaType} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.31.0/dist/modules/types/dataurl.js';
+ * import {parseMediaType} from '@schukai/monster/source/types/dataurl.mjs';
  * console.log(parseMediaType())
  * </script>
  * ```
@@ -193,6 +180,7 @@ function parseMediaType(mediatype) {
 
 /**
  * @private
+ * @license AGPLv3
  * @since 1.18.0
  * @param {String} parameter
  * @return {Monster.Types.Parameter[]|undefined}
@@ -230,7 +218,3 @@ function parseParameter(parameter) {
     return result;
 
 }
-
-
-assignToNamespace('Monster.Types', parseMediaType, MediaType);
-export {Monster, parseMediaType, MediaType};

package/source/types/{namespace.js → namespace.mjs}

@@ -1,5 +1,3 @@
-'use strict';
-
 /**
  * Namespace for types.
  *
@@ -7,10 +5,5 @@
  * @memberOf Monster
  * @author schukai GmbH
  */
+const ns = {};
 
-
-/**
- * @private
- * @type {string}
- */
-export const namespace = "Monster.Types";   

package/source/types/{node.js → node.mjs}

@@ -1,15 +1,16 @@
-'use strict';
-
 /**
- * @author schukai GmbH
+ * 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 './base.mjs';
+import {isPrimitive} from "./is.mjs";
+import {NodeList} from './nodelist.mjs';
+import {validateInstance} from './validate.mjs';
 
-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';
+export {Node}
 
 /**
  * @private
@@ -27,22 +28,7 @@ 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.31.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.31.0/dist/modules/types/node.js';
- * new Node()
- * </script>
- * ```
- *
+ * @license AGPLv3
  * @since 1.26.0
  * @copyright schukai GmbH
  * @memberOf Monster.Types
@@ -164,7 +150,7 @@ class Node extends Base {
             let label = this[internalValueSymbol];
             if (!isPrimitive(label)) label = JSON.stringify(this[internalValueSymbol])
 
-            parts.push( label);
+            parts.push(label);
         }
 
         if (!this.hasChildNodes()) {
@@ -205,6 +191,3 @@ function setChildLevelAndParent(node, operand) {
     });
     return this;
 }
-
-assignToNamespace('Monster.Types', Node);
-export {Monster, Node}

package/source/types/{nodelist.js → nodelist.mjs}

@@ -1,32 +1,20 @@
-'use strict';
-
 /**
- * @author schukai GmbH
+ * 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 {assignToNamespace, Monster} from '../namespace.js';
-import {isArray, isInstance} from "./is.js";
-import {Node} from "./node.js";
-import {validateInstance} from "./validate.js";
+
+import {isArray, isInstance} from "./is.mjs";
+import {Node} from "./node.mjs";
+import {validateInstance} from "./validate.mjs";
+
+export {NodeList}
 
 /**
  * You can create the instance via the monster namespace `new Monster.Types.NodeList()`.
  *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.31.0/dist/monster.js';
- * new Monster.Types.NodeList()
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {NodeList} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.31.0/dist/modules/types/nodelist.js';
- * new NodeList()
- * </script>
- * ```
- *
+ * @license AGPLv3
  * @since 1.26.0
  * @copyright schukai GmbH
  * @memberOf Monster.Types
@@ -43,8 +31,8 @@ class NodeList extends Set {
 
         const self = this
 
-        if(values===undefined) return;
-        
+        if (values === undefined) return;
+
         if (isArray(values)) {
             values.forEach(value => self.add(value));
         } else if (isInstance(values, NodeList)) {
@@ -111,11 +99,11 @@ class NodeList extends Set {
      */
     toString() {
         let parts = [];
-        
-        for(const node of this.toArray()) {
-            parts.push(node.toString()) 
+
+        for (const node of this.toArray()) {
+            parts.push(node.toString())
         }
-        
+
         return parts.join("\n");
     }
 
@@ -124,6 +112,3 @@ class NodeList extends Set {
     }
 }
 
-
-assignToNamespace('Monster.Types', NodeList);
-export {Monster, NodeList}

package/source/types/{noderecursiveiterator.js → noderecursiveiterator.mjs}

@@ -1,18 +1,19 @@
-'use strict';
-
 /**
- * @author schukai GmbH
+ * 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} from "../constants.mjs";
 
-import {internalSymbol} from "../constants.js";
-import {assignToNamespace, Monster} from '../namespace.js';
-import {Base} from './base.js';
-import {isInstance} from "./is.js";
-import {Node} from "./node.js";
-import {NodeList} from "./nodelist.js";
-import {validateInstance} from "./validate.js";
+import {Base} from './base.mjs';
+import {isInstance} from "./is.mjs";
+import {Node} from "./node.mjs";
+import {NodeList} from "./nodelist.mjs";
+import {validateInstance} from "./validate.mjs";
 
+export {NodeRecursiveIterator}
 
 /**
  * @private
@@ -23,62 +24,14 @@ const isNodeListSymbol = Symbol('isNodeList');
 /**
  * You can create the instance via the monster namespace `new Monster.Types.NodeRecursiveIterator()`.
  *
- * ```
- * <script type="module">
- * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.31.0/dist/monster.js';
- * new Monster.Types.NodeRecursiveIterator()
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {NodeRecursiveIterator} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.31.0/dist/modules/types/noderecursiveiterator.js';
- * new NodeRecursiveIterator()
- * </script>
- * ```
- *
- * @example
- * import {Node} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.31.0/dist/modules/types/node.js';
- * import {NodeRecursiveIterator} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.31.0/dist/modules/types/noderecursiveiterator.js';
- *
- * const node =new Node('1')
- *
- * // 1
- * // 2
- * // ├ 2.1
- * // ├ 2.2
- * // └ 2.3
- * // 3
- * // 4
- * // ├ 4.1
- * // └ 4.2
- * node.appendChild(
- * (new Node('2'))
- *       .appendChild(new Node('2.1'))
- *       .appendChild(new Node('2.2'))
- *       .appendChild(new Node('2.3')))
- * .appendChild(new Node('3'))
- * .appendChild(new Node('4')
- *       .appendChild(new Node('4.1'))
- *       .appendChild(new Node('4.2')));
- *
- * const iterator = new NodeRecursiveIterator(node);
- *
- * const result = [];
- * for (const n of iterator) {
- *      result.push(n.value);
- * }
- *
- * // ↦ ['1', '2', '2.1', '2.2', '2.3', '3', '4', '4.1', '4.2']
- *
+ * @externalExample ../../example/types/noderecursiveiterator.mjs
+ * @license AGPLv3
  * @since 1.26.0
  * @copyright schukai GmbH
  * @memberOf Monster.Types
  * @summary An iterator to run recursively through a tree of nodes
  */
-class NodeRecursiveIterator extends Base {
+ class NodeRecursiveIterator extends Base {
 
     /**
      * @param {Node} [data]
@@ -142,7 +95,3 @@ class NodeRecursiveIterator extends Base {
     }
 
 }
-
-
-assignToNamespace('Monster.Types', NodeRecursiveIterator);
-export {Monster, NodeRecursiveIterator}