@schukai/monster 3.51.5 → 3.52.1

package/source/util/processing.mjs

@@ -5,51 +5,50 @@
  * License text available at https://www.gnu.org/licenses/agpl-3.0.en.html
  */
 
-import {internalSymbol} from "../constants.mjs";
-import {Base} from "../types/base.mjs";
-import {getGlobalFunction} from "../types/global.mjs";
-import {isFunction, isInteger} from "../types/is.mjs";
-import {Queue} from "../types/queue.mjs";
-import {validateFunction, validateInteger} from "../types/validate.mjs";
+import { internalSymbol } from "../constants.mjs";
+import { Base } from "../types/base.mjs";
+import { getGlobalFunction } from "../types/global.mjs";
+import { isFunction, isInteger } from "../types/is.mjs";
+import { Queue } from "../types/queue.mjs";
+import { validateFunction, validateInteger } from "../types/validate.mjs";
 
-export {Processing};
+export { Processing };
 
 /**
  * @private
  */
 class Callback {
-    /**
-     *
-     * @param {function} callback
-     * @param {int|undefined} time
-     * @throws {TypeError} value is not a function
-     * @throws {TypeError} value is not an integer
-     * @private
-     */
-    constructor(callback, time) {
-        this[internalSymbol] = {
-            callback: validateFunction(callback),
-            time: validateInteger(time ?? 0),
-        };
-    }
+	/**
+	 *
+	 * @param {function} callback
+	 * @param {int|undefined} time
+	 * @throws {TypeError} value is not a function
+	 * @throws {TypeError} value is not an integer
+	 * @private
+	 */
+	constructor(callback, time) {
+		this[internalSymbol] = {
+			callback: validateFunction(callback),
+			time: validateInteger(time ?? 0),
+		};
+	}
 
-    /**
-     * @private
-     * @param  {*} data
-     * @return {Promise}
-     */
-    run(data) {
-        const self = this;
-        return new Promise((resolve, reject) => {
-            getGlobalFunction("setTimeout")(() => {
-                try {
-                    resolve(self[internalSymbol].callback(data));
-                } catch (e) {
-                    reject(e);
-                }
-            }, self[internalSymbol].time);
-        });
-    }
+	/**
+	 * @private
+	 * @param  {*} data
+	 * @return {Promise}
+	 */
+	run(data) {
+		return new Promise((resolve, reject) => {
+			getGlobalFunction("setTimeout")(() => {
+				try {
+					resolve(this[internalSymbol].callback(data));
+				} catch (e) {
+					reject(e);
+				}
+			}, this[internalSymbol].time);
+		});
+	}
 }
 
 /**
@@ -74,80 +73,80 @@ class Callback {
  * @summary Class to be able to execute function chains
  */
 class Processing extends Base {
-    /**
-     * Create new Processing
-     *
-     * Functions and timeouts can be passed. If a timeout is passed, it applies to all further functions.
-     * In the example
-     *
-     * `timeout1, function1, function2, function3, timeout2, function4`
-     *
-     * the timeout1 is valid for the functions 1, 2 and 3 and the timeout2 for the function4.
-     *
-     * So the execution time is timeout1+timeout1+timeout1+timeout2
-     *
-     * @throw {TypeError} the arguments must be either integer or functions
-     * @param {...(int|function)} args
-     */
-    constructor(...args) {
-        super();
+	/**
+	 * Create new Processing
+	 *
+	 * Functions and timeouts can be passed. If a timeout is passed, it applies to all further functions.
+	 * In the example
+	 *
+	 * `timeout1, function1, function2, function3, timeout2, function4`
+	 *
+	 * the timeout1 is valid for the functions 1, 2 and 3 and the timeout2 for the function4.
+	 *
+	 * So the execution time is timeout1+timeout1+timeout1+timeout2
+	 *
+	 * @throw {TypeError} the arguments must be either integer or functions
+	 * @param {...(int|function)} args
+	 */
+	constructor(...args) {
+		super();
 
-        this[internalSymbol] = {
-            queue: new Queue(),
-        };
+		this[internalSymbol] = {
+			queue: new Queue(),
+		};
 
-        let time = 0;
+		let time = 0;
 
-        if (typeof args !== "object" || args[0] === null) {
-            throw new TypeError("the arguments must be either integer or functions");
-        }
+		if (typeof args !== "object" || args[0] === null) {
+			throw new TypeError("the arguments must be either integer or functions");
+		}
 
-        for (const [, arg] of Object.entries(args)) {
-            if (isInteger(arg) && arg >= 0) {
-                time = arg;
-            } else if (isFunction(arg)) {
-                this[internalSymbol].queue.add(new Callback(arg, time));
-            } else {
-                throw new TypeError("the arguments must be either integer or functions");
-            }
-        }
-    }
+		for (const [, arg] of Object.entries(args)) {
+			if (isInteger(arg) && arg >= 0) {
+				time = arg;
+			} else if (isFunction(arg)) {
+				this[internalSymbol].queue.add(new Callback(arg, time));
+			} else {
+				throw new TypeError(
+					"the arguments must be either integer or functions",
+				);
+			}
+		}
+	}
 
-    /**
-     * Adds a function with the desired timeout
-     * If no timeout is specified, the timeout of the previous function is used.
-     *
-     * @param {function} callback
-     * @param {int|undefined} time
-     * @throws {TypeError} value is not a function
-     * @throws {TypeError} value is not an integer
-     */
-    add(callback, time) {
-        this[internalSymbol].queue.add(new Callback(callback, time));
-        return this;
-    }
+	/**
+	 * Adds a function with the desired timeout
+	 * If no timeout is specified, the timeout of the previous function is used.
+	 *
+	 * @param {function} callback
+	 * @param {int|undefined} time
+	 * @throws {TypeError} value is not a function
+	 * @throws {TypeError} value is not an integer
+	 */
+	add(callback, time) {
+		this[internalSymbol].queue.add(new Callback(callback, time));
+		return this;
+	}
 
-    /**
-     * Executes the defined functions in order.
-     *
-     * @param {*} data
-     * @return {Promise}
-     */
-    run(data) {
-        const self = this;
-        if (self[internalSymbol].queue.isEmpty()) {
-            return Promise.resolve(data);
-        }
+	/**
+	 * Executes the defined functions in order.
+	 *
+	 * @param {*} data
+	 * @return {Promise}
+	 */
+	run(data) {
+		if (this[internalSymbol].queue.isEmpty()) {
+			return Promise.resolve(data);
+		}
 
-        const callback = self[internalSymbol].queue.poll();
+		const callback = this[internalSymbol].queue.poll();
 
-        if (callback === null || callback === undefined) {
-            return Promise.resolve(data);
-        }
+		if (callback === null || callback === undefined) {
+			return Promise.resolve(data);
+		}
 
-        return callback.run(data)
-            .then((result) => {
-                return self.run(result);
-            });
-    }
+		return callback.run(data).then((result) => {
+			return this.run(result);
+		});
+	}
 }

