@aitianyu.cn/types 0.0.1 → 0.0.3

package/dist/lib/utilities/core/Errors.js

@@ -1,8 +1,9 @@
 "use strict";
 /**@format */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArgumentNullOrEmptyException = void 0;
+exports.ObjectDiffMergeFailedException = exports.ObjectDiffApplyInvalidStatusException = exports.ObjectMergeStatusCheckFailedException = exports.ObjectCloneFunctionNotSupportException = exports.ArgumentNullOrEmptyException = void 0;
 const Exception_1 = require("../../types/Exception");
+/** Argument null exception */
 class ArgumentNullOrEmptyException extends Exception_1.Exception {
     constructor(msg) {
         super(msg);
@@ -12,3 +13,74 @@ class ArgumentNullOrEmptyException extends Exception_1.Exception {
     }
 }
 exports.ArgumentNullOrEmptyException = ArgumentNullOrEmptyException;
+/**
+ * Object Clone:
+ * Function type is not supported.
+ * Exception will be thrown if try to clone a function type object
+ */
+class ObjectCloneFunctionNotSupportException extends Exception_1.Exception {
+    constructor() {
+        super();
+    }
+    toString() {
+        return `不支持的类型 - 正在克隆为Function类型不支持`;
+    }
+}
+exports.ObjectCloneFunctionNotSupportException = ObjectCloneFunctionNotSupportException;
+/**
+ * Object Clone:
+ * Object different status could not be matched.
+ * Exception will be thrown if the object diff could not to be merged
+ */
+class ObjectMergeStatusCheckFailedException extends Exception_1.Exception {
+    status;
+    path;
+    constructor(path, status) {
+        super();
+        this.path = path;
+        this.status = status === "add" ? "新增" : status === "del" ? "删除" : "修改";
+    }
+    toString() {
+        return `错误的合并状态 - ${this.status} 路径 ${this.path} 前后状态不一致`;
+    }
+}
+exports.ObjectMergeStatusCheckFailedException = ObjectMergeStatusCheckFailedException;
+/**
+ * Object Clone:
+ * Object different status could not be applied.
+ * Exception will be thrown if the object diff could not to be applied
+ */
+class ObjectDiffApplyInvalidStatusException extends Exception_1.Exception {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    toString() {
+        let v2s = "";
+        try {
+            v2s = JSON.stringify(this.value);
+        }
+        finally {
+            v2s = v2s || `[${(typeof this.value).toString()}]`;
+        }
+        return `无效的状态 - 值 ${v2s} 不能应用指定的状态`;
+    }
+}
+exports.ObjectDiffApplyInvalidStatusException = ObjectDiffApplyInvalidStatusException;
+/**
+ * Object Clone:
+ * Object different merge failed.
+ * Exception will be thrown if the object element could not be accessed
+ */
+class ObjectDiffMergeFailedException extends Exception_1.Exception {
+    path;
+    constructor(path) {
+        super();
+        this.path = path;
+    }
+    toString() {
+        return `对象合并遇到问题 - 路径 ${this.path} 存在无法访问的对象`;
+    }
+}
+exports.ObjectDiffMergeFailedException = ObjectDiffMergeFailedException;

package/dist/lib/utilities/core/Language.js

@@ -536,10 +536,23 @@ function _areaCodeToString(eArea) {
             return "zh_CN";
     }
 }
+/**
+ * Parse area code to general string
+ *
+ * @param eArea the area code
+ * @returns return the general string of specified area code
+ */
 function parseAreaCode(eArea) {
     return _areaCodeToString(eArea);
 }
 exports.parseAreaCode = parseAreaCode;
+/**
+ * Convert the string to area code
+ *
+ * @param areaStr the source string
+ * @param forceArea a boolean value indicates whether needs to have a strict check for the source string. (That means if in strict mode and the string could not be converted, an unkonwn will be returned.)
+ * @returns return the area code
+ */
 function parseAreaString(areaStr, forceArea) {
     return _parseAreaString(areaStr, forceArea);
 }

package/dist/lib/utilities/core/Log.js

@@ -99,7 +99,9 @@ function _endPerf(recorder, console) {
     }
     return perfTime;
 }
+/** Tianyu Log Instance */
 exports.Log = _log;
