ts-enum-next 1.0.4 → 1.0.5

package/dist/index.d.ts

@@ -14,11 +14,11 @@ declare abstract class Enum<T extends string | number = string | number> {
      * @description 附加说明
      */
     description?: unknown | undefined);
-    static values<T extends Enum>(): T[];
-    static fromValue<T extends Enum>(this: any, value: T['value']): T;
-    static fromName<T extends Enum>(this: any, name: string): T;
-    static setOf<T extends Enum>(this: any, ...items: T[]): Set<T>;
-    static enumMap<V>(this: any, map: Record<string | number, V>): Map<Enum, V>;
+    static values<T extends Enum>(this: new (...args: any[]) => T): T[];
+    static fromValue<T extends Enum>(this: new (...args: any[]) => T, value: T['value']): T;
+    static fromName<T extends Enum>(this: new (...args: any[]) => T, name: string): T;
+    static setOf<T extends Enum>(this: new (...args: any[]) => T, ...items: T[]): Set<T>;
+    static enumMap<V, T extends Enum = Enum>(this: new (...args: any[]) => T, map: Record<string | number, V>): Map<T, V>;
     toString(): string;
     valueOf(): string;
 }

package/dist/index.js

@@ -21,21 +21,21 @@ class Enum {
     }
     // 获取所有枚举值
     static values() {
-        return this._values.get(this) || [];
+        return Enum._values.get(this) || [];
     }
     // 通过值获取枚举实例
     static fromValue(value) {
-        const enumInstance = this._valueMap.get(this)?.get(value);
+        const enumInstance = Enum._valueMap.get(this)?.get(value);
         if (!enumInstance) {
-            console.error(`No enum value ${value} found`);
+            throw new Error(`No enum value ${value} found`);
         }
         return enumInstance;
     }
     // 通过名称获取枚举实例
     static fromName(name) {
-        const enumInstance = this._nameMap.get(this)?.get(name);
+        const enumInstance = Enum._nameMap.get(this)?.get(name);
         if (!enumInstance) {
-            console.error(`No enum name ${name} found`);
+            throw new Error(`No enum name ${name} found`);
         }
         return enumInstance;
     }
