ts-enum-next 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ricoNext
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,89 @@
+# ts-enum-next
+
+<b>English | <a href="./README.zh-CN.md">中文</a></b>
+
+- The ultimate solution for next-generation enumeration in TypeScript
+
+- Define and use enum in typescript like using enum in java.
+
+## Why？ 
+
+It is very convenient to use enum to define numeric enums and string enums in typescript, but when you are defining some enums of numeric dictionary types, you are a little overwhelmed. For example, when we define a set of states, we need to define the name of the state at the same time. We can combine enumerations and mapping objects in typescript to implement it.
+
+```ts
+enum Status {
+    PENDING = 0,
+    APPROVED = 1,
+    REJECTED = 2
+}
+
+const StatusDescriptions = {
+    [Status.PENDING]: "waiting",
+    [Status.APPROVED]: "Approved",
+    [Status.REJECTED]: "reject"
+};
+
+console.log(Status.PENDING); // 0
+console.log(StatusDescriptions[Status.PENDING]); // "waiting"
+```
+
+In simple projects, maintaining a "data dictionary" is a good way to do this, but in complex projects, we may need to maintain a large number of "data dictionaries", and these "data dictionaries" may require some inheritance of some "dictionaries" to generate new "dictionaries", or in the business we display different colors for different descriptions in a set of enum values ​​or perform different methods. At this time, the native enum of typescript begins to appear unsatisfied.
+
+ts-enum-next According to the definition and use of enum in java, an enum definition and use paradigm similar to java is provided. You can implement Class-based enum definition and use.
+
+## How to use？
+
+### install
+
+```bash
+pnpm add ts-enum-next
+```
+
+### Define data dictionary
+```ts
+class HttpStatus extends Enum<number> {
+	static readonly OK = new HttpStatus(200, 'OK', 'Request succeeded');
+	static readonly BAD_REQUEST = new HttpStatus(400, 'BAD_REQUEST', 'Error request');
+	static readonly NOT_FOUND = new HttpStatus(404, 'NOT_FOUND');
+}
+```
+
+### Using a data dictionary
+
+* Get dictionary items
+
+```ts
+console.log(HttpStatus.OK.description); // "Request succeeded"
+console.log(HttpStatus.fromValue(404).name); // "NOT_FOUND"
+console.log(HttpStatus.fromName("BAD_REQUEST").value); // 400
+```
+
+* Get all enum values
+
+```ts
+const allStatuses = HttpStatus.values();
+console.log(allStatuses.map(s => s.name)); // ["OK", "BAD_REQUEST", "NOT_FOUND"]
+```
+
+* Using enumeration collection
+
+```ts
+const errorStatuses = HttpStatus.setOf(
+    HttpStatus.BAD_REQUEST,
+    HttpStatus.NOT_FOUND
+);
+console.log(errorStatuses.has(HttpStatus.fromValue(400))); // true
+```
+
+* Using enumeration map
+
+```ts
+const statusMessages = HttpStatus.enumMap({
+    [HttpStatus.OK.value]: "Operation is successful",
+    [HttpStatus.BAD_REQUEST.value]: "Request error",
+    "NOT_FOUND": "The resource does not exist" 
+});
+console.log(statusMessages.get(HttpStatus.NOT_FOUND)); // "The resource does not exist"
+``
+
+

package/README.zh-CN.md

@@ -0,0 +1,91 @@
+# ts-enum-next
+
+<b>English | <a href="./README.zh-CN.md">中文</a></b>
+
+- TypeScript 中下一代枚举的终极解决方案
+
+- 像在 java 中使用 enum 一样，在 typescript 中定义和使用 enum。
+
+## 为什么？ 
+
+在 typescript 中使用 enum 来定义数字枚举和字符串枚举是非常方便的， 但是在面对一些数字字典类型的枚举做定义时就有点力不从心, 比如我们定义一组状态时需要同时定义状态的名称， 我们可以就需要结合 typescript 中的枚举和映射对象来实现
+
+```ts
+enum Status {
+    PENDING = 0,
+    APPROVED = 1,
+    REJECTED = 2
+}
+
+const StatusDescriptions = {
+    [Status.PENDING]: "等待处理",
+    [Status.APPROVED]: "已批准",
+    [Status.REJECTED]: "已拒绝"
+};
+
+// 使用示例
+console.log(Status.PENDING); // 0
+console.log(StatusDescriptions[Status.PENDING]); // "等待处理"
+```
+
+在简单的项目中，这样维护“数据字典”是一个不错的方法， 但是在复杂的项目中，我们可能会需要维护大量的“数据字典”， 并且这些“数据字典” 可能需要一些继承一些“字典” 生成新的“字典”，或者业务中我们对一组枚举值中的不同描述展示不同的颜色或者执行不同的方法，这时 typescript 原生的 enum 就开始显得力不从心了
+
+ts-enum-next 根据 java 中对于 enum 的定义和使用，提供了一套类似于 java 的 enum 定义和使用范式， 你可以实现基于 Class 的枚举定义和使用。
+
+
+## 使用
+
+### 安装
+
+```bash
+pnpm add ts-enum-next
+```
+
+### 定义数据字典
+```ts
+class HttpStatus extends Enum<number> {
+	static readonly OK = new HttpStatus(200, 'OK', '请求成功');
+	static readonly BAD_REQUEST = new HttpStatus(400, 'BAD_REQUEST', '错误请求');
+	static readonly NOT_FOUND = new HttpStatus(404, 'NOT_FOUND');
+}
+```
+
+### 使用数据字典
+
+* 获取字典项 
+
+```ts
+console.log(HttpStatus.OK.description); // "请求成功"
+console.log(HttpStatus.fromValue(404).name); // "NOT_FOUND"
+console.log(HttpStatus.fromName("BAD_REQUEST").value); // 400
+```
+
+* 获取所有枚举值
+
+```ts
+const allStatuses = HttpStatus.values();
+console.log(allStatuses.map(s => s.name)); // ["OK", "BAD_REQUEST", "NOT_FOUND"]
+```
+
+* 使用枚举集合
+
+```ts
+const errorStatuses = HttpStatus.setOf(
+    HttpStatus.BAD_REQUEST,
+    HttpStatus.NOT_FOUND
+);
+console.log(errorStatuses.has(HttpStatus.fromValue(400))); // true
+```
+
+* 使用枚举映射表
+
+```ts
+const statusMessages = HttpStatus.enumMap({
+    [HttpStatus.OK.value]: "操作成功",
+    [HttpStatus.BAD_REQUEST.value]: "请求错误",
+    "NOT_FOUND": "资源不存在" // 支持名称或值作为键
+});
+console.log(statusMessages.get(HttpStatus.NOT_FOUND)); // "资源不存在"
+``
+
+

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+type EnumValueType = number | string;
+declare abstract class Enum<T extends EnumValueType> {
+    readonly value: T;
+    readonly name: string;
+    readonly description?: string | undefined;
+    private static _values;
+    private static _valueMap;
+    private static _nameMap;
+    constructor(value: T, name: string, description?: string | undefined);
+    static values<T extends Enum<any>>(this: typeof Enum): T[];
+    static fromValue<T extends Enum<any>>(this: any, value: T['value']): T;
+    static fromName<T extends Enum<any>>(this: typeof Enum, name: string): T;
+    static setOf<T extends Enum<any>>(this: new () => T, ...items: T[]): Set<T>;
+    static enumMap<T extends Enum<any>, V>(this: typeof Enum, map: Record<string | number, V>): Map<T, V>;
+    toString(): string;
+    valueOf(): T;
+}
+export { Enum };
+export type { EnumValueType };

