create-enum-es 1.0.0

package/README.md

@@ -0,0 +1,82 @@
+```
+import { createEnum } from '../dist/emun-create.es.js';
+
+const enum1 = createEnum({
+  On: [1, '开启'],
+  Off: [0, '关闭'],
+})
+
+console.log(enum1.getVal('On')) // 1
+console.log(enum1.getValList('On', 'Off')) // [1, 0]
+console.log(enum1.getValList('On')) // [1]
+console.log(enum1.getValList()) // [1, 0]
+
+
+console.log(enum1.getValMap('On', 'Off')) // {On: 1, Off: 0}
+console.log(enum1.getValMap('Off')) // {Off: 0}
+console.log(enum1.getValMap()) // {On: 1, Off: 0}
+
+
+console.log(enum1.getName('On')) // 开启
+console.log(enum1.getNameByValue(enum1.Off)) // 关闭
+console.log(enum1.getName(enum1.On, { arguType: 'value' })) // 开启
+
+
+console.log(enum1.getOptions())
+// [
+//     {
+//         "value": 1,
+//         "label": "开启"
+//     },
+//     {
+//         "value": 0,
+//         "label": "关闭"
+//     }
+// ]
+console.log(enum1.getOptions({ labelKey: 'name', valueKey: 'key' }))
+// [
+//     {
+//         "key": 1,
+//         "name": "开启"
+//     },
+//     {
+//         "key": 0,
+//         "name": "关闭"
+//     }
+// ]
+console.log(enum1.getOptions('On'))
+// [
+//     {
+//         "value": 1,
+//         "label": "开启"
+//     }
+// ]
+console.log(enum1.getOptions(enum1.On, { arguType: 'value' }))
+// [
+//     {
+//         "value": 1,
+//         "label": "开启"
+//     }
+// ]
+console.log(enum1.getOptionsByValues())
+// [
+//     {
+//         "value": 1,
+//         "label": "开启"
+//     },
+//     {
+//         "value": 0,
+//         "label": "关闭"
+//     }
+// ]
+console.log(enum1.getOptionsByValues(enum1.On, { labelKey: 'name', valueKey: 'key' }))
+// [
+//     {
+//         "key": 1,
+//         "name": "开启"
+//     }
+// ]
+
+console.log(enum1.check(enum1.On, 'On')) // true
+```
+

package/dist/create-enum.cjs.js

