@schukai/monster 3.51.4 → 3.52.0

package/source/logging/logger.mjs

@@ -9,7 +9,11 @@ import { Handler } from "../logging/handler.mjs";
 import { LogEntry } from "../logging/logentry.mjs";
 
 import { Base } from "../types/base.mjs";
-import { validateInteger, validateObject, validateString } from "../types/validate.mjs";
+import {
+	validateInteger,
+	validateObject,
+	validateString,
+} from "../types/validate.mjs";
 
 export { Logger, ALL, TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF };
 
@@ -71,196 +75,196 @@ const OFF = 0;
  * @memberOf Monster.Logging
  */
 class Logger extends Base {
-    /**
-     *
-     */
-    constructor() {
-        super();
-        this.handler = new Set();
-    }
+	/**
+	 *
+	 */
+	constructor() {
+		super();
+		this.handler = new Set();
+	}
 
-    /**
-     *
-     * @param {Handler} handler
-     * @returns {Logger}
-     * @throws {Error} the handler must be an instance of Handler
-     */
-    addHandler(handler) {
-        validateObject(handler);
-        if (!(handler instanceof Handler)) {
-            throw new Error("the handler must be an instance of Handler");
-        }
+	/**
+	 *
+	 * @param {Handler} handler
+	 * @returns {Logger}
+	 * @throws {Error} the handler must be an instance of Handler
+	 */
+	addHandler(handler) {
+		validateObject(handler);
+		if (!(handler instanceof Handler)) {
+			throw new Error("the handler must be an instance of Handler");
+		}
 
-        this.handler.add(handler);
-        return this;
-    }
+		this.handler.add(handler);
+		return this;
+	}
 
-    /**
-     *
-     * @param {Handler} handler
-     * @returns {Logger}
-     * @throws {Error} the handler must be an instance of Handler
-     */
-    removeHandler(handler) {
-        validateObject(handler);
-        if (!(handler instanceof Handler)) {
-            throw new Error("the handler must be an instance of Handler");
-        }
+	/**
+	 *
+	 * @param {Handler} handler
+	 * @returns {Logger}
+	 * @throws {Error} the handler must be an instance of Handler
+	 */
+	removeHandler(handler) {
+		validateObject(handler);
+		if (!(handler instanceof Handler)) {
+			throw new Error("the handler must be an instance of Handler");
+		}
 
-        this.handler.delete(handler);
-        return this;
-    }
+		this.handler.delete(handler);
+		return this;
+	}
 
-    /**
-     * log Trace message
-     *
-     * ALL > TRACE > DEBUG > INFO > WARN > ERROR > FATAL > OFF  (ALL = 0xff;OFF = 0x00;
-     *
-     * @param {*} arguments
-     * @returns {Logger}
-     * @since 1.5.0
-     */
-    logTrace(...args) {
-        if (typeof args !== "object" || args[0] === null) {
-            throw new Error("the first argument must be an object");
-        }
+	/**
+	 * log Trace message
+	 *
+	 * ALL > TRACE > DEBUG > INFO > WARN > ERROR > FATAL > OFF  (ALL = 0xff;OFF = 0x00;
+	 *
+	 * @param {*} arguments
+	 * @returns {Logger}
+	 * @since 1.5.0
+	 */
+	logTrace(...args) {
+		if (typeof args !== "object" || args[0] === null) {
+			throw new Error("the first argument must be an object");
+		}
 
-        triggerLog.apply(this, [TRACE, ...args]);
-        return this;
-    }
+		triggerLog.apply(this, [TRACE, ...args]);
+		return this;
+	}
 
-    /**
-     * log Debug message
-     *
-     * ALL > TRACE > DEBUG > INFO > WARN > ERROR > FATAL > OFF  (ALL = 0xff;OFF = 0x00;
-     *
-     * @param {*} arguments
-     * @returns {Logger}
-     * @since 1.5.0
-     */
-    logDebug(...args) {
-        if (typeof args !== "object" || args[0] === null) {
-            throw new Error("the first argument must be an object");
-        }
+	/**
+	 * log Debug message
+	 *
+	 * ALL > TRACE > DEBUG > INFO > WARN > ERROR > FATAL > OFF  (ALL = 0xff;OFF = 0x00;
+	 *
+	 * @param {*} arguments
+	 * @returns {Logger}
+	 * @since 1.5.0
+	 */
+	logDebug(...args) {
+		if (typeof args !== "object" || args[0] === null) {
+			throw new Error("the first argument must be an object");
+		}
 
-        triggerLog.apply(this, [DEBUG, ...args]);
-        return this;
-    }
+		triggerLog.apply(this, [DEBUG, ...args]);
+		return this;
+	}
 
-    /**
-     * log Info message
-     *
-     * ALL > TRACE > DEBUG > INFO > WARN > ERROR > FATAL > OFF  (ALL = 0xff;OFF = 0x00;
-     *
-     *
-     * @param {*} arguments
-     * @returns {Logger}
-     * @since 1.5.0
-     */
-    logInfo(...args) {
-        if (typeof args !== "object" || args[0] === null) {
-            throw new Error("the first argument must be an object");
-        }
+	/**
+	 * log Info message
+	 *
+	 * ALL > TRACE > DEBUG > INFO > WARN > ERROR > FATAL > OFF  (ALL = 0xff;OFF = 0x00;
+	 *
+	 *
+	 * @param {*} arguments
+	 * @returns {Logger}
+	 * @since 1.5.0
+	 */
+	logInfo(...args) {
+		if (typeof args !== "object" || args[0] === null) {
+			throw new Error("the first argument must be an object");
+		}
 
-        triggerLog.apply(this, [INFO, ...args]);
-        return this;
-    }
+		triggerLog.apply(this, [INFO, ...args]);
+		return this;
+	}
 
-    /**
-     * log Warn message
-     *
-     * ALL > TRACE > DEBUG > INFO > WARN > ERROR > FATAL > OFF  (ALL = 0xff;OFF = 0x00;
-     *
-     * @param {*} arguments
-     * @returns {Logger}
-     * @since 1.5.0
-     */
-    logWarn(...args) {
-        if (typeof args !== "object" || args[0] === null) {
-            throw new Error("the first argument must be an object");
-        }
+	/**
+	 * log Warn message
+	 *
+	 * ALL > TRACE > DEBUG > INFO > WARN > ERROR > FATAL > OFF  (ALL = 0xff;OFF = 0x00;
+	 *
+	 * @param {*} arguments
+	 * @returns {Logger}
+	 * @since 1.5.0
+	 */
+	logWarn(...args) {
+		if (typeof args !== "object" || args[0] === null) {
+			throw new Error("the first argument must be an object");
+		}
 
-        triggerLog.apply(this, [WARN, ...args]);
-        return this;
-    }
+		triggerLog.apply(this, [WARN, ...args]);
+		return this;
+	}
 
-    /**
-     * log Error message
-     *
-     * ALL > TRACE > DEBUG > INFO > WARN > ERROR > FATAL > OFF  (ALL = 0xff;OFF = 0x00;
-     *
-     * @param {*} arguments
-     * @returns {Logger}
-     * @since 1.5.0
-     */
-    logError(...args) {
-        if (typeof args !== "object" || args[0] === null) {
-            throw new Error("the first argument must be an object");
-        }
+	/**
+	 * log Error message
+	 *
+	 * ALL > TRACE > DEBUG > INFO > WARN > ERROR > FATAL > OFF  (ALL = 0xff;OFF = 0x00;
+	 *
+	 * @param {*} arguments
+	 * @returns {Logger}
+	 * @since 1.5.0
+	 */
+	logError(...args) {
+		if (typeof args !== "object" || args[0] === null) {
+			throw new Error("the first argument must be an object");
+		}
 
-        triggerLog.apply(this, [ERROR, ...args]);
-        return this;
-    }
+		triggerLog.apply(this, [ERROR, ...args]);
+		return this;
+	}
 
-    /**
-     * log Fatal message
-     *
-     * ALL > TRACE > DEBUG > INFO > WARN > ERROR > FATAL > OFF  (ALL = 0xff;OFF = 0x00;
-     *
-     * @param {*} arguments
-     * @returns {Logger}
-     * @since 1.5.0
-     */
-    logFatal(...args) {
-        if (typeof args !== "object" || args[0] === null) {
-            throw new Error("the first argument must be an object");
-        }
+	/**
+	 * log Fatal message
+	 *
+	 * ALL > TRACE > DEBUG > INFO > WARN > ERROR > FATAL > OFF  (ALL = 0xff;OFF = 0x00;
+	 *
+	 * @param {*} arguments
+	 * @returns {Logger}
+	 * @since 1.5.0
+	 */
+	logFatal(...args) {
+		if (typeof args !== "object" || args[0] === null) {
+			throw new Error("the first argument must be an object");
+		}
 
-        triggerLog.apply(this, [FATAL, ...args]);
-        return this;
-    }
+		triggerLog.apply(this, [FATAL, ...args]);
+		return this;
+	}
 
-    /**
-     * Labels
-     *
-     * @param {integer} level
-     * @returns {string}
-     */
-    getLabel(level) {
-        validateInteger(level);
+	/**
+	 * Labels
+	 *
+	 * @param {integer} level
+	 * @returns {string}
+	 */
+	getLabel(level) {
+		validateInteger(level);
 
-        if (level === ALL) return "ALL";
-        if (level === TRACE) return "TRACE";
-        if (level === DEBUG) return "DEBUG";
-        if (level === INFO) return "INFO";
-        if (level === WARN) return "WARN";
-        if (level === ERROR) return "ERROR";
-        if (level === FATAL) return "FATAL";
-        if (level === OFF) return "OFF";
+		if (level === ALL) return "ALL";
+		if (level === TRACE) return "TRACE";
+		if (level === DEBUG) return "DEBUG";
+		if (level === INFO) return "INFO";
+		if (level === WARN) return "WARN";
+		if (level === ERROR) return "ERROR";
+		if (level === FATAL) return "FATAL";
+		if (level === OFF) return "OFF";
 
-        return "unknown";
-    }
+		return "unknown";
+	}
 
-    /**
-     * Level
-     *
-     * @param {string} label
-     * @returns {integer}
-     */
-    getLevel(label) {
-        validateString(label);
+	/**
+	 * Level
+	 *
+	 * @param {string} label
+	 * @returns {integer}
+	 */
+	getLevel(label) {
+		validateString(label);
 
-        if (label === "ALL") return ALL;
-        if (label === "TRACE") return TRACE;
-        if (label === "DEBUG") return DEBUG;
-        if (label === "INFO") return INFO;
-        if (label === "WARN") return WARN;
-        if (label === "ERROR") return ERROR;
-        if (label === "FATAL") return FATAL;
-        if (label === "OFF") return OFF;
+		if (label === "ALL") return ALL;
+		if (label === "TRACE") return TRACE;
+		if (label === "DEBUG") return DEBUG;
+		if (label === "INFO") return INFO;
+		if (label === "WARN") return WARN;
+		if (label === "ERROR") return ERROR;
+		if (label === "FATAL") return FATAL;
+		if (label === "OFF") return OFF;
 
-        return 0;
-    }
+		return 0;
+	}
 }
 
 /**
@@ -272,11 +276,9 @@ class Logger extends Base {
  * @private
  */
 function triggerLog(loglevel, ...args) {
-    var logger = this;
+	for (const handler of this.handler) {
+		handler.log(new LogEntry(loglevel, args));
+	}
 
-    for (let handler of logger.handler) {
-        handler.log(new LogEntry(loglevel, args));
-    }
-
-    return logger;
+	return this;
 }

