@schukai/monster 1.30.1 → 2.0.1

package/example/types/noderecursiveiterator.mjs

@@ -0,0 +1,32 @@
+import {Node} from '@schukai/monster/source/types/node.mjs';
+import {NodeRecursiveIterator} from '@schukai/monster/source/types/noderecursiveiterator.mjs';
+
+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']

package/example/types/observer.mjs

@@ -0,0 +1,9 @@
+import {Observer} from '@schukai/monster/source/types/observer.mjs';
+
+const observer = new Observer(function (a, b, c) {
+    console.log(this, a, b, c); // ↦ "a", 2, true 
+}, "a", 2, true);
+
+observer.update({value: true}).then(() => {
+});
+// ↦ {value: true} "a" 2 true

package/example/types/proxyobserver.mjs

@@ -0,0 +1,25 @@
+import {ProxyObserver} from '@schukai/monster/source/types/proxyobserver.mjs';
+import {Observer} from '@schukai/monster/source/types/observer.mjs';
+import {isObject} from '@schukai/monster/source/types/is.mjs';
+
+const o = new Observer(function () {
+    if (isObject(this) && this instanceof ProxyObserver) {
+        // do something (this ist ProxyObserver)
+        const subject = this.getSubject();
+        console.log(subject);
+    }
+});
+
+let realSubject = {
+    a: {
+        b: {
+            c: true
+        },
+        d: 9
+    }
+}
+
+const p = new ProxyObserver(realSubject);
+p.attachObserver(o);
+const s = p.getSubject();
+s.a.b.c = false;

package/example/types/queue.mjs

@@ -0,0 +1,20 @@
+import {Queue} from '@schukai/monster/source/types/queue.mjs';
+
+const queue = new Queue;
+
+queue.add(2);
+queue.add(true);
+queue.add("Hello");
+queue.add(4.5);
+
+console.log(queue.poll());
+// ↦ 2
+console.log(queue.poll());
+// ↦ true
+console.log(queue.poll());
+// ↦ "Hello"
+console.log(queue.poll());
+// ↦ 4.5
+console.log(queue.poll());
+// ↦ undefined
+

package/example/types/tokenlist-1.mjs

@@ -0,0 +1,4 @@
+import {TokenList} from '@schukai/monster/source/types/tokenlist.mjs';
+
+typeof new TokenList("myclass row")[Symbol.iterator];
+// ↦ "function"

package/example/types/tokenlist-2.mjs

@@ -0,0 +1,7 @@
+import {TokenList} from '@schukai/monster/source/types/tokenlist.mjs';
+
+new TokenList("start middle end").contains('start'); // ↦ true
+new TokenList("start middle end").contains('end'); // ↦ true
+new TokenList("start middle end").contains('xyz'); // ↦ false
+new TokenList("start middle end").contains(['end','start','middle']); // ↦ true
+new TokenList("start middle end").contains(['end','start','xyz']); // ↦ false

package/example/types/tokenlist-3.mjs

@@ -0,0 +1,5 @@
+import {TokenList} from '@schukai/monster/source/types/tokenlist.mjs';
+
+new TokenList().add("abc xyz").toString(); // ↦ "abc xyz"
+new TokenList().add(["abc", "xyz"]).toString(); // ↦ "abc xyz"
+new TokenList().add(undefined); // ↦ add nothing

package/example/types/tokenlist-4.mjs

@@ -0,0 +1,5 @@
+import {TokenList} from '@schukai/monster/source/types/tokenlist.mjs';
+
+new TokenList("abc xyz").remove("xyz").toString(); // ↦ "abc"
+new TokenList("abc xyz").remove(["xyz"]).toString(); // ↦ "abc"
+new TokenList("abc xyz").remove(undefined); // ↦ remove nothing

package/example/types/tokenlist-5.mjs

@@ -0,0 +1,5 @@
+import {TokenList} from '@schukai/monster/source/types/tokenlist.mjs';
+
+new TokenList("abc def ghi").toggle("def xyz").toString(); // ↦ "abc ghi xyz"
+new TokenList("abc def ghi").toggle(["abc", "xyz"]).toString(); // ↦ "def ghi xyz"
+new TokenList().toggle(undefined); // ↦ nothing

package/example/types/typeof.mjs

