@khgtrn/lib 1.0.0 → 1.0.2

package/README.md

@@ -1,8 +1,8 @@
-# KLib - Library for TS/JS
+# Library for Typescript/Javascript
 
-[![npm version](https://img.shields.io/npm/v/@khgtrn/klib.svg)](https://www.npmjs.com/package/@khgtrn/klib)
-[![npm downloads](https://img.shields.io/npm/d18m/@khgtrn/klib.svg)](https://www.npmjs.com/package/@khgtrn/klib)
-[![license](https://img.shields.io/github/license/khgtrn/ts-klib.svg)](https://github.com/khgtrn/ts-klib/blob/main/LICENSE)
+[![npm version](https://img.shields.io/npm/v/@khgtrn/lib.svg)](https://www.npmjs.com/package/@khgtrn/lib)
+[![npm downloads](https://img.shields.io/npm/d18m/@khgtrn/lib.svg)](https://www.npmjs.com/package/@khgtrn/lib)
+[![license](https://img.shields.io/github/license/khgtrn/ts-lib.svg)](https://github.com/khgtrn/ts-lib/blob/main/LICENSE)
 
 Shared TypeScript utility library: Java-style enums, common helper functions, number-to-words conversion (Vietnamese/English), and floating-point-safe rounding.
 
@@ -11,7 +11,7 @@ Built as both ESM (`dist/esm`) and CJS (`dist/cjs`), with full type declarations
 ## Installation
 
 ```bash
-pnpm add @khgtrn/klib
+pnpm add @khgtrn/lib
 ```
 
 Requires Node.js >= 19 at runtime (needed for `crypto.getRandomValues` as a global — see `engines` in [package.json](package.json)). The shipped `.d.ts` files are compatible down to **TypeScript 2.7**, and the compiled JS itself avoids syntax (`?.`, `??`) that older bundlers can't parse — no separate install/config needed to consume this package from a legacy toolchain (e.g. Angular 6).
@@ -21,7 +21,7 @@ Requires Node.js >= 19 at runtime (needed for `crypto.getRandomValues` as a glob
 `BaseEnum` is a base class for simulating Java enums: each constant is a singleton instance, and subclasses only need to `extends` and declare `static readonly` fields — no constructor to write.
 
 ```ts
-import { BaseEnum } from '@khgtrn/klib';
+import { BaseEnum } from '@khgtrn/lib';
 
 class Role extends BaseEnum<number> {
   static readonly Admin = new Role(1, 'Administrator');
@@ -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`)
 
@@ -76,7 +86,7 @@ See the JSDoc in [src/func.ts](src/func.ts) for full parameter/return details.
 ## numberToWords — spelling out numbers
 
 ```ts
-import { numberToWords } from '@khgtrn/klib';
+import { numberToWords } from '@khgtrn/lib';
 
 numberToWords(1005);            // "một nghìn không trăm linh năm" (Vietnamese by default)
 numberToWords(1005, 'en');      // "one thousand five"
@@ -92,7 +102,7 @@ numberToWords(-123, 'en');      // "negative one hundred twenty-three"
 ## round — floating-point-safe rounding
 
 ```ts
-import { round } from '@khgtrn/klib';
+import { round } from '@khgtrn/lib';
 
 round(491.66999999999996);      // 491.67 (default precision = 10)
 round(1.23456, 2);              // 1.23

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.0",
+  "version": "1.0.2",
   "description": "Library for Typescript",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -22,8 +22,7 @@
     "typescript",
     "ts",
     "lib",
-    "library",
-    "klib"
+    "library"
   ],
   "author": "khgtrn",
   "license": "MIT",