@schukai/monster 3.51.5 → 3.52.1

package/source/util/clone.mjs

@@ -30,64 +30,70 @@ export { clone };
  * @throws {Error} unable to clone obj! its type isn't supported.
  */
 function clone(obj) {
-    // typeof null results in 'object'.  https://2ality.com/2013/10/typeof-null.html
-    if (null === obj) {
-        return obj;
-    }
-
-    // Handle the two simple types, null and undefined
-    if (isPrimitive(obj)) {
-        return obj;
-    }
-
-    // Handle the two simple types, null and undefined
-    if (isFunction(obj)) {
-        return obj;
-    }
-
-    // Handle Array
-    if (isArray(obj)) {
-        let copy = [];
-        for (var i = 0, len = obj.length; i < len; i++) {
-            copy[i] = clone(obj[i]);
-        }
-
-        return copy;
-    }
-
-    if (isObject(obj)) {
-        // Handle Date
-        if (obj instanceof Date) {
-            let copy = new Date();
-            copy.setTime(obj.getTime());
-            return copy;
-        }
-
-        /** Do not clone DOM nodes */
-        if (typeof Element !== "undefined" && obj instanceof Element) return obj;
-        if (typeof HTMLDocument !== "undefined" && obj instanceof HTMLDocument) return obj;
-        if (typeof DocumentFragment !== "undefined" && obj instanceof DocumentFragment) return obj;
-
-        /** Do not clone global objects */
-        if (obj === getGlobal()) return obj;
-        if (typeof globalContext !== "undefined" && obj === globalContext) return obj;
-        if (typeof window !== "undefined" && obj === window) return obj;
-        if (typeof document !== "undefined" && obj === document) return obj;
-        if (typeof navigator !== "undefined" && obj === navigator) return obj;
-        if (typeof JSON !== "undefined" && obj === JSON) return obj;
-
-        // Handle Proxy-Object
-        try {
-            // try/catch because possible: TypeError: Function has non-object prototype 'undefined' in instanceof check
-            if (obj instanceof Proxy) {
-                return obj;
-            }
-        } catch (e) {}
-
-        return cloneObject(obj);
-    }
-
-    throw new Error("unable to clone obj! its type isn't supported.");
+	// typeof null results in 'object'.  https://2ality.com/2013/10/typeof-null.html
+	if (null === obj) {
+		return obj;
+	}
+
+	// Handle the two simple types, null and undefined
+	if (isPrimitive(obj)) {
+		return obj;
+	}
+
+	// Handle the two simple types, null and undefined
+	if (isFunction(obj)) {
+		return obj;
+	}
+
+	// Handle Array
+	if (isArray(obj)) {
+		const copy = [];
+		for (var i = 0, len = obj.length; i < len; i++) {
+			copy[i] = clone(obj[i]);
+		}
+
+		return copy;
+	}
+
+	if (isObject(obj)) {
+		// Handle Date
+		if (obj instanceof Date) {
+			const copy = new Date();
+			copy.setTime(obj.getTime());
+			return copy;
+		}
+
+		/** Do not clone DOM nodes */
+		if (typeof Element !== "undefined" && obj instanceof Element) return obj;
+		if (typeof HTMLDocument !== "undefined" && obj instanceof HTMLDocument)
+			return obj;
+		if (
+			typeof DocumentFragment !== "undefined" &&
+			obj instanceof DocumentFragment
+		)
+			return obj;
+
+		/** Do not clone global objects */
+		if (obj === getGlobal()) return obj;
+		if (typeof globalContext !== "undefined" && obj === globalContext)
+			return obj;
+		if (typeof window !== "undefined" && obj === window) return obj;
+		if (typeof document !== "undefined" && obj === document) return obj;
+		if (typeof navigator !== "undefined" && obj === navigator) return obj;
+		if (typeof JSON !== "undefined" && obj === JSON) return obj;
+
+		// Handle Proxy-Object
+		try {
+			// try/catch because possible: TypeError: Function has non-object prototype 'undefined' in instanceof check
+			if (obj instanceof Proxy) {
+				return obj;
+			}
+		} catch (e) {}
+
+		return cloneObject(obj);
+	}
+
+	throw new Error("unable to clone obj! its type isn't supported.");
 }
 
 /**
@@ -97,37 +103,43 @@ function clone(obj) {
  * @private
  */
 function cloneObject(obj) {
-    validateObject(obj);
-
-    const fkt = obj?.["constructor"];
-
-    /** Object has clone method */
-    if (typeOf(fkt) === "function") {
-        const prototype = fkt?.prototype;
-        if (typeof prototype === "object") {
-            if (prototype.hasOwnProperty("getClone") && typeOf(obj.getClone) === "function") {
-                return obj.getClone();
-            }
-        }
-    }
-
-    let copy = {};
-    if (typeof obj.constructor === "function" && typeof obj.constructor.call === "function") {
-        copy = new obj.constructor();
-    }
-
-    for (let key in obj) {
-        if (!obj.hasOwnProperty(key)) {
-            continue;
-        }
-
-        if (isPrimitive(obj[key])) {
-            copy[key] = obj[key];
-            continue;
-        }
-
-        copy[key] = clone(obj[key]);
-    }
-
-    return copy;
+	validateObject(obj);
+
+	const fkt = obj?.["constructor"];
+
+	/** Object has clone method */
+	if (typeOf(fkt) === "function") {
+		const prototype = fkt?.prototype;
+		if (typeof prototype === "object") {
+			if (
+				prototype.hasOwnProperty("getClone") &&
+				typeOf(obj.getClone) === "function"
+			) {
+				return obj.getClone();
+			}
+		}
+	}
+
+	let copy = {};
+	if (
+		typeof obj.constructor === "function" &&
+		typeof obj.constructor.call === "function"
+	) {
+		copy = new obj.constructor();
+	}
+
+	for (const key in obj) {
+		if (!obj.hasOwnProperty(key)) {
+			continue;
+		}
+
+		if (isPrimitive(obj[key])) {
+			copy[key] = obj[key];
+			continue;
+		}
+
+		copy[key] = clone(obj[key]);
+	}
+
+	return copy;
 }

