@schukai/monster 3.51.5 → 3.52.1

package/source/types/uniquequeue.mjs

@@ -21,57 +21,57 @@ export { UniqueQueue };
  * @summary A queue for unique values
  */
 class UniqueQueue extends Queue {
-    /**
-     *
-     */
-    constructor() {
-        super();
-        this[internalSymbol] = {
-            unique: new WeakSet(),
-        };
-    }
+	/**
+	 *
+	 */
+	constructor() {
+		super();
+		this[internalSymbol] = {
+			unique: new WeakSet(),
+		};
+	}
 
-    /**
-     * Add a new element to the end of the queue.
-     *
-     * @param {object} value
-     * @returns {Queue}
-     * @throws {TypeError} value is not a object
-     */
-    add(value) {
-        validateObject(value);
+	/**
+	 * Add a new element to the end of the queue.
+	 *
+	 * @param {object} value
+	 * @returns {Queue}
+	 * @throws {TypeError} value is not a object
+	 */
+	add(value) {
+		validateObject(value);
 
-        if (!this[internalSymbol].unique.has(value)) {
-            this[internalSymbol].unique.add(value);
-            super.add(value);
-        }
+		if (!this[internalSymbol].unique.has(value)) {
+			this[internalSymbol].unique.add(value);
+			super.add(value);
+		}
 
-        return this;
-    }
+		return this;
+	}
 
-    /**
-     * remove all entries
-     *
-     * @returns {Queue}
-     */
-    clear() {
-        super.clear();
-        this[internalSymbol].unique = new WeakSet();
-        return this;
-    }
+	/**
+	 * remove all entries
+	 *
+	 * @returns {Queue}
+	 */
+	clear() {
+		super.clear();
+		this[internalSymbol].unique = new WeakSet();
+		return this;
+	}
 
-    /**
-     * Remove the element at the front of the queue
-     * If the queue is empty, return undefined.
-     *
-     * @return {object}
-     */
-    poll() {
-        if (this.isEmpty()) {
-            return undefined;
-        }
-        let value = this.data.shift();
-        this[internalSymbol].unique.delete(value);
-        return value;
-    }
+	/**
+	 * Remove the element at the front of the queue
+	 * If the queue is empty, return undefined.
+	 *
+	 * @return {object}
+	 */
+	poll() {
+		if (this.isEmpty()) {
+			return undefined;
+		}
+		const value = this.data.shift();
+		this[internalSymbol].unique.delete(value);
+		return value;
+	}
 }

package/source/types/uuid.mjs

@@ -23,34 +23,34 @@ export { UUID };
  * @throws {Error} unsupported
  */
 class UUID extends Base {
-    /**
-     *
-     */
-    constructor() {
-        super();
+	/**
+	 *
+	 */
+	constructor() {
+		super();
 
-        let uuid = createWithCrypto();
+		let uuid = createWithCrypto();
 
-        if (uuid === undefined) {
-            uuid = createWithRandom();
-        }
+		if (uuid === undefined) {
+			uuid = createWithRandom();
+		}
 
-        if (uuid === undefined) {
-            throw new Error("unsupported");
-        }
+		if (uuid === undefined) {
+			throw new Error("unsupported");
+		}
 
-        this[internalSymbol] = {
-            value: uuid,
-        };
-    }
+		this[internalSymbol] = {
+			value: uuid,
+		};
+	}
 
-    /**
-     *
-     * @return {string}
-     */
-    toString() {
-        return this[internalSymbol]["value"];
-    }
+	/**
+	 *
+	 * @return {string}
+	 */
+	toString() {
+		return this[internalSymbol]["value"];
+	}
 }
 
 /**
@@ -58,11 +58,11 @@ class UUID extends Base {
  * @return {string|undefined}
  */
 function createWithRandom() {
-    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
-        const r = (random(0, 65000) * 16) | 0;
-        const v = c === "x" ? r : (r & 0x3) | 0x8;
-        return v.toString(16)[0];
-    });
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+		const r = (random(0, 65000) * 16) | 0;
+		const v = c === "x" ? r : (r & 0x3) | 0x8;
+		return v.toString(16)[0];
+	});
 }
 
 /**
@@ -70,8 +70,8 @@ function createWithRandom() {
  * @return {string|undefined}
  */
 function createWithCrypto() {
-    const crypt = getGlobalObject("crypto");
-    if (!isObject(crypt)) return;
-    if (typeof crypt?.["randomUUID"]) return;
-    return crypt.randomUUID();
+	const crypt = getGlobalObject("crypto");
+	if (!isObject(crypt)) return;
+	if (typeof crypt?.["randomUUID"]) return;
+	return crypt.randomUUID();
 }