@@ -0,0 +1,241 @@
+'use strict';
+
+/**
+ * 数据类型
+ * @param {*} data
+ * @param {String} type
+ * @returns {Boolean}
+ */
+function isType(data, type) {
+    const dataType = Object.prototype.toString.call(data).slice(8, -1).toLowerCase();
+    return type === dataType;
+}
+/**
+ * 数据是否为空
+ * @param {*} data
+ * @returns
+ */
+function isEmpty(data) {
+    if (isType(data, "array") || isType(data, "string")) {
+        return data.length === 0;
+    }
+    if (data instanceof Map || data instanceof Set) {
+        return data.size === 0;
+    }
+    if (isType(data, "object")) {
+        return Object.keys(data).length === 0;
+    }
+    return Boolean(data);
+}
+/**
+ * 深度拷贝
+ * @param {Object|Array} obj
+ * @return {Object|Array}
+ */
+function deepClone(obj) {
+    let objClone = Array.isArray(obj) ? [] : {};
+    if (obj && typeof obj === "object") {
+        for (let key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                //判断ojb子元素是否为对象，如果是，递归复制
+                if (obj[key] && typeof obj[key] === "object") {
+                    objClone[key] = deepClone(obj[key]);
+                }
+                else {
+                    //如果不是，简单复制
+                    objClone[key] = obj[key];
+                }
+            }
+        }
+    }
+    return objClone;
+}
+
+/**
+ * 获取配置参数
+ * @param {*} args
+ * @returns
+ */
+function getConfigParams(args) {
+    let config = { labelKey: "label", valueKey: "value", arguType: "key" }; // 选项参数配置
+    const lastArgu = args[args.length - 1];
+    if (isType(lastArgu, "object")) {
+        config = { ...config, ...lastArgu };
+        args = args.slice(0, args.length - 1);
+    }
+    return [config, args];
+}
+/**
+ * 判断枚举key列表是否有效
+ * @param {*} args
+ * @returns {Boolean}
+ */
+function judgEnumKeys(keys) {
+    return !isEmpty(keys) && keys.every((key) => typeof key === "string");
+}
+/**
+ * 枚举类
+ * @param {Object} enumMap 枚举对象
+ * 枚举格式：
+ * {
+ *    枚举key1: [枚举值1，枚举描述1],
+ *    枚举key2: [枚举值2，枚举描述2]
+ * }
+ */
+class Enum {
+    __enumMap__;
+    __enumValueMap__;
+    __enumNameMap__;
+    __valueNameMap__;
+    /**
+     * @param {Object} enumMap 枚举map
+     */
+    constructor(enumMap) {
+        if (!isType(enumMap, "object")) {
+            throw new TypeError("初始化参数值必须是一个object！");
+        }
+        this.#init(deepClone(enumMap));
+    }
+    /**
+     * 初始化
+     * @param {Object} enumMap 枚举对象
+     * @private
+     */
+    #init(enumMap) {
+        this.#setEnumMap(enumMap); //处理映射关系
+    }
+    /**
+     * 设置枚举间的映射
+     * @param {Object} enumMap
+     * @private
+     */
+    #setEnumMap(enumMap) {
+        const enumValueMap = {};
+        const enumNameMap = {};
+        const valueNameMap = {};
+        Object.keys(enumMap).forEach((key) => {
+            const item = enumMap[key];
+            if (!Array.isArray(item)) {
+                throw new TypeError("初始化参数对象字段的值必是一个array！");
+            }
+            enumValueMap[key] = item[0];
+            enumNameMap[key] = item[1];
+            valueNameMap[item[0]] = item[1];
+        });
+        this.__enumMap__ = Object.freeze(enumMap);
+        this.__enumValueMap__ = Object.freeze(enumValueMap);
+        this.__enumNameMap__ = Object.freeze(enumNameMap);
+        this.__valueNameMap__ = Object.freeze(valueNameMap);
+    }
+    /**
+     * 获取枚举值
+     * @param {String} key 枚举KEY
+     * @return {Number} 枚举值
+     */
+    getVal(key) {
+        return this.__enumValueMap__[key];
+    }
+    /**
+     * 获取多个枚举值
+     * @param {Array} param 多个枚举KEY
+     * @return {Array} {[枚举值]}
+     */
+    getValList(...args) {
+        let keys = Object.keys(this.__enumMap__); // 不传递返回所有
+        if (judgEnumKeys(args)) {
+            keys = Array.from(args);
+        }
+        return keys.map((key) => this.getVal(key));
+    }
+    /**
+     * 获取多个枚举值Map
+     * @param {Array} param 多个枚举KEY，如果不传递则返回所有
+     * @return {Object} {[枚举key]:枚举值}
+     */
+    getValMap(...args) {
+        let keys = Object.keys(this.__enumMap__); // 不传递返回所有
+        if (judgEnumKeys(args)) {
+            keys = Array.from(args);
+        }
+        return keys.reduce((wrap, key) => {
+            wrap[key] = this.getVal(key);
+            return wrap;
+        }, {});
+    }
+    getName(keyOrVal, _config) {
+        const [config] = getConfigParams([_config]);
+        if (config.arguType === "key") {
+            return this.__enumNameMap__[keyOrVal];
+        }
+        else if (config.arguType === "value") {
+            return this.getNameByValue(keyOrVal);
+        }
+        else {
+            throw new TypeError("参数arguType的值类型不为 key|value ！");
+        }
+    }
+    /**
+     * 通过枚举值获取枚举名称
+     * @param {String|Nunber} val
+     * @return {String|Null}
+     */
+    getNameByValue(val) {
+        return this.__valueNameMap__[val];
+    }
+    getOptions(..._args) {
+        const [config, args] = getConfigParams(_args);
+        if (config.arguType === "key") {
+            let keys = Object.keys(this.__enumMap__); // 不传递返回所有
+            if (judgEnumKeys(args)) {
+                keys = Array.from(args);
+            }
+            return keys.map((key) => {
+                const value = this.getVal(key);
+                const name = this.getName(key);
+                return { [config.valueKey]: value, [config.labelKey]: name };
+            });
+        }
+        else if (config.arguType === "value") {
+            return this.getOptionsByValues(..._args);
+        }
+        else {
+            throw new TypeError("参数arguType的值类型不为 key | value ！");
+        }
+    }
+    getOptionsByValues(..._args) {
+        const [config, args] = getConfigParams(_args);
+        let values = Object.values(this.__enumValueMap__); // 不传递返回所有
+        if (!isEmpty(args)) {
+            values = Array.from(args);
+        }
+        return values.map((value) => {
+            const name = this.getNameByValue(value);
+            return { [config.valueKey]: value, [config.labelKey]: name };
+        });
+    }
+    /**
+     * 检测字段类型
+     * @param {Number} typeVal 类型
+     * @param {String} typeKey 类型key
+     * @return {Boolean}
+     */
+    check(typeVal, typeKey) {
+        return this.getVal(typeKey) === typeVal;
+    }
+}
+/**
+ * 创建枚举
+ * @param {Object} enumMap
+ * @param {String} description
+ * @returns
+ */
+const createEnum = (enumMap) => {
+    const enumInstance = new Enum(enumMap); // 返回实例
+    const e = Object.create(enumInstance);
+    for (const key in enumMap) {
+        e[key] = enumMap[key]?.[0];
+    }
+    return Object.freeze(e);
+};
+
+exports.createEnum = createEnum;

