@schukai/monster 3.51.5 → 3.52.1

package/source/data/diff.mjs

@@ -25,7 +25,7 @@ export { diff };
  * @memberOf Monster.Data
  */
 function diff(first, second) {
-    return doDiff(first, second);
+	return doDiff(first, second);
 }
 
 /**
@@ -36,13 +36,14 @@ function diff(first, second) {
  * @return {Set<string>|Set<number>}
  */
 function getKeys(a, b, type) {
-    if (isArray(type)) {
-        const keys = a.length > b.length ? new Array(a.length) : new Array(b.length);
-        keys.fill(0);
-        return new Set(keys.map((_, i) => i));
-    }
-
-    return new Set(Object.keys(a).concat(Object.keys(b)));
+	if (isArray(type)) {
+		const keys =
+			a.length > b.length ? new Array(a.length) : new Array(b.length);
+		keys.fill(0);
+		return new Set(keys.map((_, i) => i));
+	}
+
+	return new Set(Object.keys(a).concat(Object.keys(b)));
 }
 
 /**
@@ -54,30 +55,30 @@ function getKeys(a, b, type) {
  * @return {array}
  */
 function doDiff(a, b, path, diff) {
-    let typeA = typeOf(a);
-    let typeB = typeOf(b);
-
-    const currPath = path || [];
-    const currDiff = diff || [];
-
-    if (typeA === typeB && (typeA === "object" || typeA === "array")) {
-        getKeys(a, b, typeA).forEach((v) => {
-            if (!Object.prototype.hasOwnProperty.call(a, v)) {
-                currDiff.push(buildResult(a[v], b[v], "add", currPath.concat(v)));
-            } else if (!Object.prototype.hasOwnProperty.call(b, v)) {
-                currDiff.push(buildResult(a[v], b[v], "delete", currPath.concat(v)));
-            } else {
-                doDiff(a[v], b[v], currPath.concat(v), currDiff);
-            }
-        });
-    } else {
-        const o = getOperator(a, b, typeA, typeB);
-        if (o !== undefined) {
-            currDiff.push(buildResult(a, b, o, path));
-        }
-    }
-
-    return currDiff;
+	const typeA = typeOf(a);
+	const typeB = typeOf(b);
+
+	const currPath = path || [];
+	const currDiff = diff || [];
+
+	if (typeA === typeB && (typeA === "object" || typeA === "array")) {
+		getKeys(a, b, typeA).forEach((v) => {
+			if (!Object.prototype.hasOwnProperty.call(a, v)) {
+				currDiff.push(buildResult(a[v], b[v], "add", currPath.concat(v)));
+			} else if (!Object.prototype.hasOwnProperty.call(b, v)) {
+				currDiff.push(buildResult(a[v], b[v], "delete", currPath.concat(v)));
+			} else {
+				doDiff(a[v], b[v], currPath.concat(v), currDiff);
+			}
+		});
+	} else {
+		const o = getOperator(a, b, typeA, typeB);
+		if (o !== undefined) {
+			currDiff.push(buildResult(a, b, o, path));
+		}
+	}
+
+	return currDiff;
 }
 
 /**
@@ -90,40 +91,40 @@ function doDiff(a, b, path, diff) {
  * @private
  */
 function buildResult(a, b, operator, path) {
-    const result = {
-        operator,
-        path,
-    };
-
-    if (operator !== "add") {
-        result.first = {
-            value: a,
-            type: typeof a,
-        };
-
-        if (isObject(a)) {
-            const name = Object.getPrototypeOf(a)?.constructor?.name;
-            if (name !== undefined) {
-                result.first.instance = name;
-            }
-        }
-    }
-
-    if (operator === "add" || operator === "update") {
-        result.second = {
-            value: b,
-            type: typeof b,
-        };
-
-        if (isObject(b)) {
-            const name = Object.getPrototypeOf(b)?.constructor?.name;
-            if (name !== undefined) {
-                result.second.instance = name;
-            }
-        }
-    }
-
-    return result;
+	const result = {
+		operator,
+		path,
+	};
+
+	if (operator !== "add") {
+		result.first = {
+			value: a,
+			type: typeof a,
+		};
+
+		if (isObject(a)) {
+			const name = Object.getPrototypeOf(a)?.constructor?.name;
+			if (name !== undefined) {
+				result.first.instance = name;
+			}
+		}
+	}
+
+	if (operator === "add" || operator === "update") {
+		result.second = {
+			value: b,
+			type: typeof b,
+		};
+
+		if (isObject(b)) {
+			const name = Object.getPrototypeOf(b)?.constructor?.name;
+			if (name !== undefined) {
+				result.second.instance = name;
+			}
+		}
+	}
+
+	return result;
 }
 
 /**
@@ -133,15 +134,15 @@ function buildResult(a, b, operator, path) {
  * @return {boolean}
  */
 function isNotEqual(a, b) {
-    if (typeof a !== typeof b) {
-        return true;
-    }
+	if (typeof a !== typeof b) {
+		return true;
+	}
 
-    if (a instanceof Date && b instanceof Date) {
-        return a.getTime() !== b.getTime();
-    }
+	if (a instanceof Date && b instanceof Date) {
+		return a.getTime() !== b.getTime();
+	}
 
-    return a !== b;
+	return a !== b;
 }
 
 /**
@@ -151,28 +152,28 @@ function isNotEqual(a, b) {
  * @return {string|undefined}
  */
 function getOperator(a, b) {
-    /**
-     * @type {string|undefined}
-     */
-    let operator;
-
-    /**
-     * @type {string}
-     */
-    let typeA = typeof a;
-
-    /**
-     * @type {string}
-     */
-    let typeB = typeof b;
-
-    if (typeA === "undefined" && typeB !== "undefined") {
-        operator = "add";
-    } else if (typeA !== "undefined" && typeB === "undefined") {
-        operator = "delete";
-    } else if (isNotEqual(a, b)) {
-        operator = "update";
-    }
-
-    return operator;
+	/**
+	 * @type {string|undefined}
+	 */
+	let operator;
+
+	/**
+	 * @type {string}
+	 */
+	const typeA = typeof a;
+
+	/**
+	 * @type {string}
+	 */
+	const typeB = typeof b;
+
+	if (typeA === "undefined" && typeB !== "undefined") {
+		operator = "add";
+	} else if (typeA !== "undefined" && typeB === "undefined") {
+		operator = "delete";
+	} else if (isNotEqual(a, b)) {
+		operator = "update";
+	}
+
+	return operator;
 }