package/dist/index.js

@@ -0,0 +1,63 @@
+class Enum {
+    constructor(value, name, description) {
+        this.value = value;
+        this.name = name;
+        this.description = description;
+        const enumClass = this.constructor;
+        // 初始化存储结构
+        if (!Enum._values.has(enumClass)) {
+            Enum._values.set(enumClass, []);
+            Enum._valueMap.set(enumClass, new Map());
+            Enum._nameMap.set(enumClass, new Map());
+        }
+        // 注册当前枚举实例
+        Enum._values.get(enumClass).push(this);
+        Enum._valueMap.get(enumClass).set(value, this);
+        Enum._nameMap.get(enumClass).set(name, this);
+    }
+    // 获取所有枚举值
+    static values() {
+        return this._values.get(this) || [];
+    }
+    // 通过值获取枚举实例
+    static fromValue(value) {
+        const enumInstance = this._valueMap.get(this)?.get(value);
+        if (!enumInstance) {
+            console.error(`No enum value ${value} found`);
+        }
+        return enumInstance;
+    }
+    // 通过名称获取枚举实例
+    static fromName(name) {
+        const enumInstance = this._nameMap.get(this)?.get(name);
+        if (!enumInstance) {
+            console.error(`No enum name ${name} found`);
+        }
+        return enumInstance;
+    }
+    // 创建枚举集合
+    static setOf(...items) {
+        return new Set(items);
+    }
+    // 创建枚举映射表
+    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);
+        }
+        return result;
+    }
+    // 重写toString方法
+    toString() {
+        return this.name;
+    }
+    // 重写valueOf方法
+    valueOf() {
+        return this.value;
+    }
+}
+Enum._values = new Map();
+Enum._valueMap = new Map();
+Enum._nameMap = new Map();
+export { Enum };

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "ts-enum-next",
+  "version": "1.0.0",
+  "description": "Ultimate Enum Enhancement for TypeScript",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "typescript",
+    "enum",
+    "enhancement",
+    "utility",
+    "enum-next",
+    "java"
+  ],
+  "author": "rico",
+  "license": "ISC",
+  "devDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}

