@schukai/monster 3.51.5 → 3.52.1

package/source/constraints/abstractoperator.mjs

@@ -24,29 +24,34 @@ export { AbstractOperator };
  * @summary The abstract operator constraint
  */
 class AbstractOperator extends AbstractConstraint {
-    /**
-     *
-     * @param {AbstractConstraint} operantA
-     * @param {AbstractConstraint} operantB
-     * @throws {TypeError} "parameters must be from type AbstractConstraint"
-     */
-    constructor(operantA, operantB) {
-        super();
+	/**
+	 *
+	 * @param {AbstractConstraint} operantA
+	 * @param {AbstractConstraint} operantB
+	 * @throws {TypeError} "parameters must be from type AbstractConstraint"
+	 */
+	constructor(operantA, operantB) {
+		super();
 
-        if (!(operantA instanceof AbstractConstraint && operantB instanceof AbstractConstraint)) {
-            throw new TypeError("parameters must be from type AbstractConstraint");
-        }
+		if (
+			!(
+				operantA instanceof AbstractConstraint &&
+				operantB instanceof AbstractConstraint
+			)
+		) {
+			throw new TypeError("parameters must be from type AbstractConstraint");
+		}
 
-        this.operantA = operantA;
-        this.operantB = operantB;
-    }
+		this.operantA = operantA;
+		this.operantB = operantB;
+	}
 
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 2.1.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/constraints/abstract-operator");
-    }
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 2.1.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/constraints/abstract-operator");
+	}
 }

package/source/constraints/andoperator.mjs

@@ -24,22 +24,25 @@ export { AndOperator };
  * @summary A and operator constraint
  */
 class AndOperator extends AbstractOperator {
-    /**
-     * this method return a promise containing the result of the check.
-     *
-     * @param {*} value
-     * @returns {Promise}
-     */
-    isValid(value) {
-        return Promise.all([this.operantA.isValid(value), this.operantB.isValid(value)]);
-    }
+	/**
+	 * this method return a promise containing the result of the check.
+	 *
+	 * @param {*} value
+	 * @returns {Promise}
+	 */
+	isValid(value) {
+		return Promise.all([
+			this.operantA.isValid(value),
+			this.operantB.isValid(value),
+		]);
+	}
 
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 2.1.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/constraints/and-operator");
-    }
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 2.1.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/constraints/and-operator");
+	}
 }

package/source/constraints/invalid.mjs

@@ -24,22 +24,22 @@ export { Invalid };
  * @summary A constraint that always invalid
  */
 class Invalid extends AbstractConstraint {
-    /**
-     * this method return a rejected promise
-     *
-     * @param {*} value
-     * @returns {Promise}
-     */
-    isValid(value) {
-        return Promise.reject(value);
-    }
+	/**
+	 * this method return a rejected promise
+	 *
+	 * @param {*} value
+	 * @returns {Promise}
+	 */
+	isValid(value) {
+		return Promise.reject(value);
+	}
 
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 2.1.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/constraints/invalid");
-    }
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 2.1.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/constraints/invalid");
+	}
 }

package/source/constraints/isarray.mjs

@@ -23,26 +23,26 @@ export { IsArray };
  * @summary A constraint to check if a value is an array
  */
 class IsArray extends AbstractConstraint {
-    /**
-     * this method return a promise containing the result of the check.
-     *
-     * @param {*} value
-     * @returns {Promise}
-     */
-    isValid(value) {
-        if (isArray(value)) {
-            return Promise.resolve(value);
-        }
+	/**
+	 * this method return a promise containing the result of the check.
+	 *
+	 * @param {*} value
+	 * @returns {Promise}
+	 */
+	isValid(value) {
+		if (isArray(value)) {
+			return Promise.resolve(value);
+		}
 
-        return Promise.reject(value);
-    }
+		return Promise.reject(value);
+	}
 
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 2.1.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/constraint/is-array");
-    }
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 2.1.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/constraint/is-array");
+	}
 }

package/source/constraints/isobject.mjs

@@ -23,26 +23,26 @@ export { IsObject };
  * @summary A constraint to check if a value is an object
  */
 class IsObject extends AbstractConstraint {
-    /**
-     * this method return a promise containing the result of the check.
-     *
-     * @param {*} value
-     * @returns {Promise}
-     */
-    isValid(value) {
-        if (isObject(value)) {
-            return Promise.resolve(value);
-        }
+	/**
+	 * this method return a promise containing the result of the check.
+	 *
+	 * @param {*} value
+	 * @returns {Promise}
+	 */
+	isValid(value) {
+		if (isObject(value)) {
+			return Promise.resolve(value);
+		}
 
-        return Promise.reject(value);
-    }
+		return Promise.reject(value);
+	}
 
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 2.1.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/constraint/is-object");
-    }
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 2.1.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/constraint/is-object");
+	}
 }