@@ -0,0 +1,9 @@
+import {typeOf} from '@schukai/monster/source/types/typeof.mjs';
+
+typeOf(undefined); // ↦ undefined
+typeOf(""); // ↦ string
+typeOf(5); // ↦ number
+typeOf({}); // ↦ object
+typeOf([]); // ↦ array
+typeOf(new Map); // ↦ map
+typeOf(true); // ↦ boolean

package/example/types/version-1.mjs

@@ -0,0 +1,6 @@
+import {Version} from '@schukai/monster/source/types/version.mjs';
+
+new Version('1.0.0') // ↦ 1.0.0
+new Version(1)  // ↦ 1.0.0
+new Version(1, 0, 0) // ↦ 1.0.0
+new Version('1.2.3', 4, 5) // ↦ 1.4.5

package/example/types/version-2.mjs

@@ -0,0 +1,3 @@
+import {getMonsterVersion} from '@schukai/monster/source/types/version.mjs';
+
+getMonsterVersion(); 

package/example/util/comparator.mjs

@@ -0,0 +1,10 @@
+import {Comparator} from '@schukai/monster/source/util/comparator.mjs';
+
+console.log(new Comparator().lessThanOrEqual(2, 5))
+// ↦ true
+console.log(new Comparator().greaterThan(4, 2))
+// ↦ true
+console.log(new Comparator().equal(4, 4))
+// ↦ true
+console.log(new Comparator().equal(4, 5))
+// ↦ false

package/example/util/deadmansswitch.mjs

@@ -0,0 +1,9 @@
+import {DeadMansSwitch} from '@schukai/monster/source/util/deadmansswitch.mjs';
+
+const deadmansswitch = new DeadMansSwitch(100, () => {
+    console.log('yeah!')
+    // ↦ "yeah!"
+})
+
+deadmansswitch.touch(); // from here wait again 100 ms
+deadmansswitch.touch(200); // from here wait 200 ms

package/example/util/processing.mjs

@@ -0,0 +1,17 @@
+import {Processing} from '@schukai/monster/source/util/processing.mjs';
+
+let startTime = +new Date();
+
+new Processing((url) => {
+    return fetch(url)
+}, (response) => {
+    // do something with the response
+    console.log(response.status, +new Date() - startTime)
+}, 200, () => {
+    // this function is called 200 seconds after fetch is received.
+    console.log('finished', +new Date() - startTime)
+    return 'done'
+}).run('https://monsterjs.org/assets/world.json').then(r => {
+    console.log(r)
+    // ↦ "done"
+})

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@schukai/monster",
-  "version": "1.30.1",
-  "types": "./source/types/package.d.ts",
+  "version": "2.0.1",
   "description": "Monster is a simple library for creating fast, robust and lightweight websites.",
   "keywords": [
     "framework",
@@ -30,67 +29,14 @@
     "log",
     "theme"
   ],
+  "main": "source/monster.js",
+  "module": "source/monster.js",
   "type": "module",
   "homepage": "https://monsterjs.org",
   "repository": {
     "type": "git",
     "url": "https://gitlab.schukai.com/oss/libraries/javascript/monster.git"
   },
-  "main": "dist/monster.js",
-  "module": "dist/modules/monster.js",
   "author": "schukai GmbH",
-  "license": "AGPL 3.0",
-  "browserslist": [
-    "last 10 version",
-    "> 1%",
-    "IE 10"
-  ],
-  "browserify": {
-    "transform": [
-      [
-        "babelify",
-        {
-          "presets": [
-            [
-              "@babel/preset-env",
-              {
-                "useBuiltIns": "usage",
-                "corejs": 3,
-                "targets": {
-                  "browsers": [
-                    "last 2 versions",
-                    "safari >= 7",
-                    "ie >= 11"
-                  ]
-                }
-              }
-            ]
-          ],
-          "plugins": [
-            [
-              "@babel/plugin-transform-regenerator",
-              {
-                "asyncGenerators": false,
-                "generators": false,
-                "async": false
-              }
-            ],
-            [
-              "@babel/plugin-transform-runtime",
-              {
-                "absoluteRuntime": false,
-                "corejs": false,
-                "helpers": true,
-                "regenerator": true,
-                "version": "7.0.0-beta.0"
-              }
-            ],
-            [
-              "@babel/plugin-transform-classes"
-            ]
-          ]
-        }
-      ]
-    ]
-  }
-}
+  "license": "AGPL 3.0"
+}

