@schukai/monster 1.23.0 → 1.26.1

package/source/util/trimspaces.js

@@ -0,0 +1,85 @@
+'use strict';
+
+/**
+ * @author schukai GmbH
+ */
+
+import {assignToNamespace, Monster} from "../namespace.js";
+import {ID} from "../types/id.js";
+import {isObject} from "../types/is.js";
+import {validateString} from "../types/validate.js";
+
+/**
+ * This special trim function allows to trim spaces that have been protected by a special escape character.
+ *
+ * You can call the method via the monster namespace `Monster.Util.trimSpaces()`.
+ *
+ * ```
+ * <script type="module">
+ * import {Monster} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.1/dist/monster.js';
+ * Monster.Util.trimSpaces(" hello ")
+ * </script>
+ * ```
+ *
+ * Alternatively, you can also integrate this function individually.
+ *
+ * ```
+ * <script type="module">
+ * import {trimSpaces} from 'https://cdn.jsdelivr.net/npm/@schukai/monster@1.26.1/dist/modules/util/trimspaces.js';
+ * trimSpaces(' hello \\ ')
+ * </script>
+ * ```
+ * 
+ * Hint: One stroke is escaped by the javascript interpreter, the second stroke escapes the stroke.
+ * 
+ * ```text
+ * a\ b  ↦ a b
+ * a\\ b ↦ a\ b
+ * ```
+ * 
+ * @since 1.24.0
+ * @memberOf Monster.Util
+ * @copyright schukai GmbH
+ * @param {string} value
+ * @return {string}
+ * @throws {TypeError} value is not a string
+ */
+function trimSpaces(value) {
+
+    validateString(value);
+
+    let placeholder = new Map;
+    const regex = /((?<pattern>\\(?<char>.)){1})/mig;
+
+    // The separator for args must be escaped
+    // undefined string which should not occur normally and is also not a regex
+    let result = value.matchAll(regex)
+
+    for (let m of result) {
+        let g = m?.['groups'];
+        if (!isObject(g)) {
+            continue;
+        }
+
+        let p = g?.['pattern'];
+        let c = g?.['char'];
+
+        if (p && c) {
+            let r = '__' + new ID().toString() + '__';
+            placeholder.set(r, c);
+            value = value.replace(p, r);
+        }
+
+    }
+
+    value = value.trim();
+    placeholder.forEach((v, k) => {
+        value = value.replace(k, '\\' + v)
+    })
+
+    return value;
+
+}
+
+assignToNamespace('Monster.Util', trimSpaces);
+export {Monster, trimSpaces}

package/test/cases/data/buildtree.js