package/source/util/runtime.mjs

@@ -64,56 +64,68 @@ const ENV_UNKNOWN = "unknown";
  * @returns {string} The detected runtime environment. Possible values are:
  */
 function detectRuntimeEnvironment() {
-    // AWS Lambda environment
-    if (typeof process !== "undefined" && process.env != null && process.env.AWS_LAMBDA_FUNCTION_NAME) {
-        return ENV_AWS_LAMBDA;
-    }
+	// AWS Lambda environment
+	if (
+		typeof process !== "undefined" &&
+		process.env != null &&
+		process.env.AWS_LAMBDA_FUNCTION_NAME
+	) {
+		return ENV_AWS_LAMBDA;
+	}
 
-    // Google Cloud Functions environment
-    if (typeof process !== "undefined" && process.env != null && process.env.FUNCTION_NAME) {
-        return ENV_GOOGLE_FUNCTIONS;
-    }
+	// Google Cloud Functions environment
+	if (
+		typeof process !== "undefined" &&
+		process.env != null &&
+		process.env.FUNCTION_NAME
+	) {
+		return ENV_GOOGLE_FUNCTIONS;
+	}
 
-    // Node.js environment
-    if (typeof process !== "undefined" && process.versions != null && process.versions.node != null) {
-        // Electron environment
-        if (process.versions.electron != null) {
-            return ENV_ELECTRON;
-        }
-        return ENV_NODE;
-    }
+	// Node.js environment
+	if (
+		typeof process !== "undefined" &&
+		process.versions != null &&
+		process.versions.node != null
+	) {
+		// Electron environment
+		if (process.versions.electron != null) {
+			return ENV_ELECTRON;
+		}
+		return ENV_NODE;
+	}
 
-    // Browser environment
-    if (
-        typeof window !== "undefined" &&
-        typeof window.document !== "undefined" &&
-        typeof navigator !== "undefined" &&
-        typeof navigator.userAgent === "string"
-    ) {
-        // Web Worker environment
-        if (typeof self === "object" && typeof importScripts === "function") {
-            return ENV_WEB_WORKER;
-        }
-        return ENV_BROWSER;
-    }
+	// Browser environment
+	if (
+		typeof window !== "undefined" &&
+		typeof window.document !== "undefined" &&
+		typeof navigator !== "undefined" &&
+		typeof navigator.userAgent === "string"
+	) {
+		// Web Worker environment
+		if (typeof self === "object" && typeof importScripts === "function") {
+			return ENV_WEB_WORKER;
+		}
+		return ENV_BROWSER;
+	}
 
-    // Deno environment
-    if (typeof Deno !== "undefined") {
-        return ENV_DENO;
-    }
+	// Deno environment
+	if (typeof Deno !== "undefined") {
+		return ENV_DENO;
+	}
 
-    // Unknown environment
-    return ENV_UNKNOWN;
+	// Unknown environment
+	return ENV_UNKNOWN;
 }
 
 export {
-    ENV_AWS_LAMBDA,
-    ENV_GOOGLE_FUNCTIONS,
-    ENV_ELECTRON,
-    ENV_NODE,
-    ENV_BROWSER,
-    ENV_WEB_WORKER,
-    ENV_DENO,
-    ENV_UNKNOWN,
-    detectRuntimeEnvironment,
+	ENV_AWS_LAMBDA,
+	ENV_GOOGLE_FUNCTIONS,
+	ENV_ELECTRON,
+	ENV_NODE,
+	ENV_BROWSER,
+	ENV_WEB_WORKER,
+	ENV_DENO,
+	ENV_UNKNOWN,
+	detectRuntimeEnvironment,
 };

