@schukai/monster 1.22.0 → 1.26.0

package/test/cases/dom/resourcemanager.js

@@ -0,0 +1,118 @@
+'use strict';
+
+import {expect} from "chai"
+
+import {ResourceManager} from "../../../source/dom/resourcemanager.js";
+import {cleanupDOMFromTesting, initMutationObserverForTesting} from "../../util/cleanupdom.js";
+import {initJSDOM} from "../../util/jsdom.js";
+
+describe('ResourceManager', function () {
+
+    let fetchReference, returnStatus;
+
+    before(function (done) {
+        initJSDOM().then(() => {
+            done()
+        }).catch(e => done(e));
+    });
+
+    afterEach(() => {
+        global['fetch'] = fetchReference;
+        cleanupDOMFromTesting();
+    })
+
+    beforeEach(() => {
+
+        initMutationObserverForTesting()
+
+        returnStatus = 200;
+        fetchReference = global['fetch'];
+        global['fetch'] = function (url, options) {
+
+            if (!url) throw new Error('missing url')
+
+            return new Promise((resolve, reject) => {
+                resolve({
+                    text: function () {
+                        return JSON.stringify({
+                            a: "test"
+                        })
+                    },
+                    status: returnStatus
+                });
+            })
+
+        };
+
+    })
+
+    describe('new', function () {
+        it('new ResourceManager() should return ResourceManager object', function () {
+            let d = new ResourceManager();
+            expect(d).to.be.instanceOf(ResourceManager);
+        });
+    });
+
+    describe('load resources', function () {
+
+        let manager;
+
+        beforeEach(() => {
+            manager = new ResourceManager();
+        })
+
+        it('add script should instance of ResourceManager', function () {
+            expect(manager.addScript('/example.js')).to.be.instanceOf(ResourceManager);
+        });
+
+        it('add style should instance of ResourceManager', function () {
+            expect(manager.addStylesheet('/style.js')).to.be.instanceOf(ResourceManager);
+        });
+
+        it('add data should instance of ResourceManager', function () {
+            expect(manager.addData('/data.json')).to.be.instanceOf(ResourceManager);
+        });
+
+        describe('connect resources', function () {
+            it('add script and connect should instance of ResourceManager', function () {
+                expect(manager.addScript('/example.js').connect()).to.be.instanceOf(ResourceManager);
+            });
+
+            it('add style and connect should instance of ResourceManager', function () {
+                expect(manager.addStylesheet('/style.js').connect()).to.be.instanceOf(ResourceManager);
+            });
+
+            it('add data and connect  should instance of ResourceManager', function () {
+                expect(manager.addData('/data.json').connect()).to.be.instanceOf(ResourceManager);
+            });
+        })
+
+
+        describe('check availability resources', function () {
+            it('add script and check availability should return Promise', function () {
+                expect(manager.addScript('/example.js').available()).to.be.instanceOf(Promise);
+            });
+
+            it('add style and check availability should should return Promise', function () {
+                expect(manager.addStylesheet('/style.js').available()).to.be.instanceOf(Promise);
+            });
+
+            it('add data and check availability  should should return Promise', function () {
+                expect(manager.addData('/data.json').available()).to.be.instanceOf(Promise);
+            });
+        })
+
+        describe('check availability example.json', function () {
+            it('add data and check content', function (done) {
+                manager.addData('https://example.com/example.json').connect().available().then(r => {
+                    expect(document.querySelector('html').outerHTML).contains('>{"a":"test"}</script></head>');
+                    done();
+                }).catch(e => done(e));
+            });
+
+        })
+
+    });
+
+
+});

package/test/cases/dom/updater.js

@@ -1,13 +1,12 @@
 'use strict';
 
+import chai from "chai"
 import {Updater} from "../../../source/dom/updater.js";
+import {ID} from "../../../source/types/id.js";
 import {Observer} from "../../../source/types/observer.js";
 import {ProxyObserver} from "../../../source/types/proxyobserver.js";
-
-
-import chai from "chai"
-import {initJSDOM} from "../../util/jsdom.js";
 import {chaiDom} from "../../util/chai-dom.js";
+import {initJSDOM} from "../../util/jsdom.js";
 
 let expect = chai.expect;
 
@@ -57,7 +56,7 @@ let html2 = `
     <div id="test1">
         <div data-monster-replace="path:text | tolower"> </div>
         <div data-monster-replace="path:text | call:myformatter"> </div>
-        <div data-monster-replace="static:hello"></div>
+        <div data-monster-replace="static:hello\\ "></div>
     </div>
 `;
 
