create-enum-es 1.0.3 → 3.0.0

package/dist/index.d.ts

@@ -1,127 +1,184 @@
-type IEMap = Readonly<Record<any, readonly [any, any]>>;
+/**
+ * 宽化字面量类型
+ */
+type WidenLiteral<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
+/**
+ * 枚举 Map 约束类型：{ KEY: [value, label, extra?] }
+ */
+type IEMap = Readonly<Record<string, readonly [any, any, any?]>>;
+/**
+ * 枚举 Key 联合类型
+ */
 type TEUnion<T extends IEMap> = keyof T;
-type TEValue<T extends IEMap> = T[TEUnion<T>][0];
-type IVMap<U extends string | number | symbol, T extends IEMap> = {
-    [K in U]: T[K] extends readonly [infer V, infer F] ? V : any;
+/**
+ * 枚举 Value 联合类型
+ */
+type TEValue<T extends IEMap> = T[keyof T][0];
+/**
+ * 根据 Key 获取 Value 类型
+ */
+type TValue<K, T extends IEMap> = WidenLiteral<T[K & keyof T][0]>;
+/**
+ * 根据 Key 获取 Label 类型
+ */
+type TULabel<K, T extends IEMap> = WidenLiteral<T[K & keyof T][1]>;
+/**
+ * 根据 Value 获取 Label 类型
+ */
+type TVLabel<V, T extends IEMap> = WidenLiteral<Extract<T[keyof T], readonly [V, any, any?]>[1]>;
+/**
+ * 根据 Key 获取 Extra 类型
+ */
+type TUExtra<K, T extends IEMap> = WidenLiteral<T[K & keyof T][2]>;
+/**
+ * 根据 Value 获取 Extra 类型
+ */
+type TVExtra<V, T extends IEMap> = WidenLiteral<Extract<T[keyof T], readonly [V, any, any?]>[2]>;
+/**
+ * 根据 Value 反查 Key 类型
+ */
+type TKeyOfValue<V, T extends IEMap> = {
+    [K in keyof T]: T[K][0] extends V ? K : never;
+}[keyof T];
+/**
+ * Option 项类型
+ */
+type TOption<K extends keyof T, T extends IEMap> = {
+    value: TValue<K, T>;
+    label: TULabel<K, T>;
+    extra: TUExtra<K, T>;
 };
-type IEnum<T extends IEMap, Enum> = {
-    readonly [K in keyof T]: T[K] extends readonly [infer V, infer F] ? V : any;
-} & Enum;
-interface IArguConf {
-    arguType?: "key" | "value";
-}
-interface IFeildConf {
-    labelKey?: string;
-    valueKey?: string;
-}
-type IConf = IArguConf & IFeildConf;
-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;
-
 /**
- * 枚举类
- * @param {Object} enumMap 枚举对象
- * 枚举格式：
- * {
- *    枚举key1: [枚举值1，枚举描述1],
- *    枚举key2: [枚举值2，枚举描述2]
- * }
+ * 排除指定 Key 后的枚举类型
+ */
+type TOmitEnum<T extends IEMap, K extends keyof T> = Omit<T, K> extends infer R ? R extends IEMap ? R : never : never;
+/**
+ * 选取指定 Key 的枚举类型
+ */
+type TPickEnum<T extends IEMap, K extends keyof T> = Pick<T, K> extends infer R ? R extends IEMap ? R : never : never;
+/**
+ * 最终暴露的枚举实例类型
  */
+type IEnum<T extends IEMap> = {
+    readonly [K in keyof T]: T[K][0];
+} & Enum<T>;
 declare class Enum<T extends IEMap> {
-    #private;
-    private __enumMap__;
-    private __enumValueMap__;
-    private __enumNameMap__;
-    private __valueNameMap__;
+    protected readonly __enumMap__: T;
+    protected readonly __enumLabelMap__: Record<string | number, unknown>;
+    protected readonly __enumExtraMap__: Record<string | number, unknown>;
+    protected readonly __valueKeyMap__: Record<string | number, string>;
+    constructor(enumMap: T);
     /**
-     * @param {Object} enumMap 枚举map
+     * 获取所有枚举 Key 列表
      */
-    constructor(enumMap: T);
+    keys(): TEUnion<T>[];
     /**
      * 获取枚举值
-     * @param {String} key 枚举KEY
-     * @return {Number} 枚举值
+     * @param key 枚举 Key
      */
-    getVal(key: TEUnion<T>): TEValue<T>;
+    value<K extends TEUnion<T>>(key: K): TValue<K, T>;
     /**
-     * 获取多个枚举值
-     * @param {Array} param 多个枚举KEY
-     * @return {Array} {[枚举值]}
+     * 获取多个枚举值，不传参则返回所有
+     * @param args 枚举 Key 列表
      */
-    getValList(...args: TEUnion<T>[]): TEValue<T>[];
+    values<K extends TEUnion<T>>(...args: K[]): TValue<K, T>[];
     /**
-     * 获取多个枚举值Map
-     * @param {Array} param 多个枚举KEY，如果不传递则返回所有
-     * @return {Object} {[枚举key]:枚举值}
+     * 获取枚举选项列表（适配 Select/Radio 等组件），不传参则返回所有
+     * @param args 枚举 Key 列表
      */
-    getValMap<V extends TEUnion<T>>(...args: V[]): IVMap<V, T>;
+    options<K extends TEUnion<T>>(...args: K[]): TOption<K, T>[];
     /**
-     * 获取枚举名称
-     * @param {String} keyOrVal 枚举KEY或枚举值
-     * @param {String} arguType 枚举KEY的类型，key|value
-     * @return {String} 枚举名称
+     * 获取枚举名称（通过 Key 或 Value）
+     * @param keyOrVal 枚举 Key 或 Value
      */
-    getName<U extends {
-        arguType?: "key";
-    }>(keyOrVal: TEUnion<T>, _config?: U): string;
-    getName<U extends {
-        arguType: "value";
-    }>(keyOrVal: TEValue<T>, _config?: U): string;
+    label<K extends TEUnion<T>>(key: K): TULabel<K, T>;
+    label<V extends TEValue<T>>(val: V): TVLabel<V, T>;
     /**
-     * 通过枚举值获取枚举名称
-     * @param {String|Nunber} val
-     * @return {String|Null}
+     * 获取枚举附加数据（通过 Key 或 Value）
+     * @param keyOrVal 枚举 Key 或 Value
      */
-    getNameByValue(val: TEValue<T>): string;
+    extra<K extends TEUnion<T>>(key: K): TUExtra<K, T>;
+    extra<V extends TEValue<T>>(val: V): TVExtra<V, T>;
     /**
-     * 通过枚举KEY或枚举值获取列表选项
-     * @param  {Array} param 多个枚举KEY或枚举值，如果不传递则返回所有。最后一位可以为选项的配置项
-     * @returns {Array} 选项名称、选项值的列表
+     * 通过 Value 反查 Key
+     * @param val 枚举 Value
      */
-    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>;
-    }[];
+    keyOf<V extends TEValue<T>>(val: V): TKeyOfValue<V, T>;
+    /**
+     * 检测值是否等于指定枚举 Key 对应的值
+     * @param val 待检测的值
+     * @param key 枚举 Key
+     */
+    check<K extends TEUnion<T>>(val: unknown, key: K): boolean;
+    /**
+     * 检测值是否属于该枚举的任意一个值
+     * @param val 待检测的值
+     */
+    has(val: unknown): val is TEValue<T>;
+    /**
+     * 获取枚举项数量
+     */
+    get size(): number;
     /**
-     * 检测字段类型
-     * @param {Number} typeVal 类型
-     * @param {String} typeKey 类型key
-     * @return {Boolean}
+     * 排除指定 Key，生成新的枚举实例
+     * @param args 要排除的 Key 列表
      */
-    check(typeVal: any, typeKey: TEUnion<T>): boolean;
+    omit<K extends TEUnion<T>>(...args: K[]): Readonly<IEnum<TOmitEnum<T, K>>>;
+    /**
+     * 选取指定 Key，生成新的枚举实例
+     * @param args 要保留的 Key 列表
+     */
+    pick<K extends TEUnion<T>>(...args: K[]): Readonly<IEnum<TPickEnum<T, K & string>>>;
+    /**
+     * 遍历枚举项
+     * @param callback 回调函数 (value, label, key, extra) => void
+     */
+    forEach(callback: (value: TEValue<T>, label: unknown, key: TEUnion<T>, extra: unknown) => void): void;
+    /**
+     * 将枚举转为 Map 对象 { value => label }
+     */
+    toMap(): Map<TEValue<T>, unknown>;
+    /**
+     * 将枚举转为 Record 对象 { [value]: label }
+     */
+    toRecord(): Record<string | number, unknown>;
+    /**
+     * 过滤枚举项，返回满足条件的 options
+     * @param predicate 过滤函数
+     */
+    filter(predicate: (value: TEValue<T>, label: unknown, key: TEUnion<T>, extra: unknown) => boolean): TOption<TEUnion<T>, T>[];
+    /**
+     * 支持 for...of 迭代
+     */
+    [Symbol.iterator](): Iterator<{
+        key: TEUnion<T>;
+        value: TEValue<T>;
+        label: unknown;
+        extra: unknown;
+    }>;
 }
 /**
- * 创建枚举
- * @param {Object} enumMap
- * @param {String} description
- * @returns
+ * 创建枚举实例
+ * @param enumMap 枚举定义对象，格式：{ KEY: [value, label, extra?] as const }
+ *
+ * @example
+ * const Status = createEnum({
+ *   ACTIVE:   [1, '激活', { color: 'green' }],
+ *   INACTIVE: [0, '未激活', { color: 'gray' }],
+ * } as const);
+ *
+ * Status.ACTIVE          // 1
+ * Status.value('ACTIVE') // 1
+ * Status.label('ACTIVE') // '激活'
+ * Status.label(1)        // '激活'
+ * Status.extra('ACTIVE') // { color: 'green' }
+ * Status.keyOf(1)        // 'ACTIVE'
+ * Status.has(1)          // true
+ * Status.has(99)         // false
+ * Status.options()       // [{ value: 1, label: '激活', extra: {...} }, ...]
+ * Status.pick('ACTIVE')  // 新枚举，仅包含 ACTIVE
+ * Status.omit('INACTIVE')// 新枚举，排除 INACTIVE
  */
-declare const createEnum: <T extends IEMap>(enumMap: T) => IEnum<T, Enum<T>>;
+declare const createEnum: <T extends IEMap>(enumMap: T) => Readonly<IEnum<T>>;
 
-export { createEnum };
+export { createEnum as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-enum-es",
-  "version": "1.0.3",
+  "version": "3.0.0",
   "description": "处理前端枚举的工具方法，支持ts类型检测",
   "main": "dist/create-enum.es.js",
   "types": "dist/index.d.ts",
@@ -24,16 +24,19 @@
   ],
   "type": "module",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "vitest --run",
     "build": "rollup -c",
     "dev": "rollup -cw"
   },
   "author": "Xiou.Wang",
   "license": "ISC",
   "devDependencies": {
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^11.1.6",
-    "rollup": "^4.18.1",
+    "rollup": "^4.45.1",
     "rollup-plugin-dts": "^6.1.1",
-    "typescript": "^5.5.3"
+    "typescript": "^5.5.3",
+    "vitest": "^4.1.9"
   }
 }