package/source/types/validate.mjs

@@ -6,29 +6,29 @@
  */
 
 import {
-    isArray,
-    isBoolean,
-    isFunction,
-    isInstance,
-    isInteger,
-    isIterable,
-    isObject,
-    isPrimitive,
-    isString,
-    isSymbol,
+	isArray,
+	isBoolean,
+	isFunction,
+	isInstance,
+	isInteger,
+	isIterable,
+	isObject,
+	isPrimitive,
+	isString,
+	isSymbol,
 } from "./is.mjs";
 
 export {
-    validateIterable,
-    validatePrimitive,
-    validateBoolean,
-    validateString,
-    validateObject,
-    validateInstance,
-    validateArray,
-    validateSymbol,
-    validateFunction,
-    validateInteger,
+	validateIterable,
+	validatePrimitive,
+	validateBoolean,
+	validateString,
+	validateObject,
+	validateInstance,
+	validateArray,
+	validateSymbol,
+	validateFunction,
+	validateInteger,
 };
 
 /**
@@ -54,10 +54,10 @@ export {
  * @see {@link Monster.Types#isPrimitive}
  */
 function validateIterable(value) {
-    if (!isIterable(value)) {
-        throw new TypeError("value is not iterable");
-    }
-    return value;
+	if (!isIterable(value)) {
+		throw new TypeError("value is not iterable");
+	}
+	return value;
 }
 
 /**
@@ -83,10 +83,10 @@ function validateIterable(value) {
  * @see {@link Monster.Types#isPrimitive}
  */
 function validatePrimitive(value) {
-    if (!isPrimitive(value)) {
-        throw new TypeError("value is not a primitive");
-    }
-    return value;
+	if (!isPrimitive(value)) {
+		throw new TypeError("value is not a primitive");
+	}
+	return value;
 }
 
 /**
@@ -111,10 +111,10 @@ function validatePrimitive(value) {
  * @throws {TypeError}  value is not primitive
  */
 function validateBoolean(value) {
-    if (!isBoolean(value)) {
-        throw new TypeError("value is not a boolean");
-    }
-    return value;
+	if (!isBoolean(value)) {
+		throw new TypeError("value is not a boolean");
+	}
+	return value;
 }
 
 /**
@@ -137,10 +137,10 @@ function validateBoolean(value) {
  * @throws {TypeError} value is not a string
  */
 function validateString(value) {
-    if (!isString(value)) {
-        throw new TypeError("value is not a string");
-    }
-    return value;
+	if (!isString(value)) {
+		throw new TypeError("value is not a string");
+	}
+	return value;
 }
 
 /**
@@ -164,10 +164,10 @@ function validateString(value) {
  * @throws {TypeError} value is not a object
  */
 function validateObject(value) {
-    if (!isObject(value)) {
-        throw new TypeError("value is not a object");
-    }
-    return value;
+	if (!isObject(value)) {
+		throw new TypeError("value is not a object");
+	}
+	return value;
 }
 
 /**
@@ -191,19 +191,19 @@ function validateObject(value) {
  * @throws {TypeError} value is not an instance of
  */
 function validateInstance(value, instance) {
-    if (!isInstance(value, instance)) {
-        let n = "";
-        if (isObject(instance) || isFunction(instance)) {
-            n = instance?.["name"];
-        }
+	if (!isInstance(value, instance)) {
+		let n = "";
+		if (isObject(instance) || isFunction(instance)) {
+			n = instance?.["name"];
+		}
 
-        if (n) {
-            n = ` ${n}`;
-        }
+		if (n) {
+			n = ` ${n}`;
+		}
 
-        throw new TypeError(`value is not an instance of${n}`);
-    }
-    return value;
+		throw new TypeError(`value is not an instance of${n}`);
+	}
+	return value;
 }
 
 /**
@@ -226,10 +226,10 @@ function validateInstance(value, instance) {
  * @throws {TypeError} value is not an array
  */
 function validateArray(value) {
-    if (!isArray(value)) {
-        throw new TypeError("value is not an array");
-    }
-    return value;
+	if (!isArray(value)) {
+		throw new TypeError("value is not an array");
+	}
+	return value;
 }
 
 /**
@@ -252,10 +252,10 @@ function validateArray(value) {
  * @throws {TypeError} value is not an symbol
  */
 function validateSymbol(value) {
-    if (!isSymbol(value)) {
-        throw new TypeError("value is not an symbol");
-    }
-    return value;
+	if (!isSymbol(value)) {
+		throw new TypeError("value is not an symbol");
+	}
+	return value;
 }
 
 /**
@@ -279,10 +279,10 @@ function validateSymbol(value) {
  * @throws {TypeError} value is not a function
  */
 function validateFunction(value) {
-    if (!isFunction(value)) {
-        throw new TypeError("value is not a function");
-    }
-    return value;
+	if (!isFunction(value)) {
+		throw new TypeError("value is not a function");
+	}
+	return value;
 }
 
 /**
@@ -306,8 +306,8 @@ function validateFunction(value) {
  * @throws {TypeError} value is not an integer
  */
 function validateInteger(value) {
-    if (!isInteger(value)) {
-        throw new TypeError("value is not an integer");
-    }
-    return value;
+	if (!isInteger(value)) {
+		throw new TypeError("value is not an integer");
+	}
+	return value;
 }