@@ -0,0 +1,149 @@
+"use strict";
+
+import {expect} from "chai"
+import {buildTree} from "../../../source/data/buildtree.js";
+import {NodeList} from "../../../source/types/nodelist.js";
+import {NodeRecursiveIterator} from "../../../source/types/noderecursiveiterator.js";
+
+
+describe('buildTree', function () {
+
+    describe('example', function () {
+
+        it('should run example', function () {
+
+            const objects = {
+                dataset: {
+                    "1": {
+                        id: "1",
+                        name: "vehicle",
+                        parent: null
+
+                    },
+                    "2": {
+                        id: "2",
+                        name: "car",
+                        parent: "1"
+                    },
+                    "3": {
+                        id: "3",
+                        name: "truck",
+                        parent: "1"
+                    },
+                    "4": {
+                        id: "4",
+                        name: "motorcycle",
+                        parent: "1"
+                    },
+                    "5": {
+                        id: "5",
+                        name: "SUV",
+                        parent: "2"
+                    },
+                    "6": {
+                        id: "6",
+                        name: "sports car",
+                        parent: "2"
+                    }
+                }
+            }
+
+            const nodes = buildTree(objects, 'dataset.*', 'id', 'parent');
+
+            let result = ""
+            nodes.forEach(node => {
+                new NodeRecursiveIterator(node).forEach(n => {
+                    result +="".padStart(n.level * 2, '.') + (n.value.name);
+                });
+
+            });
+
+            expect(result).to.be.equal('vehicle..car....SUV....sports car..truck..motorcycle');
+            expect(nodes).to.be.instanceOf(NodeList);
+            expect(nodes.length).to.equal(1);
+            expect(nodes.length).to.equal(1);
+
+
+        })
+    })
+
+    describe('buildTree()', function () {
+
+        let obj1 = {
+            dataset: {
+                "1": {
+                    id: "1",
+                    name: "Test 1",
+                    address: "Here 1",
+                    parent: null
+
+                },
+                "2": {
+                    id: "2",
+                    name: "Test 2",
+                    address: "Here 2",
+                    parent: "1"
+                },
+                "3": {
+                    id: "3",
+                    name: "Test 3",
+                    address: "Here 3",
+                    parent: "2"
+                },
+                "4": {
+                    id: "4",
+                    name: "Test 4",
+                    address: "Here 4",
+                    parent: "2"
+                },
+                "5": {
+                    id: "5",
+                    name: "Test 5",
+                    address: "Here 5",
+                    parent: "1"
+                },
+                "6": {
+                    id: "6",
+                    name: "Test 6",
+                    address: "Here 6",
+                    parent: "4"
+                }
+            }
+        };
+
+        it('should return Node Instance.', function () {
+            expect(buildTree({}, '')).to.be.instanceOf(NodeList);
+        });
+
+        [
+            [obj1, 'dataset.*', '1,2,3,4,6,5'],
+            [obj1, 'x', ''],
+            [obj1, 'dataset.*', '1,2,3,4,6,5'],
+        ].forEach(function (data) {
+
+            let a = data.shift()
+            let b = data.shift()
+            let c = data.shift()
+
+            it('buildTree(' + JSON.stringify(a) + ',' + JSON.stringify(b) + ') should return ' + JSON.stringify(c) + ' ', function () {
+                let nodelist = buildTree(a, b, 'id', 'parent');
+
+                let result = [];
+
+                const firstNode = nodelist.toArray().shift();
+                
+                if (firstNode) {
+                    for (const node of new NodeRecursiveIterator(firstNode)) {
+                        result.push(node.value.id);
+                    }
+                }
+
+                expect(result.join(',')).to.be.equal(c);
+            });
+        });
+
+
+    });
+
+
+});

package/test/cases/data/datasource/restapi.js