@@ -283,10 +282,10 @@ describe('DOM', function () {
                     if (e === undefined && expected.length === 0) done(new Error('to many calls'));
 
                     if (this.getSubject()['state'] !== e) done(new Error(this.getSubject()['state'] + ' should ' + e));
-                    if (expected.length === 0) { 
+                    if (expected.length === 0) {
                         done();
                     } else {
-                       
+
                         setTimeout(() => {
                             form1.querySelector('[name=checkbox]').click();
                         }, 10)
@@ -501,21 +500,22 @@ describe('DOM', function () {
                     return a + 'yes!'
                 })
 
-                d.run().then(() => {
+                setTimeout(() => {
+                    d.run().then(() => {
 
-                    expect(typeof d).is.equal('object');
-                    expect(element).contain.html('<div data-monster-replace="path:text | tolower">hallo</div>');
-                    expect(element).contain.html('<div data-monster-replace="path:text | call:myformatter">HALLOyes!</div>');
-                    expect(element).contain.html('<div data-monster-replace="static:hello">hello</div>');
-
-                    done();
-                }).catch(
-                    e => {
-                        done(new Error(e))
-                    })
+                        expect(typeof d).is.equal('object');
+                        expect(element).contain.html('<div data-monster-replace="path:text | tolower">hallo</div>');
+                        expect(element).contain.html('<div data-monster-replace="path:text | call:myformatter">HALLOyes!</div>');
+                        expect(element).contain.html('<div data-monster-replace="static:hello\\ ">hello </div>');
 
+                        return done();
+                    }).catch(
+                        e => {
+                            done(new Error(e))
+                        })
+                }, 100)
 
-            });
+            }); 
         });
     });
 
@@ -638,4 +638,27 @@ describe('DOM', function () {
         });
     });
 
+
+    describe('Get Attribute Pipe', function () {
+        let id, mocks;
+        beforeEach(() => {
+            mocks = document.getElementById('mocks');
+            id = new ID('monster');
+            mocks.innerHTML = ` <div id="` + id + `"
+                             data-monster-replace="path:a | if:value:\\ "></div>`
+        })
+
+        afterEach(() => {
+            mocks.innerHTML = "";
+        })
+
+        it('should include space', function () {
+            const div = document.getElementById(id.toString())
+
+            const pipe = div.getAttribute('data-monster-replace');
+            expect(pipe.length).to.be.equal(20);
+
+        });
+    });
+
 });

package/test/cases/dom/worker/factory.js

@@ -0,0 +1,63 @@
+import {expect} from "chai"
+
+import {Factory} from "../../../../source/dom/worker/factory.js";
+import {getGlobal} from "../../../../source/types/global.js";
+import {initJSDOM, isNode} from "../../../util/jsdom.js";
+
+const global = getGlobal();
+
+describe('Worker', function () {
+
+    before(function (done) {
+
+        if (isNode()) {
+            Object.defineProperty(global['URL'], 'createObjectURL', {
+                writable: true,
+                value: () => {
+                    return "/example.js"
+                }
+            })
+
+            global['Worker'] = class {
+                terminate() {
+                    
+                }
+
+                onerror() {
+                    
+                }
+
+                onmessage() {
+                    
+                }
+            }
+
+            let a = typeof global['Worker'];
+            let a1 = typeof Worker;
+
+        }
+
+        const jsdom = initJSDOM().then(() => {
+            done();
+        });
+
+
+    })
+
+    describe('Factory', function () {
+
+        it('create worker', function () {
+
+            const factory = new Factory();
+            const worker = factory.createFromScript('console.log("hello world");')
+            expect(worker).is.instanceof(Worker);
+
+            expect(factory.terminate(worker)).is.instanceof(Factory)
+
+
+        });
+
+    });
+
+
+});

package/test/cases/i18n/formatter.js

@@ -0,0 +1,66 @@
+import {expect} from "chai"
+import {Formatter} from "../../../source/i18n/formatter.js";
+import {Translations} from "../../../source/i18n/translations.js";
+
+
+describe('Formatter', function () {
+
+    describe('example', function () {
+
+        it('should run with marker', function () {
+
+            const translations = new Translations('en')
+                .assignTranslations({
+                    thekey: "${animal} has eaten the ${food}!"
+                });
+
+            const f = new Formatter({}, translations);
+            
+            expect(f.format("i18n{thekey::animal=dog::food=cake}")).to.be.equal('dog has eaten the cake!');
+            // ↦ dog has eaten the cake!                
+
+        });
+        
+        it('should run without marker', function () {
+
+            const translations = new Translations('en')
+                .assignTranslations({
+                    thekey: "${animal} has eaten the ${food}!"
+                });
+
+            // missing marker
+            expect(new Formatter({}, translations).format("thekey::animal=dog::food=cake")).to.be.equal('dog has eaten the cake!');
+            // ↦ dog has eaten the cake!                
+
+        });
+    });
+
+
+    describe('format', function () {
+
+        [
+            ['i18n{translationkey::a=3::b=5}', 'test is 3 and 5'],
+
+        ].forEach(function (data) {
+
+            let a = data.shift()
+            let b = data.shift()
+
+            it('format ' + a + ' should ' + b, function () {
+
+                const translations = new Translations('de').assignTranslations({
+                    translationkey: "test is ${a} and ${b}"
+                })
+
+                expect(
+                    new Formatter({}, translations).format(a)
+                ).to.equal(b)
+            });
+        });
+
+
+    })
+
+
+})
+;

