@schukai/monster 3.51.4 → 3.52.0

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.4");
+	/** don't touch, replaced by make with package.json version */
+	monsterVersion = new Version("3.52.0");
 
-    return monsterVersion;
+	return monsterVersion;
 }

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