package/dist/create-enum.es.js

@@ -0,0 +1,239 @@
+/**
+ * 数据类型
+ * @param {*} data
+ * @param {String} type
+ * @returns {Boolean}
+ */
+function isType(data, type) {
+    const dataType = Object.prototype.toString.call(data).slice(8, -1).toLowerCase();
+    return type === dataType;
+}
+/**
+ * 数据是否为空
+ * @param {*} data
+ * @returns
+ */
+function isEmpty(data) {
+    if (isType(data, "array") || isType(data, "string")) {
+        return data.length === 0;
+    }
+    if (data instanceof Map || data instanceof Set) {
+        return data.size === 0;
+    }
+    if (isType(data, "object")) {
+        return Object.keys(data).length === 0;
+    }
+    return Boolean(data);
+}
+/**
+ * 深度拷贝
+ * @param {Object|Array} obj
+ * @return {Object|Array}
+ */
+function deepClone(obj) {
+    let objClone = Array.isArray(obj) ? [] : {};
+    if (obj && typeof obj === "object") {
+        for (let key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                //判断ojb子元素是否为对象，如果是，递归复制
+                if (obj[key] && typeof obj[key] === "object") {
+                    objClone[key] = deepClone(obj[key]);
+                }
+                else {
+                    //如果不是，简单复制
+                    objClone[key] = obj[key];
+                }
+            }
+        }
+    }
+    return objClone;
+}
+
+/**
+ * 获取配置参数
+ * @param {*} args
+ * @returns
+ */
+function getConfigParams(args) {
+    let config = { labelKey: "label", valueKey: "value", arguType: "key" }; // 选项参数配置
+    const lastArgu = args[args.length - 1];
+    if (isType(lastArgu, "object")) {
+        config = { ...config, ...lastArgu };
+        args = args.slice(0, args.length - 1);
+    }
+    return [config, args];
+}
+/**
+ * 判断枚举key列表是否有效
+ * @param {*} args
+ * @returns {Boolean}
+ */
+function judgEnumKeys(keys) {
+    return !isEmpty(keys) && keys.every((key) => typeof key === "string");
+}
+/**
+ * 枚举类
+ * @param {Object} enumMap 枚举对象
+ * 枚举格式：
+ * {
+ *    枚举key1: [枚举值1，枚举描述1],
+ *    枚举key2: [枚举值2，枚举描述2]
+ * }
+ */
+class Enum {
+    __enumMap__;
+    __enumValueMap__;
+    __enumNameMap__;
+    __valueNameMap__;
+    /**
+     * @param {Object} enumMap 枚举map
+     */
+    constructor(enumMap) {
+        if (!isType(enumMap, "object")) {
+            throw new TypeError("初始化参数值必须是一个object！");
+        }
+        this.#init(deepClone(enumMap));
+    }
+    /**
+     * 初始化
+     * @param {Object} enumMap 枚举对象
+     * @private
+     */
+    #init(enumMap) {
+        this.#setEnumMap(enumMap); //处理映射关系
+    }
+    /**
+     * 设置枚举间的映射
+     * @param {Object} enumMap
+     * @private
+     */
+    #setEnumMap(enumMap) {
+        const enumValueMap = {};
+        const enumNameMap = {};
+        const valueNameMap = {};
+        Object.keys(enumMap).forEach((key) => {
+            const item = enumMap[key];
+            if (!Array.isArray(item)) {
+                throw new TypeError("初始化参数对象字段的值必是一个array！");
+            }
+            enumValueMap[key] = item[0];
+            enumNameMap[key] = item[1];
+            valueNameMap[item[0]] = item[1];
+        });
+        this.__enumMap__ = Object.freeze(enumMap);
+        this.__enumValueMap__ = Object.freeze(enumValueMap);
+        this.__enumNameMap__ = Object.freeze(enumNameMap);
+        this.__valueNameMap__ = Object.freeze(valueNameMap);
+    }
+    /**
+     * 获取枚举值
+     * @param {String} key 枚举KEY
+     * @return {Number} 枚举值
+     */
+    getVal(key) {
+        return this.__enumValueMap__[key];
+    }
+    /**
+     * 获取多个枚举值
+     * @param {Array} param 多个枚举KEY
+     * @return {Array} {[枚举值]}
+     */
+    getValList(...args) {
+        let keys = Object.keys(this.__enumMap__); // 不传递返回所有
+        if (judgEnumKeys(args)) {
+            keys = Array.from(args);
+        }
+        return keys.map((key) => this.getVal(key));
+    }
+    /**
+     * 获取多个枚举值Map
+     * @param {Array} param 多个枚举KEY，如果不传递则返回所有
+     * @return {Object} {[枚举key]:枚举值}
+     */
+    getValMap(...args) {
+        let keys = Object.keys(this.__enumMap__); // 不传递返回所有
+        if (judgEnumKeys(args)) {
+            keys = Array.from(args);
+        }
+        return keys.reduce((wrap, key) => {
+            wrap[key] = this.getVal(key);
+            return wrap;
+        }, {});
+    }
+    getName(keyOrVal, _config) {
+        const [config] = getConfigParams([_config]);
+        if (config.arguType === "key") {
+            return this.__enumNameMap__[keyOrVal];
+        }
+        else if (config.arguType === "value") {
+            return this.getNameByValue(keyOrVal);
+        }
+        else {
+            throw new TypeError("参数arguType的值类型不为 key|value ！");
+        }
+    }
+    /**
+     * 通过枚举值获取枚举名称
+     * @param {String|Nunber} val
+     * @return {String|Null}
+     */
+    getNameByValue(val) {
+        return this.__valueNameMap__[val];
+    }
+    getOptions(..._args) {
+        const [config, args] = getConfigParams(_args);
+        if (config.arguType === "key") {
+            let keys = Object.keys(this.__enumMap__); // 不传递返回所有
+            if (judgEnumKeys(args)) {
+                keys = Array.from(args);
+            }
+            return keys.map((key) => {
+                const value = this.getVal(key);
+                const name = this.getName(key);
+                return { [config.valueKey]: value, [config.labelKey]: name };
+            });
+        }
+        else if (config.arguType === "value") {
+            return this.getOptionsByValues(..._args);
+        }
+        else {
+            throw new TypeError("参数arguType的值类型不为 key | value ！");
+        }
+    }
+    getOptionsByValues(..._args) {
+        const [config, args] = getConfigParams(_args);
+        let values = Object.values(this.__enumValueMap__); // 不传递返回所有
+        if (!isEmpty(args)) {
+            values = Array.from(args);
+        }
+        return values.map((value) => {
+            const name = this.getNameByValue(value);
+            return { [config.valueKey]: value, [config.labelKey]: name };
+        });
+    }
+    /**
+     * 检测字段类型
+     * @param {Number} typeVal 类型
+     * @param {String} typeKey 类型key
+     * @return {Boolean}
+     */
+    check(typeVal, typeKey) {
+        return this.getVal(typeKey) === typeVal;
+    }
+}
+/**
+ * 创建枚举
+ * @param {Object} enumMap
+ * @param {String} description
+ * @returns
+ */
+const createEnum = (enumMap) => {
+    const enumInstance = new Enum(enumMap); // 返回实例
+    const e = Object.create(enumInstance);
+    for (const key in enumMap) {
+        e[key] = enumMap[key]?.[0];
+    }
+    return Object.freeze(e);
+};
+
+export { createEnum };