package/source/math/random.mjs

@@ -25,31 +25,31 @@ export { random };
  * @copyright schukai GmbH
  */
 function random(min, max) {
-    if (min === undefined) {
-        min = 0;
-    }
-    if (max === undefined) {
-        max = MAX;
-    }
-
-    if (max < min) {
-        throw new Error("max must be greater than min");
-    }
-
-    return Math.round(create(min, max));
+	if (min === undefined) {
+		min = 0;
+	}
+	if (max === undefined) {
+		max = MAX;
+	}
+
+	if (max < min) {
+		throw new Error("max must be greater than min");
+	}
+
+	return Math.round(create(min, max));
 }
 
 /**
  * @private
  * @type {number}
  */
-var MAX = 1000000000;
+const MAX = 1000000000;
 
 Math.log2 =
-    Math.log2 ||
-    function (n) {
-        return Math.log(n) / Math.log(2);
-    };
+	Math.log2 ||
+	function (n) {
+		return Math.log(n) / Math.log(2);
+	};
 
 /**
  *
@@ -62,46 +62,50 @@ Math.log2 =
  * @throws {Error} the distance is too small to create a random number.
  */
 function create(min, max) {
-    let crypt;
-    let globalReference = getGlobal();
-
-    crypt = globalReference?.["crypto"] || globalReference?.["msCrypto"] || globalReference?.["crypto"] || undefined;
-
-    if (typeof crypt === "undefined") {
-        throw new Error("missing crypt");
-    }
-
-    let rval = 0;
-    const range = max - min;
-    if (range < 2) {
-        throw new Error("the distance is too small to create a random number.");
-    }
-
-    const bitsNeeded = Math.ceil(Math.log2(range));
-    if (bitsNeeded > 53) {
-        throw new Error("we cannot generate numbers larger than 53 bits.");
-    }
-    const bytesNeeded = Math.ceil(bitsNeeded / 8);
-    const mask = Math.pow(2, bitsNeeded) - 1;
-
-    const byteArray = new Uint8Array(bytesNeeded);
-    crypt.getRandomValues(byteArray);
-
-    let p = (bytesNeeded - 1) * 8;
-    for (var i = 0; i < bytesNeeded; i++) {
-        rval += byteArray[i] * Math.pow(2, p);
-        p -= 8;
-    }
-
-    rval = rval & mask;
-
-    if (rval >= range) {
-        return create(min, max);
-    }
-
-    if (rval < min) {
-        rval += min;
-    }
-
-    return rval;
+	let crypt;
+	const globalReference = getGlobal();
+
+	crypt =
+		globalReference?.["crypto"] ||
+		globalReference?.["msCrypto"] ||
+		globalReference?.["crypto"] ||
+		undefined;
+
+	if (typeof crypt === "undefined") {
+		throw new Error("missing crypt");
+	}
+
+	let rval = 0;
+	const range = max - min;
+	if (range < 2) {
+		throw new Error("the distance is too small to create a random number.");
+	}
+
+	const bitsNeeded = Math.ceil(Math.log2(range));
+	if (bitsNeeded > 53) {
+		throw new Error("we cannot generate numbers larger than 53 bits.");
+	}
+	const bytesNeeded = Math.ceil(bitsNeeded / 8);
+	const mask = Math.pow(2, bitsNeeded) - 1;
+
+	const byteArray = new Uint8Array(bytesNeeded);
+	crypt.getRandomValues(byteArray);
+
+	let p = (bytesNeeded - 1) * 8;
+	for (var i = 0; i < bytesNeeded; i++) {
+		rval += byteArray[i] * Math.pow(2, p);
+		p -= 8;
+	}
+
+	rval = rval & mask;
+
+	if (rval >= range) {
+		return create(min, max);
+	}
+
+	if (rval < min) {
+		rval += min;
+	}
+
+	return rval;
 }