package/src/index.ts

@@ -0,0 +1,78 @@
+type EnumValueType = number | string;
+
+abstract class Enum<T extends EnumValueType> {
+	private static _values: Map<typeof Enum, Enum<any>[]> = new Map();
+	private static _valueMap: Map<typeof Enum, Map<EnumValueType, Enum<any>>> = new Map();
+	private static _nameMap: Map<typeof Enum, Map<string, Enum<any>>> = new Map();
+
+	constructor(
+		public readonly value: T,
+		public readonly name: string,
+		public readonly description?: string
+	) {
+		const enumClass = this.constructor as typeof Enum;
+
+		// 初始化存储结构
+		if (!Enum._values.has(enumClass)) {
+			Enum._values.set(enumClass, []);
+			Enum._valueMap.set(enumClass, new Map());
+			Enum._nameMap.set(enumClass, new Map());
+		}
+
+		// 注册当前枚举实例
+		Enum._values.get(enumClass)!.push(this);
+		Enum._valueMap.get(enumClass)!.set(value, this);
+		Enum._nameMap.get(enumClass)!.set(name, this);
+	}
+
+	// 获取所有枚举值
+	static values<T extends Enum<any>>(this: typeof Enum): T[] {
+		return (this._values.get(this) as T[]) || [];
+	}
+
+	// 通过值获取枚举实例
+	static fromValue<T extends Enum<any>>(this: any, value: T['value']): T {
+		const enumInstance = this._valueMap.get(this)?.get(value);
+		if (!enumInstance) {
+			console.error(`No enum value ${value} found`);
+		}
+		return enumInstance as T;
+	}
+
+	// 通过名称获取枚举实例
+	static fromName<T extends Enum<any>>(this: typeof Enum, name: string): T {
+		const enumInstance = this._nameMap.get(this)?.get(name);
+		if (!enumInstance) {
+			console.error(`No enum name ${name} found`);
+		}
+		return enumInstance as T;
+	}
+
+	// 创建枚举集合
+	static setOf<T extends Enum<any>>(this: new () => T, ...items: T[]): Set<T> {
+		return new Set(items);
+	}
+
+	// 创建枚举映射表
+	static enumMap<T extends Enum<any>, V>(this: typeof Enum, map: Record<string | number, V>): Map<T, V> {
+		const result = new Map<T, V>();
+		for (const [key, value] of Object.entries(map)) {
+			const enumKey = isNaN(Number(key)) ? (this.fromName(key) as T) : (this.fromValue(key as any) as T);
+			result.set(enumKey, value);
+		}
+		return result;
+	}
+
+	// 重写toString方法
+	toString(): string {
+		return this.name;
+	}
+
+	// 重写valueOf方法
+	valueOf(): T {
+		return this.value;
+	}
+}
+
+export { Enum };
+export type { EnumValueType };

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "ESNext",
+        "esModuleInterop": true,
+        "strict": true,
+        "skipLibCheck": true,
+        "rootDir": "./src",
+        "outDir": "./dist",
+        "declaration": true,
+        "incremental": false,
+        "baseUrl": "./",
+        "moduleResolution": "node"
+    },
+    "include": ["src"]
+}