package/source/{constants.js → constants.mjs}

@@ -1,15 +1,18 @@
-'use strict';
-
-import {Monster} from './namespace.js';
 /**
  * Property-Keys
  * @author schukai GmbH
  */
 
+export {
+    internalSymbol,
+    internalStateSymbol
+}
+
 /**
  * @private
  * @type {symbol}
  * @memberOf Monster
+ * @license AGPLv3
  * @since 1.24.0
  */
 const internalSymbol = Symbol('internalData');
@@ -18,14 +21,8 @@ const internalSymbol = Symbol('internalData');
  * @private
  * @type {symbol}
  * @memberOf Monster
+ * @license AGPLv3
  * @since 1.25.0
  */
 const internalStateSymbol = Symbol('state');
 
-
-export {
-    Monster,
-    internalSymbol,
-    internalStateSymbol
-}
-

package/source/constraints/{abstract.js → abstract.mjs}

@@ -1,12 +1,13 @@
-'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 '../types/base.js';
+import {Base} from '../types/base.mjs';
 
+export {AbstractConstraint}
 
 /**
  * Constraints are used to define conditions that must be met by the value of a variable.
@@ -15,8 +16,9 @@ import {Base} from '../types/base.js';
  * 
  * The abstract constraint defines the api for all constraints. mainly the method isValid() is defined.
  *
- * derived classes must implement the method isValid().
+ * Derived classes must implement the method isValid().
  *
+ * @license AGPLv3
  * @since 1.3.0
  * @copyright schukai GmbH
  * @memberOf Monster.Constraints
@@ -41,6 +43,3 @@ class AbstractConstraint extends Base {
         return Promise.reject(value);
     }
 }
-
-assignToNamespace('Monster.Constraints', AbstractConstraint);
-export {Monster, AbstractConstraint}

package/source/constraints/{abstractoperator.js → abstractoperator.mjs}

@@ -1,18 +1,23 @@
-'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 {AbstractConstraint} from "./abstract.js";
+
+import {AbstractConstraint} from "./abstract.mjs";
+
+export {AbstractOperator}
 
 /**
  * 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.
+ * 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.
  *
+ * @license AGPLv3
  * @since 1.3.0
  * @copyright schukai GmbH
  * @memberOf Monster.Constraints
@@ -41,5 +46,3 @@ class AbstractOperator extends AbstractConstraint {
 
 }
 
-assignToNamespace('Monster.Constraints', AbstractOperator);
-export {Monster, AbstractOperator}

package/source/constraints/andoperator.mjs

@@ -0,0 +1,38 @@
+/**
+ * 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 {AbstractOperator} from "./abstractoperator.mjs";
+
+export {AndOperator}
+
+/**
+ * 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 constraints. The constraint is fulfilled if all constraints of the operators are fulfilled.
+ *
+ * @externalExample ../../example/constraints/andoperator.mjs
+ * @license AGPLv3
+ * @since 1.3.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Constraints
+ * @summary A and operator constraint
+ */
+class AndOperator extends AbstractOperator {
+
+    /**
+     * this method return a promise containing the result of the check.
+     *
+     * @param {*} value
+     * @returns {Promise}
+     */
+    isValid(value) {
+        return Promise.all([this.operantA.isValid(value), this.operantB.isValid(value)]);
+    }
+
+}

package/source/constraints/invalid.mjs

@@ -0,0 +1,38 @@
+/**
+ * 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 {AbstractConstraint} from "./abstract.mjs";
+
+export {Invalid}
+
+/**
+ * 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.
+ *
+ * @externalExample ../../example/constraints/invalid.mjs
+ * @license AGPLv3
+ * @since 1.3.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Constraints
+ * @summary A constraint that always invalid
+ */
+class Invalid extends AbstractConstraint {
+
+    /**
+     * this method return a rejected promise
+     *
+     * @param {*} value
+     * @returns {Promise}
+     */
+    isValid(value) {
+        return Promise.reject(value);
+    }
+
+}

package/source/constraints/isarray.mjs

