add significants changes

Author: Srabutdotcom

deno.json

@@ -15,6 +15,7 @@
   "imports": {
     "@aicone/byte": "jsr:@aicone/byte@^0.5.0",
     "@std/assert": "jsr:@std/assert@^1.0.2",
+    "@tls/extension": "jsr:@tls/extension@^0.0.6",
     "@tls/struct": "jsr:@tls/struct@^0.2.0"
   }
 }

playground/enum.js

@@ -0,0 +1,132 @@
+// deno-lint-ignore-file no-slow-types
+// @ts-self-types="../type/enum.d.ts"
+
+export class Enum {
+   static #instances = new Map();
+   static #frozen = new Set();
+
+   #name;
+   #value;
+   #ordinal;
+
+   constructor(name, value) {
+       if (this.constructor === Enum) {
+           throw new TypeError("Cannot instantiate abstract Enum class directly");
+       }
+       
+       this.#name = name;
+       this.#value = value;
+       this.#ordinal = this.constructor.size;
+       
+       if (!Enum.#instances.has(this.constructor)) {
+           Enum.#instances.set(this.constructor, new Map());
+       }
+       
+       const instanceMap = Enum.#instances.get(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)) {
+           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}`);
+           }
+       }
+       
+       instanceMap.set(name, this);
+   }
+
+   get name() {
+       return this.#name;
+   }
+
+   get value() {
+       return this.#value;
+   }
+
+   get ordinal() {
+       return this.#ordinal;
+   }
+
+   static get size() {
+       return this.values().length;
+   }
+
+   static values() {
+       const instanceMap = Enum.#instances.get(this) || new Map();
+       return Array.from(instanceMap.values());
+   }
+
+   static names() {
+       const instanceMap = Enum.#instances.get(this) || new Map();
+       return Array.from(instanceMap.keys());
+   }
+
+   static valueOf(name) {
+       const instanceMap = Enum.#instances.get(this);
+       if (!instanceMap || !instanceMap.has(name)) {
+           throw new Error(`No enum constant ${this.name}.${name}`);
+       }
+       return instanceMap.get(name);
+   }
+
+   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}`);
+       }
+       return instance;
+   }
+
+   static freeze() {
+       Enum.#frozen.add(this);
+       return this;
+   }
+
+   static isFrozen() {
+       return Enum.#frozen.has(this);
+   }
+
+   toString() {
+       return `${this.constructor.name}.${this.name}`;
+   }
+
+   toJSON() {
+       return {
+           name: this.name,
+           value: this.value,
+           ordinal: this.ordinal
+       };
+   }
+
+   [Symbol.toPrimitive](hint) {
+       switch (hint) {
+           case 'number':
+               return this.value;
+           case 'string':
+               return this.toString();
+           default:
+               return this.value;
+       }
+   }
+
+   equals(other) {
+       if (!(other instanceof this.constructor)) {
+           return false;
+       }
+       return this.name === other.name && this.value === other.value;
+   }
+
+   compareTo(other) {
+       if (!(other instanceof this.constructor)) {
+           throw new TypeError(`Cannot compare ${this.constructor.name} with ${other?.constructor?.name}`);
+       }
+       return this.ordinal - other.ordinal;
+   }
+}
+

src/alert.js

@@ -22,7 +22,7 @@ export class AlertLevel extends Enum {
     * @param {Uint8Array} octet
     * @returns {AlertLevel }
     */
-   static parse(octet) {
+   static from(octet) {
       return AlertLevel.fromValue(octet[0]) ?? Error(`Unknown ${octet[0]} AlertLevel type`);
    }
 
@@ -189,7 +189,7 @@ export class AlertDescription extends Enum {
     * @param {Uint8Array} octet
     * @returns {AlertDescription }
     */
-   static parse(octet) {
+   static from(octet) {
       return AlertDescription.fromValue(octet[0]) ?? Error(`Unknown ${octet[0]} AlertDescription type`);
    }
 

src/certificatetype.js

@@ -16,7 +16,7 @@ export class CertificateType  extends Enum {
     * @param {Uint8Array} octet
     * @returns {CertificateType }
     */
-   static parse(octet) {
+   static from(octet) {
       return CertificateType.fromValue(octet[0]) ?? Error(`Unknown ${octet[0]} CertificateType type`);
    }
 

src/contentype.js

@@ -24,7 +24,7 @@ export class ContentType extends Enum {
     * @param {Uint8Array} octet
     * @returns {ContentType }
     */
-   static parse(octet) {
+   static from(octet) {
       return ContentType.fromValue(octet[0]) ?? Error(`Unknown ${octet[0]} ContentType type`);
    }
 

src/dep.js

@@ -1,5 +1,6 @@
-export { Uint8, Uint16, Uint24 } from "jsr:@aicone/byte"
 export { Struct, Constrained, Byte } from "jsr:@tls/struct"
+export { Uint8, Uint16, Uint24, Uint32 } from "jsr:@tls/struct"
+export { Extension } from "@tls/extension"
 export { p256 } from 'npm:@noble/[email protected]/p256'
 export { p384 } from 'npm:@noble/[email protected]/p384'
 export { p521 } from 'npm:@noble/[email protected]/p521'