package/dist/create-enum.umd.js

@@ -0,0 +1,247 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.$Enum = {}));
+})(this, (function (exports) { 'use strict';
+
+    /**
+     * 数据类型
+     * @param {*} data
+     * @param {String} type
+     * @returns {Boolean}
+     */
+    function isType(data, type) {
+        const dataType = Object.prototype.toString.call(data).slice(8, -1).toLowerCase();
+        return type === dataType;
+    }
+    /**
+     * 数据是否为空
+     * @param {*} data
+     * @returns
+     */
+    function isEmpty(data) {
+        if (isType(data, "array") || isType(data, "string")) {
+            return data.length === 0;
+        }
+        if (data instanceof Map || data instanceof Set) {
+            return data.size === 0;
+        }
+        if (isType(data, "object")) {
+            return Object.keys(data).length === 0;
+        }
+        return Boolean(data);
+    }
+    /**
+     * 深度拷贝
+     * @param {Object|Array} obj
+     * @return {Object|Array}
+     */
+    function deepClone(obj) {
+        let objClone = Array.isArray(obj) ? [] : {};
+        if (obj && typeof obj === "object") {
+            for (let key in obj) {
+                if (obj.hasOwnProperty(key)) {
+                    //判断ojb子元素是否为对象，如果是，递归复制
+                    if (obj[key] && typeof obj[key] === "object") {
+                        objClone[key] = deepClone(obj[key]);
+                    }
+                    else {
+                        //如果不是，简单复制
+                        objClone[key] = obj[key];
+                    }
+                }
+            }
+        }
+        return objClone;
+    }
+
+    /**
+     * 获取配置参数
+     * @param {*} args
+     * @returns
+     */
+    function getConfigParams(args) {
+        let config = { labelKey: "label", valueKey: "value", arguType: "key" }; // 选项参数配置
+        const lastArgu = args[args.length - 1];
+        if (isType(lastArgu, "object")) {
+            config = { ...config, ...lastArgu };
+            args = args.slice(0, args.length - 1);
+        }
+        return [config, args];
+    }
+    /**
+     * 判断枚举key列表是否有效
+     * @param {*} args
+     * @returns {Boolean}
+     */
+    function judgEnumKeys(keys) {
+        return !isEmpty(keys) && keys.every((key) => typeof key === "string");
+    }
+    /**
+     * 枚举类
+     * @param {Object} enumMap 枚举对象
+     * 枚举格式：
+     * {
+     *    枚举key1: [枚举值1，枚举描述1],
+     *    枚举key2: [枚举值2，枚举描述2]
+     * }
+     */
+    class Enum {
+        __enumMap__;
+        __enumValueMap__;
+        __enumNameMap__;
+        __valueNameMap__;
+        /**
+         * @param {Object} enumMap 枚举map
+         */
+        constructor(enumMap) {
+            if (!isType(enumMap, "object")) {
+                throw new TypeError("初始化参数值必须是一个object！");
+            }
+            this.#init(deepClone(enumMap));
+        }
+        /**
+         * 初始化
+         * @param {Object} enumMap 枚举对象
+         * @private
+         */
+        #init(enumMap) {
+            this.#setEnumMap(enumMap); //处理映射关系
+        }
+        /**
+         * 设置枚举间的映射
+         * @param {Object} enumMap
+         * @private
+         */
+        #setEnumMap(enumMap) {
+            const enumValueMap = {};
+            const enumNameMap = {};
+            const valueNameMap = {};
+            Object.keys(enumMap).forEach((key) => {
+                const item = enumMap[key];
+                if (!Array.isArray(item)) {
+                    throw new TypeError("初始化参数对象字段的值必是一个array！");
+                }
+                enumValueMap[key] = item[0];
+                enumNameMap[key] = item[1];
+                valueNameMap[item[0]] = item[1];
+            });
+            this.__enumMap__ = Object.freeze(enumMap);
+            this.__enumValueMap__ = Object.freeze(enumValueMap);
+            this.__enumNameMap__ = Object.freeze(enumNameMap);
+            this.__valueNameMap__ = Object.freeze(valueNameMap);
+        }
+        /**
+         * 获取枚举值
+         * @param {String} key 枚举KEY
+         * @return {Number} 枚举值
+         */
+        getVal(key) {
+            return this.__enumValueMap__[key];
+        }
+        /**
+         * 获取多个枚举值
+         * @param {Array} param 多个枚举KEY
+         * @return {Array} {[枚举值]}
+         */
+        getValList(...args) {
+            let keys = Object.keys(this.__enumMap__); // 不传递返回所有
+            if (judgEnumKeys(args)) {
+                keys = Array.from(args);
+            }
+            return keys.map((key) => this.getVal(key));
+        }
+        /**
+         * 获取多个枚举值Map
+         * @param {Array} param 多个枚举KEY，如果不传递则返回所有
+         * @return {Object} {[枚举key]:枚举值}
+         */
+        getValMap(...args) {
+            let keys = Object.keys(this.__enumMap__); // 不传递返回所有
+            if (judgEnumKeys(args)) {
+                keys = Array.from(args);
+            }
+            return keys.reduce((wrap, key) => {
+                wrap[key] = this.getVal(key);
+                return wrap;
+            }, {});
+        }
+        getName(keyOrVal, _config) {
+            const [config] = getConfigParams([_config]);
+            if (config.arguType === "key") {
+                return this.__enumNameMap__[keyOrVal];
+            }
+            else if (config.arguType === "value") {
+                return this.getNameByValue(keyOrVal);
+            }
+            else {
+                throw new TypeError("参数arguType的值类型不为 key|value ！");
+            }
+        }
+        /**
+         * 通过枚举值获取枚举名称
+         * @param {String|Nunber} val
+         * @return {String|Null}
+         */
+        getNameByValue(val) {
+            return this.__valueNameMap__[val];
+        }
+        getOptions(..._args) {
+            const [config, args] = getConfigParams(_args);
+            if (config.arguType === "key") {
+                let keys = Object.keys(this.__enumMap__); // 不传递返回所有
+                if (judgEnumKeys(args)) {
+                    keys = Array.from(args);
+                }
+                return keys.map((key) => {
+                    const value = this.getVal(key);
+                    const name = this.getName(key);
+                    return { [config.valueKey]: value, [config.labelKey]: name };
+                });
+            }
+            else if (config.arguType === "value") {
+                return this.getOptionsByValues(..._args);
+            }
+            else {
+                throw new TypeError("参数arguType的值类型不为 key | value ！");
+            }
+        }
+        getOptionsByValues(..._args) {
+            const [config, args] = getConfigParams(_args);
+            let values = Object.values(this.__enumValueMap__); // 不传递返回所有
+            if (!isEmpty(args)) {
+                values = Array.from(args);
+            }
+            return values.map((value) => {
+                const name = this.getNameByValue(value);
+                return { [config.valueKey]: value, [config.labelKey]: name };
+            });
+        }
+        /**
+         * 检测字段类型
+         * @param {Number} typeVal 类型
+         * @param {String} typeKey 类型key
+         * @return {Boolean}
+         */
+        check(typeVal, typeKey) {
+            return this.getVal(typeKey) === typeVal;
+        }
+    }
+    /**
+     * 创建枚举
+     * @param {Object} enumMap
+     * @param {String} description
+     * @returns
+     */
+    const createEnum = (enumMap) => {
+        const enumInstance = new Enum(enumMap); // 返回实例
+        const e = Object.create(enumInstance);
+        for (const key in enumMap) {
+            e[key] = enumMap[key]?.[0];
+        }
+        return Object.freeze(e);
+    };
+
+    exports.createEnum = createEnum;
+
+}));

