@schukai/monster 1.21.1 → 1.25.0

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/monster.js

@@ -9,7 +9,7 @@ describe('Monster', function () {
         let monsterVersion
 
     /**#@+ dont touch, replaced by make with package.json version */
-    monsterVersion = new Version('1.21.1')
+    monsterVersion = new Version('1.25.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)
             });
         });
@@ -108,6 +105,41 @@ 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('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/proxyobserver.js

@@ -1,23 +1,65 @@
 import {expect} from "chai"
+import {extend} from "../../../source/data/extend.js";
+import {isObject} from "../../../source/types/is.js";
+import {Observer} from "../../../source/types/observer.js";
 
 import {ProxyObserver} from "../../../source/types/proxyobserver.js";
-import {Observer} from "../../../source/types/observer.js";
-import {isObject} from "../../../source/types/is.js";
 
 describe('ProxyObserver', function () {
 
+    describe('create', function () {
+        it('should return instanceof ProxyObserver', function () {
+            let o = new ProxyObserver({});
+            extend(o.getSubject(), {a: 4});
+            expect(o.getRealSubject()).is.eql({a: 4});
+        });
+    });
+
+    describe('setSubject', function () {
+        it('should run observer', function (done) {
+            let o = new ProxyObserver({a: 1});
+            expect(o.getRealSubject()).is.eql({a: 1});
+            let counter = 0;
+            o.attachObserver(new Observer(function () {
+                if (isObject(this) && this instanceof ProxyObserver) {
+                    counter++;
+                    // only one change as notify runs later
+                    if (counter === 1) {
+                        done();
+                        return;
+                    }
+                    done("called for error");
+                    return;
+                }
+
+                done(new Error("this is not ProxyObserver"))
+            }))
+
+            o.getSubject().c = 4;
+            expect(o.getRealSubject()).is.eql({a: 1, c: 4});
+
+            o.setSubject({b: 2});
+            expect(o.getRealSubject()).is.eql({b: 2});
+
+            o.getSubject().d = 5;
+            expect(o.getRealSubject()).is.eql({b: 2, d: 5});
+
+
+        });
+    });
+
     describe('create', function () {
         it('should return instanceof ProxyObserver', function () {
             let o = new ProxyObserver({});
             expect(o).is.instanceOf(ProxyObserver);
         });
     });
-    
+
     describe('proxy objects', function () {
         it('Proxy objects should not be recommitted', function () {
-            let o = new ProxyObserver({a:{b:true}});
-            o.getSubject().a.b=o.getSubject();
-            o.getSubject().a.b.a.b=false;
+            let o = new ProxyObserver({a: {b: true}});
+            o.getSubject().a.b = o.getSubject();
+            o.getSubject().a.b.a.b = false;
             //expect(o.getSubject()===p.getSubject()).to.be.true;
         });
     });
@@ -67,7 +109,7 @@ describe('ProxyObserver', function () {
 
         it('check Reflect.set() with Subject', function () {
             let r;
-            
+
             const obj = (new ProxyObserver({})).getSubject();
 
             [
@@ -75,14 +117,16 @@ describe('ProxyObserver', function () {
                 undefined,
                 "no"
             ].forEach(function (value) {
-                expect(()=>{obj['data']=value}).to.not.throw();
+                expect(() => {
+                    obj['data'] = value
+                }).to.not.throw();
                 //r = Reflect.set(obj, 'data', value)
                 //expect(r).to.be.true;
             })
-            
-            
+
+
         });
-        
+
 
         [
             ['that', {that: 'checked1'}],

package/test/cases/types/uuid.js

@@ -0,0 +1,42 @@
+import * as Crypto from "@peculiar/webcrypto";
+import {expect} from "chai"
+import {UUID} from "../../../source/types/uuid.js";
+
+if (!global['crypto']) {
+    global['crypto'] = new Crypto.Crypto();
+}
+
+
+describe('UUID', function () {
+
+    describe('.toString()', function () {
+        let uuid = new UUID()
+        let result = uuid.toString();
+
+        it('should return a string', function () {
+            expect(result).is.a('string')
+            expect(result.length).is.equal(36)
+        });
+
+        it('test format', function (done) {
+
+            const regexExp = /^[A-F\d]{8}-[A-F\d]{4}-4[A-F\d]{3}-[89AB][A-F\d]{3}-[A-F\d]{12}$/i;
+
+            for (let i = 0; i < 2000; i++) {
+                const u = new UUID().toString();
+                const r = regexExp.test(u);
+
+                if (r !== true) {
+                    done('no uuid ' + u + ' => ' + r);
+                    return;
+                }
+            }
+
+            done();
+
+        });
+
+    });
+
+});
+

package/test/cases/util/freeze.js

@@ -10,13 +10,39 @@ describe('deepFreeze', function () {
 
             let obj1 = {
                 a: {
-                    b: {}
+                    b: {
+                        c:1
+                    }
                 }
             };
             
-            expect(() => obj1.a.b.c = 1).to.not.throw(TypeError);
-            const  obj2 = deepFreeze(obj1);
-            expect(() => obj2.a.b.c = 1).to.throw(TypeError);
+            let obj2 = {
+                a: {
+                    b: {
+                        c:2
+                    }
+                }
+            };
+
+            expect(obj2).to.not.eql(obj1)
+            obj1.a.b.c = 2;
+            expect(obj2).to.eql(obj1);
+
+            const obj1Freezed = deepFreeze(obj1);
+
+            expect(obj2).to.eql(obj1Freezed);
+
+            try {
+                // https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze
+                // no change to the object, exception depends on mode (strict ES 2015, etc)
+                obj1Freezed.a.b.c = 3    
+            } catch (_) {
+
+            }
+
+            expect(obj2).to.eql(obj1Freezed);
+            
+            
         });
 
     });

package/test/cases/util/trimspaces.js

@@ -0,0 +1,24 @@
+import {expect} from "chai"
+import {trimSpaces} from "../../../source/util/trimspaces.js";
+
+
+describe('trimSpaces', function () {
+    [
+        // one stroke is escped by the javascript interpreter, the second stroke escapes the stroke
+        [' value ', 'value'],
+        [' value\\ ', 'value\\ '],
+        ['\\ value\\ ', '\\ value\\ '],
+        ['\ value\ ', 'value'],   
+        ["   value \ ", 'value'], 
+
+    ].forEach(function (data) {
+
+        let a = data.shift()
+        let b = data.shift()
+
+        it('trimSpaces(' + JSON.stringify(a) + ') should return ' + JSON.stringify(b), function () {
+            expect(trimSpaces(a)).to.be.equal(b);
+        });
+    });
+});
+    

package/test/util/cleanupdom.js

@@ -0,0 +1,48 @@
+'use strict';
+
+
+let addedNodes, mutationobserver;
+
+function init() {
+
+    addedNodes = [];
+    mutationobserver = new MutationObserver(function (mutations) {
+        mutations.forEach(function (mutation) {
+            if (mutation.type === 'childList' && mutation.removedNodes) {
+
+                mutation.addedNodes.forEach((n) => {
+                    if (n instanceof HTMLElement) {
+                        addedNodes.push(n);
+                    }
+                })
+            }
+
+        });
+    });
+
+
+}
+
+
+/**
+ *
+ */
+export function initMutationObserverForTesting() {
+
+    if (mutationobserver === undefined) {
+        init()
+    }
+
+    mutationobserver.observe(document.querySelector('head'), {childList: true});
+}
+
+/**
+ *
+ */
+export function cleanupDOMFromTesting() {
+    mutationobserver.disconnect();
+
+    for (const n of addedNodes) {
+        n.remove();
+    }
+}

package/test/util/jsdom.js

@@ -1,29 +1,40 @@
 'use strict';
 
+import {extend} from "../../source/data/extend.js";
 import {getGlobal} from "../../source/types/global.js";
 
+export const isBrowser = new Function("try {return this===window;}catch(e){ return false;}");
+
+export const isNode = new Function("try {return this===global;}catch(e){return false;}");
+
+
 /**
  * this helper function creates the dom stack in the node environment
  *
  * @return {Promise<unknown>|Promise<void>}
  */
-function initJSDOM() {
+function initJSDOM(options) {
     if (typeof window === "object" && window['DOMParser']) return Promise.resolve();
+// if(isBrowser()) return Promise.resolve();
 
     const g = getGlobal();
 
+    options = extend({}, {
+        pretendToBeVisual: true,
+        contentType: "text/html",
+        includeNodeLocations: true,
+        storageQuota: 10000000,
+        runScripts: "dangerously",
+        resources: "usable"
+    }, options||{})
+
     return import("jsdom").then(({JSDOM}) => {
         const {window} = new JSDOM(`<html>
 <head>
 </head>
 <body>
 <div id="mocks"></div>
-</body>`, {
-            pretendToBeVisual: true,
-            contentType: "text/html",
-            includeNodeLocations: true,
-            storageQuota: 10000000
-        });
+</body>`, options);
 
         g['window'] = window;
 
@@ -35,6 +46,7 @@ function initJSDOM() {
                     'HTMLCollection',
                     'NodeList',
                     'ElementInternals',
+                    'HTMLDocument',
                     'HTMLFormElement',
                     'HTMLInputElement',
                     'HTMLSelectElement',
@@ -44,7 +56,6 @@ function initJSDOM() {
                     'Node',
                     'ShadowRoot',
                     'Event',
-                    'fetch',
                     'CustomEvent',
                     'Element',
                     'HTMLElement',
@@ -59,8 +70,11 @@ function initJSDOM() {
                     'NodeFilter',
                     'navigator',
                     'InputEvent',
+                    'Blob',
                     'CustomEvent'
-                ].forEach(key => (g[key] = window[key]));
+                ].forEach(key => {
+                    g[key] = window[key]
+                });
 
                 resolve();
             })

package/test/util/localstorage.js

@@ -0,0 +1,81 @@
+function createStorage() {
+    let UNSET = Symbol();
+    let s = {},
+        noopCallback = () => {
+        },
+        _itemInsertionCallback = noopCallback;
+
+    Object.defineProperty(s, 'setItem', {
+        get: () => {
+            return (k, v = UNSET) => {
+                if (v === UNSET) {
+                    throw new TypeError(`Failed to execute 'setItem' on 'Storage': 2 arguments required, but only 1 present.`);
+                }
+                k = k + '';
+                if (!s.hasOwnProperty(k)) {
+                    _itemInsertionCallback(s.length);
+                }
+                s[k] = v + '';
+            };
+        }
+    });
+    Object.defineProperty(s, 'getItem', {
+        get: () => {
+            return k => {
+                k = k + '';
+                if (s.hasOwnProperty(k)) {
+                    return s[k];
+                } else {
+                    return null;
+                }
+            };
+        }
+    });
+    Object.defineProperty(s, 'removeItem', {
+        get: () => {
+            return k => {
+                k = k + '';
+                if (s.hasOwnProperty(k)) {
+                    delete s[k];
+                }
+            };
+        }
+    });
+    Object.defineProperty(s, 'clear', {
+        get: () => {
+            return () => {
+                for (let k in s) {
+                    if (s.hasOwnProperty(k)) {
+                        delete s[k];
+                    }
+                }
+            };
+        }
+    });
+    Object.defineProperty(s, 'length', {
+        get: () => {
+            return Object.keys(s).length;
+        }
+    });
+    Object.defineProperty(s, "key", {
+        value: k => {
+            let key = Object.keys(s)[k];
+            return (!key) ? null : key;
+        },
+    });
+    Object.defineProperty(s, 'itemInsertionCallback', {
+        get: () => {
+            return _itemInsertionCallback;
+        },
+        set: v => {
+            if (!v || typeof v != 'function') {
+                v = noopCallback;
+            }
+            _itemInsertionCallback = v;
+        }
+    });
+    return s;
+}
+
+
+export {createStorage};