@aitianyu.cn/types 0.0.1 → 0.0.2

package/dist/lib/index.js

@@ -1,7 +1,8 @@
 "use strict";
 /**@format */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hash = exports.guid = exports.Performance = exports.Log = exports.parseAreaString = exports.parseAreaCode = exports.ArgumentNullOrEmptyException = exports.EncryptOption = exports.LogLevel = exports.Exception = exports.AreaCode = void 0;
+exports.hash = exports.guid = exports.ObjectHelper = exports.Performance = exports.Log = exports.parseAreaString = exports.parseAreaCode = exports.ObjectCloneFunctionNotSupportException = exports.ArgumentNullOrEmptyException = exports.PathProcessor = exports.PathDirectoryValidationFailException = exports.PathProcessorSourceLostException = exports.EncryptOption = exports.LogLevel = exports.Exception = exports.AreaCode = void 0;
+// src/types
 var AreaCode_1 = require("./types/AreaCode");
 Object.defineProperty(exports, "AreaCode", { enumerable: true, get: function () { return AreaCode_1.AreaCode; } });
 var Exception_1 = require("./types/Exception");
@@ -10,14 +11,26 @@ var Logs_1 = require("./types/Logs");
 Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return Logs_1.LogLevel; } });
 var Security_1 = require("./types/Security");
 Object.defineProperty(exports, "EncryptOption", { enumerable: true, get: function () { return Security_1.EncryptOption; } });
+// utilities
+// coding
+var Error_1 = require("./utilities/coding/Error");
+Object.defineProperty(exports, "PathProcessorSourceLostException", { enumerable: true, get: function () { return Error_1.PathProcessorSourceLostException; } });
+Object.defineProperty(exports, "PathDirectoryValidationFailException", { enumerable: true, get: function () { return Error_1.PathDirectoryValidationFailException; } });
+var PathProcessor_1 = require("./utilities/coding/PathProcessor");
+Object.defineProperty(exports, "PathProcessor", { enumerable: true, get: function () { return PathProcessor_1.PathProcessor; } });
+// core
 var Errors_1 = require("./utilities/core/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; } });
 var Language_1 = require("./utilities/core/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("./utilities/core/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; } });
+var ObjectHelper_1 = require("./utilities/core/ObjectHelper");
+Object.defineProperty(exports, "ObjectHelper", { enumerable: true, get: function () { return ObjectHelper_1.ObjectHelper; } });
+// security
 var Guid_1 = require("./utilities/security/Guid");
 Object.defineProperty(exports, "guid", { enumerable: true, get: function () { return Guid_1.guid; } });
 var Hash_1 = require("./utilities/security/Hash");

package/dist/lib/types/Coding.js

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

package/dist/lib/utilities/coding/Error.js

@@ -0,0 +1,23 @@
+"use strict";
+/**@format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathDirectoryValidationFailException = exports.PathProcessorSourceLostException = void 0;
+const Exception_1 = require("../../types/Exception");
+class PathProcessorSourceLostException extends Exception_1.Exception {
+    constructor(msg) {
+        super(msg);
+    }
+    toString() {
+        return `路径处理器 - 指定的参数 ( path.file ) 为空`;
+    }
+}
+exports.PathProcessorSourceLostException = PathProcessorSourceLostException;
+class PathDirectoryValidationFailException extends Exception_1.Exception {
+    constructor(msg) {
+        super(msg);
+    }
+    toString() {
+        return `路径处理器 - 指定的路径目录 ( ${this.message} ) 无效`;
+    }
+}
+exports.PathDirectoryValidationFailException = PathDirectoryValidationFailException;

package/dist/lib/utilities/coding/PathProcessor.js

@@ -0,0 +1,108 @@
+"use strict";
+/**@format */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathProcessor = void 0;
+const Error_1 = require("./Error");
+const __charInDirValidation = {
+    "/": { file: false, dir: false },
+    ".": { file: true, dir: false },
+};
+function _dirNameChecker(dir) {
+    if (!dir)
+        return "drop";
+    for (const ch of dir) {
+        const validation = __charInDirValidation[ch];
+        if (validation && !validation.dir) {
+            return "invalid";
+        }
+    }
+    return "valid";
+}
+function _dirFileTypeChecker(src) {
+    if (!src)
+        return "drop";
+    let dirType = false;
+    let fileType = false;
+    for (const char of src) {
+        const validation = __charInDirValidation[char];
+        if (dirType) {
+            if (validation && !validation.dir)
+                return "invalid";
+        }
+        else if (fileType) {
+            if (validation && !validation.file)
+                return "invalid";
+        }
+        else {
+            if (validation) {
+                if (validation.dir && !validation.file)
+                    dirType = true;
+                else if (!validation.dir && validation.file)
+                    fileType = true;
+                else if (!validation.dir && !validation.file)
+                    return "invalid";
+            }
+        }
+    }
+    if ((!dirType && !fileType) || dirType)
+        return "directory";
+    else
+        return "file";
+}
+class PathProcessor {
+    static parsePathFromString(src) {
+        const path = { dirs: [], type: "directory" };
+        if (!src) {
+            return path;
+        }
+        const srcSplit = src.split("/");
+        if (srcSplit.length === 0) {
+            return path;
+        }
+        for (let i = 0; i < srcSplit.length - 1; ++i) {
+            const dir = srcSplit[i];
+            const validation = _dirNameChecker(dir);
+            if (validation === "invalid") {
+                throw new Error_1.PathDirectoryValidationFailException(dir);
+            }
+            if (validation === "valid") {
+                path.dirs.push(dir);
+            }
+        }
+        const lastDir = srcSplit[srcSplit.length - 1];
+        const dirType = _dirFileTypeChecker(lastDir);
+        if (dirType === "directory") {
+            path.dirs.push(lastDir);
+        }
+        else if (dirType === "file") {
+            path.file = lastDir;
+            path.type = "file";
+        }
+        return path;
+    }
+    static formatPathToString(path) {
+        if (path.type === "file" && !!!path.file) {
+            throw new Error_1.PathProcessorSourceLostException();
+        }
+        if (path.dirs.length === 0 && !!!path.file) {
+            return "";
+        }
+        const dirs = [];
+        for (const dirItem of path.dirs) {
+            const validation = _dirNameChecker(dirItem);
+            if (validation === "invalid") {
+                throw new Error_1.PathDirectoryValidationFailException(dirItem);
+            }
+            if (validation === "valid") {
+                dirs.push(dirItem);
+            }
+        }
+        if (!!path.file)
+            dirs.push(path.file);
+        if (dirs.length === 0) {
+            return "";
+        }
+        return dirs.join("/");
+    }
+}
+exports.PathProcessor = PathProcessor;

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

