chore: update dependencies and improve HashedSet implementation

Author: kastov

libs/hashed-set/README.md

@@ -1,120 +1 @@
 # @remnawave/hashed-set
-
-A high-performance Set implementation that maintains a hash value for fast equality comparison. This allows for O(1) set comparison operations instead of O(n) when comparing two sets.
-
-## Features
-
-- **Fast Set Comparison**: Compare sets in O(1) time using hash values
-- **TypeScript Support**: Full TypeScript definitions included
-- **Standard Set API**: Extends native JavaScript Set with additional methods
-- **Memory Efficient**: Minimal overhead compared to standard Set
-- **Multiple Data Types**: Supports numbers, strings, and objects
-
-## Installation
-
-```bash
-npm install @remnawave/hashed-set
-```
-
-## Usage
-
-### Basic Usage
-
-```typescript
-import { HashedSet } from '@remnawave/hashed-set';
-
-// Create a new HashedSet
-const set1 = new HashedSet([1, 2, 3]);
-const set2 = new HashedSet([3, 2, 1]);
-
-// Fast comparison using hash values
-console.log(set1.hash === set2.hash); // true - same elements, same hash
-
-// Standard Set operations work as expected
-set1.add(4);
-set1.delete(1);
-console.log(set1.has(2)); // true
-console.log(set1.size); // 3
-```
-
-### Advanced Features
-
-```typescript
-import { HashedSet } from '@remnawave/hashed-set';
-
-const set1 = new HashedSet(['alice@example.com', 'bob@example.com']);
-const set2 = new HashedSet(['bob@example.com', 'alice@example.com']);
-
-// Quick hash comparison
-if (set1.hasSameHash(set2)) {
-  console.log('Sets likely contain the same elements');
-}
-
-// Get unique hash for the set
-console.log(`Set hash: ${set1.hash}`);
-```
-
-### Performance Example
-
-```typescript
-import { HashedSet } from '@remnawave/hashed-set';
-
-// Create large sets
-const emails1 = Array.from({ length: 100000 }, (_, i) => `user${i}@example.com`);
-const emails2 = [...emails1].reverse();
-
-const set1 = new HashedSet(emails1);
-const set2 = new HashedSet(emails2);
-
-// O(1) comparison instead of O(n)
-const startTime = performance.now();
-const areEqual = set1.hash === set2.hash;
-const endTime = performance.now();
-
-console.log(`Comparison took ${endTime - startTime}ms`); // ~0.01ms instead of ~100ms
-```
-
-## API Reference
-
-### Constructor
-
-- `new HashedSet<T>(iterable?: Iterable<T>)` - Creates a new HashedSet
-
-### Properties
-
-- `hash: number` - Gets the current hash value of the set (unsigned 32-bit integer)
-- `size: number` - Number of elements in the set (inherited from Set)
-
-### Methods
-
-#### Standard Set Methods
-
-- `add(value: T): this` - Adds a value to the set
-- `delete(value: T): boolean` - Removes a value from the set
-- `has(value: T): boolean` - Checks if a value exists in the set
-- `clear(): void` - Removes all values from the set
-- `forEach()`, `values()`, `keys()`, `entries()` - Standard iteration methods
-
-#### Additional Methods
-
-- `hasSameHash(other: HashedSet<T>): boolean` - Fast hash-based comparison
-
-## Hash Algorithm
-
-The library uses a combination of:
-
-- **Numbers**: Direct integer conversion
-- **Strings**: 31-polynomial rolling hash
-- **Objects**: Random unique identifier assignment
-
-The final set hash is computed using XOR operations, making it order-independent.
-
-## Performance Characteristics
-
-- **Set Creation**: O(n) where n is the number of elements
-- **Add/Delete**: O(1) average case
-- **Hash Comparison**: O(1)
-
-## License
-
-AGPL-3.0-only

libs/hashed-set/examples/basic-usage.ts