package/test/cases/monster.js

@@ -9,7 +9,7 @@ describe('Monster', function () {
         let monsterVersion
 
     /**#@+ dont touch, replaced by make with package.json version */
-    monsterVersion = new Version('1.22.0')
+    monsterVersion = new Version('1.26.0')
     /**#@-*/
 
         let m = Monster.getVersion();

package/test/cases/text/formatter.js

@@ -1,5 +1,3 @@
-
-
 import {expect} from "chai"
 import {Formatter} from "../../../source/text/formatter.js";
 
@@ -57,10 +55,9 @@ describe('Formatter', function () {
             it('format ' + a + ' with marker ' + b + ' and ' + c + ' should return  ' + b, function () {
 
                 expect(
-                        new Formatter({
-                            a: "test"
-                        }).setMarker(b,c).format(a)
-                    
+                    new Formatter({
+                        a: "test"
+                    }).setMarker(b, c).format(a)
                 ).to.equal(d)
             });
         });
@@ -72,6 +69,7 @@ describe('Formatter', function () {
 
         [
             ['${a | tojson}', "{\"b\":{\"c\":\"Hello\"},\"d\":\"World\",\"e\":1}"],
+            ['click ${a.d} times', "click World times"],
             [' ${a.b.c} ', ' Hello '],
             [' ${a.b.c}', ' Hello'],
             ['${a.b.c} ', 'Hello '],
@@ -87,9 +85,8 @@ describe('Formatter', function () {
 
             let a = data.shift()
             let b = data.shift()
-            let c = data.shift()
 
-            it('format ' + a + ' should return ' + c, function () {
+            it('format ' + a + ' should return ' + b, function () {
 
                 let obj = {
                     a: {
@@ -108,6 +105,72 @@ describe('Formatter', function () {
 
     });
 
+    describe('Marker in marker', function () {
+
+        let text = '${mykey${subkey}}';
+        let expected = '1';
+
+        it('format ' + text + ' should ' + expected, function () {
+
+            let obj = {
+                mykey2: "1",
+                subkey: "2"
+            };
+
+            expect(new Formatter(obj).format(text)).is.equal(expected)
+
+        });
+
+
+    });
+
+    describe('setParameterChars()', function () {
+
+        it('setParameterChars() should return Instance', function () {
+            expect(new Formatter({}).setParameterChars('a', 'b')).is.instanceof(Formatter);
+
+        });
+
+
+    });
+
+
+    describe('with callbacks', function () {
+
+        it('add callback', function () {
+            const formatter = new Formatter({
+                x: '1'
+            }, {
+                callbacks: {
+                    my: (value) => {
+                        return "!" + value + "!"
+                    }
+                }
+            });
+
+            expect(formatter.format('${x | call:my}')).is.equal('!1!');
+
+        });
+
+
+    });
+
+    describe('Marker in marker with parameter', function () {
+
+        let text = '${mykey::mykey=${subkey}}';
+        let expected = '2';
+
+        it('format ' + text + ' should ' + expected, function () {
+
+            let obj = {
+                subkey: "2"
+            };
+
+            expect(new Formatter(obj).format(text)).is.equal(expected)
+
+        });
+    });
+
     describe('exceptions', function () {
 
         [

package/test/cases/types/node.js

@@ -0,0 +1,196 @@
+'use strict';
+
+import {expect} from "chai"
+import {Node} from "../../../source/types/node.js";
+import {NodeList} from "../../../source/types/nodelist.js";
+import {NodeRecursiveIterator} from "../../../source/types/noderecursiveiterator.js";
+
+describe('NodeList', function () {
+    describe('#constructor', function () {
+        it('should create an empty NodeList', function () {
+            let nodeList = new NodeList();
+
+            expect(nodeList.size).to.equal(0);
+        });
+
+        it('should create a NodeList from an array', function () {
+            let nodeList = new NodeList([
+                new Node('div'),
+                new Node('div'),
+                new Node('div')
+            ]);
+
+            expect(nodeList.size).to.equal(3);
+        });
+
+        it('should create a NodeList from a NodeList', function () {
+            let nodeList = new NodeList([
+                new Node('div'),
+                new Node('div'),
+                new Node('div')
+            ]);
+
+            let nodeList2 = new NodeList(nodeList);
+
+            expect(nodeList2.size).to.equal(3);
+        });
+    });
+
+    it('create NodeList', function () {
+        expect(new NodeList()).is.instanceof(NodeList);
+    })
+
+    it('add Node', function () {
+        expect(new NodeList().add(new Node())).to.be.instanceof(NodeList);
+    })
+
+    it('remove Node', function () {
+        expect(new NodeList().remove(new Node())).to.be.instanceof(NodeList);
+    })
+
+    it('has unknown Node', function () {
+        expect(new NodeList().has(new Node)).to.be.false;
+    })
+
+    it('has added Node', function () {
+        const n = new Node;
+        expect(new NodeList().add(n).has(n)).to.be.true;
+    })
+
+    it('throw exception', function () {
+        expect(() => new NodeList().add(1)).to.throw(Error);
+    })
+
+    it('check level', function () {
+
+        const root = new Node('root');
+
+        const n1 = new Node('n1');
+        const n2 = new Node('n2');
+        const n3 = new Node('n3');
+        const n4 = new Node('n4');
+
+        const n11 = new Node('n11');
+        const n12 = new Node('n12');
+        const n13 = new Node('n13');
+
+        const n21 = new Node('n21');
+        const n22 = new Node('n22');
+        const n23 = new Node('n23');
+
+        const n41 = new Node('n41');
+        const n42 = new Node('n42');
+
+        const n411 = new Node('n411');
+        const n412 = new Node('n412');
+        const n413 = new Node('n413');
+
+        const n4121 = new Node('n4121');
+
+        root.appendChild(n1).appendChild(n2).appendChild(n3).appendChild(n4);
+        n1.appendChild(n11).appendChild(n12).appendChild(n13);
+        n2.appendChild(n21).appendChild(n22).appendChild(n23);
+        n4.appendChild(n41).appendChild(n42);
+        n41.appendChild(n411).appendChild(n412).appendChild(n413);
+        n412.appendChild(n4121);
+
+        let iterator = new NodeRecursiveIterator(root);
+
+        let result = [];
+        for (const n of iterator) {
+            expect(n).to.be.an.instanceof(Node);
+            result.push(n.value + ":" + n.level);
+        }
+
+        
+        expect(result).to.deep.equal([
+            'root:0',
+            'n1:1',
+            'n11:2',
+            'n12:2',
+            'n13:2',
+            'n2:1',
+            'n21:2',
+            'n22:2',
+            'n23:2',
+            'n3:1',
+            'n4:1',
+            'n41:2',
+            'n411:3',
+            'n412:3',
+            'n4121:4',
+            'n413:3',
+            'n42:2'
+
+        ]);
+
+        n4121.appendChild(new Node('n41211'));
+
+        iterator = new NodeRecursiveIterator(root);
+        result = [];
+        for (const n of iterator) {
+            expect(n).to.be.an.instanceof(Node);
+            result.push(n.value + ":" + n.level);
+        }
+
+        expect(result).to.deep.equal([
+            'root:0',
+            'n1:1',
+            'n11:2',
+            'n12:2',
+            'n13:2',
+            'n2:1',
+            'n21:2',
+            'n22:2',
+            'n23:2',
+            'n3:1',
+            'n4:1',
+            'n41:2',
+            'n411:3',
+            'n412:3',
+            'n4121:4',
+            'n41211:5',
+            'n413:3',
+            'n42:2'
+
+        ]);
+
+
+        const bb = new Node('bb') // big bang
+
+        bb.appendChild(root);
+        iterator = new NodeRecursiveIterator(bb);
+
+        result = [];
+        for (const n of iterator) {
+            expect(n).to.be.an.instanceof(Node);
+            result.push(n.value + ":" + n.level);
+        }
+
+        expect(result).to.deep.equal([
+            'bb:0',
+            'root:1',
+            'n1:2',
+            'n11:3',
+            'n12:3',
+            'n13:3',
+            'n2:2',
+            'n21:3',
+            'n22:3',
+            'n23:3',
+            'n3:2',
+            'n4:2',
+            'n41:3',
+            'n411:4',
+            'n412:4',
+            'n4121:5',
+            'n41211:6',
+            'n413:4',
+            'n42:3'
+
+        ]);
+
+    })
+
+
+});