package/source/util/comparator.mjs

@@ -37,112 +37,112 @@ export { Comparator };
  * @memberOf Monster.Util
  */
 class Comparator extends Base {
-    /**
-     * create new comparator
-     *
-     * @param {Monster.Util~exampleCallback} [callback] Comparator callback
-     * @throw {TypeError} unsupported type
-     * @throw {TypeError} impractical comparison
-     */
-    constructor(callback) {
-        super();
+	/**
+	 * create new comparator
+	 *
+	 * @param {Monster.Util~exampleCallback} [callback] Comparator callback
+	 * @throw {TypeError} unsupported type
+	 * @throw {TypeError} impractical comparison
+	 */
+	constructor(callback) {
+		super();
 
-        if (isFunction(callback)) {
-            this.compare = callback;
-        } else if (callback !== undefined) {
-            throw new TypeError("unsupported type");
-        } else {
-            // default compare function
+		if (isFunction(callback)) {
+			this.compare = callback;
+		} else if (callback !== undefined) {
+			throw new TypeError("unsupported type");
+		} else {
+			// default compare function
 
-            /**
-             *
-             * @param {*} a
-             * @param {*} b
-             * @return {integer} -1, 0 or 1
-             */
-            this.compare = function (a, b) {
-                if (typeof a !== typeof b) {
-                    throw new TypeError("impractical comparison", "types/comparator.mjs");
-                }
+			/**
+			 *
+			 * @param {*} a
+			 * @param {*} b
+			 * @return {integer} -1, 0 or 1
+			 */
+			this.compare = function (a, b) {
+				if (typeof a !== typeof b) {
+					throw new TypeError("impractical comparison", "types/comparator.mjs");
+				}
 
-                if (a === b) {
-                    return 0;
-                }
-                return a < b ? -1 : 1;
-            };
-        }
-    }
+				if (a === b) {
+					return 0;
+				}
+				return a < b ? -1 : 1;
+			};
+		}
+	}
 
-    /**
-     * changes the order of the operators
-     *
-     * @return {Comparator}
-     */
-    reverse() {
-        const original = this.compare;
-        this.compare = (a, b) => original(b, a);
-        return this;
-    }
+	/**
+	 * changes the order of the operators
+	 *
+	 * @return {Comparator}
+	 */
+	reverse() {
+		const original = this.compare;
+		this.compare = (a, b) => original(b, a);
+		return this;
+	}
 
-    /**
-     * Checks if two variables are equal.
-     *
-     * @param {*} a
-     * @param {*} b
-     *
-     * @return {boolean}
-     */
-    equal(a, b) {
-        return this.compare(a, b) === 0;
-    }
+	/**
+	 * Checks if two variables are equal.
+	 *
+	 * @param {*} a
+	 * @param {*} b
+	 *
+	 * @return {boolean}
+	 */
+	equal(a, b) {
+		return this.compare(a, b) === 0;
+	}
 
-    /**
-     * Checks if variable `a` is greater than `b`
-     *
-     * @param {*} a
-     * @param {*} b
-     *
-     * @return {boolean}
-     */
-    greaterThan(a, b) {
-        return this.compare(a, b) > 0;
-    }
+	/**
+	 * Checks if variable `a` is greater than `b`
+	 *
+	 * @param {*} a
+	 * @param {*} b
+	 *
+	 * @return {boolean}
+	 */
+	greaterThan(a, b) {
+		return this.compare(a, b) > 0;
+	}
 
-    /**
-     * Checks if variable `a` is greater than or equal to `b`
-     *
-     * @param {*} a
-     * @param {*} b
-     *
-     * @return {boolean}
-     */
-    greaterThanOrEqual(a, b) {
-        return this.greaterThan(a, b) || this.equal(a, b);
-    }
+	/**
+	 * Checks if variable `a` is greater than or equal to `b`
+	 *
+	 * @param {*} a
+	 * @param {*} b
+	 *
+	 * @return {boolean}
+	 */
+	greaterThanOrEqual(a, b) {
+		return this.greaterThan(a, b) || this.equal(a, b);
+	}
 
-    /**
-     * Checks if variable `a` is less than or equal to `b`
-     *
-     * @param {*} a
-     * @param {*} b
-     *
-     * @return {boolean}
-     */
-    lessThanOrEqual(a, b) {
-        return this.lessThan(a, b) || this.equal(a, b);
-    }
+	/**
+	 * Checks if variable `a` is less than or equal to `b`
+	 *
+	 * @param {*} a
+	 * @param {*} b
+	 *
+	 * @return {boolean}
+	 */
+	lessThanOrEqual(a, b) {
+		return this.lessThan(a, b) || this.equal(a, b);
+	}
 
-    /**
-     * Checks if variable a is less than b
-     *
-     * @param {*} a
-     * @param {*} b
-     *
-     * @return {boolean}
-     */
-    lessThan(a, b) {
-        return this.compare(a, b) < 0;
-    }
+	/**
+	 * Checks if variable a is less than b
+	 *
+	 * @param {*} a
+	 * @param {*} b
+	 *
+	 * @return {boolean}
+	 */
+	lessThan(a, b) {
+		return this.compare(a, b) < 0;
+	}
 }
 
 /**

package/source/util/deadmansswitch.mjs

@@ -24,53 +24,51 @@ export { DeadMansSwitch };
  * @summary Class to be able to execute function chains
  */
 class DeadMansSwitch extends Base {
-    /**
-     * Create new dead man's switch
-     *
-     * @param {Integer} delay
-     * @param {function} callback
-     * @throw {TypeError} the arguments must be either integer or functions
-     * @throws {TypeError} value is not an integer
-     */
-    constructor(delay, callback) {
-        super();
+	/**
+	 * Create new dead man's switch
+	 *
+	 * @param {Integer} delay
+	 * @param {function} callback
+	 * @throw {TypeError} the arguments must be either integer or functions
+	 * @throws {TypeError} value is not an integer
+	 */
+	constructor(delay, callback) {
+		super();
 
-        init.call(this, validateInteger(delay), validateFunction(callback));
-    }
+		init.call(this, validateInteger(delay), validateFunction(callback));
+	}
 
-    /**
-     *
-     * @param {Integer|undefined} [delay]
-     */
-    touch(delay) {
-        if (this[internalSymbol]["isAlreadyRun"] === true) {
-            throw new Error("has already run");
-        }
+	/**
+	 *
+	 * @param {Integer|undefined} [delay]
+	 */
+	touch(delay) {
+		if (this[internalSymbol]["isAlreadyRun"] === true) {
+			throw new Error("has already run");
+		}
 
-        if (isInteger(delay)) {
-            this[internalSymbol]["delay"] = delay;
-        } else if (delay !== undefined) {
-            throw new Error("unsupported argument");
-        }
+		if (isInteger(delay)) {
+			this[internalSymbol]["delay"] = delay;
+		} else if (delay !== undefined) {
+			throw new Error("unsupported argument");
+		}
 
-        clearTimeout(this[internalSymbol]["timer"]);
+		clearTimeout(this[internalSymbol]["timer"]);
 
-        initCallback.call(this);
+		initCallback.call(this);
 
-        return this;
-    }
+		return this;
+	}
 }
 
 /**
  * @private
  */
 function initCallback() {
-    const self = this;
-
-    self[internalSymbol]["timer"] = setTimeout(() => {
-        self[internalSymbol]["isAlreadyRun"] = true;
-        self[internalSymbol]["callback"]();
-    }, self[internalSymbol]["delay"]);
+	this[internalSymbol]["timer"] = setTimeout(() => {
+		this[internalSymbol]["isAlreadyRun"] = true;
+		this[internalSymbol]["callback"]();
+	}, this[internalSymbol]["delay"]);
 }
 
 /**
@@ -79,14 +77,12 @@ function initCallback() {
  * @param {function} callback
  */
 function init(delay, callback) {
-    const self = this;
-
-    self[internalSymbol] = {
-        callback,
-        delay,
-        isAlreadyRun: false,
-        timer: undefined,
-    };
+	this[internalSymbol] = {
+		callback,
+		delay,
+		isAlreadyRun: false,
+		timer: undefined,
+	};
 
-    initCallback.call(self);
+	initCallback.call(this);
 }

package/source/util/freeze.mjs

@@ -21,17 +21,18 @@ export { deepFreeze };
  * @throws {TypeError} value is not a object
  */
 function deepFreeze(object) {
-    validateObject(object);
+	validateObject(object);
 
-    // Retrieve the defined property names of the object
-    var propNames = Object.getOwnPropertyNames(object);
+	// Retrieve the defined property names of the object
+	var propNames = Object.getOwnPropertyNames(object);
 
-    // Freeze properties before freezing yourself
-    for (let name of propNames) {
-        let value = object[name];
+	// Freeze properties before freezing yourself
+	for (const name of propNames) {
+		const value = object[name];
 
-        object[name] = value && typeof value === "object" ? deepFreeze(value) : value;
-    }
+		object[name] =
+			value && typeof value === "object" ? deepFreeze(value) : value;
+	}
 
-    return Object.freeze(object);
+	return Object.freeze(object);
 }

package/source/util/namespace.mjs

@@ -4,7 +4,7 @@
  */
 
 /**
- * Namespace for utilities.
+ * Namespace for all util related functions.
  *
  * @namespace Monster.Util
  * @memberOf Monster