@schukai/monster 3.51.5 → 3.52.0

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

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);
+		});
+	}
 }