add bimap.js for Enum

Author: Srabutdotcom

deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@tls/enum",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "exports": "./src/mod.ts",
   "publish": {
     "exclude": ["dist/"]

playground/enum.js

@@ -0,0 +1,13 @@
+import { Enum } from "../src/enum.js";
+
+class Color extends Enum {
+    /** @type {Color} Red color constant */
+    static RED = new Color('RED', '#FF0000');
+    /** @type {Color} Green color constant */
+    static GREEN = new Color('GREEN', '#00FF00');
+    /** @type {Color} Blue color constant */
+    static BLUE = new Color('BLUE', '#0000FF');
+}
+
+const test = Color.fromValue('#00FF00');
+//const test_2 = Color.fromValue('#000000')

playground/enum_2.js

@@ -0,0 +1,64 @@
+// @ts-self-types="../type/bimap.d.ts"
+
+export class BiMap {
+   constructor() {
+      this.keyToValue = new Map();
+      this.valueToKey = new Map();
+   }
+
+   // Add a key-value pair
+   set(key, value) {
+      if (this.keyToValue.has(key) || this.valueToKey.has(value)) {
+         throw new Error("Key or value already exists!");
+      }
+      this.keyToValue.set(key, value);
+      this.valueToKey.set(value, key);
+   }
+
+   // Get a value by key
+   getValue(key) {
+      return this.keyToValue.get(key);
+   }
+
+   // Get a key by value
+   getKey(value) {
+      return this.valueToKey.get(value);
+   }
+
+   // Check if a key exists
+   hasKey(key) {
+      return this.keyToValue.has(key);
+   }
+
+   // Check if a value exists
+   hasValue(value) {
+      return this.valueToKey.has(value);
+   }
+
+   // Delete by key
+   deleteByKey(key) {
+      const value = this.keyToValue.get(key);
+      if (value !== undefined) {
+         this.keyToValue.delete(key);
+         this.valueToKey.delete(value);
+      }
+   }
+
+   // Delete by value
+   deleteByValue(value) {
+      const key = this.valueToKey.get(value);
+      if (key !== undefined) {
+         this.valueToKey.delete(value);
+         this.keyToValue.delete(key);
+      }
+   }
+
+   // Clear all entries
+   clear() {
+      this.keyToValue.clear();
+      this.valueToKey.clear();
+   }
+
+   keys(){ return this.keyToValue.keys() }
+   values(){ return this.keyToValue.values() }
+}

src/bimap.js

@@ -3,8 +3,10 @@
 
 import { Uint8, Uint16, Struct } from "./dep.ts";
 import { Enum } from "./enum.js";
+import { Handshake } from "./handshaketype.js";
 import { HandshakeType } from "./handshaketype.js";
 import { Version } from "./version.js";
+import { Alert } from "./alert.js"
 
 /**
  * The higher-level protocol used to process the enclosed
@@ -79,6 +81,16 @@ export class TLSPlaintext extends Uint8Array {
       this.version = version;
       this.fragment = fragment
       this.items = struct.items
+
+      this.parseFragment();
+   }
+   parseFragment(){
+      if(this.type == ContentType.HANDSHAKE){
+         this.handshake = Handshake.from(this.fragment);
+      }
+      if(this.type == ContentType.ALERT){
+         this.alert = Alert.from(this.fragment);
+      }
    }
 }
 

src/contentype.js

@@ -1,6 +1,8 @@
 // deno-lint-ignore-file no-slow-types
 // @ts-self-types="../type/enum.d.ts"
 
+import { BiMap } from "./bimap.js";
+
 /**
  * Abstract base class for creating enumeration types in JavaScript
  * @abstract
@@ -19,7 +21,7 @@
  */
 export class Enum {
     /** @private @static @type {Map<Function, Map<string, Enum>>} */
-    static #instances = new Map();
+    static #instances = new BiMap();
 
     /** @private @static @type {Set<Function>} */
     static #frozen = new Set();
@@ -50,27 +52,25 @@ export class Enum {
         this.#ordinal = this.constructor.size;
 
         // Register instance
-        if (!Enum.#instances.has(this.constructor)) {
-            Enum.#instances.set(this.constructor, new Map());
+        if (!Enum.#instances.hasKey(this.constructor)) {
+            Enum.#instances.set(this.constructor, new BiMap());
         }
 
-        const instanceMap = Enum.#instances.get(this.constructor);
+        const instanceMap = Enum.#instances.getValue(this.constructor);
 
         if (Enum.#frozen.has(this.constructor)) {
             throw new Error(`Cannot add new enum constant ${name} to frozen enum ${this.constructor.name}`);
         }
 
-        if (instanceMap.has(name)) {
+        if (instanceMap.hasKey(name)) {
             throw new Error(`Duplicate enum constant name: ${name}`);
         }
 
-        for (const [, instance] of instanceMap) {
-            if (instance.value === value) {
-                throw new Error(`Duplicate enum value: ${value} for constant ${name}`);
-            }
+        if (instanceMap.hasValue(value)) {
+            throw new Error(`Duplicate enum value: ${value} for constant ${name}`);
         }
 
-        instanceMap.set(name, this);
+        instanceMap.set(name, value);
     }
 
     /**
@@ -110,7 +110,7 @@ export class Enum {
      * @returns {Enum[]} Array of all enum constants
      */
     static values() {
-        const instanceMap = Enum.#instances.get(this) || new Map();
+        const instanceMap = Enum.#instances.getValue(this) || new Map();
         return Array.from(instanceMap.values());
     }
 
@@ -119,7 +119,7 @@ export class Enum {
      * @returns {string[]} Array of all enum constant names
      */
     static names() {
-        const instanceMap = Enum.#instances.get(this) || new Map();
+        const instanceMap = Enum.#instances.getValue(this) || new Map();
         return Array.from(instanceMap.keys());
     }
 
@@ -130,11 +130,11 @@ export class Enum {
      * @throws {Error} If no constant exists with the given name
      */
     static valueOf(name) {
-        const instanceMap = Enum.#instances.get(this);
-        if (!instanceMap || !instanceMap.has(name)) {
+        const instanceMap = Enum.#instances.getValue(this);
+        if (!instanceMap || !instanceMap.hasKey(name)) {
             throw new Error(`No enum constant ${this.name}.${name}`);
         }
-        return instanceMap.get(name);
+        return instanceMap.getValue(name);
     }
 
     /**
@@ -144,11 +144,13 @@ export class Enum {
      * @throws {Error} If no constant exists with the given value
      */
     static fromValue(value) {
-        const instance = this.values().find(inst => inst.value === value);
-        if (!instance) {
-            throw new Error(`No enum constant with value ${value} in ${this.name}`);
+        //const instance = this.values().find(inst => inst.value === value);
+        const biMap = Enum.#instances.getValue(this);
+        if(!biMap.hasValue(value)){
+            throw new Error(`No enum constant with value ${value} in ${this.name}`);    
         }
-        return instance;
+        const key = biMap.getKey(value);
+        return this[key]
     }
 
     /**
@@ -230,4 +232,6 @@ export class Enum {
     }
 }
 
+
+
 // npx -p typescript tsc ./src/enum.js --declaration --allowJs --emitDeclarationOnly --lib ESNext --outDir ./dist