@@ -47,8 +47,21 @@ class Enum {
     static enumMap(map) {
         const result = new Map();
         for (const [key, value] of Object.entries(map)) {
-            const enumKey = isNaN(Number(key)) ? this.fromName(key) : this.fromValue(key);
-            result.set(enumKey, value);
+            // 判断 key 是否为纯数字字符串
+            const isNumericKey = /^\d+$/.test(key);
+            let enumKey;
+            try {
+                enumKey = isNumericKey
+                    ? this.fromValue(Number(key))
+                    : this.fromName(key);
+            }
+            catch {
+                // 如果找不到对应的枚举值，跳过该键
+                continue;
+            }
+            if (enumKey) {
+                result.set(enumKey, value);
+            }
         }
         return result;
     }

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.test.js

@@ -0,0 +1,296 @@
+import { describe, expect, it } from 'vitest';
+import { Enum } from './index';
+// 定义测试用的枚举类
+class HttpStatus extends Enum {
+}
+HttpStatus.OK = new HttpStatus(200, 'OK', 'Request succeeded');
+HttpStatus.CREATED = new HttpStatus(201, 'CREATED', 'Resource created');
+HttpStatus.BAD_REQUEST = new HttpStatus(400, 'BAD_REQUEST', 'Invalid request');
+HttpStatus.NOT_FOUND = new HttpStatus(404, 'NOT_FOUND', 'Resource not found');
+HttpStatus.SERVER_ERROR = new HttpStatus(500, 'SERVER_ERROR', 'Internal server error');
+class OrderStatus extends Enum {
+}
+OrderStatus.PENDING = new OrderStatus('PENDING', 'Pending', 'Order is pending');
+OrderStatus.PROCESSING = new OrderStatus('PROCESSING', 'Processing', 'Order is being processed');
+OrderStatus.COMPLETED = new OrderStatus('COMPLETED', 'Completed', 'Order completed');
+OrderStatus.CANCELLED = new OrderStatus('CANCELLED', 'Cancelled', 'Order cancelled');
+class Priority extends Enum {
+}
+Priority.LOW = new Priority(1, 'LOW');
+Priority.MEDIUM = new Priority(2, 'MEDIUM');
+Priority.HIGH = new Priority(3, 'HIGH');
+describe('Enum', () => {
+    describe('Constructor and basic properties', () => {
+        it('should create enum instance with value, name and description', () => {
+            expect(HttpStatus.OK.value).toBe(200);
+            expect(HttpStatus.OK.name).toBe('OK');
+            expect(HttpStatus.OK.description).toBe('Request succeeded');
+        });
+        it('should create enum instance without description', () => {
+            expect(Priority.LOW.value).toBe(1);
+            expect(Priority.LOW.name).toBe('LOW');
+            expect(Priority.LOW.description).toBeUndefined();
+        });
+        it('should support string value enums', () => {
+            expect(OrderStatus.PENDING.value).toBe('PENDING');
+            expect(OrderStatus.PENDING.name).toBe('Pending');
+            expect(OrderStatus.PENDING.description).toBe('Order is pending');
+        });
+        it('should support number value enums', () => {
+            expect(HttpStatus.NOT_FOUND.value).toBe(404);
+            expect(HttpStatus.NOT_FOUND.name).toBe('NOT_FOUND');
+        });
+    });
+    describe('values()', () => {
+        it('should return all enum values for HttpStatus', () => {
+            const values = HttpStatus.values();
+            expect(values).toHaveLength(5);
+            expect(values).toContain(HttpStatus.OK);
+            expect(values).toContain(HttpStatus.CREATED);
+            expect(values).toContain(HttpStatus.BAD_REQUEST);
+            expect(values).toContain(HttpStatus.NOT_FOUND);
+            expect(values).toContain(HttpStatus.SERVER_ERROR);
+        });
+        it('should return all enum values for OrderStatus', () => {
+            const values = OrderStatus.values();
+            expect(values).toHaveLength(4);
+            expect(values).toContain(OrderStatus.PENDING);
+            expect(values).toContain(OrderStatus.PROCESSING);
+            expect(values).toContain(OrderStatus.COMPLETED);
+            expect(values).toContain(OrderStatus.CANCELLED);
+        });
+        it('should return all enum values for Priority', () => {
+            const values = Priority.values();
+            expect(values).toHaveLength(3);
+            expect(values).toContain(Priority.LOW);
+            expect(values).toContain(Priority.MEDIUM);
+            expect(values).toContain(Priority.HIGH);
+        });
+        it('should not share values between different enum classes', () => {
+            const httpValues = HttpStatus.values();
+            const orderValues = OrderStatus.values();
+            expect(httpValues).not.toEqual(orderValues);
+        });
+    });
+    describe('fromValue()', () => {
+        it('should find enum by numeric value', () => {
+            const status = HttpStatus.fromValue(200);
+            expect(status).toBe(HttpStatus.OK);
+            expect(status.name).toBe('OK');
+        });
+        it('should find enum by string value', () => {
+            const status = OrderStatus.fromValue('PENDING');
+            expect(status).toBe(OrderStatus.PENDING);
+            expect(status.name).toBe('Pending');
+        });
+        it('should find different enum instances by different values', () => {
+            expect(HttpStatus.fromValue(200)).toBe(HttpStatus.OK);
+            expect(HttpStatus.fromValue(404)).toBe(HttpStatus.NOT_FOUND);
+            expect(HttpStatus.fromValue(500)).toBe(HttpStatus.SERVER_ERROR);
+        });
+        it('should throw error for non-existent numeric value', () => {
+            expect(() => HttpStatus.fromValue(999)).toThrow('No enum value 999 found');
+        });
+        it('should throw error for non-existent string value', () => {
+            expect(() => OrderStatus.fromValue('INVALID')).toThrow('No enum value INVALID found');
+        });
+    });
+    describe('fromName()', () => {
+        it('should find enum by name', () => {
+            const status = HttpStatus.fromName('OK');
+            expect(status).toBe(HttpStatus.OK);
+            expect(status.value).toBe(200);
+        });
+        it('should find enum by name for string value enum', () => {
+            const status = OrderStatus.fromName('Pending');
+            expect(status).toBe(OrderStatus.PENDING);
+            expect(status.value).toBe('PENDING');
+        });
+        it('should find different enum instances by different names', () => {
+            expect(HttpStatus.fromName('OK')).toBe(HttpStatus.OK);
+            expect(HttpStatus.fromName('NOT_FOUND')).toBe(HttpStatus.NOT_FOUND);
+            expect(HttpStatus.fromName('SERVER_ERROR')).toBe(HttpStatus.SERVER_ERROR);
+        });
+        it('should throw error for non-existent name', () => {
+            expect(() => HttpStatus.fromName('INVALID')).toThrow('No enum name INVALID found');
+        });
+        it('should be case-sensitive', () => {
+            expect(() => HttpStatus.fromName('ok')).toThrow('No enum name ok found');
+        });
+    });
+    describe('setOf()', () => {
+        it('should create a Set containing specified enum values', () => {
+            const errorStatuses = HttpStatus.setOf(HttpStatus.BAD_REQUEST, HttpStatus.NOT_FOUND, HttpStatus.SERVER_ERROR);
+            expect(errorStatuses.size).toBe(3);
+            expect(errorStatuses.has(HttpStatus.BAD_REQUEST)).toBe(true);
+            expect(errorStatuses.has(HttpStatus.NOT_FOUND)).toBe(true);
+            expect(errorStatuses.has(HttpStatus.SERVER_ERROR)).toBe(true);
+            expect(errorStatuses.has(HttpStatus.OK)).toBe(false);
+        });
+        it('should create empty Set when no arguments provided', () => {
+            const emptySet = HttpStatus.setOf();
+            expect(emptySet.size).toBe(0);
+        });
+        it('should handle duplicate values', () => {
+            const set = HttpStatus.setOf(HttpStatus.OK, HttpStatus.OK, HttpStatus.NOT_FOUND);
+            expect(set.size).toBe(2);
+        });
+        it('should work with string value enums', () => {
+            const activeStatuses = OrderStatus.setOf(OrderStatus.PENDING, OrderStatus.PROCESSING);
+            expect(activeStatuses.size).toBe(2);
+            expect(activeStatuses.has(OrderStatus.PENDING)).toBe(true);
+            expect(activeStatuses.has(OrderStatus.PROCESSING)).toBe(true);
+            expect(activeStatuses.has(OrderStatus.COMPLETED)).toBe(false);
+        });
+    });
+    describe('enumMap()', () => {
+        it('should create map using numeric value as key', () => {
+            const statusMessages = HttpStatus.enumMap({
+                200: 'Success',
+                404: 'Not Found',
+                500: 'Error'
+            });
+            expect(statusMessages.size).toBe(3);
+            expect(statusMessages.get(HttpStatus.OK)).toBe('Success');
+            expect(statusMessages.get(HttpStatus.NOT_FOUND)).toBe('Not Found');
+            expect(statusMessages.get(HttpStatus.SERVER_ERROR)).toBe('Error');
+        });
+        it('should create map using name as key', () => {
+            const statusMessages = HttpStatus.enumMap({
+                OK: 'Operation successful',
+                NOT_FOUND: 'Resource does not exist'
+            });
+            expect(statusMessages.size).toBe(2);
+            expect(statusMessages.get(HttpStatus.OK)).toBe('Operation successful');
+            expect(statusMessages.get(HttpStatus.NOT_FOUND)).toBe('Resource does not exist');
+        });
+        it('should create map mixing numeric and name keys', () => {
+            const statusMessages = HttpStatus.enumMap({
+                200: 'Success',
+                NOT_FOUND: 'Resource does not exist',
+                500: 'Error'
+            });
+            expect(statusMessages.size).toBe(3);
+            expect(statusMessages.get(HttpStatus.OK)).toBe('Success');
+            expect(statusMessages.get(HttpStatus.NOT_FOUND)).toBe('Resource does not exist');
+            expect(statusMessages.get(HttpStatus.SERVER_ERROR)).toBe('Error');
+        });
+        it('should skip invalid keys silently', () => {
+            const statusMessages = HttpStatus.enumMap({
+                200: 'Success',
+                999: 'Invalid',
+                INVALID_NAME: 'Also Invalid'
+            });
+            expect(statusMessages.size).toBe(1);
+            expect(statusMessages.get(HttpStatus.OK)).toBe('Success');
+        });
+        it('should work with string value enums', () => {
+            const orderMessages = OrderStatus.enumMap({
+                Pending: 'Waiting for payment',
+                Completed: 'Order finished'
+            });
+            expect(orderMessages.size).toBe(2);
+            expect(orderMessages.get(OrderStatus.PENDING)).toBe('Waiting for payment');
+            expect(orderMessages.get(OrderStatus.COMPLETED)).toBe('Order finished');
+        });
+        it('should create empty map for empty input', () => {
+            const emptyMap = HttpStatus.enumMap({});
+            expect(emptyMap.size).toBe(0);
+        });
+        it('should handle complex value types', () => {
+            const statusConfig = HttpStatus.enumMap({
+                200: { color: 'green', icon: 'check' },
+                400: { color: 'orange', icon: 'warning' },
+                NOT_FOUND: { color: 'red', icon: 'error' }
+            });
+            expect(statusConfig.get(HttpStatus.OK)).toEqual({ color: 'green', icon: 'check' });
+            expect(statusConfig.get(HttpStatus.BAD_REQUEST)).toEqual({ color: 'orange', icon: 'warning' });
+            expect(statusConfig.get(HttpStatus.NOT_FOUND)).toEqual({ color: 'red', icon: 'error' });
+        });
+    });
+    describe('toString()', () => {
+        it('should return the name', () => {
+            expect(HttpStatus.OK.toString()).toBe('OK');
+            expect(OrderStatus.PENDING.toString()).toBe('Pending');
+        });
+        it('should work with string concatenation', () => {
+            // valueOf() is called during string concatenation, which returns the value
+            const messageWithValue = 'Status: ' + HttpStatus.OK;
+            expect(messageWithValue).toBe('Status: 200');
+            // Use toString() explicitly to get the name
+            const messageWithName = 'Status: ' + HttpStatus.OK.toString();
+            expect(messageWithName).toBe('Status: OK');
+        });
+    });
+    describe('valueOf()', () => {
+        it('should return string representation of numeric value', () => {
+            expect(HttpStatus.OK.valueOf()).toBe('200');
+            expect(HttpStatus.NOT_FOUND.valueOf()).toBe('404');
+        });
+        it('should return string value for string enum', () => {
+            expect(OrderStatus.PENDING.valueOf()).toBe('PENDING');
+            expect(OrderStatus.COMPLETED.valueOf()).toBe('COMPLETED');
+        });
+    });
+    describe('Multiple enum classes isolation', () => {
+        it('should maintain separate instances for different enum classes', () => {
+            expect(HttpStatus.values().length).toBe(5);
+            expect(OrderStatus.values().length).toBe(4);
+            expect(Priority.values().length).toBe(3);
+        });
+        it('should not interfere with each other when querying by value', () => {
+            // 虽然值相同，但是不同的枚举类
+            expect(() => HttpStatus.fromValue('PENDING')).toThrow();
+            expect(() => OrderStatus.fromValue(200)).toThrow();
+        });
+        it('should not interfere with each other when querying by name', () => {
+            expect(() => HttpStatus.fromName('Pending')).toThrow();
+            expect(() => OrderStatus.fromName('OK')).toThrow();
+        });
+    });
+    describe('Edge cases', () => {
+        it('should handle enum with same value but different names', () => {
+            class DuplicateValueEnum extends Enum {
+            }
+            DuplicateValueEnum.FIRST = new DuplicateValueEnum(1, 'FIRST');
+            DuplicateValueEnum.SECOND = new DuplicateValueEnum(1, 'SECOND');
+            // 最后一个定义的会覆盖前面的（Map 的行为）
+            const found = DuplicateValueEnum.fromValue(1);
+            expect(found.name).toBe('SECOND');
+        });
+        it('should handle description as different types', () => {
+            class MixedDescEnum extends Enum {
+            }
+            MixedDescEnum.STRING_DESC = new MixedDescEnum(1, 'STRING', 'string description');
+            MixedDescEnum.NUMBER_DESC = new MixedDescEnum(2, 'NUMBER', 42);
+            MixedDescEnum.OBJECT_DESC = new MixedDescEnum(3, 'OBJECT', { key: 'value' });
+            MixedDescEnum.ARRAY_DESC = new MixedDescEnum(4, 'ARRAY', ['a', 'b']);
+            expect(MixedDescEnum.STRING_DESC.description).toBe('string description');
+            expect(MixedDescEnum.NUMBER_DESC.description).toBe(42);
+            expect(MixedDescEnum.OBJECT_DESC.description).toEqual({ key: 'value' });
+            expect(MixedDescEnum.ARRAY_DESC.description).toEqual(['a', 'b']);
+        });
+        it('should work with zero and empty string values', () => {
+            class EdgeValueEnum extends Enum {
+            }
+            EdgeValueEnum.ZERO = new EdgeValueEnum(0, 'ZERO');
+            EdgeValueEnum.EMPTY = new EdgeValueEnum('', 'EMPTY');
+            expect(EdgeValueEnum.fromValue(0)).toBe(EdgeValueEnum.ZERO);
+            expect(EdgeValueEnum.fromValue('')).toBe(EdgeValueEnum.EMPTY);
+        });
+    });
+    describe('Type exports', () => {
+        it('should have correct EnumValueType', () => {
+            const numValue = 123;
+            const strValue = 'test';
+            expect(typeof numValue).toBe('number');
+            expect(typeof strValue).toBe('string');
+        });
+        it('should extract enum values with EnumValues type', () => {
+            const value1 = 200;
+            const value2 = 404;
+            expect(value1).toBe(200);
+            expect(value2).toBe(404);
+        });
+    });
+});

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "ts-enum-next",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Ultimate Enum Enhancement for TypeScript",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "prepublishOnly": "pnpm run build"
   },
   "keywords": [
@@ -24,7 +27,7 @@
   "homepage": "https://github.com/ricoNext/ts-enum-next",
   "repository": {
     "type": "git",
-    "url": "https://github.com/ricoNext/ts-enum-next.git"
+    "url": "git+https://github.com/ricoNext/ts-enum-next.git"
   },
   "authors": {
     "name": "ricoNext",
@@ -32,6 +35,8 @@
   },
   "license": "ISC",
   "devDependencies": {
-    "typescript": "^5.8.3"
+    "@vitest/coverage-v8": "^4.0.16",
+    "typescript": "^5.8.3",
+    "vitest": "^4.0.16"
   }
 }