@aitianyu.cn/types 0.0.12 → 0.1.0

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

@@ -1,201 +1,202 @@
-"use strict";
-/**@format */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectHelper = void 0;
-const Errors_1 = require("../Errors");
-/** Object Helper of Tianyu to provide data type checking, objects comparing, validation, data clone and other functions */
-class ObjectHelper {
-    /**
-     * check whether the specified value does extend from nodejs native type
-     *
-     * @param {any} value supported value type of tianyu store
-     * @returns {boolean} return true if the value is based on type number, string, boolean, function, otherwise false
-     */
-    static isSimpleDataType(value) {
-        if (!!!value)
-            return true;
-        const typeofValue = typeof value;
-        return typeofValue === "boolean" || typeofValue === "string" || typeofValue === "number" || typeofValue === "symbol";
-    }
-    /**
-     * get a deep copy from source
-     *
-     * @param {any} sources the specified source value
-     * @returns {any} return a new value that is independent from sources
-     */
-    static clone(source) {
-        return ObjectHelper._clone(source);
-    }
-    static _clone(source) {
-        if (typeof source === "function") {
-            throw new Errors_1.ObjectCloneFunctionNotSupportException();
-        }
-        // check if source is simple data type, return directly
-        if (ObjectHelper.isSimpleDataType(source)) {
-            return source;
-        }
-        if (Array.isArray(source)) {
-            // if is array type
-            return ObjectHelper._cloneArray(source);
-        }
-        // otherwise, source value is a record type
-        return ObjectHelper._cloneRecordType(source);
-    }
-    static _cloneArray(source) {
-        // create a new array to save result
-        const result = [];
-        if (0 === source.length) {
-            // if source value is empty array, return directly
-            return result;
-        }
-        // loop all the item in the source value and to clone the item
-        for (const item of source) {
-            result.push(ObjectHelper._clone(item));
-        }
-        return result;
-    }
-    static _cloneRecordType(source) {
-        // get all the record key from source object
-        const keys = Object.keys(source);
-        if (0 === keys.length) {
-            // if the object is empty, return an empty object
-            return {};
-        }
-        const result = {};
-        // loop all the items in the source object by the key name
-        for (const keyName of keys) {
-            const sourceItem = source[keyName];
-            result[keyName] = ObjectHelper._clone(sourceItem);
-        }
-        return result;
-    }
-    /**
-     * Check the object whether can be stringified
-     *
-     * @param obj be checked object
-     * @returns return true is valid, otherwise false
-     */
-    static validateSerializable(obj) {
-        // if type is function, is not invaliable to be string
-        if (typeof obj === "function") {
-            return false;
-        }
-        // if is simple data type, is valiable
-        if (ObjectHelper.isSimpleDataType(obj)) {
-            return true;
-        }
-        // if is array, check member
-        if (Array.isArray(obj)) {
-            for (const item of obj) {
-                // contains invalid member, return false
-                if (!ObjectHelper.validateSerializable(item)) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        try {
-            // if is object, check member
-            const keys = Object.keys(obj);
-            for (const keyName of keys) {
-                const item = obj[keyName];
-                // contains invalid member, return false
-                if (!ObjectHelper.validateSerializable(item)) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        catch {
-            // if the object is not an object type, return false
-            return false;
-        }
-    }
-    /**
-     * Compare two or more objects are the same or different
-     *
-     * @param objs the objects which need to be compared
-     * @returns same - if all the objects are same, different - if at least one object is not same to other objects
-     * @description if there are only one parameter or no parameter is provided, same result will be returned
-     */
-    static compareObjects(...objs) {
-        // if objs less than 2, is not comparable
-        if (objs.length < 2) {
-            return "same";
-        }
-        // if the first obj is simple data type, return different if other objects is not simple obj
-        // or the type is not totally same.
-        if (ObjectHelper.isSimpleDataType(objs[0])) {
-            return ObjectHelper._compareSimpleType(...objs);
-        }
-        // if the first obj is array type, check all the objects are array and to do the detail checking
-        if (Array.isArray(objs[0])) {
-            return ObjectHelper._compareArrayType(...objs);
-        }
-        return ObjectHelper._compareObjectType(...objs);
-    }
-    static _compareSimpleType(...objs) {
-        const firstObjType = typeof objs[0];
-        for (let i = 1; i < objs.length; ++i) {
-            if (firstObjType !== typeof objs[i] || objs[0] !== objs[i]) {
-                return "different";
-            }
-        }
-        return "same";
-    }
-    static _compareArrayType(...objs) {
-        for (let i = 1; i < objs.length; ++i) {
-            // check the type and array length if the obj is array type
-            if (!Array.isArray(objs[i]) || objs[i].length !== objs[0].length) {
-                return "different";
-            }
-        }
-        // loop each item of the array to have a detail checking
-        for (let j = 0; j < objs[0].length; ++j) {
-            // create a checking array
-            const items = [objs[0][j]];
-            for (let i = 1; i < objs.length; ++i) {
-                // add all the items of the each object which have the same index
-                items.push(objs[i][j]);
-            }
-            const cmpRes = ObjectHelper.compareObjects(...items);
-            if (cmpRes !== "same") {
-                return cmpRes;
-            }
-        }
-        return "same";
-    }
-    static _compareObjectType(...objs) {
-        try {
-            // other cases, the first obj is not simple obj and array, take checking as object
-            // start add all the objects keys
-            const keysOfObjs = [];
-            keysOfObjs.push(Object.keys(objs[0]));
-            // firstly, check the types of other objects
-            for (let i = 1; i < objs.length; ++i) {
-                keysOfObjs.push(Object.keys(objs[i]));
-            }
-            // check the keys are same or different
-            if (ObjectHelper.compareObjects(...keysOfObjs) !== "same") {
-                return "different";
-            }
-            // compare all the items
-            for (const key of keysOfObjs[0]) {
-                const items = [];
-                for (const obj of objs) {
-                    items.push(obj[key]);
-                }
-                // get the items compare result
-                const cmpRes = ObjectHelper.compareObjects(...items);
-                if (cmpRes !== "same") {
-                    return cmpRes;
-                }
-            }
-            return "same";
-        }
-        catch {
-            return "different";
-        }
-    }
-}
-exports.ObjectHelper = ObjectHelper;
+"use strict";
+/**@format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectHelper = void 0;
+const Errors_1 = require("../Errors");
+/** Object Helper of Tianyu to provide data type checking, objects comparing, validation, data clone and other functions */
+class ObjectHelper {
+    /**
+     * check whether the specified value does extend from nodejs native type
+     *
+     * @param {any} value supported value type of tianyu store
+     * @returns {boolean} return true if the value is based on type number, string, boolean, function, otherwise false
+     */
+    static isSimpleDataType(value) {
+        if (!!!value) {
+            return true;
+        }
+        const typeofValue = typeof value;
+        return typeofValue === "boolean" || typeofValue === "string" || typeofValue === "number" || typeofValue === "symbol";
+    }
+    /**
+     * get a deep copy from source
+     *
+     * @param {any} sources the specified source value
+     * @returns {any} return a new value that is independent from sources
+     */
+    static clone(source) {
+        return ObjectHelper._clone(source);
+    }
+    static _clone(source) {
+        if (typeof source === "function") {
+            throw new Errors_1.ObjectCloneFunctionNotSupportException();
+        }
+        // check if source is simple data type, return directly
+        if (ObjectHelper.isSimpleDataType(source)) {
+            return source;
+        }
+        if (Array.isArray(source)) {
+            // if is array type
+            return ObjectHelper._cloneArray(source);
+        }
+        // otherwise, source value is a record type
+        return ObjectHelper._cloneRecordType(source);
+    }
+    static _cloneArray(source) {
+        // create a new array to save result
+        const result = [];
+        if (0 === source.length) {
+            // if source value is empty array, return directly
+            return result;
+        }
+        // loop all the item in the source value and to clone the item
+        for (const item of source) {
+            result.push(ObjectHelper._clone(item));
+        }
+        return result;
+    }
+    static _cloneRecordType(source) {
+        // get all the record key from source object
+        const keys = Object.keys(source);
+        if (0 === keys.length) {
+            // if the object is empty, return an empty object
+            return {};
+        }
+        const result = {};
+        // loop all the items in the source object by the key name
+        for (const keyName of keys) {
+            const sourceItem = source[keyName];
+            result[keyName] = ObjectHelper._clone(sourceItem);
+        }
+        return result;
+    }
+    /**
+     * Check the object whether can be stringified
+     *
+     * @param obj be checked object
+     * @returns return true is valid, otherwise false
+     */
+    static validateSerializable(obj) {
+        // if type is function, is not invaliable to be string
+        if (typeof obj === "function") {
+            return false;
+        }
+        // if is simple data type, is valiable
+        if (ObjectHelper.isSimpleDataType(obj)) {
+            return true;
+        }
+        // if is array, check member
+        if (Array.isArray(obj)) {
+            for (const item of obj) {
+                // contains invalid member, return false
+                if (!ObjectHelper.validateSerializable(item)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        try {
+            // if is object, check member
+            const keys = Object.keys(obj);
+            for (const keyName of keys) {
+                const item = obj[keyName];
+                // contains invalid member, return false
+                if (!ObjectHelper.validateSerializable(item)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        catch /* istanbul ignore next */ {
+            // if the object is not an object type, return false
+            return false;
+        }
+    }
+    /**
+     * Compare two or more objects are the same or different
+     *
+     * @param objs the objects which need to be compared
+     * @returns same - if all the objects are same, different - if at least one object is not same to other objects
+     * @description if there are only one parameter or no parameter is provided, same result will be returned
+     */
+    static compareObjects(...objs) {
+        // if objs less than 2, is not comparable
+        if (objs.length < 2) {
+            return "same";
+        }
+        // if the first obj is simple data type, return different if other objects is not simple obj
+        // or the type is not totally same.
+        if (ObjectHelper.isSimpleDataType(objs[0])) {
+            return ObjectHelper._compareSimpleType(...objs);
+        }
+        // if the first obj is array type, check all the objects are array and to do the detail checking
+        if (Array.isArray(objs[0])) {
+            return ObjectHelper._compareArrayType(...objs);
+        }
+        return ObjectHelper._compareObjectType(...objs);
+    }
+    static _compareSimpleType(...objs) {
+        const firstObjType = typeof objs[0];
+        for (let i = 1; i < objs.length; ++i) {
+            if (firstObjType !== typeof objs[i] || objs[0] !== objs[i]) {
+                return "different";
+            }
+        }
+        return "same";
+    }
+    static _compareArrayType(...objs) {
+        for (let i = 1; i < objs.length; ++i) {
+            // check the type and array length if the obj is array type
+            if (!Array.isArray(objs[i]) || objs[i].length !== objs[0].length) {
+                return "different";
+            }
+        }
+        // loop each item of the array to have a detail checking
+        for (let j = 0; j < objs[0].length; ++j) {
+            // create a checking array
+            const items = [objs[0][j]];
+            for (let i = 1; i < objs.length; ++i) {
+                // add all the items of the each object which have the same index
+                items.push(objs[i][j]);
+            }
+            const cmpRes = ObjectHelper.compareObjects(...items);
+            if (cmpRes !== "same") {
+                return cmpRes;
+            }
+        }
+        return "same";
+    }
+    static _compareObjectType(...objs) {
+        try {
+            // other cases, the first obj is not simple obj and array, take checking as object
+            // start add all the objects keys
+            const keysOfObjs = [];
+            keysOfObjs.push(Object.keys(objs[0]));
+            // firstly, check the types of other objects
+            for (let i = 1; i < objs.length; ++i) {
+                keysOfObjs.push(Object.keys(objs[i]));
+            }
+            // check the keys are same or different
+            if (ObjectHelper.compareObjects(...keysOfObjs) !== "same") {
+                return "different";
+            }
+            // compare all the items
+            for (const key of keysOfObjs[0]) {
+                const items = [];
+                for (const obj of objs) {
+                    items.push(obj[key]);
+                }
+                // get the items compare result
+                const cmpRes = ObjectHelper.compareObjects(...items);
+                if (cmpRes !== "same") {
+                    return cmpRes;
+                }
+            }
+            return "same";
+        }
+        catch /* istanbul ignore next */ {
+            return "different";
+        }
+    }
+}
+exports.ObjectHelper = ObjectHelper;

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

@@ -0,0 +1,61 @@
+"use strict";
+/**@format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringHelper = void 0;
+class StringHelper {
+    static format(source, args) {
+        if (!args) {
+            return source;
+        }
+        const argument = Array.isArray(args) ? args : [args];
+        return source.replace(/('')|\{([0-9]+(?:\s*,[^{}]*)?)\}|[{}]/g, (_match, $1, $2, _$3) => {
+            if ($1) {
+                return "'";
+            }
+            else if ($2) {
+                return String(argument[parseInt($2, 10)]);
+            }
+            return "";
+        });
+    }
+    /**
+     * @deprecated
+     *
+     * convert an object to be a string.
+     * This is an unsafe function to convert an object to be string. suggest to use stringifySafe to convert object to string.
+     *
+     * @param src source object
+     * @returns target string
+     */
+    static stringify(data) {
+        const type = typeof data;
+        if (type === "undefined") {
+            return "undefined";
+        }
+        if (type === "function") {
+            throw new Error("Could not stringify a 'function' type object");
+        }
+        if (type === "string") {
+            return data;
+        }
+        if (type === "bigint" || type === "number" || type === "symbol" || type === "boolean") {
+            return data.toString();
+        }
+        return JSON.stringify(data);
+    }
+    /**
+     * convert an object to be a string safty. empty string will be return when error occurs in converting
+     *
+     * @param src source object
+     * @returns target string
+     */
+    static stringifySafe(data) {
+        try {
+            return StringHelper.stringify(data);
+        }
+        catch {
+            return "";
+        }
+    }
+}
+exports.StringHelper = StringHelper;

package/dist/lib/{utilities/core → core}/type/TArray.js

@@ -1,7 +1,8 @@
-"use strict";
-/** @format */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TArray = void 0;
-class TArray {
-}
-exports.TArray = TArray;
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TArray = void 0;
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+class TArray {
+}
+exports.TArray = TArray;

package/dist/lib/{utilities/core → core}/type/TBoolean.js

@@ -1,7 +1,7 @@
-"use strict";
-/** @format */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TBoolean = void 0;
-class TBoolean {
-}
-exports.TBoolean = TBoolean;
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TBoolean = void 0;
+class TBoolean {
+}
+exports.TBoolean = TBoolean;

package/dist/lib/{utilities/core → core}/type/TJSON.js

@@ -1,7 +1,7 @@
-"use strict";
-/** @format */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TJSON = void 0;
-class TJSON {
-}
-exports.TJSON = TJSON;
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TJSON = void 0;
+class TJSON {
+}
+exports.TJSON = TJSON;

package/dist/lib/{utilities/core → core}/type/TNumber.js

@@ -1,7 +1,7 @@
-"use strict";
-/** @format */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TNumber = void 0;
-class TNumber {
-}
-exports.TNumber = TNumber;
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TNumber = void 0;
+class TNumber {
+}
+exports.TNumber = TNumber;

package/dist/lib/{utilities/core → core}/type/TObject.js

@@ -1,7 +1,7 @@
-"use strict";
-/** @format */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TObject = void 0;
-class TObject {
-}
-exports.TObject = TObject;
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TObject = void 0;
+class TObject {
+}
+exports.TObject = TObject;

package/dist/lib/{utilities/core → core}/type/TString.js

@@ -1,7 +1,7 @@
-"use strict";
-/** @format */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TString = void 0;
-class TString {
-}
-exports.TString = TString;
+"use strict";
+/** @format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TString = void 0;
+class TString {
+}
+exports.TString = TString;