@@ -0,0 +1,41 @@
+/**
+ * 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 {isArray} from "../types/is.mjs";
+import {AbstractConstraint} from "./abstract.mjs";
+
+export {IsArray}
+
+/**
+ * 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.
+ * 
+ * @externalExample ../../example/constraints/isarray.mjs
+ * @license AGPLv3
+ * @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 {
+
+    /**
+     * this method return a promise containing the result of the check.
+     *
+     * @param {*} value
+     * @returns {Promise}
+     */
+    isValid(value) {
+        if (isArray(value)) {
+            return Promise.resolve(value);
+        }
+
+        return Promise.reject(value);
+    }
+
+}

package/source/constraints/isobject.mjs

@@ -0,0 +1,41 @@
+/**
+ * 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 {isObject} from "../types/is.mjs";
+import {AbstractConstraint} from "./abstract.mjs";
+
+export {IsObject}
+
+/**
+ * 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.
+ *
+ * @externalExample ../../example/constraints/isobject.mjs
+ * @license AGPLv3
+ * @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 {
+
+    /**
+     * this method return a promise containing the result of the check.
+     *
+     * @param {*} value
+     * @returns {Promise}
+     */
+    isValid(value) {
+        if (isObject(value)) {
+            return Promise.resolve(value);
+        }
+
+        return Promise.reject(value);
+    }
+
+}

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

@@ -1,15 +1,10 @@
-'use strict';
+
 
 /**
  * Constraints are used to define conditions that must be met by the value of a variable so that the value can be transferred to the system.
  *
- * @namespace Constraints
+ * @namespace Monster.Constraints
  * @memberOf Monster
  * @author schukai GmbH
  */
-
-/**
- * @private
- * @type {string}
- */
-export const namespace = "Monster.Constraints";
+const ns = {};

package/source/constraints/{oroperator.js → oroperator.mjs}

@@ -1,10 +1,13 @@
-'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 {AbstractOperator} from "./abstractoperator.js";
+
+import {AbstractOperator} from "./abstractoperator.mjs";
+
+export {OrOperator}
 
 /**
  * Constraints are used to define conditions that must be met by the value of a variable.
@@ -13,40 +16,8 @@ import {AbstractOperator} from "./abstractoperator.js";
  *
  * 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.30.1/dist/monster.js';
- * new Monster.Constraint.OrOperator();
- * </script>
- * ```
- *
- * Alternatively, you can also integrate this function individually.
- *
- * ```
- * <script type="module">
- * import {OrOperator} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/constraint/oroperator.js';
- * new OrOperator();
- * </script>
- * ```
- *
- * @example
- *
- * import {Valid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/constraints/valid.js';
- * import {Invalid} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/constraints/invalid.js';
- * import {OrOperator} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.30.1/dist/modules/constraints/oroperator.js';
- *
- * new OrOperator(
- * new Valid(), new Invalid()).isValid()
- * .then(()=>console.log(true))
- * .catch(()=>console.log(false));
- * // ↦ true
- *
- * new OrOperator(
- * new Invalid(), new Invalid()).isValid()
- * .then(()=>console.log(true))
- * .catch(()=>console.log(false));
- * // ↦ false
- *
+ * @externalExample ../../example/constraints/oroperator.mjs
+ * @license AGPLv3
  * @since 1.3.0
  * @copyright schukai GmbH
  * @memberOf Monster.Constraints
@@ -92,6 +63,3 @@ class OrOperator extends AbstractOperator {
 
 
 }
-
-assignToNamespace('Monster.Constraints', OrOperator);
-export {Monster, OrOperator}

package/source/constraints/valid.mjs

@@ -0,0 +1,38 @@
+/**
+ * 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 {AbstractConstraint} from "./abstract.mjs";
+
+export {Valid}
+
+/**
+ * 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.
+ *
+ * @externalExample ../../example/constraints/valid.mjs
+ * @license AGPLv3
+ * @since 1.3.0
+ * @copyright schukai GmbH
+ * @memberOf Monster.Constraints
+ * @summary A constraint that always valid
+ */
+class Valid extends AbstractConstraint {
+
+    /**
+     * this method return a promise containing the result of the check.
+     *
+     * @param {*} value
+     * @returns {Promise}
+     */
+    isValid(value) {
+        return Promise.resolve(value);
+    }
+
+}