@@ -7,7 +7,7 @@ import {validateObject} from "../../../../source/types/validate.js";
 
 describe('RestAPI', function () {
 
-    let fetchReference;
+    let fetchReference; 
     let returnStatus;
 
     afterEach(() => {

package/test/cases/data/datasource.js

@@ -44,13 +44,13 @@ describe('Datasource', function () {
     describe('get/set', function () {
         const datasource = new Datasource();
         it('get should return undefined', function () {
-            expect( datasource.get()).to.be.undefined;
+            expect( datasource.get()).to.be.eql({});
         });
         
         it('write should throw exeption', function () {
-            expect( datasource.get()).to.be.undefined;
-            expect( datasource.set('myvalue')).to.be.instanceof(Datasource);
-            expect( datasource.get()).to.be.equal('myvalue');
+            expect( datasource.get()).to.be.eql({});
+            expect( datasource.set({a:'myvalue'})).to.be.instanceof(Datasource);
+            expect( datasource.get()).to.be.eql({a:'myvalue'});
         });
 
 

package/test/cases/data/diff.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import {expect} from "chai"
-import {Diff} from "../../../source/data/diff.js";
+import {diff} from "../../../source/data/diff.js";
 import {Queue} from "../../../source/types/queue.js";
 
 describe('Diff', function () {
@@ -27,12 +27,12 @@ describe('Diff', function () {
         });
 
         it('Diff value with null ', function () {
-            let d = Diff(obj1, obj2);
+            let d = diff(obj1, obj2);
             expect(JSON.stringify(d)).is.equal('[{"operator":"update","path":["count"],"first":{"value":1,"type":"number"},"second":{"value":2,"type":"number"}},{"operator":"delete","path":["info"],"first":{"value":"test","type":"string"}}]');
         });
 
         it('Diff identical value with null ', function () {
-            let d = Diff(obj1, obj1);
+            let d = diff(obj1, obj1);
             expect(JSON.stringify(d)).is.equal('[]');
         });
 
@@ -194,7 +194,7 @@ describe('Diff', function () {
 
 
         it('Diff should result ' + c, function () {
-            let d = Diff(a, b);
+            let d = diff(a, b);
             expect(JSON.stringify(d)).is.equal(c);
         });
 

package/test/cases/data/pathfinder.js

@@ -85,6 +85,13 @@ describe('Pathfinder', function () {
 
         let pathfinder, object;
 
+
+        class A {
+            get a() {
+                return 1
+            }
+        }
+
         beforeEach(() => {
 
             object = {
@@ -106,7 +113,8 @@ describe('Pathfinder', function () {
                         k: (new Map).set('m', {n: 3}),
                         l: (new Set).add({n: 4})
                     }
-                }
+                },
+                b: new A
             };
 
             pathfinder = new Pathfinder(object);
@@ -186,25 +194,24 @@ describe('Pathfinder', function () {
 
             it('.setVia(' + a + ', ' + b + ') should change object', function () {
                 pathfinder.setVia(a, b);
-                expect(JSON.stringify(object)).is.equal('{"a":{"b":{"c":[4,"test1",false,null,null],"e":false,"f":[{"g":false,"h":3,"i":["test2"]}],"j":{},"k":{},"l":{}},"x":"true"}}');
+                expect(JSON.stringify(object)).is.equal('{"a":{"b":{"c":[4,"test1",false,null,null],"e":false,"f":[{"g":false,"h":3,"i":["test2"]}],"j":{},"k":{},"l":{}},"x":"true"},"b":{}}');
             });
 
             it('.setVia(' + c + ', ' + b + ') should change object', function () {
                 pathfinder.setVia(c, b);
-                expect(JSON.stringify(object)).is.equal('{"a":{"b":{"c":[4,"test1",false,null,null],"e":false,"f":[{"g":false,"h":3,"i":["test2"]}],"j":{},"k":{},"l":{}},"y":{"d":"true"}}}');
+                expect(JSON.stringify(object)).is.equal('{"a":{"b":{"c":[4,"test1",false,null,null],"e":false,"f":[{"g":false,"h":3,"i":["test2"]}],"j":{},"k":{},"l":{}},"y":{"d":"true"}},"b":{}}');
             });
 
         });
 
 
         describe('.exists()', function () {
-
-
             [
+                ['a.b.c.1', true],
+                ['b.a', true],
                 ['a.b.x', false],
                 ['a.x', false],
                 ['a.b.q', false],
-                ['a.b.c.1', true],
                 ['a.b.c.0', true],
                 ['a.b.d', true],
                 ['a.b.f.0.g', true],
@@ -224,13 +231,14 @@ describe('Pathfinder', function () {
 
             });
 
+
         });
 
         describe('.deleteVia()', function () {
             [
-                ['a.b.e', '{"a":{"b":{"c":[4,"test1",false,null,null],"f":[{"g":false,"h":3,"i":["test2"]}],"j":{},"k":{},"l":{}}}}'],
-                ['a.b.f', '{"a":{"b":{"c":[4,"test1",false,null,null],"e":false,"j":{},"k":{},"l":{}}}}'],
-                ['a.b.j', '{"a":{"b":{"c":[4,"test1",false,null,null],"e":false,"f":[{"g":false,"h":3,"i":["test2"]}],"k":{},"l":{}}}}'],
+                ['a.b.e', '{"a":{"b":{"c":[4,"test1",false,null,null],"f":[{"g":false,"h":3,"i":["test2"]}],"j":{},"k":{},"l":{}}},"b":{}}'],
+                ['a.b.f', '{"a":{"b":{"c":[4,"test1",false,null,null],"e":false,"j":{},"k":{},"l":{}}},"b":{}}'],
+                ['a.b.j', '{"a":{"b":{"c":[4,"test1",false,null,null],"e":false,"f":[{"g":false,"h":3,"i":["test2"]}],"k":{},"l":{}}},"b":{}}'],
 
             ].forEach(function (data) {
 
@@ -291,6 +299,7 @@ describe('Pathfinder', function () {
                 });
 
                 [
+                    ['a.*', '[["b",{"c":[4,"test1",false,null,null],"e":false,"f":[{"g":false,"h":3,"i":["test2"]}],"j":{},"k":{},"l":{},"o":[{"p":{"q":1,"r":true}},{"p":{"q":2,"r":true}},{"p":{"q":3,"r":true}},{"p":{"q":4,"r":true}},{"p":{"q":5,"r":true}}],"s":{"t":{"a":1},"u":{"a":2},"v":{"a":3},"x":{"a":4}}}]]'],
                     ['a.b.s.*.a', '[["t",1],["u",2],["v",3],["x",4]]'],
                     ['a.b.s.*', '[["t",{"a":1}],["u",{"a":2}],["v",{"a":3}],["x",{"a":4}]]'],
                     ['a.b.o.*.p.q', '[["0",1],["1",2],["2",3],["3",4],["4",5]]'],

package/test/cases/data/pipe.js

@@ -1,14 +1,38 @@
 "use strict";
 
-import {Pipe} from "../../../source/data/pipe.js";
-import {expect} from "chai"
 import * as Crypto from "@peculiar/webcrypto";
+import {expect} from "chai"
+import {Pipe} from "../../../source/data/pipe.js";
 
 if (!global['crypto']) {
     global['crypto'] = new Crypto.Crypto();
 }
 
 describe('Pipe', function () {
+    describe('run different pipes', function () {
+        [
+            ['path:b | if:x:\\ ', {a:true}, ' '],   // '\\ '.length ↦ 2
+            ['path:a | if:x:\\ ', {a:true}, 'x'],
+            ['nop', 'abcdefghijklmnop', 'abcdefghijklmnop'],
+
+        ].forEach(function (data) {
+
+            let a = data.shift()
+            let b = data.shift()
+            let c = data.shift()
+
+            it('Pipe.run(' + JSON.stringify(a) + ').run(' + JSON.stringify(b) + ') should return ' + JSON.stringify(c), function () {
+                let t = new Pipe(a);
+
+                const r = t.run(b);
+                expect(r).to.be.eql(c);
+            });
+        });
+
+
+    });
+
+
     describe('new Pipe should create new Instance', function () {
 
         it('should return Instance', function () {

package/test/cases/data/transformer.js

@@ -1,9 +1,9 @@
 "use strict";
 
-import {Transformer} from "../../../source/data/transformer.js";
+import * as Crypto from "@peculiar/webcrypto";
 import {expect} from "chai"
+import {Transformer} from "../../../source/data/transformer.js";
 import {initJSDOM} from "../../util/jsdom.js";
-import * as Crypto from "@peculiar/webcrypto";
 
 
 if (!global['crypto']) {
@@ -22,6 +22,31 @@ describe('Transformer', function () {
     describe('Transformer.run()', function () {
 
         [
+            ['??:a', null, 'a'],
+            ['??:a', undefined, 'a'],
+            ['??:a', 'true', 'true'],
+            ['??:a', false, false],
+            [' if:a: ', false, undefined], // without \\
+            [' if:a:\\ ', false, " "],
+            [' if:a:\\ ', true, "a"],
+            ['default:yes', null, 'yes'],
+            ['default:yes', undefined, 'yes'],
+            ['default:1:bool', undefined, true],
+            ['default:on:bool', undefined, true],
+            ['default:true:bool', undefined, true],
+            ['default:yes:bool', undefined, true],
+            ['default:undefined:bool', undefined, false],
+            ['default:false:bool', undefined, false],
+            ['default:1:int', undefined, 1],
+            ['default:1:string', undefined, '1'],
+            ['first-key', {a: 1, c: 3, b: 2}, 1],
+            ['last-key', {a: 1, c: 3, b: 2}, 3],
+            ['nth-last-key:0', {a: 1, c: 3, b: 2}, 3],
+            ['nth-last-key:1', {a: 1, c: 3, b: 2}, 2],
+            ['nth-last-key:2', {a: 1, c: 3, b: 2}, 1],
+            ['nth-key:2', {a: 1, b: 2, c: 3}, 3],
+            ['nth-key:0', {c: 3, a: 1, b: 2}, 1],
+            ['nth-key:2', {a: 1, c: 3, b: 2}, 3],
             ['prefix:Hello\\ ', 'test', "Hello test"],
             ['tojson', {a: 4}, "{\"a\":4}"],
             ['prefix:a\\\\: ', 'test', "a\\test"],
@@ -55,7 +80,10 @@ describe('Transformer', function () {
             ['ucwords', 'cAr runs', "CAr Runs"],
             ['tointeger', '6', 6],
             ['length', 'test', 4],
-            ['base64', 'test', "dGVzdA=="],
+            ['to-base64', 'Hello World!', "SGVsbG8gV29ybGQh"],
+            ['from-base64', 'SGVsbG8gV29ybGQh', "Hello World!"],
+            ['to-base64', 'test', "dGVzdA=="],
+            ['from-base64', "dGVzdA==", 'test'],
             ['prefix:a', 'test', "atest"],
             ['suffix:a', 'test', "testa"],
             ['index:a', {a: 4}, 4],
@@ -80,13 +108,8 @@ describe('Transformer', function () {
                     return a + b + c + d;
                 });
 
-                if (typeof c === 'object') {
-                    b = JSON.stringify(b);
-                    c = JSON.stringify(c);
-                }
-
-
-                expect(t.run(b)).to.be.equal(c);
+                const r = t.run(b);
+                expect(r).to.be.eql(c);
             });
         });
 
@@ -140,6 +163,14 @@ describe('Transformer', function () {
 
     });
 
+    describe('new Transformer().run("default:eyJiIjoxfQ==:object")', function () {
+        it('should return Object', function () {
+            let t = new Transformer('default:eyJiIjoxfQ==:object');
+            expect(t.run(undefined)).to.eql({b: 1});
+        });
+
+    });
+
 
     describe('new Transformer()', function () {
         it('should return instanceof Transformer', function () {

package/test/cases/dom/attributes.js

@@ -4,23 +4,28 @@ import {expect} from "chai"
 
 import {
     addAttributeToken,
-    toggleAttributeToken,
-    containsAttributeToken,
-    replaceAttributeToken,
+    addToObjectLink,
     clearAttributeTokens,
-    removeAttributeToken,
+    containsAttributeToken,
+    findClosestByAttribute,
+    findClosestObjectLink,
+    getLinkedObjects,
     hasObjectLink,
-    addToObjectLink,
+    removeAttributeToken,
     removeObjectLink,
-    getLinkedObjects,
-    findClosestObjectLink,
-    findClosestByAttribute
+    replaceAttributeToken,
+    toggleAttributeToken
 } from "../../../source/dom/attributes.js";
 
 import {initJSDOM} from "../../util/jsdom.js";
 
-let html1 = `<div id="test1"></div>`;
-let html2 = `<div id="test1">
+let html1, html2, html3;
+
+describe('Attributes', function () {
+    before(function (done) {
+
+        html1 = `<div id="test1"></div>`;
+        html2 = `<div id="test1">
     <div id="sub1">
         <div id="sub2">
             <div id="sub3">
@@ -32,7 +37,7 @@ let html2 = `<div id="test1">
     </div>
 </div>
 `;
-let html3 = `<div data-monster-role="test1">
+        html3 = `<div data-monster-role="test1">
     <div data-monster-role="sub1" id="a1">
         <div data-monster-role="sub2" id="a2">
             <div data-monster-role="sub3" id="a3">
@@ -45,11 +50,10 @@ let html3 = `<div data-monster-role="test1">
 </div>
 `;
 
-describe('Attributes', function () {
-    before(function (done) {
+
         initJSDOM().then(() => {
             done()
-        });
+        }).catch(e => done(e));
     });
 
     describe('ObjectLink', function () {

package/test/cases/dom/customcontrol.js

@@ -1,11 +1,10 @@
 'use strict';
 
+import chai from "chai"
 import {ATTRIBUTE_OPTIONS} from "../../../source/dom/constants.js";
 import {getDocument} from "../../../source/dom/util.js";
-import {ID} from "../../../source/types/id.js";
-import {initJSDOM} from "../../util/jsdom.js";
-import chai from "chai"
 import {chaiDom} from "../../util/chai-dom.js";
+import {initJSDOM} from "../../util/jsdom.js";
 
 
 let expect = chai.expect;
@@ -77,10 +76,12 @@ describe('DOM', function () {
 
         describe('connect empty element', function () {
             it('document should contain monster-customcontrol', function () {
+                
                 let d = document.createElement('monster-customcontrol');
                 document.getElementById('test1').appendChild(d);
                 expect(document.getElementsByTagName('monster-customcontrol').length).is.equal(1);
-                expect(document.getElementById('test1')).contain.html('<monster-customcontrol data-monster-objectlink="Symbol(monsterUpdater)"></monster-customcontrol>');
+                // no data-monster-objectlink="Symbol(monsterUpdater)" because it has nothing to update
+                expect(document.getElementById('test1')).contain.html('<monster-customcontrol></monster-customcontrol>');
             });
         });
 
@@ -97,7 +98,7 @@ describe('DOM', function () {
 
 
         })
-        
+
         describe('Test ElementInternals', function () {
 
             let form;