@khgtrn/lib 1.0.1 → 1.0.2

package/README.md

@@ -43,7 +43,17 @@ Role.Admin.name();                 // 'Admin'
 new Role(2, 'x');                  // compile error — constructor is protected
 ```
 
-The constructor also accepts an optional `opts?: Record<string, any>` parameter for storing arbitrary extra data per constant.
+The constructor also accepts an optional third parameter, `opt?: O`, for storing arbitrary extra data per constant. Pass the second type argument on `BaseEnum<T, O>` to get accurate type hints on `opt`:
+
+```ts
+class Role extends BaseEnum<number, { icon: string }> {
+  static readonly Admin = new Role(1, 'Administrator', { icon: 'shield' });
+}
+
+Role.Admin.opt?.icon;   // typed as `string | undefined`
+```
+
+Without an explicit `O`, it defaults to `any`.
 
 ## Utility functions (`func.ts`)
 

package/dist/cjs/base-enum.d.ts

@@ -2,7 +2,7 @@
  * Base class for simulating Java-style enums in TypeScript.
  *
  * Subclasses only need to `extends BaseEnum<...>` and declare constants as
- * `static readonly Xxx = new SubClass(value, label, opts?)`, without
+ * `static readonly Xxx = new SubClass(value, label, opt?)`, without
  * redeclaring a constructor. Because `BaseEnum`'s constructor is `protected`,
  * subclasses inherit it while keeping the same protection — instances can't
  * be `new`-ed from outside the class, which preserves enum singleton/identity
@@ -10,10 +10,10 @@
  *
  * @typeParam T - Type of the `value` field (defaults to `number`).
  */
-export declare abstract class BaseEnum<T = number> {
+export declare abstract class BaseEnum<T = number, O = any> {
     readonly value: T;
     readonly label: string;
-    readonly opts?: Record<string, any> | undefined;
+    readonly opt?: O | undefined;
     /**
      * Registry of every instance created, keyed per subclass and per `value`.
      * The outer key is the subclass constructor (so each subclass has its own
@@ -28,9 +28,9 @@ export declare abstract class BaseEnum<T = number> {
      *
      * @param value - Identifying value of the constant (used by `fromValue()`, `equals()`).
      * @param label - Display label/description of the constant.
-     * @param opts - Optional extra data, freely defined by the subclass as needed.
+     * @param opt - Optional extra data, freely defined by the subclass as needed.
      */
-    protected constructor(value: T, label: string, opts?: Record<string, any> | undefined);
+    protected constructor(value: T, label: string, opt?: O | undefined);
     /**
      * Returns the names of the `static readonly` fields declared on the
      * subclass, in declaration order. Mirrors the idea of an enum constant's

package/dist/cjs/base-enum.js

@@ -5,7 +5,7 @@ exports.BaseEnum = void 0;
  * Base class for simulating Java-style enums in TypeScript.
  *
  * Subclasses only need to `extends BaseEnum<...>` and declare constants as
- * `static readonly Xxx = new SubClass(value, label, opts?)`, without
+ * `static readonly Xxx = new SubClass(value, label, opt?)`, without
  * redeclaring a constructor. Because `BaseEnum`'s constructor is `protected`,
  * subclasses inherit it while keeping the same protection — instances can't
  * be `new`-ed from outside the class, which preserves enum singleton/identity
@@ -21,12 +21,12 @@ class BaseEnum {
      *
      * @param value - Identifying value of the constant (used by `fromValue()`, `equals()`).
      * @param label - Display label/description of the constant.
-     * @param opts - Optional extra data, freely defined by the subclass as needed.
+     * @param opt - Optional extra data, freely defined by the subclass as needed.
      */
-    constructor(value, label, opts) {
+    constructor(value, label, opt) {
         this.value = value;
         this.label = label;
-        this.opts = opts;
+        this.opt = opt;
         let map = BaseEnum.registry.get(this.constructor);
         if (!map) {
             map = new Map();

package/dist/esm/base-enum.d.ts

@@ -2,7 +2,7 @@
  * Base class for simulating Java-style enums in TypeScript.
  *
  * Subclasses only need to `extends BaseEnum<...>` and declare constants as
- * `static readonly Xxx = new SubClass(value, label, opts?)`, without
+ * `static readonly Xxx = new SubClass(value, label, opt?)`, without
  * redeclaring a constructor. Because `BaseEnum`'s constructor is `protected`,
  * subclasses inherit it while keeping the same protection — instances can't
  * be `new`-ed from outside the class, which preserves enum singleton/identity
@@ -10,10 +10,10 @@
  *
  * @typeParam T - Type of the `value` field (defaults to `number`).
  */
-export declare abstract class BaseEnum<T = number> {
+export declare abstract class BaseEnum<T = number, O = any> {
     readonly value: T;
     readonly label: string;
-    readonly opts?: Record<string, any> | undefined;
+    readonly opt?: O | undefined;
     /**
      * Registry of every instance created, keyed per subclass and per `value`.
      * The outer key is the subclass constructor (so each subclass has its own
@@ -28,9 +28,9 @@ export declare abstract class BaseEnum<T = number> {
      *
      * @param value - Identifying value of the constant (used by `fromValue()`, `equals()`).
      * @param label - Display label/description of the constant.
-     * @param opts - Optional extra data, freely defined by the subclass as needed.
+     * @param opt - Optional extra data, freely defined by the subclass as needed.
      */
-    protected constructor(value: T, label: string, opts?: Record<string, any> | undefined);
+    protected constructor(value: T, label: string, opt?: O | undefined);
     /**
      * Returns the names of the `static readonly` fields declared on the
      * subclass, in declaration order. Mirrors the idea of an enum constant's

package/dist/esm/base-enum.js

@@ -2,7 +2,7 @@
  * Base class for simulating Java-style enums in TypeScript.
  *
  * Subclasses only need to `extends BaseEnum<...>` and declare constants as
- * `static readonly Xxx = new SubClass(value, label, opts?)`, without
+ * `static readonly Xxx = new SubClass(value, label, opt?)`, without
  * redeclaring a constructor. Because `BaseEnum`'s constructor is `protected`,
  * subclasses inherit it while keeping the same protection — instances can't
  * be `new`-ed from outside the class, which preserves enum singleton/identity
@@ -18,12 +18,12 @@ export class BaseEnum {
      *
      * @param value - Identifying value of the constant (used by `fromValue()`, `equals()`).
      * @param label - Display label/description of the constant.
-     * @param opts - Optional extra data, freely defined by the subclass as needed.
+     * @param opt - Optional extra data, freely defined by the subclass as needed.
      */
-    constructor(value, label, opts) {
+    constructor(value, label, opt) {
         this.value = value;
         this.label = label;
-        this.opts = opts;
+        this.opt = opt;
         let map = BaseEnum.registry.get(this.constructor);
         if (!map) {
             map = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@khgtrn/lib",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Library for Typescript",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",