package/source/constraints/oroperator.mjs

@@ -24,53 +24,53 @@ export { OrOperator };
  * @summary A or operator
  */
 class OrOperator extends AbstractOperator {
-    /**
-     * this method return a promise containing the result of the check.
-     *
-     * @param {*} value
-     * @returns {Promise}
-     */
-    isValid(value) {
-        var self = this;
+	/**
+	 * this method return a promise containing the result of the check.
+	 *
+	 * @param {*} value
+	 * @returns {Promise}
+	 */
+	isValid(value) {
+		var self = this;
 
-        return new Promise(function (resolve, reject) {
-            let a;
-            let b;
+		return new Promise(function (resolve, reject) {
+			let a;
+			let b;
 
-            self.operantA
-                .isValid(value)
-                .then(function () {
-                    resolve();
-                })
-                .catch(function () {
-                    a = false;
-                    /** b has already been evaluated and was not true */
-                    if (b === false) {
-                        reject();
-                    }
-                });
+			self.operantA
+				.isValid(value)
+				.then(function () {
+					resolve();
+				})
+				.catch(function () {
+					a = false;
+					/** b has already been evaluated and was not true */
+					if (b === false) {
+						reject();
+					}
+				});
 
-            self.operantB
-                .isValid(value)
-                .then(function () {
-                    resolve();
-                })
-                .catch(function () {
-                    b = false;
-                    /** b has already been evaluated and was not true */
-                    if (a === false) {
-                        reject();
-                    }
-                });
-        });
-    }
+			self.operantB
+				.isValid(value)
+				.then(function () {
+					resolve();
+				})
+				.catch(function () {
+					b = false;
+					/** b has already been evaluated and was not true */
+					if (a === false) {
+						reject();
+					}
+				});
+		});
+	}
 
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 2.1.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/constraints/or-operator");
-    }
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 2.1.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/constraints/or-operator");
+	}
 }

package/source/constraints/valid.mjs

@@ -24,22 +24,22 @@ export { Valid };
  * @summary A constraint that always valid
  */
 class Valid extends AbstractConstraint {
-    /**
-     * this method return a promise containing the result of the check.
-     *
-     * @param {*} value
-     * @returns {Promise}
-     */
-    isValid(value) {
-        return Promise.resolve(value);
-    }
+	/**
+	 * this method return a promise containing the result of the check.
+	 *
+	 * @param {*} value
+	 * @returns {Promise}
+	 */
+	isValid(value) {
+		return Promise.resolve(value);
+	}
 
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 2.1.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/constraints/valid");
-    }
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 2.1.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/constraints/valid");
+	}
 }

package/source/data/buildmap.mjs

