@etsoo/shared 1.2.52 → 1.2.54

package/src/DataTypes.ts

@@ -5,801 +5,792 @@
  */
 
 declare global {
-    interface BigInt {
-        toJSON(): String;
-    }
+  interface BigInt {
+    toJSON(): String;
+  }
 }
 
 BigInt.prototype.toJSON = function () {
-    return this.toString() + 'n';
+  return this.toString() + "n";
 };
 
 /**
  * Interface data types
  */
 export namespace DataTypes {
-    /**
-     * Basic types, includes number, bigint, Date, boolean, string
-     */
-    export type Basic = number | bigint | Date | boolean | string;
+  /**
+   * Basic types, includes number, bigint, Date, boolean, string
+   */
+  export type Basic = number | bigint | Date | boolean | string;
+
+  /**
+   * Basic type and basic type array names array
+   */
+  export const BasicArray = [
+    "number",
+    "number[]",
+    "bigint",
+    "bigint[]",
+    "date",
+    "date[]",
+    "boolean",
+    "boolean[]",
+    "string",
+    "string[]",
+    "unknown[]"
+  ] as const;
+
+  /**
+   * Basic type names
+   */
+  export type BasicNames = (typeof BasicArray)[number];
+
+  /**
+   * Basic type template
+   */
+  export type BasicTemplate = { [key: string]: BasicNames };
+
+  /**
+   * Basic template type
+   */
+  export type BasicTemplateType<T extends BasicTemplate> = {
+    [P in keyof T]?: BasicConditional<T[P]>;
+  };
+
+  /**
+   * Basic conditinal type
+   */
+  export type BasicConditional<T extends BasicNames> = T extends "string"
+    ? string
+    : T extends "string[]"
+    ? string[]
+    : T extends "date"
+    ? Date
+    : T extends "date[]"
+    ? Date[]
+    : T extends "boolean"
+    ? boolean
+    : T extends "boolean[]"
+    ? boolean[]
+    : T extends "number"
+    ? number
+    : T extends "number[]"
+    ? number[]
+    : T extends "bigint"
+    ? bigint
+    : T extends "bigint[]"
+    ? bigint[]
+    : unknown[];
+
+  /**
+   * Basic or basic array type
+   */
+  export type Simple = Basic | Array<Basic>;
+
+  /**
+   * Simple type enum
+   */
+  export enum SimpleEnum {
+    Number = 1,
+    Bigint = 2,
+    Date = 3,
+    Boolean = 4,
+    String = 5,
+    Array = 9
+  }
+
+  /**
+   * Simple type names
+   */
+  export type SimpleNames = Lowercase<keyof typeof SimpleEnum>;
+
+  /**
+   * Extended type enum
+   */
+  export enum ExtendedEnum {
+    Unkwown = 0,
+
+    Int = 10,
+    Money = 11,
+    IntMoney = 12,
+    DateTime = 13,
+
+    Email = 21,
+    Phone = 22,
+    URL = 23,
+    Logo = 24
+  }
+
+  /**
+   * Combined type enum
+   */
+  export const CombinedEnum = {
+    ...SimpleEnum,
+    ...ExtendedEnum
+  };
+  export type CombinedEnum = SimpleEnum | ExtendedEnum;
+
+  /**
+   * Horizontal align enum
+   */
+  export enum HAlignEnum {
+    Left = 1,
+    Center = 2,
+    Right = 3
+  }
+
+  /**
+   * Horizontal align
+   */
+  export type HAlign = Lowercase<keyof typeof HAlignEnum>;
+
+  /**
+   * Vertical align enum
+   */
+  export enum VAlignEnum {
+    Top = 1,
+    Center = 2,
+    Bottom = 3
+  }
+
+  /**
+   * Vertical align
+   */
+  export type VAlign = Lowercase<keyof typeof VAlignEnum>;
+
+  /**
+   * Placement enum
+   */
+  export enum PlacementEnum {
+    TopLeft,
+    TopCenter,
+    TopRight,
+
+    MiddleLeft,
+    Center,
+    MiddleRight,
+
+    BottomLeft,
+    BottomCenter,
+    BottomRight,
+
+    Unknown // Reserved for modal, only one instance held at the same time
+  }
+
+  /**
+   * Placement type
+   */
+  export type Placement = keyof typeof PlacementEnum;
+
+  /**
+   * Add and edit data type
+   * ChangedFields for editing case
+   */
+  export type AddAndEditType<
+    T extends { [key in D]: IdType },
+    D extends string = "id"
+  > =
+    | (Omit<T, D> & { [key in D]?: undefined | never })
+    | (Partial<T> & Readonly<Pick<T, D>> & { changedFields?: string[] });
+
+  /**
+   * Add or edit conditional type
+   * ChangedFields for editing case
+   */
+  export type AddOrEditType<
+    T extends { [key in D]: IdType }, // Entity modal
+    E extends boolean, // Editing or not
+    D extends string = "id" // Default is 'id' field
+  > = E extends false
+    ? Optional<T, D>
+    : Partial<T> & Readonly<Pick<T, D>> & { changedFields?: string[] };
+
+  /**
+   * Key collection, like { key1: {}, key2: {} }
+   */
+  export type KeyCollection<K extends readonly string[], I extends object> = {
+    [P in K[number]]: I;
+  };
+
+  /**
+   * Enum value type
+   */
+  export type EnumValue = number | string;
+
+  /**
+   * Enum base type
+   */
+  export type EnumBase = Record<string, EnumValue>;
+
+  /**
+   * Function type
+   */
+  export type Func<R> = (...args: any[]) => R;
+
+  /**
+   * Mixins constructor
+   */
+  export type MConstructor<T = {}> = new (...args: any[]) => T;
+
+  /**
+   * Make properties optional
+   */
+  export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+
+  /**
+   * String key, unknown value Record
+   */
+  export type StringRecord = Record<string, unknown>;
+
+  /**
+   * String key, string value Record
+   */
+  export type StringDictionary = Record<string, string>;
+
+  /**
+   * Simple object, string key, simple type and null value Record
+   */
+  export type SimpleObject = Record<string, Simple | null | undefined>;
+
+  /**
+   * Item with id property
+   */
+  export type IdItem<T extends IdType = number> = {
+    /**
+     * Id field
+     */
+    id: T;
+  };
+
+  /**
+   * Item with id and label property
+   */
+  export type IdLabelItem<T extends IdType = number> = IdItem<T> & {
+    /**
+     * label field
+     */
+    label: string;
+  };
+
+  /**
+   * Item with id and name property
+   */
+  export type IdNameItem<T extends IdType = number> = IdItem<T> & {
+    /**
+     * name field
+     */
+    name: string;
+  };
+
+  /**
+   * Item with id and title property
+   */
+  export type IdTitleItem<T extends IdType = number> = IdItem<T> & {
+    /**
+     * title field
+     */
+    title: string;
+  };
+
+  /**
+   * Item with id and label dynamic type
+   */
+  export type IdLabelType<
+    I extends string,
+    L extends string,
+    D extends IdType = number
+  > = DIS<I, D> & DIS<L, string>;
+
+  /**
+   * Get specific type keys
+   */
+  export type Keys<T extends object, R = IdType> = {
+    [k in keyof T]: T[k] extends R ? k : never;
+  }[keyof T];
+
+  /**
+   * Require at least one property of the keys
+   */
+  export type RequireAtLeastOne<T, Keys extends keyof T> = Pick<
+    T,
+    Exclude<keyof T, Keys>
+  > &
+    {
+      [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+    }[Keys];
 
+  /**
+   * Culture definiton
+   */
+  export type CultureDefinition<T extends StringRecord = StringRecord> = {
     /**
-     * Basic type and basic type array names array
+     * Name, like zh-CN
      */
-    export const BasicArray = [
-        'number',
-        'number[]',
-        'bigint',
-        'bigint[]',
-        'date',
-        'date[]',
-        'boolean',
-        'boolean[]',
-        'string',
-        'string[]',
-        'unknown[]'
-    ] as const;
+    readonly name: string;
 
     /**
-     * Basic type names
+     * Label for description, like Simplifined Chinese
      */
-    export type BasicNames = (typeof BasicArray)[number];
+    label: string;
 
     /**
-     * Basic type template
+     * Resources
      */
-    export type BasicTemplate = { [key: string]: BasicNames };
+    resources: T | (() => Promise<T>);
 
     /**
-     * Basic template type
+     * Compatible names
      */
-    export type BasicTemplateType<T extends BasicTemplate> = {
-        [P in keyof T]?: BasicConditional<T[P]>;
-    };
+    readonly compatibleNames?: string[];
+  };
 
-    /**
-     * Basic conditinal type
-     */
-    export type BasicConditional<T extends BasicNames> = T extends 'string'
-        ? string
-        : T extends 'string[]'
-        ? string[]
-        : T extends 'date'
-        ? Date
-        : T extends 'date[]'
-        ? Date[]
-        : T extends 'boolean'
-        ? boolean
-        : T extends 'boolean[]'
-        ? boolean[]
-        : T extends 'number'
-        ? number
-        : T extends 'number[]'
-        ? number[]
-        : T extends 'bigint'
-        ? bigint
-        : T extends 'bigint[]'
-        ? bigint[]
-        : unknown[];
+  /**
+   * Dynamic interface with multiple properties
+   */
+  export type DI<K extends readonly string[], T> = { [P in K[number]]: T };
 
-    /**
-     * Basic or basic array type
-     */
-    export type Simple = Basic | Array<Basic>;
+  /**
+   * Dynamic interface with single property
+   */
+  export type DIS<K extends string, T> = { [P in K]: T };
 
-    /**
-     * Simple type enum
-     */
-    export enum SimpleEnum {
-        Number = 1,
-        Bigint = 2,
-        Date = 3,
-        Boolean = 4,
-        String = 5,
-        Array = 9
-    }
+  /**
+   * Convert value to target type
+   * @param input Input value
+   * @param target Target type
+   * @returns Converted value
+   */
+  export function convert<T>(input: unknown, target: T): T | undefined {
+    // null or undefined
+    if (input == null) return undefined;
 
-    /**
-     * Simple type names
-     */
-    export type SimpleNames = Lowercase<keyof typeof SimpleEnum>;
+    // Array
+    if (Array.isArray(target)) {
+      // Element item
+      const elementItem = target.length > 0 ? target[0] : input;
+      const elementType = getBasicNameByValue(elementItem, true);
 
-    /**
-     * Extended type enum
-     */
-    export enum ExtendedEnum {
-        Unkwown = 0,
-
-        Int = 10,
-        Money = 11,
-        IntMoney = 12,
-        DateTime = 13,
-
-        Email = 21,
-        Phone = 22,
-        URL = 23,
-        Logo = 24
+      if (elementType == null) return <T>input;
+      return <any>convertByType(input, elementType);
     }
 
-    /**
-     * Combined type enum
-     */
-    export const CombinedEnum = {
-        ...SimpleEnum,
-        ...ExtendedEnum
-    };
-    export type CombinedEnum = SimpleEnum | ExtendedEnum;
-
-    /**
-     * Horizontal align enum
-     */
-    export enum HAlignEnum {
-        Left = 1,
-        Center = 2,
-        Right = 3
+    // Target type
+    const targetType = getBasicNameByValue(target, false);
+    if (targetType == null) {
+      if (typeof input === typeof target) return <T>input;
+      return undefined;
     }
-
-    /**
-     * Horizontal align
-     */
-    export type HAlign = Lowercase<keyof typeof HAlignEnum>;
-
-    /**
-     * Vertical align enum
-     */
-    export enum VAlignEnum {
-        Top = 1,
-        Center = 2,
-        Bottom = 3
+    return <T>convertByType(input, targetType);
+  }
+
+  /**
+   * Convert by type name like 'string'
+   * @param input Input value
+   * @param targetType Target type
+   * @returns Converted value
+   */
+  export function convertByType<T extends BasicNames>(
+    input: unknown,
+    targetType: T
+  ): BasicConditional<T> | undefined {
+    // null or undefined
+    // And avoid empty string to mass up in different type
+    if (input == null || (typeof input === "string" && input.trim() === ""))
+      return undefined;
+
+    // Return type
+    type returnType = BasicConditional<T>;
+
+    // Array
+    if (targetType.endsWith("[]")) {
+      // Input array
+      const inputArray = Array.isArray(input)
+        ? input
+        : typeof input === "string"
+        ? input.split(/,\s*/g) // Support comma separated array
+        : [input];
+
+      // Element type
+      const elementType = <BasicNames>(
+        targetType.slice(0, targetType.length - 2)
+      );
+
+      // Convert type
+      return <returnType>(
+        inputArray
+          .map((item) => convertByType(item, elementType))
+          .filter((item) => item != null) // Remove undefined item
+      );
     }
 
-    /**
-     * Vertical align
-     */
-    export type VAlign = Lowercase<keyof typeof VAlignEnum>;
-
-    /**
-     * Placement enum
-     */
-    export enum PlacementEnum {
-        TopLeft,
-        TopCenter,
-        TopRight,
-
-        MiddleLeft,
-        Center,
-        MiddleRight,
-
-        BottomLeft,
-        BottomCenter,
-        BottomRight,
-
-        Unknown // Reserved for modal, only one instance held at the same time
+    // Same type
+    if (typeof input === targetType) return <returnType>input;
+
+    // Date
+    if (targetType === "date") {
+      if (input instanceof Date) return <returnType>input;
+      if (typeof input === "string" || typeof input === "number") {
+        const date = new Date(input);
+        return date == null ? undefined : <returnType>date;
+      }
+      return undefined;
     }
 
-    /**
-     * Placement type
-     */
-    export type Placement = keyof typeof PlacementEnum;
-
-    /**
-     * Add and edit data type
-     * ChangedFields for editing case
-     */
-    export type AddAndEditType<
-        T extends { [key in D]: IdType },
-        D extends string = 'id'
-    > =
-        | (Omit<T, D> & { [key in D]?: undefined | never })
-        | (Partial<T> & Readonly<Pick<T, D>> & { changedFields?: string[] });
-
-    /**
-     * Add or edit conditional type
-     * ChangedFields for editing case
-     */
-    export type AddOrEditType<
-        T extends { [key in D]: IdType }, // Entity modal
-        E extends boolean, // Editing or not
-        D extends string = 'id' // Default is 'id' field
-    > = E extends false
-        ? Optional<T, D>
-        : Partial<T> & Readonly<Pick<T, D>> & { changedFields?: string[] };
-
-    /**
-     * Key collection, like { key1: {}, key2: {} }
-     */
-    export type KeyCollection<K extends readonly string[], I extends object> = {
-        [P in K[number]]: I;
-    };
-
-    /**
-     * Enum value type
-     */
-    export type EnumValue = number | string;
-
-    /**
-     * Enum base type
-     */
-    export type EnumBase = Record<string, EnumValue>;
-
-    /**
-     * Function type
-     */
-    export type Func<R> = (...args: any[]) => R;
-
-    /**
-     * Mixins constructor
-     */
-    export type MConstructor<T = {}> = new (...args: any[]) => T;
-
-    /**
-     * Make properties optional
-     */
-    export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> &
-        Omit<T, K>;
-
-    /**
-     * String key, unknown value Record
-     */
-    export type StringRecord = Record<string, unknown>;
-
-    /**
-     * String key, string value Record
-     */
-    export type StringDictionary = Record<string, string>;
-
-    /**
-     * Simple object, string key, simple type and null value Record
-     */
-    export type SimpleObject = Record<string, Simple | null | undefined>;
-
-    /**
-     * Item with id property
-     */
-    export type IdItem<T extends IdType = number> = {
-        /**
-         * Id field
-         */
-        id: T;
-    };
-
-    /**
-     * Item with id and label property
-     */
-    export type IdLabelItem<T extends IdType = number> = IdItem<T> & {
-        /**
-         * label field
-         */
-        label: string;
-    };
-
-    /**
-     * Item with id and name property
-     */
-    export type IdNameItem<T extends IdType = number> = IdItem<T> & {
-        /**
-         * name field
-         */
-        name: string;
-    };
-
-    /**
-     * Item with id and title property
-     */
-    export type IdTitleItem<T extends IdType = number> = IdItem<T> & {
-        /**
-         * title field
-         */
-        title: string;
-    };
-
-    /**
-     * Item with id and label dynamic type
-     */
-    export type IdLabelType<
-        I extends string,
-        L extends string,
-        D extends IdType = number
-    > = DIS<I, D> & DIS<L, string>;
-
-    /**
-     * Get specific type keys
-     */
-    export type Keys<T extends object, R = IdType> = {
-        [k in keyof T]: T[k] extends R ? k : never;
-    }[keyof T];
-
-    /**
-     * Require at least one property of the keys
-     */
-    export type RequireAtLeastOne<T, Keys extends keyof T> = Pick<
-        T,
-        Exclude<keyof T, Keys>
-    > &
-        {
-            [K in Keys]-?: Required<Pick<T, K>> &
-                Partial<Pick<T, Exclude<Keys, K>>>;
-        }[Keys];
-
-    /**
-     * Culture definiton
-     */
-    export type CultureDefinition<T extends StringRecord = StringRecord> = {
-        /**
-         * Name, like zh-CN
-         */
-        readonly name: string;
-
-        /**
-         * Label for description, like Simplifined Chinese
-         */
-        label: string;
-
-        /**
-         * Resources
-         */
-        resources: T | (() => Promise<T>);
-
-        /**
-         * Compatible names
-         */
-        readonly compatibleNames?: string[];
-    };
-
-    /**
-     * Dynamic interface with multiple properties
-     */
-    export type DI<K extends readonly string[], T> = { [P in K[number]]: T };
-
-    /**
-     * Dynamic interface with single property
-     */
-    export type DIS<K extends string, T> = { [P in K]: T };
-
-    /**
-     * Convert value to target type
-     * @param input Input value
-     * @param target Target type
-     * @returns Converted value
-     */
-    export function convert<T>(input: unknown, target: T): T | undefined {
-        // null or undefined
-        if (input == null) return undefined;
-
-        // Array
-        if (Array.isArray(target)) {
-            // Element item
-            const elementItem = target.length > 0 ? target[0] : input;
-            const elementType = getBasicNameByValue(elementItem, true);
-
-            if (elementType == null) return <T>input;
-            return <any>convertByType(input, elementType);
-        }
-
-        // Target type
-        const targetType = getBasicNameByValue(target, false);
-        if (targetType == null) {
-            if (typeof input === typeof target) return <T>input;
-            return undefined;
-        }
-        return <T>convertByType(input, targetType);
+    // Bigint
+    if (targetType === "bigint") {
+      if (
+        typeof input === "string" ||
+        typeof input === "number" ||
+        typeof input === "boolean"
+      )
+        return <returnType>BigInt(input);
+      return undefined;
     }
 
-    /**
-     * Convert by type name like 'string'
-     * @param input Input value
-     * @param targetType Target type
-     * @returns Converted value
-     */
-    export function convertByType<T extends BasicNames>(
-        input: unknown,
-        targetType: T
-    ): BasicConditional<T> | undefined {
-        // null or undefined
-        // And avoid empty string to mass up in different type
-        if (input == null || (typeof input === 'string' && input.trim() === ''))
-            return undefined;
-
-        // Return type
-        type returnType = BasicConditional<T>;
-
-        // Array
-        if (targetType.endsWith('[]')) {
-            // Input array
-            const inputArray = Array.isArray(input)
-                ? input
-                : typeof input === 'string'
-                ? input.split(/,\s*/g) // Support comma separated array
-                : [input];
-
-            // Element type
-            const elementType = <BasicNames>(
-                targetType.slice(0, targetType.length - 2)
-            );
-
-            // Convert type
-            return <returnType>(
-                inputArray
-                    .map((item) => convertByType(item, elementType))
-                    .filter((item) => item != null) // Remove undefined item
-            );
-        }
-
-        // Same type
-        if (typeof input === targetType) return <returnType>input;
-
-        // Date
-        if (targetType === 'date') {
-            if (input instanceof Date) return <returnType>input;
-            if (typeof input === 'string' || typeof input === 'number') {
-                const date = new Date(input);
-                return date == null ? undefined : <returnType>date;
-            }
-            return undefined;
-        }
-
-        // Bigint
-        if (targetType === 'bigint') {
-            if (
-                typeof input === 'string' ||
-                typeof input === 'number' ||
-                typeof input === 'boolean'
-            )
-                return <returnType>BigInt(input);
-            return undefined;
-        }
-
-        // Boolean
-        if (targetType === 'boolean') {
-            if (typeof input === 'string' || typeof input === 'number') {
-                // Here are different with official definition
-                // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean
-                if (input === '0' || input === 'false')
-                    return <returnType>false;
-                return <returnType>Boolean(input);
-            }
-            return undefined;
-        }
-
-        // Number
-        if (targetType === 'number') {
-            const number = Number(input);
-            return isNaN(number) ? undefined : <returnType>number;
-        }
-
-        // String
-        if (targetType === 'string') {
-            return <returnType>String(input);
-        }
-
-        // Default
-        return undefined;
+    // Boolean
+    if (targetType === "boolean") {
+      if (typeof input === "string" || typeof input === "number") {
+        // Here are different with official definition
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+        if (input === "0" || input === "false") return <returnType>false;
+        return <returnType>Boolean(input);
+      }
+      return undefined;
     }
 
-    /**
-     * Convert value to target enum type
-     * @param input Input value
-     * @param enumType  Target enum type
-     * @returns Converted type
-     */
-    export function convertSimple(
-        input: unknown,
-        enumType: CombinedEnum
-    ): Simple | unknown[] | undefined {
-        const type = getBasicName(enumType);
-        const value = convertByType(input, type);
-        if (value == null) return undefined;
-
-        if (typeof value === 'number') {
-            if (
-                enumType === CombinedEnum.Int ||
-                enumType === CombinedEnum.IntMoney
-            )
-                return Math.round(value);
-
-            if (enumType === CombinedEnum.Money)
-                return Math.round(10000 * value) / 10000;
-        }
-
-        return value;
+    // Number
+    if (targetType === "number") {
+      const number = Number(input);
+      return isNaN(number) ? undefined : <returnType>number;
     }
 
-    /**
-     * Get basic type name from Enum type
-     * @param enumType Enum type
-     * @returns Basic type name result
-     */
-    export function getBasicName(enumType: CombinedEnum): BasicNames {
-        switch (enumType) {
-            case CombinedEnum.Array:
-                return 'unknown[]';
-            case CombinedEnum.Bigint:
-                return 'bigint';
-            case CombinedEnum.Boolean:
-                return 'boolean';
-            case CombinedEnum.Date:
-            case CombinedEnum.DateTime:
-                return 'date';
-            case CombinedEnum.Number:
-            case CombinedEnum.Int:
-            case CombinedEnum.IntMoney:
-            case CombinedEnum.Money:
-                return 'number';
-            default:
-                return 'string';
-        }
+    // String
+    if (targetType === "string") {
+      return <returnType>String(input);
     }
 
-    /**
-     * Get value's basic type name
-     * @param value Input value
-     * @param isArray Is array
-     * @returns Value's basic type name
-     */
-    export function getBasicNameByValue(
-        value: unknown,
-        isArray: boolean = false
-    ): BasicNames | undefined {
-        // null or undefined
-        if (value == null) return undefined;
-
-        // Date
-        if (value instanceof Date) {
-            return isArray ? 'date[]' : 'date';
-        }
-
-        // No array
-
-        // Other cases
-        const valueType = typeof value;
-        const typeName = isArray ? valueType + '[]' : valueType;
-        if (!isBasicName(typeName)) return undefined;
-
-        return typeName;
+    // Default
+    return undefined;
+  }
+
+  /**
+   * Convert value to target enum type
+   * @param input Input value
+   * @param enumType  Target enum type
+   * @returns Converted type
+   */
+  export function convertSimple(
+    input: unknown,
+    enumType: CombinedEnum
+  ): Simple | unknown[] | undefined {
+    const type = getBasicName(enumType);
+    const value = convertByType(input, type);
+    if (value == null) return undefined;
+
+    if (typeof value === "number") {
+      if (enumType === CombinedEnum.Int || enumType === CombinedEnum.IntMoney)
+        return Math.round(value);
+
+      if (enumType === CombinedEnum.Money)
+        return Math.round(10000 * value) / 10000;
     }
 
-    /**
-     * Get enum item from key
-     * @param enumItem Enum
-     * @param key Key
-     * @returns Enum item
-     */
-    export function getEnumByKey<T extends EnumBase, K extends keyof T>(
-        enumItem: T,
-        key: string
-    ): T[K] | undefined {
-        if (key in enumItem) return <T[K]>enumItem[key];
-        return undefined;
+    return value;
+  }
+
+  /**
+   * Get basic type name from Enum type
+   * @param enumType Enum type
+   * @returns Basic type name result
+   */
+  export function getBasicName(enumType: CombinedEnum): BasicNames {
+    switch (enumType) {
+      case CombinedEnum.Array:
+        return "unknown[]";
+      case CombinedEnum.Bigint:
+        return "bigint";
+      case CombinedEnum.Boolean:
+        return "boolean";
+      case CombinedEnum.Date:
+      case CombinedEnum.DateTime:
+        return "date";
+      case CombinedEnum.Number:
+      case CombinedEnum.Int:
+      case CombinedEnum.IntMoney:
+      case CombinedEnum.Money:
+        return "number";
+      default:
+        return "string";
     }
-
-    /**
-     * Get enum item from value
-     * @param enumItem Enum
-     * @param value Key
-     * @returns Enum item or undefined
-     */
-    export function getEnumByValue<T extends EnumBase, K extends keyof T>(
-        enumItem: T,
-        value: EnumValue
-    ): T[K] | undefined {
-        if (value in enumItem) return <T[K]>value;
-        return undefined;
+  }
+
+  /**
+   * Get value's basic type name
+   * @param value Input value
+   * @param isArray Is array
+   * @returns Value's basic type name
+   */
+  export function getBasicNameByValue(
+    value: unknown,
+    isArray: boolean = false
+  ): BasicNames | undefined {
+    // null or undefined
+    if (value == null) return undefined;
+
+    // Date
+    if (value instanceof Date) {
+      return isArray ? "date[]" : "date";
     }
 
-    /**
-     * Get enum string literal type value
-     * @param enumItem Enum item
-     * @param value Value
-     * @returns Result
-     */
-    export function getEnumKey(enumItem: EnumBase, value: EnumValue) {
-        return enumItem[value].toString();
+    // No array
+
+    // Other cases
+    const valueType = typeof value;
+    const typeName = isArray ? valueType + "[]" : valueType;
+    if (!isBasicName(typeName)) return undefined;
+
+    return typeName;
+  }
+
+  /**
+   * Get enum item from key
+   * @param enumItem Enum
+   * @param key Key
+   * @returns Enum item
+   */
+  export function getEnumByKey<T extends EnumBase, K extends keyof T>(
+    enumItem: T,
+    key: string
+  ): T[K] | undefined {
+    if (key in enumItem) return <T[K]>enumItem[key];
+    return undefined;
+  }
+
+  /**
+   * Get enum item from value
+   * @param enumItem Enum
+   * @param value Key
+   * @returns Enum item or undefined
+   */
+  export function getEnumByValue<T extends EnumBase, K extends keyof T>(
+    enumItem: T,
+    value: EnumValue
+  ): T[K] | undefined {
+    if (value in enumItem) return <T[K]>value;
+    return undefined;
+  }
+
+  /**
+   * Get enum string literal type value
+   * @param enumItem Enum item
+   * @param value Value
+   * @returns Result
+   */
+  export function getEnumKey(enumItem: EnumBase, value: EnumValue) {
+    return enumItem[value].toString();
+  }
+
+  /**
+   * Get Enum keys
+   * @param input Input Enum
+   * @returns Keys
+   */
+  export function getEnumKeys<T extends EnumBase, K extends keyof T & string>(
+    input: T
+  ): K[] {
+    return Object.keys(input)
+      .filter((key) => !/^\d+$/.test(key))
+      .map((item) => <K>item);
+  }
+
+  /**
+   * Get ListType2 item label
+   * @param item Item
+   * @returns Result
+   */
+  export function getListItemLabel<D extends ListType2>(item: D) {
+    return "label" in item
+      ? item.label
+      : "name" in item
+      ? item.name
+      : item.title;
+  }
+
+  /**
+   * Get object item label
+   * @param item Item
+   * @returns Result
+   */
+  export function getObjectItemLabel(item: object): string {
+    return "label" in item
+      ? `${item.label}`
+      : "name" in item
+      ? `${item.name}`
+      : "title" in item
+      ? `${item.title}`
+      : `${item}`;
+  }
+
+  /**
+   * Get object field value
+   * @param data Data
+   * @param key Property name
+   * @returns Value
+   */
+  export function getValue<T extends object, K extends keyof T | string>(
+    data: T | undefined | null,
+    key: K
+  ): K extends keyof T ? T[K] : undefined {
+    if (data != null && typeof key === "string" && key in data) {
+      return Reflect.get(data, key);
     }
-
-    /**
-     * Get Enum keys
-     * @param input Input Enum
-     * @returns Keys
-     */
-    export function getEnumKeys<T extends EnumBase, K extends keyof T & string>(
-        input: T
-    ): K[] {
-        return Object.keys(input)
-            .filter((key) => !/^\d+$/.test(key))
-            .map((item) => <K>item);
+    return undefined as any;
+  }
+
+  /**
+   * Get object id field value
+   * @param data Data
+   * @param key Property name
+   * @returns Id value
+   */
+  export function getIdValue<T extends object, K extends Keys<T, IdType>>(
+    data: T,
+    key: K
+  ): T[K] {
+    return data[key];
+  }
+
+  /**
+   * Get object id field value 1
+   * @param data Data
+   * @param key Property name
+   * @returns Id value
+   */
+  export function getIdValue1<T extends object, K extends keyof T | string>(
+    data: T | undefined | null,
+    key: K
+  ): K extends keyof T ? (T[K] extends number ? number : string) : undefined {
+    const value = getValue(data, key);
+    if (value == null) return undefined as any;
+    if (typeof value === "number") return value as any;
+    return `${value}` as any;
+  }
+
+  /**
+   * Get object string field value
+   * @param data Data
+   * @param key Property name
+   * @returns String value
+   */
+  export function getStringValue<T extends object>(
+    data: T | undefined | null,
+    key: keyof T | string
+  ): string | undefined {
+    const value = getValue(data, key);
+    if (value == null) return undefined;
+    if (typeof value === "string") return value;
+    return `${value}`;
+  }
+
+  /**
+   * Check the type is a basic type or not (type guard)
+   * @param name Type name
+   * @returns Is basic type
+   */
+  export function isBasicName(name: string): name is BasicNames {
+    return BasicArray.includes(<BasicNames>name);
+  }
+
+  /**
+   * Is the target a simple object (Type guard)
+   * @param input Test data
+   * @param includeArray Include array as simple type
+   * @returns Result
+   */
+  export function isSimpleObject(
+    input: unknown,
+    includeArray: boolean = true
+  ): input is SimpleObject {
+    return (
+      typeof input === "object" &&
+      input != null &&
+      Object.values(input).every((value) => isSimpleType(value, includeArray))
+    );
+  }
+
+  /**
+   * Is the input value simple type, include null and undefined
+   * @param input Input value
+   * @param includeArray Is array included, first non null element shoud also be basic type
+   */
+  export function isSimpleType(
+    input: unknown,
+    includeArray: boolean = true
+  ): boolean {
+    // null & undefined
+    if (input == null) return true;
+
+    // Date
+    if (input instanceof Date) return true;
+
+    // Array
+    if (Array.isArray(input)) {
+      if (includeArray) {
+        return isSimpleType(input.find((item) => item != null));
+      } else {
+        // No array needed
+        return false;
+      }
     }
 
-    /**
-     * Get ListType2 item label
-     * @param item Item
-     * @returns Result
-     */
-    export function getListItemLabel<D extends ListType2>(item: D) {
-        return 'label' in item
-            ? item.label
-            : 'name' in item
-            ? item.name
-            : item.title;
-    }
-
-    /**
-     * Get object item label
-     * @param item Item
-     * @returns Result
-     */
-    export function getObjectItemLabel(item: object): string {
-        return 'label' in item
-            ? `${item.label}`
-            : 'name' in item
-            ? `${item.name}`
-            : 'title' in item
-            ? `${item.title}`
-            : `${item}`;
-    }
-
-    /**
-     * Get object field value
-     * @param data Data
-     * @param key Property name
-     * @returns Value
-     */
-    export function getValue<T extends object, K extends keyof T | string>(
-        data: T | undefined | null,
-        key: K
-    ): K extends keyof T ? T[K] : undefined {
-        if (data != null && typeof key === 'string' && key in data) {
-            return Reflect.get(data, key);
-        }
-        return undefined as any;
-    }
-
-    /**
-     * Get object id field value
-     * @param data Data
-     * @param key Property name
-     * @returns Id value
-     */
-    export function getIdValue<T extends object, K extends Keys<T, IdType>>(
-        data: T,
-        key: K
-    ): T[K] {
-        return data[key];
-    }
-
-    /**
-     * Get object id field value 1
-     * @param data Data
-     * @param key Property name
-     * @returns Id value
-     */
-    export function getIdValue1<T extends object, K extends keyof T | string>(
-        data: T | undefined | null,
-        key: K
-    ): K extends keyof T ? (T[K] extends number ? number : string) : undefined {
-        const value = getValue(data, key);
-        if (value == null) return undefined as any;
-        if (typeof value === 'number') return value as any;
-        return `${value}` as any;
-    }
-
-    /**
-     * Get object string field value
-     * @param data Data
-     * @param key Property name
-     * @returns String value
-     */
-    export function getStringValue<T extends object>(
-        data: T | undefined | null,
-        key: keyof T | string
-    ): string | undefined {
-        const value = getValue(data, key);
-        if (value == null) return undefined;
-        if (typeof value === 'string') return value;
-        return `${value}`;
-    }
-
-    /**
-     * Check the type is a basic type or not (type guard)
-     * @param name Type name
-     * @returns Is basic type
-     */
-    export function isBasicName(name: string): name is BasicNames {
-        return BasicArray.includes(<BasicNames>name);
-    }
-
-    /**
-     * Is the target a simple object (Type guard)
-     * @param input Test data
-     * @param includeArray Include array as simple type
-     * @returns Result
-     */
-    export function isSimpleObject(
-        input: unknown,
-        includeArray: boolean = true
-    ): input is SimpleObject {
-        return (
-            typeof input === 'object' &&
-            input != null &&
-            Object.values(input).every((value) =>
-                isSimpleType(value, includeArray)
-            )
-        );
-    }
-
-    /**
-     * Is the input value simple type, include null and undefined
-     * @param input Input value
-     * @param includeArray Is array included, first non null element shoud also be basic type
-     */
-    export function isSimpleType(
-        input: unknown,
-        includeArray: boolean = true
-    ): boolean {
-        // null & undefined
-        if (input == null) return true;
-
-        // Date
-        if (input instanceof Date) return true;
-
-        // Array
-        if (Array.isArray(input)) {
-            if (includeArray) {
-                return isSimpleType(input.find((item) => item != null));
-            } else {
-                // No array needed
-                return false;
-            }
-        }
-
-        // Other cases
-        const type = typeof input;
-        if (type === 'function' || type === 'object' || type === 'symbol')
-            return false;
-
-        return true;
-    }
-
-    /**
-     * JSON.stringify replacer with full path
-     * https://stackoverflow.com/questions/61681176/json-stringify-replacer-how-to-get-full-path
-     */
-    export function jsonReplacer(
-        replacer: (this: any, key: string, value: any, path: string) => any
-    ) {
-        const m = new Map();
-
-        return function (this: any, key: any, value: any) {
-            const path =
-                m.get(this) + (Array.isArray(this) ? `[${key}]` : '.' + key);
-            if (value === Object(value)) m.set(value, path);
-
-            return replacer.call(
-                this,
-                key,
-                value,
-                path.replace(/undefined\.\.?/, '')
-            );
-        };
-    }
-
-    /**
-     * JSON.stringify receiver for bigint
-     * @param args Keys or paths to convert to bigint
-     * @returns JSON receiver function
-     */
-    export function jsonBigintReceiver(...args: string[]) {
-        return jsonReplacer(function (key, value, path) {
-            if (
-                (args.includes(key) || args.includes(path)) &&
-                typeof value === 'string'
-            ) {
-                if (value.endsWith('n')) return BigInt(value.slice(0, -1));
-                else return BigInt(value);
-            }
-
-            return value;
-        });
-    }
+    // Other cases
+    const type = typeof input;
+    if (type === "function" || type === "object" || type === "symbol")
+      return false;
+
+    return true;
+  }
+
+  /**
+   * JSON.stringify replacer with full path
+   * https://stackoverflow.com/questions/61681176/json-stringify-replacer-how-to-get-full-path
+   */
+  export function jsonReplacer(
+    replacer: (this: any, key: string, value: any, path: string) => any
+  ) {
+    const m = new Map();
+
+    return function (this: any, key: any, value: any) {
+      const path = m.get(this) + (Array.isArray(this) ? `[${key}]` : "." + key);
+      if (value === Object(value)) m.set(value, path);
+
+      return replacer.call(
+        this,
+        key,
+        value,
+        path.replace(/undefined\.\.?/, "")
+      );
+    };
+  }
+
+  /**
+   * JSON.stringify receiver for bigint
+   * @param args Keys or paths to convert to bigint
+   * @returns JSON receiver function
+   */
+  export function jsonBigintReceiver(...args: string[]) {
+    return jsonReplacer(function (key, value, path) {
+      if (
+        (args.includes(key) || args.includes(path)) &&
+        typeof value === "string"
+      ) {
+        if (value.endsWith("n")) return BigInt(value.slice(0, -1));
+        else return BigInt(value);
+      }
+
+      return value;
+    });
+  }
 }
 
 /**
@@ -821,27 +812,27 @@ export type ListType1 = DataTypes.IdLabelItem<string>;
  * List item with compatible id and name / label / title
  */
 export type ListType2 = {
-    id: IdType;
+  id: IdType;
 } & ({ label: string } | { name: string } | { title: string });
 
 /**
  * Id default type
  */
 export type IdDefaultType<
-    T extends object,
-    I extends IdType = IdType
-> = T extends { id: I } ? DataTypes.Keys<T, I> & 'id' : DataTypes.Keys<T, I>;
+  T extends object,
+  I extends IdType = IdType
+> = T extends { id: I } ? DataTypes.Keys<T, I> & "id" : DataTypes.Keys<T, I>;
 
 /**
  * Label default type
  */
 export type LabelDefaultType<T extends object> = T extends { label: string }
-    ? DataTypes.Keys<T, string> & 'label'
-    : DataTypes.Keys<T, string>;
+  ? DataTypes.Keys<T, string> & "label"
+  : DataTypes.Keys<T, string>;
 
 /**
  * Title default type
  */
 export type TitleDefaultType<T extends object> = T extends { title: string }
-    ? DataTypes.Keys<T, string> & 'title'
-    : DataTypes.Keys<T, string>;
+  ? DataTypes.Keys<T, string> & "title"
+  : DataTypes.Keys<T, string>;