@aitianyu.cn/types 0.0.13 → 0.1.0

package/dist/lib/{utilities/core → core}/object/Calculater.js

@@ -1,230 +1,240 @@
-"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 ObjectHelper_1 = require("./ObjectHelper");
+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 = ObjectHelper_1.ObjectHelper.isSimpleDataType(pre);
+        const isNextSimple = ObjectHelper_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: ObjectHelper_1.ObjectHelper.clone(pre),
+                    new: ObjectHelper_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 = ObjectHelper_1.ObjectHelper.compareObjects(pre, next);
+                if (isSame === "different") {
+                    this.diffs.set(path, {
+                        path: path.toString(),
+                        old: ObjectHelper_1.ObjectHelper.clone(pre),
+                        new: ObjectHelper_1.ObjectHelper.clone(next),
+                    });
+                }
+            }
+            else {
+                // Pre或Next为数组，另外一个为object类型
+                // Pre为简单对象 & Next为数组
+                // Pre为数组 & Next为简单对象
+                this.diffs.set(path, {
+                    path: path.toString(),
+                    old: ObjectHelper_1.ObjectHelper.clone(pre),
+                    new: ObjectHelper_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: ObjectHelper_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: ObjectHelper_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 ObjectHelper_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: ObjectHelper_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
+                        ? /* istanbul ignore next */ "del"
+                        : rootPathDiff.added
+                            ? /* istanbul ignore next */ "add"
+                            : "modify");
+                }
+                // 直接设置新值
+                resultObj.root = ObjectHelper_1.ObjectHelper.clone(rootPathDiff.new);
+                // 原始值为简单数据类型 或 数组类型 需要根目录修改
+            }
+            else if (ObjectHelper_1.ObjectHelper.isSimpleDataType(resultObj.root) || Array.isArray(resultObj.root)) {
+                throw new Errors_1.ObjectDiffApplyInvalidStatusException(resultObj.root);
+            }
+            else {
+                // 没有根目录修改
+                // 并且对象不是简单类型
+                // 按照复杂值递归进行更改
+                // 依次遍历所有的路径
+                for (const [path, info] of diff) {
+                    // 此处不应该进入条件
+                    /* istanbul ignore if */
+                    if (!!!path || !!!info) {
+                        continue;
+                    }
+                    // 获取路径并预处理
+                    const pathDir = path.getDirs();
+                    const endDir = pathDir.pop();
+                    // 此处不应该进入条件
+                    /* istanbul ignore if */
+                    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];
+                    }
+                    // 再次检查对象状态 （理论上不应该进入此判断）
+                    /* istanbul ignore if */
+                    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] = ObjectHelper_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] = ObjectHelper_1.ObjectHelper.clone(info.new);
+                    }
+                }
+            }
+        }
+        return resultObj.root;
+    }
+}
+exports.ObjectCalculater = ObjectCalculater;

package/dist/lib/core/object/DataView.js

@@ -0,0 +1,23 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataView = void 0;
+/** DataView Object Type */
+class DataView {
+    /**
+     * Create a new node:DataView from given data buffer
+     *
+     * @param data source data buffer
+     * @returns return node:DataView type equals to given data buffer
+     */
+    static parse(data) {
+        if (data instanceof Int8Array || data instanceof Uint8Array || data instanceof Uint8ClampedArray) {
+            return new globalThis.DataView(data.buffer, data.byteOffset, data.byteLength);
+        }
+        if (data instanceof ArrayBuffer) {
+            return new globalThis.DataView(data);
+        }
+        throw new Error("Expected `data` to be an ArrayBuffer, Buffer, Int8Array, Uint8Array or Uint8ClampedArray");
+    }
+}
+exports.DataView = DataView;

package/dist/lib/core/object/Integer.js

@@ -0,0 +1,117 @@
+"use strict";
+/** @format */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Integer = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+/** Integer Object Type */
+class Integer {
+    /**
+     * Get a random integer between min value and max value.
+     * min value should greater than 0, max value should less than 2^48-1 (281474976710655)
+     *
+     * @param min the min value (0 will be applied when not given)
+     * @param max the max value (281474976710655 will be applied when not given)
+     * @returns return the random value
+     */
+    static random(min, max) {
+        const minNum = Math.max(min ?? 0, 0);
+        const maxNum = Math.max(max ?? 281474976710655, minNum + 1);
+        return crypto_1.default.randomInt(Math.min(minNum, maxNum), Math.max(minNum, maxNum));
+    }
+    /**
+     * convert source number to be a 8-byte array
+     *
+     * @param srcValue source value
+     * @returns return a 8-byte array
+     */
+    static toBytes(srcValue) {
+        const bytes = [];
+        let num = srcValue;
+        for (let i = 7; i >= 0; --i) {
+            bytes[i] = Integer.and(num, 255);
+            num = Integer.right(num, 8);
+        }
+        return bytes;
+    }
+    /**
+     * number left shift
+     * times will be calculated to get the end 6-bit at the beginning to avoid over-flow
+     *
+     * @param value source value
+     * @param times left shift steps
+     * @returns return result value
+     */
+    static left(value, times) {
+        // eslint-disable-next-line no-bitwise
+        return value << (times & 0x3f);
+    }
+    /**
+     * number right shift
+     * times will be calculated to get the end 6-bit at the beginning to avoid over-flow
+     *
+     * @param value source value
+     * @param times right shift steps
+     * @returns return result value
+     */
+    static right(value, times) {
+        // eslint-disable-next-line no-bitwise
+        return value >> (times & 0x3f);
+    }
+    /**
+     * number unsigned right shift
+     * times will be calculated to get the end 6-bit at the beginning to avoid over-flow
+     *
+     * @param value source value
+     * @param times right shift steps
+     * @returns return result value
+     */
+    static rightUnsigned(value, times) {
+        // eslint-disable-next-line no-bitwise
+        return value >>> (times & 0x3f);
+    }
+    /**
+     * or
+     *
+     * @param value1 the first value
+     * @param values the following values array
+     * @returns return calculated value
+     */
+    static or(value1, ...values) {
+        let value = value1;
+        for (const i of values) {
+            // eslint-disable-next-line no-bitwise
+            value |= i;
+        }
+        return value;
+    }
+    /**
+     * and
+     *
+     * @param value1 the first value
+     * @param values the following values array
+     * @returns return calculated value
+     */
+    static and(value1, ...values) {
+        let value = value1;
+        for (const i of values) {
+            // eslint-disable-next-line no-bitwise
+            value &= i;
+        }
+        return value;
+    }
+    /**
+     * xor
+     *
+     * @param value1 the first value
+     * @param value2 the second value
+     * @returns return calculated value
+     */
+    static xor(value1, value2) {
+        // eslint-disable-next-line no-bitwise
+        return value1 ^ value2;
+    }
+}
+exports.Integer = Integer;

package/dist/lib/core/object/Json.js

@@ -0,0 +1,35 @@
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Json = void 0;
+/** Json Lib */
+class Json {
+    /**
+     * @deprecated
+     *
+     * convert a string to be a javascript object.
+     * This is an unsafe function to convert a string to be object. suggest to use parseSafe to convert string to object.
+     *
+     * @param src source string
+     * @returns target js-object
+     */
+    static parse(src) {
+        return JSON.parse(src);
+    }
+    /**
+     * convert a string to be a javascript object safty
+     *
+     * @param src source string
+     * @param failed value returned when converted failed, default is null
+     * @returns target js-object
+     */
+    static parseSafe(src, failed = null) {
+        try {
+            return JSON.parse(src);
+        }
+        catch {
+            return failed;
+        }
+    }
+}
+exports.Json = Json;