@schukai/monster 3.51.5 → 3.52.0

package/source/data/pathfinder.mjs

@@ -6,9 +6,19 @@
  */
 
 import { Base } from "../types/base.mjs";
-import { isArray, isInteger, isObject, isPrimitive, isString } from "../types/is.mjs";
+import {
+	isArray,
+	isInteger,
+	isObject,
+	isPrimitive,
+	isString,
+} from "../types/is.mjs";
 import { Stack } from "../types/stack.mjs";
-import { validateInteger, validateBoolean, validateString } from "../types/validate.mjs";
+import {
+	validateInteger,
+	validateBoolean,
+	validateString,
+} from "../types/validate.mjs";
 
 export { Pathfinder, DELIMITER, WILDCARD };
 
@@ -72,99 +82,99 @@ const WILDCARD = "*";
  * @memberOf Monster.Data
  */
 class Pathfinder extends Base {
-    /**
-     * @param {array|object|Map|Set} value
-     * @since 1.4.0
-     * @throws  {Error} the parameter must not be a simple type
-     **/
-    constructor(object) {
-        super();
-
-        if (isPrimitive(object)) {
-            throw new Error("the parameter must not be a simple type");
-        }
-
-        this.object = object;
-        this.wildCard = WILDCARD;
-    }
-
-    /**
-     * set wildcard
-     *
-     * @param {string} wildcard
-     * @return {Pathfinder}
-     * @since 1.7.0
-     */
-    setWildCard(wildcard) {
-        validateString(wildcard);
-        this.wildCard = wildcard;
-        return this;
-    }
-
-    /**
-     *
-     * @param {string|array} path
-     * @since 1.4.0
-     * @returns {*}
-     * @throws {TypeError} unsupported type
-     * @throws {Error} the journey is not at its end
-     * @throws {TypeError} value is not a string
-     * @throws {TypeError} value is not an integer
-     * @throws {Error} unsupported action for this data type
-     */
-    getVia(path) {
-        return getValueViaPath.call(this, this.object, path);
-    }
-
-    /**
-     *
-     * @param {string|array} path
-     * @param {*} value
-     * @returns {Pathfinder}
-     * @since 1.4.0
-     * @throws {TypeError} unsupported type
-     * @throws {TypeError} value is not a string
-     * @throws {TypeError} value is not an integer
-     * @throws {Error} unsupported action for this data type
-     */
-    setVia(path, value) {
-        setValueViaPath.call(this, this.object, path, value);
-        return this;
-    }
-
-    /**
-     * Delete Via Path
-     *
-     * @param {string|array} path
-     * @returns {Pathfinder}
-     * @since 1.6.0
-     * @throws {TypeError} unsupported type
-     * @throws {TypeError} value is not a string
-     * @throws {TypeError} value is not an integer
-     * @throws {Error} unsupported action for this data type
-     */
-    deleteVia(path) {
-        deleteValueViaPath.call(this, this.object, path);
-        return this;
-    }
-
-    /**
-     *
-     * @param {string|array} path
-     * @return {bool}
-     * @throws {TypeError} unsupported type
-     * @throws {TypeError} value is not a string
-     * @throws {TypeError} value is not an integer
-     * @since 1.4.0
-     */
-    exists(path) {
-        try {
-            getValueViaPath.call(this, this.object, path, true);
-            return true;
-        } catch (e) {}
-
-        return false;
-    }
+	/**
+	 * @param {array|object|Map|Set} value
+	 * @since 1.4.0
+	 * @throws  {Error} the parameter must not be a simple type
+	 **/
+	constructor(object) {
+		super();
+
+		if (isPrimitive(object)) {
+			throw new Error("the parameter must not be a simple type");
+		}
+
+		this.object = object;
+		this.wildCard = WILDCARD;
+	}
+
+	/**
+	 * set wildcard
+	 *
+	 * @param {string} wildcard
+	 * @return {Pathfinder}
+	 * @since 1.7.0
+	 */
+	setWildCard(wildcard) {
+		validateString(wildcard);
+		this.wildCard = wildcard;
+		return this;
+	}
+
+	/**
+	 *
+	 * @param {string|array} path
+	 * @since 1.4.0
+	 * @returns {*}
+	 * @throws {TypeError} unsupported type
+	 * @throws {Error} the journey is not at its end
+	 * @throws {TypeError} value is not a string
+	 * @throws {TypeError} value is not an integer
+	 * @throws {Error} unsupported action for this data type
+	 */
+	getVia(path) {
+		return getValueViaPath.call(this, this.object, path);
+	}
+
+	/**
+	 *
+	 * @param {string|array} path
+	 * @param {*} value
+	 * @returns {Pathfinder}
+	 * @since 1.4.0
+	 * @throws {TypeError} unsupported type
+	 * @throws {TypeError} value is not a string
+	 * @throws {TypeError} value is not an integer
+	 * @throws {Error} unsupported action for this data type
+	 */
+	setVia(path, value) {
+		setValueViaPath.call(this, this.object, path, value);
+		return this;
+	}
+
+	/**
+	 * Delete Via Path
+	 *
+	 * @param {string|array} path
+	 * @returns {Pathfinder}
+	 * @since 1.6.0
+	 * @throws {TypeError} unsupported type
+	 * @throws {TypeError} value is not a string
+	 * @throws {TypeError} value is not an integer
+	 * @throws {Error} unsupported action for this data type
+	 */
+	deleteVia(path) {
+		deleteValueViaPath.call(this, this.object, path);
+		return this;
+	}
+
+	/**
+	 *
+	 * @param {string|array} path
+	 * @return {bool}
+	 * @throws {TypeError} unsupported type
+	 * @throws {TypeError} value is not a string
+	 * @throws {TypeError} value is not an integer
+	 * @since 1.4.0
+	 */
+	exists(path) {
+		try {
+			getValueViaPath.call(this, this.object, path, true);
+			return true;
+		} catch (e) {}
+
+		return false;
+	}
 }
 
 /**
@@ -179,27 +189,27 @@ class Pathfinder extends Base {
  * @private
  */
 function iterate(subject, path, check) {
-    if (check === undefined) {
-        check = false;
-    }
-    validateBoolean(check);
-
-    const result = new Map();
-
-    if (isArray(path)) {
-        path = path.join(DELIMITER);
-    }
-
-    if (isObject(subject) || isArray(subject)) {
-        for (const [key, value] of Object.entries(subject)) {
-            result.set(key, getValueViaPath.call(this, value, path, check));
-        }
-    } else {
-        let key = path.split(DELIMITER).shift();
-        result.set(key, getValueViaPath.call(this, subject, path, check));
-    }
-
-    return result;
+	if (check === undefined) {
+		check = false;
+	}
+	validateBoolean(check);
+
+	const result = new Map();
+
+	if (isArray(path)) {
+		path = path.join(DELIMITER);
+	}
+
+	if (isObject(subject) || isArray(subject)) {
+		for (const [key, value] of Object.entries(subject)) {
+			result.set(key, getValueViaPath.call(this, value, path, check));
+		}
+	} else {
+		const key = path.split(DELIMITER).shift();
+		result.set(key, getValueViaPath.call(this, subject, path, check));
+	}
+
+	return result;
 }
 
 /**
@@ -214,68 +224,71 @@ function iterate(subject, path, check) {
  * @private
  */
 function getValueViaPath(subject, path, check) {
-    if (check === undefined) {
-        check = false;
-    }
-    validateBoolean(check);
-
-    if (!(isArray(path) || isString(path))) {
-        throw new Error("type error: path must be a string or an array");
-    }
-
-    let parts;
-    if (isString(path)) {
-        if (path === "") {
-            return subject;
-        }
-
-        parts = path.split(DELIMITER);
-    }
-
-    let current = parts.shift();
-
-    if (current === this.wildCard) {
-        return iterate.call(this, subject, parts.join(DELIMITER), check);
-    }
-
-    if (isObject(subject) || isArray(subject)) {
-        let anchor;
-        if (subject instanceof Map || subject instanceof WeakMap) {
-            anchor = subject.get(current);
-        } else if (subject instanceof Set || subject instanceof WeakSet) {
-            current = parseInt(current);
-            validateInteger(current);
-            anchor = [...subject]?.[current];
-        } else if (typeof WeakRef === "function" && subject instanceof WeakRef) {
-            throw Error("unsupported action for this data type");
-        } else if (isArray(subject)) {
-            current = parseInt(current);
-            validateInteger(current);
-            anchor = subject?.[current];
-        } else {
-            anchor = subject?.[current];
-        }
-
-        if (isObject(anchor) || isArray(anchor)) {
-            return getValueViaPath.call(this, anchor, parts.join(DELIMITER), check);
-        }
-
-        if (parts.length > 0) {
-            throw Error(`the journey is not at its end (${parts.join(DELIMITER)})`);
-        }
-
-        if (check === true) {
-            const descriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(subject), current);
-
-            if (!subject.hasOwnProperty(current) && descriptor === undefined) {
-                throw Error("unknown value");
-            }
-        }
-
-        return anchor;
-    }
-
-    throw TypeError(`unsupported type ${typeof subject}`);
+	if (check === undefined) {
+		check = false;
+	}
+	validateBoolean(check);
+
+	if (!(isArray(path) || isString(path))) {
+		throw new Error("type error: path must be a string or an array");
+	}
+
+	let parts;
+	if (isString(path)) {
+		if (path === "") {
+			return subject;
+		}
+
+		parts = path.split(DELIMITER);
+	}
+
+	let current = parts.shift();
+
+	if (current === this.wildCard) {
+		return iterate.call(this, subject, parts.join(DELIMITER), check);
+	}
+
+	if (isObject(subject) || isArray(subject)) {
+		let anchor;
+		if (subject instanceof Map || subject instanceof WeakMap) {
+			anchor = subject.get(current);
+		} else if (subject instanceof Set || subject instanceof WeakSet) {
+			current = parseInt(current);
+			validateInteger(current);
+			anchor = [...subject]?.[current];
+		} else if (typeof WeakRef === "function" && subject instanceof WeakRef) {
+			throw Error("unsupported action for this data type");
+		} else if (isArray(subject)) {
+			current = parseInt(current);
+			validateInteger(current);
+			anchor = subject?.[current];
+		} else {
+			anchor = subject?.[current];
+		}
+
+		if (isObject(anchor) || isArray(anchor)) {
+			return getValueViaPath.call(this, anchor, parts.join(DELIMITER), check);
+		}
+
+		if (parts.length > 0) {
+			throw Error(`the journey is not at its end (${parts.join(DELIMITER)})`);
+		}
+
+		if (check === true) {
+			const descriptor = Object.getOwnPropertyDescriptor(
+				Object.getPrototypeOf(subject),
+				current,
+			);
+
+			if (!subject.hasOwnProperty(current) && descriptor === undefined) {
+				throw Error("unknown value");
+			}
+		}
+
+		return anchor;
+	}
+
+	throw TypeError(`unsupported type ${typeof subject}`);
 }
 
 /**
@@ -291,72 +304,72 @@ function getValueViaPath(subject, path, check) {
  * @private
  */
 function setValueViaPath(subject, path, value) {
-    if (!(isArray(path) || isString(path))) {
-        throw new Error("type error: path must be a string or an array");
-    }
-
-    let parts;
-    if (isArray(path)) {
-        if (path.length === 0) {
-            return subject;
-        }
-
-        parts = path;
-    } else {
-        parts = path.split(DELIMITER);
-    }
-
-    let last = parts.pop();
-    let subpath = parts.join(DELIMITER);
-
-    let stack = new Stack();
-    let current = subpath;
-    while (true) {
-        try {
-            getValueViaPath.call(this, subject, current, true);
-            break;
-        } catch (e) {}
-
-        stack.push(current);
-        parts.pop();
-        current = parts.join(DELIMITER);
-
-        if (current === "") break;
-    }
-
-    while (!stack.isEmpty()) {
-        current = stack.pop();
-        let obj = {};
-
-        if (!stack.isEmpty()) {
-            let n = stack.peek().split(DELIMITER).pop();
-            if (isInteger(parseInt(n))) {
-                obj = [];
-            }
-        }
-
-        setValueViaPath.call(this, subject, current, obj);
-    }
-
-    let anchor = getValueViaPath.call(this, subject, subpath);
-
-    if (!(isObject(subject) || isArray(subject))) {
-        throw TypeError(`unsupported type: ${typeof subject}`);
-    }
-
-    if (anchor instanceof Map || anchor instanceof WeakMap) {
-        anchor.set(last, value);
-    } else if (anchor instanceof Set || anchor instanceof WeakSet) {
-        anchor.append(value);
-    } else if (typeof WeakRef === "function" && anchor instanceof WeakRef) {
-        throw Error("unsupported action for this data type");
-    } else if (isArray(anchor)) {
-        last = parseInt(last);
-        validateInteger(last);
-        assignProperty(anchor, last, value);
-    } else {
-        assignProperty(anchor, last, value);
-    }
+	if (!(isArray(path) || isString(path))) {
+		throw new Error("type error: path must be a string or an array");
+	}
+
+	let parts;
+	if (isArray(path)) {
+		if (path.length === 0) {
+			return subject;
+		}
+
+		parts = path;
+	} else {
+		parts = path.split(DELIMITER);
+	}
+
+	let last = parts.pop();
+	const subpath = parts.join(DELIMITER);
+
+	const stack = new Stack();
+	let current = subpath;
+	while (true) {
+		try {
+			getValueViaPath.call(this, subject, current, true);
+			break;
+		} catch (e) {}
+
+		stack.push(current);
+		parts.pop();
+		current = parts.join(DELIMITER);
+
+		if (current === "") break;
+	}
+
+	while (!stack.isEmpty()) {
+		current = stack.pop();
+		let obj = {};
+
+		if (!stack.isEmpty()) {
+			const n = stack.peek().split(DELIMITER).pop();
+			if (isInteger(parseInt(n))) {
+				obj = [];
+			}
+		}
+
+		setValueViaPath.call(this, subject, current, obj);
+	}
+
+	const anchor = getValueViaPath.call(this, subject, subpath);
+
+	if (!(isObject(subject) || isArray(subject))) {
+		throw TypeError(`unsupported type: ${typeof subject}`);
+	}
+
+	if (anchor instanceof Map || anchor instanceof WeakMap) {
+		anchor.set(last, value);
+	} else if (anchor instanceof Set || anchor instanceof WeakSet) {
+		anchor.append(value);
+	} else if (typeof WeakRef === "function" && anchor instanceof WeakRef) {
+		throw Error("unsupported action for this data type");
+	} else if (isArray(anchor)) {
+		last = parseInt(last);
+		validateInteger(last);
+		assignProperty(anchor, last, value);
+	} else {
+		assignProperty(anchor, last, value);
+	}
 }
 
 /**
@@ -366,16 +379,16 @@ function setValueViaPath(subject, path, value) {
  * @param {*} value
  */
 function assignProperty(object, key, value) {
-    if (!object.hasOwnProperty(key)) {
-        object[key] = value;
-        return;
-    }
+	if (!object.hasOwnProperty(key)) {
+		object[key] = value;
+		return;
+	}
 
-    if (value === undefined) {
-        delete object[key];
-    }
+	if (value === undefined) {
+		delete object[key];
+	}
 
-    object[key] = value;
+	object[key] = value;
 }
 
 /**
@@ -392,40 +405,40 @@ function assignProperty(object, key, value) {
  * @private
  */
 function deleteValueViaPath(subject, path) {
-    if (!(isArray(path) || isString(path))) {
-        throw new Error("type error: path must be a string or an array");
-    }
-
-    let parts;
-    if (isArray(path)) {
-        if (path.length === 0) {
-            return subject;
-        }
-
-        parts = path;
-    } else {
-        parts = path.split(DELIMITER);
-    }
-
-    let last = parts.pop();
-    const subpath = parts.join(DELIMITER);
-
-    const anchor = getValueViaPath.call(this, subject, subpath);
-
-    if (anchor instanceof Map) {
-        anchor.delete(last);
-    } else if (
-        anchor instanceof Set ||
-        anchor instanceof WeakMap ||
-        anchor instanceof WeakSet ||
-        (typeof WeakRef === "function" && anchor instanceof WeakRef)
-    ) {
-        throw Error("unsupported action for this data type");
-    } else if (isArray(anchor)) {
-        last = parseInt(last);
-        validateInteger(last);
-        delete anchor[last];
-    } else {
-        delete anchor[last];
-    }
+	if (!(isArray(path) || isString(path))) {
+		throw new Error("type error: path must be a string or an array");
+	}
+
+	let parts;
+	if (isArray(path)) {
+		if (path.length === 0) {
+			return subject;
+		}
+
+		parts = path;
+	} else {
+		parts = path.split(DELIMITER);
+	}
+
+	let last = parts.pop();
+	const subpath = parts.join(DELIMITER);
+
+	const anchor = getValueViaPath.call(this, subject, subpath);
+
+	if (anchor instanceof Map) {
+		anchor.delete(last);
+	} else if (
+		anchor instanceof Set ||
+		anchor instanceof WeakMap ||
+		anchor instanceof WeakSet ||
+		(typeof WeakRef === "function" && anchor instanceof WeakRef)
+	) {
+		throw Error("unsupported action for this data type");
+	} else if (isArray(anchor)) {
+		last = parseInt(last);
+		validateInteger(last);
+		delete anchor[last];
+	} else {
+		delete anchor[last];
+	}
 }