@@ -1,6 +1,6 @@
 {
     "name": "@remnawave/hashed-set",
-    "version": "0.0.2",
+    "version": "0.0.4",
     "public": true,
     "license": "AGPL-3.0-only",
     "description": "A high-performance Set implementation with hash-based equality comparison for fast set operations.",

libs/hashed-set/package.json

@@ -1,110 +1,97 @@
-/**
- * A high-performance Set implementation that maintains a hash value for fast equality comparison.
- * This allows for O(1) set comparison operations instead of O(n) when comparing two sets.
- *
- * @example
- * ```typescript
- * const set1 = new HashedSet([1, 2, 3]);
- * const set2 = new HashedSet([3, 2, 1]);
- *
- * // Fast comparison using hash values
- * console.log(set1.hash === set2.hash); // true - same elements, same hash
- *
- * // Standard Set operations work as expected
- * set1.add(4);
- * set1.delete(1);
- * console.log(set1.has(2)); // true
- * ```
- */
-export class HashedSet<T = any> extends Set<T> {
-    private _hash: number;
+export class HashedSet extends Set<string> {
+    private _hashHigh: number = 0;
+    private _hashLow: number = 0;
 
-    /**
-     * Creates a new HashedSet instance.
-     * @param iterable Optional iterable to initialize the set with
-     */
-    constructor(iterable?: Iterable<T>) {
-        super(iterable ? Array.from(iterable) : undefined);
-        this._hash = 0;
-        for (const v of this) {
-            this._hash ^= this._valHash(v);
+    constructor(iterable?: Iterable<string>) {
+        super(iterable);
+        for (const str of this) {
+            const hash64 = this._djb2Dual(str);
+            this._hashHigh ^= hash64.high;
+            this._hashLow ^= hash64.low;
         }
     }
 
-    /**
-     * Computes a hash value for a given value.
-     * @param v The value to hash
-     * @returns The computed hash value
-     */
-    private _valHash(v: T): number {
-        if (typeof v === 'number') return v | 0;
-        if (typeof v === 'string') {
-            let h = 0;
-            for (let i = 0; i < v.length; i++) {
-                h = (h * 31 + v.charCodeAt(i)) | 0;
-            }
-            return h;
+    private _djb2Dual(str: string): { high: number; low: number } {
+        let high = 5381;
+        let low = 5387;
+
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+
+            high = ((high << 5) + high + char) | 0;
+            low = ((low << 6) + low + char * 37) | 0;
         }
-        return Object.is(v, null) ? 0 : this._objHash(v);
-    }
 
-    /**
-     * Computes a hash value for an object by assigning a unique identifier.
-     * @param obj The object to hash
-     * @returns The computed hash value
-     */
-    private _objHash(obj: any): number {
-        return (obj.__hid ??= (Math.random() * 0xffffffff) | 0);
+        return {
+            high: high >>> 0,
+            low: low >>> 0,
+        };
     }
 
-    /**
-     * Adds a value to the set and updates the hash.
-     * @param v The value to add
-     * @returns The HashedSet instance
-     */
-    add(v: T): this {
-        if (!this.has(v)) {
-            this._hash ^= this._valHash(v);
+    add(str: string): this {
+        if (!this.has(str)) {
+            const hash64 = this._djb2Dual(str);
+            this._hashHigh ^= hash64.high;
+            this._hashLow ^= hash64.low;
         }
-        return super.add(v);
+        return super.add(str);
     }
 
-    /**
-     * Removes a value from the set and updates the hash.
-     * @param v The value to remove
-     * @returns True if the value was removed, false otherwise
-     */
-    delete(v: T): boolean {
-        if (this.has(v)) {
-            this._hash ^= this._valHash(v);
+    delete(str: string): boolean {
+        if (this.has(str)) {
+            const hash64 = this._djb2Dual(str);
+            this._hashHigh ^= hash64.high;
+            this._hashLow ^= hash64.low;
         }
-        return super.delete(v);
+        return super.delete(str);
     }
 
-    /**
-     * Clears all values from the set and resets the hash.
-     */
     clear(): void {
-        this._hash = 0;
         super.clear();
+        this._hashHigh = 0;
+        this._hashLow = 0;
+    }
+
+    get hashHigh(): number {
+        return this._hashHigh;
+    }
+    get hashLow(): number {
+        return this._hashLow;
     }
 
-    /**
-     * Gets the current hash value of the set.
-     * Two sets with the same elements will have the same hash value.
-     * @returns The hash value as an unsigned 32-bit integer
-     */
-    get hash(): number {
-        return this._hash >>> 0;
+    hasSameHash(other: HashedSet): boolean {
+        return this.hashHigh === other.hashHigh && this.hashLow === other.hashLow;
     }
 
-    /**
-     * Checks if this set has the same hash as another HashedSet.
-     * This is a fast way to check if two sets might be equal.
-     * @param other The other HashedSet to compare with
-     * @returns True if the hash values are equal
-     */
-    hasSameHash(other: HashedSet<T>): boolean {
-        return this.hash === other.hash;
+    get hash64String(): string {
+        return (
+            this.hashHigh.toString(16).padStart(8, '0') + this.hashLow.toString(16).padStart(8, '0')
+        );
+    }
+
+    fastEquals(other: HashedSet): boolean {
+        return this.size === other.size && this.hasSameHash(other);
+    }
+
+    getHashStats(): {
+        size: number;
+        hashHigh: string;
+        hashLow: string;
+        hash64: string;
+        entropy: number;
+    } {
+        let setBits = 0;
+        for (let i = 0; i < 32; i++) {
+            if (this._hashHigh & (1 << i)) setBits++;
+            if (this._hashLow & (1 << i)) setBits++;
+        }
+
+        return {
+            size: this.size,
+            hashHigh: this._hashHigh.toString(16).padStart(8, '0'),
+            hashLow: this._hashLow.toString(16).padStart(8, '0'),
+            hash64: this.hash64String,
+            entropy: setBits / 64,
+        };
     }
 }