package/source/util/trimspaces.mjs

@@ -37,35 +37,35 @@ export { trimSpaces };
  * @throws {TypeError} value is not a string
  */
 function trimSpaces(value) {
-    validateString(value);
+	validateString(value);
 
-    let placeholder = new Map();
-    const regex = /((?<pattern>\\(?<char>.)){1})/gim;
+	const placeholder = new Map();
+	const regex = /((?<pattern>\\(?<char>.)){1})/gim;
 
-    // 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);
+	// The separator for args must be escaped
+	// undefined string which should not occur normally and is also not a regex
+	const result = value.matchAll(regex);
 
-    for (let m of result) {
-        let g = m?.["groups"];
-        if (!isObject(g)) {
-            continue;
-        }
+	for (const m of result) {
+		const g = m?.["groups"];
+		if (!isObject(g)) {
+			continue;
+		}
 
-        let p = g?.["pattern"];
-        let c = g?.["char"];
+		const p = g?.["pattern"];
+		const c = g?.["char"];
 
-        if (p && c) {
-            let r = `__${new ID().toString()}__`;
-            placeholder.set(r, c);
-            value = value.replace(p, r);
-        }
-    }
+		if (p && c) {
+			const 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}`);
-    });
+	value = value.trim();
+	placeholder.forEach((v, k) => {
+		value = value.replace(k, `\\${v}`);
+	});
 
-    return value;
+	return value;
 }

package/test/cases/components/form/button.mjs

@@ -0,0 +1,122 @@
+import {getGlobal} from "../../../../source/types/global.mjs";
+import chai from "chai"
+import {chaiDom} from "../../../util/chai-dom.mjs";
+import {initJSDOM} from "../../../util/jsdom.mjs";
+
+let expect = chai.expect;
+chai.use(chaiDom);
+
+const global = getGlobal();
+
+let html1 = `
+    <div id="test1">
+    </div>
+`;
+
+let html2 = `
+    <div id="test2">
+    <monster-button
+                        tabindex="0"
+                        data-monster-bind="path:values.checkbox"
+                        data-monster-options='{
+  "url": "mock-data.json",
+  "mapping": {
+    "valuePath": "\${first_name} \${last_name}",
+    "keyPath": "id"
+  },
+      "type":"checkbox"
+
+}'></monster-button>
+    </div>
+`;
+
+let Button;
+
+describe('Button', function () {
+
+    before(function (done) {
+        initJSDOM().then(() => {
+
+            import("element-internals-polyfill").catch(e => done(e));
+
+            import("../../../../source/components/form/button.mjs").then((m) => {
+                Button = m['Button'];
+                done()
+            }).catch(e => done(e))
+
+
+        });
+    })
+
+    describe('new Button', function () {
+
+        beforeEach(() => {
+            let mocks = document.getElementById('mocks');
+            mocks.innerHTML = html1;
+        })
+
+        afterEach(() => {
+            let mocks = document.getElementById('mocks');
+            mocks.innerHTML = "";
+        })
+
+        describe('create from template', function () {
+            beforeEach(() => {
+                let mocks = document.getElementById('mocks');
+                mocks.innerHTML = html2;
+            });
+
+            afterEach(() => {
+                let mocks = document.getElementById('mocks');
+                mocks.innerHTML = "";
+
+            })
+
+            describe('create from template', function () {
+                it('should contains monster-button', function () {
+                    expect(document.getElementById('test2')).contain.html('<monster-button');
+                });
+            });
+
+        });
+
+        describe('document.createElement', function () {
+            it('should instance of button', function () {
+                expect(document.createElement('monster-button')).is.instanceof(Button);
+            });
+        });
+
+    });
+
+    describe('document.createElement()', function () {
+
+        afterEach(() => {
+            let mocks = document.getElementById('mocks');
+            mocks.innerHTML = "";
+        })
+
+        it('should has no options', function (done) {
+
+            let mocks = document.getElementById('mocks');
+            const button = document.createElement('monster-button');
+            mocks.appendChild(button);
+
+            setTimeout(() => {
+                try {
+                    const options = button.shadowRoot.querySelector('button');
+
+                    expect(options).is.instanceof(HTMLButtonElement);
+                    expect(options.hasChildNodes()).to.be.true;
+                } catch (e) {
+                    return done(e);
+                }
+
+                done();
+            }, 0)
+
+
+        });
+    });
+
+
+});

package/test/cases/components/form/confirm-button.mjs

@@ -0,0 +1,127 @@
+import {DataUrl} from "../../../../source/types/dataurl.mjs";
+
+import {getGlobal} from "../../../../source/types/global.mjs";
+import chai from "chai"
+import {chaiDom} from "../../../util/chai-dom.mjs";
+import {initJSDOM} from "../../../util/jsdom.mjs";
+import {ResizeObserverMock} from "../../../util/resize-observer.mjs";
+
+let expect = chai.expect;
+chai.use(chaiDom);
+
+const global = getGlobal();
+
+let html1, options, html2, ConfirmButton;
+
+describe('ConfirmButton', function () {
+
+    before(function (done) {
+
+        import("element-internals-polyfill").catch(e => done(e));    
+        
+        if(!global.ResizeObserver) {
+            global.ResizeObserver = ResizeObserverMock;
+        }
+
+        options = new DataUrl(btoa(JSON.stringify({
+            popper: {
+                placement: "top"
+            },
+        })), 'application/json', true).toString()
+
+        html2 = `
+    <div id="test2">
+    <monster-confirm-button
+                        tabindex="0"
+                        data-monster-bind="path:values.checkbox"
+                        data-monster-options="` + options + `"></monster-confirm-button>
+    </div>
+`;
+
+        html1 = `
+    <div id="test1">
+    </div>
+`
+
+
+        initJSDOM().then(() => {
+
+            import("../../../../source/components/form/confirm-button.mjs").then((m) => {
+                ConfirmButton = m['ConfirmButton'];
+                done()
+            }).catch(e => done(e))
+
+
+        });
+    })
+
+    describe('new ConfirmButton', function () {
+
+        beforeEach(() => {
+            let mocks = document.getElementById('mocks');
+            mocks.innerHTML = html1;
+        })
+
+        afterEach(() => {
+            let mocks = document.getElementById('mocks');
+            mocks.innerHTML = "";
+        })
+
+        describe('create from template', function () {
+            beforeEach(() => {
+                let mocks = document.getElementById('mocks');
+                mocks.innerHTML = html2;
+            });
+
+            afterEach(() => {
+                let mocks = document.getElementById('mocks');
+                mocks.innerHTML = "";
+
+            })
+
+            describe('create from template', function () {
+                it('should contains monster-confirm-button', function () {
+                    expect(document.getElementById('test2')).contain.html('<monster-confirm-button');
+                });
+            });
+
+        });
+
+        describe('document.createElement', function () {
+            it('should instance of button', function () {
+                expect(document.createElement('monster-confirm-button')).is.instanceof(ConfirmButton);
+            });
+        });
+
+    });
+
+    describe('document.createElement()', function () {
+
+        afterEach(() => {
+            let mocks = document.getElementById('mocks');
+            mocks.innerHTML = "";
+        })
+
+        it('should has childs', function (done) {
+
+            let mocks = document.getElementById('mocks');
+            const button = document.createElement('monster-confirm-button');
+            mocks.appendChild(button);
+
+            setTimeout(() => {
+                try {
+                    const content = button.shadowRoot.querySelector('monster-button');
+                    expect(content.hasChildNodes()).to.be.true;
+                } catch (e) {
+                    return done(e);
+                }
+
+                done();
+            }, 0)
+
+
+        });
+    });
+
+
+});