package/dist/types/index.d.ts

@@ -0,0 +1,97 @@
+import { IEnum, IEMap, TEUnion, IVMap, IFeildConf, IArgLastConfig, TEValue } from "./typeing";
+/**
+ * 枚举类
+ * @param {Object} enumMap 枚举对象
+ * 枚举格式：
+ * {
+ *    枚举key1: [枚举值1，枚举描述1],
+ *    枚举key2: [枚举值2，枚举描述2]
+ * }
+ */
+declare class Enum<T extends IEMap> {
+    #private;
+    private __enumMap__;
+    private __enumValueMap__;
+    private __enumNameMap__;
+    private __valueNameMap__;
+    /**
+     * @param {Object} enumMap 枚举map
+     */
+    constructor(enumMap: T);
+    /**
+     * 获取枚举值
+     * @param {String} key 枚举KEY
+     * @return {Number} 枚举值
+     */
+    getVal(key: TEUnion<T>): TEValue<T>;
+    /**
+     * 获取多个枚举值
+     * @param {Array} param 多个枚举KEY
+     * @return {Array} {[枚举值]}
+     */
+    getValList(...args: TEUnion<T>[]): TEValue<T>[];
+    /**
+     * 获取多个枚举值Map
+     * @param {Array} param 多个枚举KEY，如果不传递则返回所有
+     * @return {Object} {[枚举key]:枚举值}
+     */
+    getValMap<V extends TEUnion<T>>(...args: V[]): IVMap<V, T>;
+    /**
+     * 获取枚举名称
+     * @param {String} keyOrVal 枚举KEY或枚举值
+     * @param {String} arguType 枚举KEY的类型，key|value
+     * @return {String} 枚举名称
+     */
+    getName<U extends {
+        arguType?: "key";
+    }>(keyOrVal: TEUnion<T>, _config?: U): string;
+    getName<U extends {
+        arguType: "value";
+    }>(keyOrVal: TEValue<T>, _config?: U): string;
+    /**
+     * 通过枚举值获取枚举名称
+     * @param {String|Nunber} val
+     * @return {String|Null}
+     */
+    getNameByValue(val: TEValue<T>): string;
+    /**
+     * 通过枚举KEY或枚举值获取列表选项
+     * @param  {Array} param 多个枚举KEY或枚举值，如果不传递则返回所有。最后一位可以为选项的配置项
+     * @returns {Array} 选项名称、选项值的列表
+     */
+    getOptions<U extends TEUnion<T>[]>(..._args: U): {
+        label: string;
+        value: TEValue<T>;
+    }[];
+    getOptions<U extends [...TEUnion<T>[], {
+        arguType?: "key";
+    } & IFeildConf]>(..._args: U): IArgLastConfig<U, T>[];
+    getOptions<U extends [...TEValue<T>[], {
+        arguType: "value";
+    } & IFeildConf]>(..._args: U): IArgLastConfig<U, T>[];
+    /**
+     * 通过枚举值获取列表选项
+     * @param  {Array} param args 多个枚举值，如果不传递则返回所有。最后一位可以为选项的配置项
+     * @returns {Array} 选项名称、选项值的列表
+     */
+    getOptionsByValues<U extends [...TEValue<T>[], IFeildConf]>(..._args: U): IArgLastConfig<U, T>[];
+    getOptionsByValues<U extends [...TEValue<T>[]]>(..._args: U): {
+        label: string;
+        value: TEValue<T>;
+    }[];
+    /**
+     * 检测字段类型
+     * @param {Number} typeVal 类型
+     * @param {String} typeKey 类型key
+     * @return {Boolean}
+     */
+    check(typeVal: any, typeKey: TEUnion<T>): boolean;
+}
+/**
+ * 创建枚举
+ * @param {Object} enumMap
+ * @param {String} description
+ * @returns
+ */
+declare const createEnum: <T extends IEMap>(enumMap: T) => IEnum<T, Enum<T>>;
+export { createEnum };