package/source/types/version.mjs

@@ -22,105 +22,115 @@ export { Version, getMonsterVersion };
  * @summary The version object contains a sematic version number
  */
 class Version extends Base {
-    /**
-     *
-     * @param major
-     * @param minor
-     * @param patch
-     * @throws {Error} major is not a number
-     * @throws {Error} minor is not a number
-     * @throws {Error} patch is not a number
-     */
-    constructor(major, minor, patch) {
-        super();
-
-        if (typeof major === "string" && minor === undefined && patch === undefined) {
-            let parts = major.toString().split(".");
-            major = parseInt(parts[0] || 0);
-            minor = parseInt(parts[1] || 0);
-            patch = parseInt(parts[2] || 0);
-        }
-
-        if (major === undefined) {
-            throw new Error("major version is undefined");
-        }
-
-        if (minor === undefined) {
-            minor = 0;
-        }
-
-        if (patch === undefined) {
-            patch = 0;
-        }
-
-        this.major = parseInt(major);
-        this.minor = parseInt(minor);
-        this.patch = parseInt(patch);
-
-        if (isNaN(this.major)) {
-            throw new Error("major is not a number");
-        }
-
-        if (isNaN(this.minor)) {
-            throw new Error("minor is not a number");
-        }
-
-        if (isNaN(this.patch)) {
-            throw new Error("patch is not a number");
-        }
-    }
-
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 2.1.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/types/version");
-    }
-
-    /**
-     *
-     * @returns {string}
-     */
-    toString() {
-        return `${this.major}.${this.minor}.${this.patch}`;
-    }
-
-    /**
-     * returns 0 if equal, -1 if the object version is less and 1 if greater
-     * than the compared version
-     *
-     * @param {string|Version} version Version to compare
-     * @returns {number}
-     */
-    compareTo(version) {
-        if (version instanceof Version) {
-            version = version.toString();
-        }
-
-        if (typeof version !== "string") {
-            throw new Error("type exception");
-        }
-
-        if (version === this.toString()) {
-            return 0;
-        }
-
-        let a = [this.major, this.minor, this.patch];
-        let b = version.split(".");
-        let len = Math.max(a.length, b.length);
-
-        for (let i = 0; i < len; i += 1) {
-            if ((a[i] && !b[i] && parseInt(a[i]) > 0) || parseInt(a[i]) > parseInt(b[i])) {
-                return 1;
-            } else if ((b[i] && !a[i] && parseInt(b[i]) > 0) || parseInt(a[i]) < parseInt(b[i])) {
-                return -1;
-            }
-        }
-
-        return 0;
-    }
+	/**
+	 *
+	 * @param major
+	 * @param minor
+	 * @param patch
+	 * @throws {Error} major is not a number
+	 * @throws {Error} minor is not a number
+	 * @throws {Error} patch is not a number
+	 */
+	constructor(major, minor, patch) {
+		super();
+
+		if (
+			typeof major === "string" &&
+			minor === undefined &&
+			patch === undefined
+		) {
+			const parts = major.toString().split(".");
+			major = parseInt(parts[0] || 0);
+			minor = parseInt(parts[1] || 0);
+			patch = parseInt(parts[2] || 0);
+		}
+
+		if (major === undefined) {
+			throw new Error("major version is undefined");
+		}
+
+		if (minor === undefined) {
+			minor = 0;
+		}
+
+		if (patch === undefined) {
+			patch = 0;
+		}
+
+		this.major = parseInt(major);
+		this.minor = parseInt(minor);
+		this.patch = parseInt(patch);
+
+		if (isNaN(this.major)) {
+			throw new Error("major is not a number");
+		}
+
+		if (isNaN(this.minor)) {
+			throw new Error("minor is not a number");
+		}
+
+		if (isNaN(this.patch)) {
+			throw new Error("patch is not a number");
+		}
+	}
+
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 2.1.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/types/version");
+	}
+
+	/**
+	 *
+	 * @returns {string}
+	 */
+	toString() {
+		return `${this.major}.${this.minor}.${this.patch}`;
+	}
+
+	/**
+	 * returns 0 if equal, -1 if the object version is less and 1 if greater
+	 * than the compared version
+	 *
+	 * @param {string|Version} version Version to compare
+	 * @returns {number}
+	 */
+	compareTo(version) {
+		if (version instanceof Version) {
+			version = version.toString();
+		}
+
+		if (typeof version !== "string") {
+			throw new Error("type exception");
+		}
+
+		if (version === this.toString()) {
+			return 0;
+		}
+
+		const a = [this.major, this.minor, this.patch];
+		const b = version.split(".");
+		const len = Math.max(a.length, b.length);
+
+		for (let i = 0; i < len; i += 1) {
+			if (
+				(a[i] && !b[i] && parseInt(a[i]) > 0) ||
+				parseInt(a[i]) > parseInt(b[i])
+			) {
+				return 1;
+			} else if (
+				(b[i] && !a[i] && parseInt(b[i]) > 0) ||
+				parseInt(a[i]) < parseInt(b[i])
+			) {
+				return -1;
+			}
+		}
+
+		return 0;
+	}
 }
 
 let monsterVersion;
@@ -137,12 +147,12 @@ let monsterVersion;
  * @memberOf Monster
  */
 function getMonsterVersion() {
-    if (monsterVersion instanceof Version) {
-        return monsterVersion;
-    }
+	if (monsterVersion instanceof Version) {
+		return monsterVersion;
+	}
 
-    /** don't touch, replaced by make with package.json version */
-    monsterVersion = new Version("3.51.5");
+	/** don't touch, replaced by make with package.json version */
+	monsterVersion = new Version("3.52.1");
 
-    return monsterVersion;
+	return monsterVersion;
 }