@@ -1,7 +1,7 @@
 "use strict";
 /**@format */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArgumentNullOrEmptyException = void 0;
+exports.ObjectCloneFunctionNotSupportException = exports.ArgumentNullOrEmptyException = void 0;
 const Exception_1 = require("../../types/Exception");
 class ArgumentNullOrEmptyException extends Exception_1.Exception {
     constructor(msg) {
@@ -12,3 +12,12 @@ class ArgumentNullOrEmptyException extends Exception_1.Exception {
     }
 }
 exports.ArgumentNullOrEmptyException = ArgumentNullOrEmptyException;
+class ObjectCloneFunctionNotSupportException extends Exception_1.Exception {
+    constructor() {
+        super();
+    }
+    toString() {
+        return `不支持的类型 - 正在克隆为Function类型不支持`;
+    }
+}
+exports.ObjectCloneFunctionNotSupportException = ObjectCloneFunctionNotSupportException;

package/dist/lib/utilities/core/ObjectHelper.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/types/index.d.ts

@@ -1,11 +1,15 @@
 /**@format */
 export { AreaCode } from "./types/AreaCode";
+export { type PathTargetType, type IPath } from "./types/Coding";
 export { Exception } from "./types/Exception";
 export { LogLevel, type ILog, type IPerfRecorder } from "./types/Logs";
 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 { PathProcessorSourceLostException, PathDirectoryValidationFailException } from "./utilities/coding/Error";
+export { PathProcessor } from "./utilities/coding/PathProcessor";
+export { ArgumentNullOrEmptyException, ObjectCloneFunctionNotSupportException } from "./utilities/core/Errors";
 export { parseAreaCode, parseAreaString } from "./utilities/core/Language";
 export { Log, Performance } from "./utilities/core/Log";
+export { ObjectHelper } from "./utilities/core/ObjectHelper";
 export { guid } from "./utilities/security/Guid";
 export { hash } from "./utilities/security/Hash";

package/dist/types/types/Coding.d.ts

@@ -0,0 +1,7 @@
+/**@format */
+export type PathTargetType = "directory" | "file";
+export interface IPath {
+    type: PathTargetType;
+    dirs: string[];
+    file?: string;
+}

package/dist/types/utilities/coding/Error.d.ts

@@ -0,0 +1,10 @@
+/**@format */
+import { Exception } from "../../types/Exception";
+export declare class PathProcessorSourceLostException extends Exception {
+    constructor(msg?: string);
+    toString(): string;
+}
+export declare class PathDirectoryValidationFailException extends Exception {
+    constructor(msg?: string);
+    toString(): string;
+}

package/dist/types/utilities/coding/PathProcessor.d.ts

@@ -0,0 +1,6 @@
+/**@format */
+import { IPath } from "../../types/Coding";
+export declare class PathProcessor {
+    static parsePathFromString(src: string): IPath;
+    static formatPathToString(path: IPath): string;
+}

package/dist/types/utilities/core/Errors.d.ts

@@ -4,3 +4,7 @@ export declare class ArgumentNullOrEmptyException extends Exception {
     constructor(msg: string);
     toString(): string;
 }
+export declare class ObjectCloneFunctionNotSupportException extends Exception {
+    constructor();
+    toString(): string;
+}

package/dist/types/utilities/core/ObjectHelper.d.ts

@@ -0,0 +1,39 @@
+/**@format */
+/** Object Helper of Tianyu to provide data type checking, objects comparing, validation, data clone and other functions */
+export declare 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: any): boolean;
+    /**
+     * 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: any): any;
+    private static _clone;
+    private static _cloneArray;
+    private static _cloneRecordType;
+    /**
+     * Check the object whether can be stringified
+     *
+     * @param obj be checked object
+     * @returns return true is valid, otherwise false
+     */
+    static validateSerializable(obj: any): boolean;
+    /**
+     * 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: any): "same" | "different";
+    private static _compareSimpleType;
+    private static _compareArrayType;
+    private static _compareObjectType;
+}

package/package.json

@@ -1,8 +1,8 @@
 {
     "name": "@aitianyu.cn/types",
-    "version": "0.0.1",
+    "version": "0.0.2",
     "private": false,
-    "description": "Basic components for aitianyu nodejs server",
+    "description": "Common modules (types, functions, classes) for aitianyu",
     "main": "./dist/lib/index.js",
     "types": "./dist/types/index.d.ts",
     "exports": {
@@ -12,6 +12,11 @@
         "dist"
     ],
     "type": "commonjs",
+    "keywords": [
+        "aitianyu.cn",
+        "base type",
+        "common lib"
+    ],
     "scripts": {
         "start": "ts-node packages/index.ts",
         "build": "npm run before-build && npm run compiler && npm run copy-lib && npm run copy-types && npm run after-build",