@@ -40,11 +40,11 @@ const PARENT = "^";
  * @throws {TypeError} - If the selector callback does not return a map.
  **/
 function buildMap(subject, selector, valueTemplate, keyTemplate, filter) {
-    return assembleParts(subject, selector, filter, function (v, k, m) {
-        k = build(v, keyTemplate, k);
-        v = build(v, valueTemplate);
-        this.set(k, v);
-    });
+	return assembleParts(subject, selector, filter, function (v, k, m) {
+		k = build(v, keyTemplate, k);
+		v = build(v, valueTemplate);
+		this.set(k, v);
+	});
 }
 
 /**
@@ -110,34 +110,34 @@ function buildMap(subject, selector, valueTemplate, keyTemplate, filter) {
  * @memberOf Monster.Data
  */
 function assembleParts(subject, selector, filter, callback) {
-    const result = new Map();
-
-    let map;
-    if (isFunction(selector)) {
-        map = selector(subject);
-        if (!(map instanceof Map)) {
-            throw new TypeError("the selector callback must return a map");
-        }
-    } else if (isString(selector)) {
-        map = new Map();
-        buildFlatMap.call(map, subject, selector);
-    } else {
-        throw new TypeError("selector is neither a string nor a function");
-    }
-
-    if (!(map instanceof Map)) {
-        return result;
-    }
-
-    map.forEach((v, k, m) => {
-        if (isFunction(filter)) {
-            if (filter.call(m, v, k) !== true) return;
-        }
-
-        callback.call(result, v, k, m);
-    });
-
-    return result;
+	const result = new Map();
+
+	let map;
+	if (isFunction(selector)) {
+		map = selector(subject);
+		if (!(map instanceof Map)) {
+			throw new TypeError("the selector callback must return a map");
+		}
+	} else if (isString(selector)) {
+		map = new Map();
+		buildFlatMap.call(map, subject, selector);
+	} else {
+		throw new TypeError("selector is neither a string nor a function");
+	}
+
+	if (!(map instanceof Map)) {
+		return result;
+	}
+
+	map.forEach((v, k, m) => {
+		if (isFunction(filter)) {
+			if (filter.call(m, v, k) !== true) return;
+		}
+
+		callback.call(result, v, k, m);
+	});
+
+	return result;
 }
 
 /**
@@ -149,58 +149,63 @@ function assembleParts(subject, selector, filter, callback) {
  * @return {*}
  */
 function buildFlatMap(subject, selector, key, parentMap) {
-    const result = this;
-    const currentMap = new Map();
-
-    const resultLength = result.size;
-
-    if (key === undefined) key = [];
-
-    let parts = selector.split(DELIMITER);
-    let current = "";
-    let currentPath = [];
-    do {
-        current = parts.shift();
-        currentPath.push(current);
-
-        if (current === WILDCARD) {
-            let finder = new Pathfinder(subject);
-            let map;
-
-            try {
-                map = finder.getVia(currentPath.join(DELIMITER));
-            } catch (e) {
-                let a = e;
-                map = new Map();
-            }
-
-            for (const [k, o] of map) {
-                let copyKey = clone(key);
-
-                currentPath.map((a) => {
-                    copyKey.push(a === WILDCARD ? k : a);
-                });
-
-                let kk = copyKey.join(DELIMITER);
-                let sub = buildFlatMap.call(result, o, parts.join(DELIMITER), copyKey, o);
-
-                if (isObject(sub) && parentMap !== undefined) {
-                    sub[PARENT] = parentMap;
-                }
-
-                currentMap.set(kk, sub);
-            }
-        }
-    } while (parts.length > 0);
-
-    // no set in child run
-    if (resultLength === result.size) {
-        for (const [k, o] of currentMap) {
-            result.set(k, o);
-        }
-    }
-
-    return subject;
+	const currentMap = new Map();
+
+	const resultLength = this.size;
+
+	if (key === undefined) key = [];
+
+	const parts = selector.split(DELIMITER);
+	let current = "";
+	const currentPath = [];
+	do {
+		current = parts.shift();
+		currentPath.push(current);
+
+		if (current === WILDCARD) {
+			const finder = new Pathfinder(subject);
+			let map;
+
+			try {
+				map = finder.getVia(currentPath.join(DELIMITER));
+			} catch (e) {
+				const a = e;
+				map = new Map();
+			}
+
+			for (const [k, o] of map) {
+				const copyKey = clone(key);
+
+				currentPath.map((a) => {
+					copyKey.push(a === WILDCARD ? k : a);
+				});
+
+				const kk = copyKey.join(DELIMITER);
+				const sub = buildFlatMap.call(
+					this,
+					o,
+					parts.join(DELIMITER),
+					copyKey,
+					o,
+				);
+
+				if (isObject(sub) && parentMap !== undefined) {
+					sub[PARENT] = parentMap;
+				}
+
+				currentMap.set(kk, sub);
+			}
+		}
+	} while (parts.length > 0);
+
+	// no set in child run
+	if (resultLength === this.size) {
+		for (const [k, o] of currentMap) {
+			this.set(k, o);
+		}
+	}
+
+	return subject;
 }
 
 /**
@@ -354,30 +359,30 @@ function buildFlatMap(subject, selector, key, parentMap) {
  * @return {*}
  */
 function build(subject, definition, defaultValue) {
-    if (definition === undefined) return defaultValue ? defaultValue : subject;
-    validateString(definition);
+	if (definition === undefined) return defaultValue ? defaultValue : subject;
+	validateString(definition);
 
-    const regexp = /(?<placeholder>\${(?<path>[a-z\^A-Z.\-_0-9]*)})/gm;
-    const array = [...definition.matchAll(regexp)];
+	const regexp = /(?<placeholder>\${(?<path>[a-z\^A-Z.\-_0-9]*)})/gm;
+	const array = [...definition.matchAll(regexp)];
 
-    let finder = new Pathfinder(subject);
+	const finder = new Pathfinder(subject);
 
-    if (array.length === 0) {
-        return finder.getVia(definition);
-    }
+	if (array.length === 0) {
+		return finder.getVia(definition);
+	}
 
-    array.forEach((a) => {
-        let groups = a?.["groups"];
-        let placeholder = groups?.["placeholder"];
-        if (placeholder === undefined) return;
+	array.forEach((a) => {
+		const groups = a?.["groups"];
+		const placeholder = groups?.["placeholder"];
+		if (placeholder === undefined) return;
 
-        let path = groups?.["path"];
+		const path = groups?.["path"];
 
-        let v = finder.getVia(path);
-        if (v === undefined) v = defaultValue;
+		let v = finder.getVia(path);
+		if (v === undefined) v = defaultValue;
 
-        definition = definition.replaceAll(placeholder, v);
-    });
+		definition = definition.replaceAll(placeholder, v);
+	});
 
-    return definition;
+	return definition;
 }