package/dist/types/typeing.d.ts

@@ -0,0 +1,30 @@
+export type ITypeData = "undefined" | "null" | "boolean" | "number" | "string" | "symbol" | "function" | "array" | "object" | "date" | "regexp" | "error" | "map" | "set" | "weakmap" | "weakset" | "arraybuffer" | "dataview" | "promise" | "int8array" | "uint8array" | "uint8clampedarray" | "int16array" | "uint16array" | "int32array" | "uint32array" | "float32array" | "float64array" | "bigint64array" | "biguint64array";
+export type IEMap = Readonly<Record<any, readonly [any, any]>>;
+export type TEUnion<T extends IEMap> = keyof T;
+export type TEValue<T extends IEMap> = T[TEUnion<T>][0];
+export type IVMap<U extends string | number | symbol, T extends IEMap> = {
+    [K in U]: T[K] extends readonly [infer V, infer F] ? V : any;
+};
+export type IEnum<T extends IEMap, Enum> = {
+    readonly [K in keyof T]: T[K] extends readonly [infer V, infer F] ? V : any;
+} & Enum;
+export interface IArguConf {
+    arguType?: "key" | "value";
+}
+export interface IFeildConf {
+    labelKey?: string;
+    valueKey?: string;
+}
+export type IConf = IArguConf & IFeildConf;
+export type IArgLastConfig<U, T extends IEMap> = U extends [...infer Rest, infer Last] ? Last extends IConf ? (Last["labelKey"] extends string ? {
+    [K in Last["labelKey"]]: TEValue<T>;
+} : {
+    label: string;
+}) & (Last["valueKey"] extends string ? {
+    [K in Last["valueKey"]]: any;
+} : {
+    value: TEValue<T>;
+}) : {
+    label: string;
+    value: TEValue<T>;
+} : never;