+/** Tianyu Performance Instance */
 exports.Performance = {
     startPerf: _startPerf,
     endPerf: _endPerf,

package/dist/lib/utilities/core/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**@format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectHelper = exports.ObjectCalculater = exports.Performance = exports.Log = exports.parseAreaString = exports.parseAreaCode = exports.ObjectDiffMergeFailedException = exports.ObjectDiffApplyInvalidStatusException = exports.ObjectMergeStatusCheckFailedException = exports.ObjectCloneFunctionNotSupportException = exports.ArgumentNullOrEmptyException = void 0;
+var Errors_1 = require("./Errors");
+Object.defineProperty(exports, "ArgumentNullOrEmptyException", { enumerable: true, get: function () { return Errors_1.ArgumentNullOrEmptyException; } });
+Object.defineProperty(exports, "ObjectCloneFunctionNotSupportException", { enumerable: true, get: function () { return Errors_1.ObjectCloneFunctionNotSupportException; } });
+Object.defineProperty(exports, "ObjectMergeStatusCheckFailedException", { enumerable: true, get: function () { return Errors_1.ObjectMergeStatusCheckFailedException; } });
+Object.defineProperty(exports, "ObjectDiffApplyInvalidStatusException", { enumerable: true, get: function () { return Errors_1.ObjectDiffApplyInvalidStatusException; } });
+Object.defineProperty(exports, "ObjectDiffMergeFailedException", { enumerable: true, get: function () { return Errors_1.ObjectDiffMergeFailedException; } });
+var Language_1 = require("./Language");
+Object.defineProperty(exports, "parseAreaCode", { enumerable: true, get: function () { return Language_1.parseAreaCode; } });
+Object.defineProperty(exports, "parseAreaString", { enumerable: true, get: function () { return Language_1.parseAreaString; } });
+var Log_1 = require("./Log");
+Object.defineProperty(exports, "Log", { enumerable: true, get: function () { return Log_1.Log; } });
+Object.defineProperty(exports, "Performance", { enumerable: true, get: function () { return Log_1.Performance; } });
+//// object
+var Calculater_1 = require("./object/Calculater");
+Object.defineProperty(exports, "ObjectCalculater", { enumerable: true, get: function () { return Calculater_1.ObjectCalculater; } });
+var Helper_1 = require("./object/Helper");
+Object.defineProperty(exports, "ObjectHelper", { enumerable: true, get: function () { return Helper_1.ObjectHelper; } });

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

@@ -0,0 +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;

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

@@ -0,0 +1,201 @@
+"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;

package/dist/lib/utilities/security/Guid.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.guid = void 0;
 const perf_hooks_1 = require("perf_hooks");
+/** Generate a Guid value string */
 function guid() {
     let d = new Date().getTime();
     d += perf_hooks_1.performance.now(); //use high-precision timer if available

package/dist/lib/utilities/security/Hash.js

@@ -2,6 +2,7 @@
 /**@format */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hash = void 0;
+/** Generate a hash code number of the string */
 function hash(source) {
     let length = source.length;
     let hashCode = 0;

package/dist/lib/utilities/security/index.js

@@ -0,0 +1,8 @@
+"use strict";
+/**@format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hash = exports.guid = void 0;
+var Guid_1 = require("./Guid");
+Object.defineProperty(exports, "guid", { enumerable: true, get: function () { return Guid_1.guid; } });
+var Hash_1 = require("./Hash");
+Object.defineProperty(exports, "hash", { enumerable: true, get: function () { return Hash_1.hash; } });

package/dist/types/index.d.ts

@@ -2,10 +2,17 @@
 export { AreaCode } from "./types/AreaCode";
 export { Exception } from "./types/Exception";
 export { LogLevel, type ILog, type IPerfRecorder } from "./types/Logs";
+export { type IObjectDiffInfo, type ObjectDiffMap } from "./types/Object";
+export { PathBase } from "./types/PathBase";
 export { EncryptOption, type ICipher } from "./types/Security";
-export { type MapOfBoolean, type MapOfStrings, type MapOfString, type MapOfType, type CallbackAction, type CallbackActionT, } from "./types/Types";
-export { ArgumentNullOrEmptyException } from "./utilities/core/Errors";
+export { TMap } from "./types/TMap";
+export { type MapOfBoolean, type MapOfStrings, type MapOfString, type MapOfType, type CallbackAction, type CallbackActionT, type IComparable, } from "./types/Types";
+export { PathProcessorSourceLostException, PathDirectoryValidationFailException, PathDirAndFileConvertInvaild, } from "./utilities/coding/Error";
+export { type PathTargetType, Path } from "./utilities/coding/Path";
+export { ArgumentNullOrEmptyException, ObjectCloneFunctionNotSupportException, ObjectMergeStatusCheckFailedException, ObjectDiffApplyInvalidStatusException, ObjectDiffMergeFailedException, } from "./utilities/core/Errors";
 export { parseAreaCode, parseAreaString } from "./utilities/core/Language";
 export { Log, Performance } from "./utilities/core/Log";
+export { ObjectCalculater } from "./utilities/core/object/Calculater";
+export { ObjectHelper } from "./utilities/core/object/Helper";
 export { guid } from "./utilities/security/Guid";
 export { hash } from "./utilities/security/Hash";

package/dist/types/types/AreaCode.d.ts

@@ -1,4 +1,5 @@
 /**@format */
+/** International Area name and its code */
 export declare enum AreaCode {
     unknown = 0,
     af_ZA = 1078,

package/dist/types/types/Exception.d.ts

@@ -1,5 +1,11 @@
 /**@format */
+/** Exception base class */
 export declare class Exception extends Error {
     constructor(msg?: string, options?: ErrorOptions);
+    /**
+     * Get a string of the Exception object
+     *
+     * @returns return an error message
+     */
     toString(): string;
 }