package/source/data/extend.mjs

@@ -26,55 +26,55 @@ export { extend };
  * @throws {Error} unsupported argument
  */
 function extend(...args) {
-    let o;
-    let i;
+	let o;
+	let i;
 
-    if (typeof args !== "object" || args[0] === null) {
-        throw new Error(`unsupported argument ${JSON.stringify(args[0])}`);
-    }
+	if (typeof args !== "object" || args[0] === null) {
+		throw new Error(`unsupported argument ${JSON.stringify(args[0])}`);
+	}
 
-    for (i = 0; i < args.length; i++) {
-        let a = args[i];
+	for (i = 0; i < args.length; i++) {
+		const a = args[i];
 
-        if (!(isObject(a) || isArray(a))) {
-            throw new Error(`unsupported argument ${JSON.stringify(a)}`);
-        }
+		if (!(isObject(a) || isArray(a))) {
+			throw new Error(`unsupported argument ${JSON.stringify(a)}`);
+		}
 
-        if (o === undefined) {
-            o = a;
-            continue;
-        }
+		if (o === undefined) {
+			o = a;
+			continue;
+		}
 
-        for (let k in a) {
-            let v = a?.[k];
+		for (const k in a) {
+			const v = a?.[k];
 
-            if (v === o?.[k]) {
-                continue;
-            }
+			if (v === o?.[k]) {
+				continue;
+			}
 
-            if ((isObject(v) && typeOf(v) === "object") || isArray(v)) {
-                if (o[k] === undefined) {
-                    if (isArray(v)) {
-                        o[k] = [];
-                    } else {
-                        o[k] = {};
-                    }
-                } else {
-                    if (typeOf(o[k]) !== typeOf(v)) {
-                        throw new Error(
-                            `type mismatch: ${JSON.stringify(o[k])}(${typeOf(o[k])}) != ${JSON.stringify(v)}(${typeOf(
-                                v,
-                            )})`,
-                        );
-                    }
-                }
+			if ((isObject(v) && typeOf(v) === "object") || isArray(v)) {
+				if (o[k] === undefined) {
+					if (isArray(v)) {
+						o[k] = [];
+					} else {
+						o[k] = {};
+					}
+				} else {
+					if (typeOf(o[k]) !== typeOf(v)) {
+						throw new Error(
+							`type mismatch: ${JSON.stringify(o[k])}(${typeOf(
+								o[k],
+							)}) != ${JSON.stringify(v)}(${typeOf(v)})`,
+						);
+					}
+				}
 
-                o[k] = extend(o[k], v);
-            } else {
-                o[k] = v;
-            }
-        }
-    }
+				o[k] = extend(o[k], v);
+			} else {
+				o[k] = v;
+			}
+		}
+	}
 
-    return o;
+	return o;
 }