package/dist/types/utils/index.d.ts

@@ -0,0 +1,20 @@
+import { ITypeData } from "../typeing";
+/**
+ * 数据类型
+ * @param {*} data
+ * @param {String} type
+ * @returns {Boolean}
+ */
+export declare function isType<T>(data: T, type: ITypeData): boolean;
+/**
+ * 数据是否为空
+ * @param {*} data
+ * @returns
+ */
+export declare function isEmpty<T>(data: T): boolean;
+/**
+ * 深度拷贝
+ * @param {Object|Array} obj
+ * @return {Object|Array}
+ */
+export declare function deepClone(obj: any): {};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "create-enum-es",
+  "version": "1.0.0",
+  "description": "处理前端枚举的工具方法，支持ts类型检测",
+  "main": "dist/create-enum.es.js",
+  "private": false,
+  "files": [
+    "dist/",
+    "package.json",
+    "README.md"
+  ],
+  "keywords": [
+    "enum",
+    "枚举",
+    "TS"
+  ],
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "rollup -c",
+    "dev": "rollup -cw"
+  },
+  "author": "Xiou.Wang",
+  "license": "ISC",
+  "devDependencies": {
+    "@rollup/plugin-typescript": "^11.1.6",
+    "rollup": "^4.18.1",
+    "typescript": "^5.5.3"
+  }
+}