@aitianyu.cn/types 0.0.11 → 0.0.13

package/dist/lib/utilities/core/object/Calculater.js

@@ -1,230 +1,230 @@
-"use strict";
-/**@format */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectCalculater = void 0;
-const TMap_1 = require("../../../types/TMap");
-const PathBase_1 = require("../../../types/PathBase");
-const Helper_1 = require("./Helper");
-const Errors_1 = require("../Errors");
-class ObjectDiffCalculation {
-    preObj;
-    nextObj;
-    objStack;
-    diffs;
-    constructor(pre, next) {
-        this.preObj = pre;
-        this.nextObj = next;
-        this.objStack = [];
-        this.diffs = new TMap_1.TMap();
-    }
-    calculate() {
-        this._calculate(this.preObj, this.nextObj);
-        return this.diffs;
-    }
-    _calculate(pre, next) {
-        const isPreSimple = Helper_1.ObjectHelper.isSimpleDataType(pre);
-        const isNextSimple = Helper_1.ObjectHelper.isSimpleDataType(next);
-        // 如果是基本数据类型
-        if (isPreSimple && isNextSimple) {
-            // 如果数据不相同，则记录
-            if (pre !== next) {
-                const path = new PathBase_1.PathBase(this.objStack);
-                this.diffs.set(path, {
-                    path: path.toString(),
-                    old: Helper_1.ObjectHelper.clone(pre),
-                    new: Helper_1.ObjectHelper.clone(next),
-                });
-            }
-            // 直接返回
-            return;
-        }
-        // 获取新老对象是否为数组类型
-        const isPreArray = Array.isArray(pre);
-        const isNextArray = Array.isArray(next);
-        if (isPreArray || isNextArray) {
-            const path = new PathBase_1.PathBase(this.objStack);
-            if (isPreArray && isNextArray) {
-                // Pre为数组 Next为数组
-                const isSame = Helper_1.ObjectHelper.compareObjects(pre, next);
-                if (isSame === "different") {
-                    this.diffs.set(path, {
-                        path: path.toString(),
-                        old: Helper_1.ObjectHelper.clone(pre),
-                        new: Helper_1.ObjectHelper.clone(next),
-                    });
-                }
-            }
-            else {
-                // Pre或Next为数组，另外一个为object类型
-                // Pre为简单对象 & Next为数组
-                // Pre为数组 & Next为简单对象
-                this.diffs.set(path, {
-                    path: path.toString(),
-                    old: Helper_1.ObjectHelper.clone(pre),
-                    new: Helper_1.ObjectHelper.clone(next),
-                });
-            }
-            return;
-        }
-        // 新老对象都是Object类型，按照Object类型进行比对
-        this._calculateObject(pre, next);
-    }
-    _calculateObject(pre, next) {
-        const preKeys = Object.keys(pre);
-        const nextKeys = Object.keys(next);
-        const sameItems = [];
-        // 寻找已经删除的
-        for (const key of preKeys) {
-            if (nextKeys.includes(key)) {
-                sameItems.push(key);
-            }
-            else {
-                // 已经被删除的对象，储存下来
-                this.objStack.push(key);
-                const path = new PathBase_1.PathBase(this.objStack);
-                this.diffs.set(path, {
-                    path: path.toString(),
-                    old: Helper_1.ObjectHelper.clone(pre[key]),
-                    new: undefined,
-                    deleted: true,
-                });
-                this.objStack.pop();
-            }
-        }
-        // 寻找新加的元素
-        for (const key of nextKeys) {
-            if (!preKeys.includes(key)) {
-                // 老的对象中不存在，新加的状态储存下来
-                this.objStack.push(key);
-                const path = new PathBase_1.PathBase(this.objStack);
-                this.diffs.set(path, {
-                    path: path.toString(),
-                    old: undefined,
-                    new: Helper_1.ObjectHelper.clone(next[key]),
-                    added: true,
-                });
-                this.objStack.pop();
-            }
-        }
-        // 依次遍历所有相同的元素，判断其是否存在改变
-        for (const key of sameItems) {
-            this.objStack.push(key);
-            this._calculate(pre[key], next[key]);
-            this.objStack.pop();
-        }
-    }
-}
-function __checkOldAndNewStatus(pre, next) {
-    return Helper_1.ObjectHelper.compareObjects(pre, next) === "same";
-}
-/** Object Calculation Manager of Tianyu to provide data changes delta calculation and merge */
-class ObjectCalculater {
-    /**
-     * Compare two objects and get the delta changes between the two objects
-     *
-     * @param previous the previous object
-     * @param newest the newest object
-     * @returns return the defferents map
-     */
-    static calculateDiff(previous, newest) {
-        const calculationEntity = new ObjectDiffCalculation(previous, newest);
-        return calculationEntity.calculate();
-    }
-    /**
-     * Merge the object value status from one to another one following with the object different maps
-     *
-     * @param value the raw value(status)
-     * @param diffs the value changed status map array, contains multiply status maps and the status merge will be one by one.
-     * @param strict a boolean value used to whether the program needs a strict status check to avoid some data errors
-     * @returns return a new value status
-     */
-    static mergeDiff(value, diffs, strict) {
-        const resultObj = { root: Helper_1.ObjectHelper.clone(value) };
-        if (0 === diffs.length) {
-            return resultObj.root;
-        }
-        for (const diff of diffs) {
-            const rootPathDiff = diff.get(new PathBase_1.PathBase([]));
-            if (rootPathDiff) {
-                if (strict && diff.size() > 1) {
-                    throw new Errors_1.ObjectDiffApplyInvalidStatusException(resultObj.root);
-                }
-                if (strict && !__checkOldAndNewStatus(resultObj.root, rootPathDiff.old)) {
-                    throw new Errors_1.ObjectMergeStatusCheckFailedException("", rootPathDiff.deleted ? "del" : rootPathDiff.added ? "add" : "modify");
-                }
-                // 直接设置新值
-                resultObj.root = Helper_1.ObjectHelper.clone(rootPathDiff.new);
-                // 原始值为简单数据类型 或 数组类型 需要根目录修改
-            }
-            else if (Helper_1.ObjectHelper.isSimpleDataType(resultObj.root) || Array.isArray(resultObj.root)) {
-                throw new Errors_1.ObjectDiffApplyInvalidStatusException(resultObj.root);
-            }
-            else {
-                // 没有根目录修改
-                // 并且对象不是简单类型
-                // 按照复杂值递归进行更改
-                // 依次遍历所有的路径
-                for (const [path, info] of diff) {
-                    // 此处不应该进入条件
-                    if (!!!path || !!!info)
-                        continue;
-                    // 获取路径并预处理
-                    const pathDir = path.getDirs();
-                    const endDir = pathDir.pop();
-                    // 此处不应该进入条件
-                    if (!!!endDir)
-                        continue;
-                    const mergeType = info.added ? "add" : info.deleted ? "del" : "modify";
-                    // 依次查询元素路径
-                    // 检查父元素是否不存在（error）
-                    let obj = resultObj.root;
-                    for (const key of pathDir) {
-                        if (!!!obj[key]) {
-                            // 如果父对象不存在 在严格模式下抛出异常
-                            if (strict) {
-                                throw new Errors_1.ObjectMergeStatusCheckFailedException(info.path, mergeType);
-                            }
-                            else {
-                                obj[key] = {};
-                            }
-                        }
-                        // 目标点向下移动
-                        obj = obj[key];
-                    }
-                    // 再次检查对象状态 （理论上不应该进入此判断）
-                    if (!!!obj)
-                        throw new Errors_1.ObjectDiffMergeFailedException(info.path);
-                    if (info.added) {
-                        // 新增一个元素
-                        // 严格模式下 不允许新增对象存在
-                        if (strict && obj[endDir]) {
-                            throw new Errors_1.ObjectMergeStatusCheckFailedException(info.path, mergeType);
-                        }
-                        // 执行拷贝
-                        obj[endDir] = Helper_1.ObjectHelper.clone(info.new);
-                    }
-                    else if (info.deleted) {
-                        // 删除一个元素
-                        // 严格模式下 不允许删除对象不存在
-                        if (strict && !!!obj[endDir]) {
-                            throw new Errors_1.ObjectMergeStatusCheckFailedException(info.path, mergeType);
-                        }
-                        // 执行删除（如果对象存在）
-                        !!obj[endDir] && delete obj[endDir];
-                    }
-                    else {
-                        // 修改一个元素
-                        // 严格模式下 不允许修改对象不存在
-                        if (strict && (!!!obj[endDir] || __checkOldAndNewStatus(info.old, obj[endDir]))) {
-                            throw new Errors_1.ObjectMergeStatusCheckFailedException(info.path, mergeType);
-                        }
-                        // 执行修改
-                        obj[endDir] = Helper_1.ObjectHelper.clone(info.new);
-                    }
-                }
-            }
-        }
-        return resultObj.root;
-    }
-}
-exports.ObjectCalculater = ObjectCalculater;
+"use strict";
+/**@format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectCalculater = void 0;
+const TMap_1 = require("../../../types/TMap");
+const PathBase_1 = require("../../../types/PathBase");
+const Helper_1 = require("./Helper");
+const Errors_1 = require("../Errors");
+class ObjectDiffCalculation {
+    preObj;
+    nextObj;
+    objStack;
+    diffs;
+    constructor(pre, next) {
+        this.preObj = pre;
+        this.nextObj = next;
+        this.objStack = [];
+        this.diffs = new TMap_1.TMap();
+    }
+    calculate() {
+        this._calculate(this.preObj, this.nextObj);
+        return this.diffs;
+    }
+    _calculate(pre, next) {
+        const isPreSimple = Helper_1.ObjectHelper.isSimpleDataType(pre);
+        const isNextSimple = Helper_1.ObjectHelper.isSimpleDataType(next);
+        // 如果是基本数据类型
+        if (isPreSimple && isNextSimple) {
+            // 如果数据不相同，则记录
+            if (pre !== next) {
+                const path = new PathBase_1.PathBase(this.objStack);
+                this.diffs.set(path, {
+                    path: path.toString(),
+                    old: Helper_1.ObjectHelper.clone(pre),
+                    new: Helper_1.ObjectHelper.clone(next),
+                });
+            }
+            // 直接返回
+            return;
+        }
+        // 获取新老对象是否为数组类型
+        const isPreArray = Array.isArray(pre);
+        const isNextArray = Array.isArray(next);
+        if (isPreArray || isNextArray) {
+            const path = new PathBase_1.PathBase(this.objStack);
+            if (isPreArray && isNextArray) {
+                // Pre为数组 Next为数组
+                const isSame = Helper_1.ObjectHelper.compareObjects(pre, next);
+                if (isSame === "different") {
+                    this.diffs.set(path, {
+                        path: path.toString(),
+                        old: Helper_1.ObjectHelper.clone(pre),
+                        new: Helper_1.ObjectHelper.clone(next),
+                    });
+                }
+            }
+            else {
+                // Pre或Next为数组，另外一个为object类型
+                // Pre为简单对象 & Next为数组
+                // Pre为数组 & Next为简单对象
+                this.diffs.set(path, {
+                    path: path.toString(),
+                    old: Helper_1.ObjectHelper.clone(pre),
+                    new: Helper_1.ObjectHelper.clone(next),
+                });
+            }
+            return;
+        }
+        // 新老对象都是Object类型，按照Object类型进行比对
+        this._calculateObject(pre, next);
+    }
+    _calculateObject(pre, next) {
+        const preKeys = Object.keys(pre);
+        const nextKeys = Object.keys(next);
+        const sameItems = [];
+        // 寻找已经删除的
+        for (const key of preKeys) {
+            if (nextKeys.includes(key)) {
+                sameItems.push(key);
+            }
+            else {
+                // 已经被删除的对象，储存下来
+                this.objStack.push(key);
+                const path = new PathBase_1.PathBase(this.objStack);
+                this.diffs.set(path, {
+                    path: path.toString(),
+                    old: Helper_1.ObjectHelper.clone(pre[key]),
+                    new: undefined,
+                    deleted: true,
+                });
+                this.objStack.pop();
+            }
+        }
+        // 寻找新加的元素
+        for (const key of nextKeys) {
+            if (!preKeys.includes(key)) {
+                // 老的对象中不存在，新加的状态储存下来
+                this.objStack.push(key);
+                const path = new PathBase_1.PathBase(this.objStack);
+                this.diffs.set(path, {
+                    path: path.toString(),
+                    old: undefined,
+                    new: Helper_1.ObjectHelper.clone(next[key]),
+                    added: true,
+                });
+                this.objStack.pop();
+            }
+        }
+        // 依次遍历所有相同的元素，判断其是否存在改变
+        for (const key of sameItems) {
+            this.objStack.push(key);
+            this._calculate(pre[key], next[key]);
+            this.objStack.pop();
+        }
+    }
+}
+function __checkOldAndNewStatus(pre, next) {
+    return Helper_1.ObjectHelper.compareObjects(pre, next) === "same";
+}
+/** Object Calculation Manager of Tianyu to provide data changes delta calculation and merge */
+class ObjectCalculater {
+    /**
+     * Compare two objects and get the delta changes between the two objects
+     *
+     * @param previous the previous object
+     * @param newest the newest object
+     * @returns return the defferents map
+     */
+    static calculateDiff(previous, newest) {
+        const calculationEntity = new ObjectDiffCalculation(previous, newest);
+        return calculationEntity.calculate();
+    }
+    /**
+     * Merge the object value status from one to another one following with the object different maps
+     *
+     * @param value the raw value(status)
+     * @param diffs the value changed status map array, contains multiply status maps and the status merge will be one by one.
+     * @param strict a boolean value used to whether the program needs a strict status check to avoid some data errors
+     * @returns return a new value status
+     */
+    static mergeDiff(value, diffs, strict) {
+        const resultObj = { root: Helper_1.ObjectHelper.clone(value) };
+        if (0 === diffs.length) {
+            return resultObj.root;
+        }
+        for (const diff of diffs) {
+            const rootPathDiff = diff.get(new PathBase_1.PathBase([]));
+            if (rootPathDiff) {
+                if (strict && diff.size() > 1) {
+                    throw new Errors_1.ObjectDiffApplyInvalidStatusException(resultObj.root);
+                }
+                if (strict && !__checkOldAndNewStatus(resultObj.root, rootPathDiff.old)) {
+                    throw new Errors_1.ObjectMergeStatusCheckFailedException("", rootPathDiff.deleted ? "del" : rootPathDiff.added ? "add" : "modify");
+                }
+                // 直接设置新值
+                resultObj.root = Helper_1.ObjectHelper.clone(rootPathDiff.new);
+                // 原始值为简单数据类型 或 数组类型 需要根目录修改
+            }
+            else if (Helper_1.ObjectHelper.isSimpleDataType(resultObj.root) || Array.isArray(resultObj.root)) {
+                throw new Errors_1.ObjectDiffApplyInvalidStatusException(resultObj.root);
+            }
+            else {
+                // 没有根目录修改
+                // 并且对象不是简单类型
+                // 按照复杂值递归进行更改
+                // 依次遍历所有的路径
+                for (const [path, info] of diff) {
+                    // 此处不应该进入条件
+                    if (!!!path || !!!info)
+                        continue;
+                    // 获取路径并预处理
+                    const pathDir = path.getDirs();
+                    const endDir = pathDir.pop();
+                    // 此处不应该进入条件
+                    if (!!!endDir)
+                        continue;
+                    const mergeType = info.added ? "add" : info.deleted ? "del" : "modify";
+                    // 依次查询元素路径
+                    // 检查父元素是否不存在（error）
+                    let obj = resultObj.root;
+                    for (const key of pathDir) {
+                        if (!!!obj[key]) {
+                            // 如果父对象不存在 在严格模式下抛出异常
+                            if (strict) {
+                                throw new Errors_1.ObjectMergeStatusCheckFailedException(info.path, mergeType);
+                            }
+                            else {
+                                obj[key] = {};
+                            }
+                        }
+                        // 目标点向下移动
+                        obj = obj[key];
+                    }
+                    // 再次检查对象状态 （理论上不应该进入此判断）
+                    if (!!!obj)
+                        throw new Errors_1.ObjectDiffMergeFailedException(info.path);
+                    if (info.added) {
+                        // 新增一个元素
+                        // 严格模式下 不允许新增对象存在
+                        if (strict && obj[endDir]) {
+                            throw new Errors_1.ObjectMergeStatusCheckFailedException(info.path, mergeType);
+                        }
+                        // 执行拷贝
+                        obj[endDir] = Helper_1.ObjectHelper.clone(info.new);
+                    }
+                    else if (info.deleted) {
+                        // 删除一个元素
+                        // 严格模式下 不允许删除对象不存在
+                        if (strict && !!!obj[endDir]) {
+                            throw new Errors_1.ObjectMergeStatusCheckFailedException(info.path, mergeType);
+                        }
+                        // 执行删除（如果对象存在）
+                        !!obj[endDir] && delete obj[endDir];
+                    }
+                    else {
+                        // 修改一个元素
+                        // 严格模式下 不允许修改对象不存在
+                        if (strict && (!!!obj[endDir] || __checkOldAndNewStatus(info.old, obj[endDir]))) {
+                            throw new Errors_1.ObjectMergeStatusCheckFailedException(info.path, mergeType);
+                        }
+                        // 执行修改
+                        obj[endDir] = Helper_1.ObjectHelper.clone(info.new);
+                    }
+                }
+            }
+        }
+        return resultObj.root;
+    }
+}
+exports.ObjectCalculater = ObjectCalculater;