@sepiariver/unique-set 2.0.3 → 3.1.0

package/dist/index.mjs

@@ -1,178 +1,160 @@
 // index.ts
 import equal from "fast-deep-equal/es6/index.js";
-var serialize = (item) => {
-  if (typeof item === "number" && isNaN(item)) {
-    return "NaN";
-  }
-  if (item && typeof item === "object") {
-    if (Array.isArray(item)) {
-      return `[${item.map(serialize).join("")}]`;
-    } else {
-      return `{${Object.entries(item).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}:${serialize(v)}`).join("")}}`;
-    }
-  }
-  return String(item);
+var _f64 = new Float64Array(1);
+var _u8 = new Uint8Array(_f64.buffer);
+var structuralHash = (value) => {
+  return _shash(value, 2166136261) >>> 0;
 };
-var fnv1a = (str) => {
-  if (typeof str !== "string") {
-    str = String(str);
-  }
-  let hash = 2166136261;
+var _mix = (hash, byte) => {
+  return Math.imul(hash ^ byte, 16777619);
+};
+var _mixStr = (hash, str) => {
   for (let i = 0; i < str.length; i++) {
-    hash ^= str.charCodeAt(i);
-    hash = hash * 16777619 >>> 0;
+    hash = Math.imul(hash ^ str.charCodeAt(i), 16777619);
   }
-  return hash >>> 0;
+  return hash;
 };
-var findNextPrime = (num) => {
-  if (num < 2) return 2;
-  if ((num & 1) === 0) num++;
-  while (!isPrime(num)) {
-    num += 2;
+var _shash = (value, hash) => {
+  if (value === null) return _mix(hash, 0);
+  if (value === void 0) return _mix(hash, 1);
+  switch (typeof value) {
+    case "boolean":
+      return _mix(hash, value ? 3 : 2);
+    case "number":
+      hash = _mix(hash, 5);
+      if (isNaN(value)) return _mix(hash, 4);
+      if (value === 0) return _mix(hash, 48);
+      _f64[0] = value;
+      for (let i = 0; i < 8; i++) hash = _mix(hash, _u8[i]);
+      return hash;
+    case "string":
+      hash = _mix(hash, 6);
+      return _mixStr(hash, value);
+    case "bigint":
+      hash = _mix(hash, 7);
+      return _mixStr(hash, value.toString());
+    case "function":
+    case "symbol":
+      hash = _mix(hash, 8);
+      return _mixStr(hash, String(value));
+    default:
+      break;
   }
-  return num;
-};
-var isPrime = (num) => {
-  if (num < 2) return false;
-  if (num === 2 || num === 3) return true;
-  if ((num & 1) === 0) return false;
-  if (num % 3 === 0) return false;
-  const sqrt = Math.sqrt(num);
-  for (let i = 5; i <= sqrt; i += 6) {
-    if (num % i === 0 || num % (i + 2) === 0) return false;
-  }
-  return true;
+  if (Array.isArray(value)) {
+    hash = _mix(hash, 16);
+    for (let i = 0; i < value.length; i++) hash = _shash(value[i], hash);
+    return hash;
+  }
+  if (value instanceof Map) {
+    hash = _mix(hash, 17);
+    const entries = Array.from(value.entries()).sort(
+      ([a], [b]) => String(a).localeCompare(String(b))
+    );
+    for (const [k, v] of entries) {
+      hash = _shash(k, hash);
+      hash = _shash(v, hash);
+    }
+    return hash;
+  }
+  if (value instanceof Set) {
+    hash = _mix(hash, 18);
+    for (const v of value) hash = _shash(v, hash);
+    return hash;
+  }
+  if (value instanceof Date) {
+    hash = _mix(hash, 20);
+    _f64[0] = value.getTime();
+    for (let i = 0; i < 8; i++) hash = _mix(hash, _u8[i]);
+    return hash;
+  }
+  if (value instanceof RegExp) {
+    hash = _mix(hash, 21);
+    return _mixStr(hash, value.toString());
+  }
+  hash = _mix(hash, 19);
+  const keys = Object.keys(value).sort();
+  for (const key of keys) {
+    hash = _mixStr(hash, key);
+    hash = _shash(value[key], hash);
+  }
+  return hash;
 };
-var UniqueSet = class extends Set {
-  /*** @throws TypeError If the input is not iterable. */
+var MapSet = class {
+  #map;
+  #size;
   constructor(iterable = []) {
     if (!Array.isArray(iterable) && !iterable[Symbol.iterator]) {
-      throw new TypeError("UniqueSet requires an iterable");
+      throw new TypeError("MapSet requires an iterable");
     }
-    super();
+    this.#map = /* @__PURE__ */ new Map();
+    this.#size = 0;
     for (const item of iterable) {
       this.add(item);
     }
   }
-  /**
-   * Determines whether an object is in the UniqueSet using deep equality.
-   * @param o The object to check for presence in the UniqueSet.
-   * @returns `true` if the object is found, `false` otherwise.
-   */
-  has(o) {
-    for (const i of this) {
-      if (equal(o, i)) {
-        return true;
+  add(value) {
+    const hash = structuralHash(value);
+    const bucket = this.#map.get(hash);
+    if (!bucket) {
+      this.#map.set(hash, [value]);
+      this.#size++;
+    } else {
+      for (const item of bucket) {
+        if (equal(value, item)) return this;
       }
-    }
-    return false;
-  }
-  /**
-   * Adds a new object to the UniqueSet if it is not already present.
-   * @param o The object to add to the UniqueSet.
-   * @returns The `UniqueSet` instance, allowing for chaining.
-   */
-  add(o) {
-    if (!this.has(o)) {
-      super.add(o);
+      bucket.push(value);
+      this.#size++;
     }
     return this;
   }
-};
-var BloomSet = class extends Set {
-  #bitArray;
-  #aSize;
-  #hashCount;
-  /**
-   * Creates a new `BloomSet` instance.
-   * @param iterable Optional: an iterable object with which to initialize the BloomSet.
-   * @param options Bloom filter configuration options.
-   * @param options.size The size of the Bloom filter's bit array. Defaults to 6553577.
-   * @param options.hashCount The number of hash functions to use. Defaults to 7.
-   * @throws TypeError If the input is not iterable.
-   */
-  constructor(iterable = [], options = {}) {
-    if (!Array.isArray(iterable) && !iterable[Symbol.iterator]) {
-      throw new TypeError("BloomSet requires an iterable");
-    }
-    super();
-    if (!options || typeof options !== "object") {
-      options = {};
-    }
-    options.hashCount ??= 7;
-    options.size ??= 6553577;
-    let { size, hashCount } = options;
-    if (typeof size !== "number" || size <= 0) {
-      size = 6553577;
-    }
-    this.#aSize = findNextPrime(size);
-    if (typeof hashCount !== "number" || hashCount <= 0) {
-      hashCount = 7;
-    }
-    this.#hashCount = hashCount;
-    this.#bitArray = new Uint8Array(Math.ceil(size / 8));
-    for (const item of iterable) {
-      this.add(item);
-    }
-  }
-  /** @internal */
-  #hashes(item) {
-    const hashes = [];
-    const str = serialize(item);
-    let hash = fnv1a(str);
-    for (let i = 0; i < this.#hashCount; i++) {
-      hash %= this.#aSize;
-      hashes.push(hash);
-      hash = (hash ^ hash >>> 13) * 3266489909;
-      hash >>>= 0;
-    }
-    return hashes;
-  }
-  /** @internal */
-  #setBits(hashes) {
-    for (const hash of hashes) {
-      const index = Math.floor(hash / 8);
-      const bit = hash % 8;
-      this.#bitArray[index] |= 1 << bit;
+  has(value) {
+    const hash = structuralHash(value);
+    const bucket = this.#map.get(hash);
+    if (!bucket) return false;
+    for (const item of bucket) {
+      if (equal(value, item)) return true;
     }
+    return false;
   }
-  /** @internal */
-  #checkBits(hashes) {
-    for (const hash of hashes) {
-      const index = Math.floor(hash / 8);
-      const bit = hash % 8;
-      if (!(this.#bitArray[index] & 1 << bit)) {
-        return false;
+  delete(value) {
+    const hash = structuralHash(value);
+    const bucket = this.#map.get(hash);
+    if (!bucket) return false;
+    for (let i = 0; i < bucket.length; i++) {
+      if (equal(value, bucket[i])) {
+        bucket.splice(i, 1);
+        if (bucket.length === 0) this.#map.delete(hash);
+        this.#size--;
+        return true;
       }
     }
-    return true;
+    return false;
   }
-  /** Determines existence of an object in the BloomSet using the Bloom filter and deep equality */
-  has(o) {
-    const hashes = this.#hashes(o);
-    if (!this.#checkBits(hashes)) {
-      return false;
-    }
-    for (const i of this) {
-      if (equal(o, i)) {
-        return true;
+  get size() {
+    return this.#size;
+  }
+  clear() {
+    this.#map.clear();
+    this.#size = 0;
+  }
+  forEach(callback, thisArg) {
+    for (const bucket of this.#map.values()) {
+      for (const value of bucket) {
+        callback.call(thisArg, value, value, this);
       }
     }
-    return false;
   }
-  /** Adds a new object to the BloomSet if it is not already present.
-   * @returns The `BloomSet` instance, allowing for chaining.
-   */
-  add(o) {
-    if (!this.has(o)) {
-      const hashes = this.#hashes(o);
-      this.#setBits(hashes);
-      super.add(o);
+  *values() {
+    for (const bucket of this.#map.values()) {
+      yield* bucket;
     }
-    return this;
+  }
+  *[Symbol.iterator]() {
+    yield* this.values();
   }
 };
 export {
-  BloomSet,
-  UniqueSet
+  MapSet,
+  MapSet as UniqueSet,
+  structuralHash
 };

package/index.ts

@@ -1,210 +1,182 @@
 import equal from "fast-deep-equal/es6/index.js";
 
-/** Utility functions */
-
-const serialize = (item: any | number | object): string => {
-  if (typeof item === "number" && isNaN(item)) {
-    return "NaN";
-  }
-
-  if (item && typeof item === "object") {
-    if (Array.isArray(item)) {
-      return `[${item.map(serialize).join("")}]`;
-    } else {
-      return `{${Object.entries(item)
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([k, v]) => `${k}:${serialize(v)}`)
-        .join("")}}`;
-    }
-  }
+/** 
+ * Streaming structural hash — computes a 32-bit FNV-1a hash by traversing
+ * the value directly, without allocating an intermediate string.
+ */
+const _f64 = new Float64Array(1);
+const _u8 = new Uint8Array(_f64.buffer);
+
+export const structuralHash = (value: unknown): number => {
+  return _shash(value, 0x811c9dc5) >>> 0;
+};
 
-  return String(item);
+const _mix = (hash: number, byte: number): number => {
+  return Math.imul(hash ^ byte, 0x01000193);
 };
 
-const fnv1a = (str: string) => {
-  if (typeof str !== "string") {
-    str = String(str);
-  }
-  let hash = 2166136261; // FNV offset basis for 32-bit
+const _mixStr = (hash: number, str: string): number => {
   for (let i = 0; i < str.length; i++) {
-    hash ^= str.charCodeAt(i);
-    hash = (hash * 16777619) >>> 0; // Multiply by the FNV prime and ensure 32-bit unsigned
+    hash = Math.imul(hash ^ str.charCodeAt(i), 0x01000193);
   }
-  return hash >>> 0;
+  return hash;
 };
 
-const findNextPrime = (num: number) => {
-  if (num < 2) return 2;
-  if ((num & 1) === 0) num++; // Odd numbers only
-
-  while (!isPrime(num)) {
-    num += 2; // Odd numbers only
+const _shash = (value: unknown, hash: number): number => {
+  if (value === null) return _mix(hash, 0x00);
+  if (value === undefined) return _mix(hash, 0x01);
+
+  switch (typeof value) {
+    case "boolean":
+      return _mix(hash, value ? 0x03 : 0x02);
+    case "number":
+      hash = _mix(hash, 0x05);
+      if (isNaN(value)) return _mix(hash, 0x04);
+      if (value === 0) return _mix(hash, 0x30); // normalize 0 and -0
+      _f64[0] = value;
+      for (let i = 0; i < 8; i++) hash = _mix(hash, _u8[i]!);
+      return hash;
+    case "string":
+      hash = _mix(hash, 0x06);
+      return _mixStr(hash, value);
+    case "bigint":
+      hash = _mix(hash, 0x07);
+      return _mixStr(hash, value.toString());
+    case "function":
+    case "symbol":
+      hash = _mix(hash, 0x08);
+      return _mixStr(hash, String(value));
+    default:
+      break;
   }
 
-  return num;
-};
-
-const isPrime = (num: number): boolean => {
-  if (num < 2) return false;
-  if (num === 2 || num === 3) return true;
-  if ((num & 1) === 0) return false;
-  if (num % 3 === 0) return false;
-
-  const sqrt = Math.sqrt(num);
-  for (let i = 5; i <= sqrt; i += 6) {
-    if (num % i === 0 || num % (i + 2) === 0) return false;
+  if (Array.isArray(value)) {
+    hash = _mix(hash, 0x10);
+    for (let i = 0; i < value.length; i++) hash = _shash(value[i], hash);
+    return hash;
+  }
+  if (value instanceof Map) {
+    hash = _mix(hash, 0x11);
+    const entries = Array.from(value.entries()).sort(([a], [b]) =>
+      String(a).localeCompare(String(b))
+    );
+    for (const [k, v] of entries) {
+      hash = _shash(k, hash);
+      hash = _shash(v, hash);
+    }
+    return hash;
+  }
+  if (value instanceof Set) {
+    hash = _mix(hash, 0x12);
+    for (const v of value) hash = _shash(v, hash);
+    return hash;
+  }
+  if (value instanceof Date) {
+    hash = _mix(hash, 0x14);
+    _f64[0] = value.getTime();
+    for (let i = 0; i < 8; i++) hash = _mix(hash, _u8[i]!);
+    return hash;
+  }
+  if (value instanceof RegExp) {
+    hash = _mix(hash, 0x15);
+    return _mixStr(hash, value.toString());
   }
 
-  return true;
+  // Plain object — sort keys for order-independence
+  hash = _mix(hash, 0x13);
+  const keys = Object.keys(value as object).sort();
+  for (const key of keys) {
+    hash = _mixStr(hash, key);
+    hash = _shash((value as Record<string, unknown>)[key], hash);
+  }
+  return hash;
 };
 
-/** A `Set` extension that ensures uniqueness of items using deep equality checks. */
-export class UniqueSet<T> extends Set<T> {
-  /*** @throws TypeError If the input is not iterable. */
+export class MapSet<T> {
+  #map: Map<number, T[]>;
+  #size: number;
+
   constructor(iterable: Iterable<T> = []) {
     if (!Array.isArray(iterable) && !iterable[Symbol.iterator]) {
-      throw new TypeError("UniqueSet requires an iterable");
+      throw new TypeError("MapSet requires an iterable");
     }
-    super();
+    this.#map = new Map();
+    this.#size = 0;
     for (const item of iterable) {
       this.add(item);
     }
   }
-  /**
-   * Determines whether an object is in the UniqueSet using deep equality.
-   * @param o The object to check for presence in the UniqueSet.
-   * @returns `true` if the object is found, `false` otherwise.
-   */
-  has(o: T): boolean {
-    for (const i of this) {
-      if (equal(o, i)) {
-        return true;
+
+  add(value: T): this {
+    const hash = structuralHash(value);
+    const bucket = this.#map.get(hash);
+    if (!bucket) {
+      this.#map.set(hash, [value]);
+      this.#size++;
+    } else {
+      for (const item of bucket) {
+        if (equal(value, item)) return this;
       }
-    }
-    return false;
-  }
-  /**
-   * Adds a new object to the UniqueSet if it is not already present.
-   * @param o The object to add to the UniqueSet.
-   * @returns The `UniqueSet` instance, allowing for chaining.
-   */
-  add(o: T): this {
-    if (!this.has(o)) {
-      super.add(o);
+      bucket.push(value);
+      this.#size++;
     }
     return this;
   }
-}
 
-/** A `Set` extension that uses a Bloom filter for fast existence checks combined with deep equality for accuracy. */
-export class BloomSet<T> extends Set<T> {
-  #bitArray: Uint8Array;
-  #aSize: number;
-  #hashCount: number;
-  /**
-   * Creates a new `BloomSet` instance.
-   * @param iterable Optional: an iterable object with which to initialize the BloomSet.
-   * @param options Bloom filter configuration options.
-   * @param options.size The size of the Bloom filter's bit array. Defaults to 6553577.
-   * @param options.hashCount The number of hash functions to use. Defaults to 7.
-   * @throws TypeError If the input is not iterable.
-   */
-  constructor(
-    iterable: Iterable<T> = [],
-    options: { size?: number; hashCount?: number } = {}
-  ) {
-    if (!Array.isArray(iterable) && !iterable[Symbol.iterator]) {
-      throw new TypeError("BloomSet requires an iterable");
-    }
-    super();
-
-    if (!options || typeof options !== "object") {
-      options = {};
-    }
-
-    options.hashCount ??= 7;
-    options.size ??= 6553577;
-
-    let { size, hashCount } = options;
-
-    if (typeof size !== "number" || size <= 0) {
-      size = 6553577; // Targeting < 1 collision per 100,000 elements, ~819 KB memory, needs 7 hashes
-    }
-    this.#aSize = findNextPrime(size);
-
-    if (typeof hashCount !== "number" || hashCount <= 0) {
-      hashCount = 7;
-    }
-    this.#hashCount = hashCount;
-    this.#bitArray = new Uint8Array(Math.ceil(size / 8));
-
-    for (const item of iterable) {
-      this.add(item);
+  has(value: T): boolean {
+    const hash = structuralHash(value);
+    const bucket = this.#map.get(hash);
+    if (!bucket) return false;
+    for (const item of bucket) {
+      if (equal(value, item)) return true;
     }
+    return false;
   }
 
-  /** @internal */
-  #hashes(item: T) {
-    const hashes: number[] = [];
-    const str = serialize(item);
-    let hash = fnv1a(str); // Base hash
-
-    // Bloom into hashCount hash values
-    for (let i = 0; i < this.#hashCount; i++) {
-      hash %= this.#aSize; // Ensure within bounds
-      // Track
-      hashes.push(hash);
-      // Modify
-      hash = (hash ^ (hash >>> 13)) * 0xc2b2ae35;
-      hash >>>= 0; // Ensure unsigned 32-bit integer
+  delete(value: T): boolean {
+    const hash = structuralHash(value);
+    const bucket = this.#map.get(hash);
+    if (!bucket) return false;
+    for (let i = 0; i < bucket.length; i++) {
+      if (equal(value, bucket[i])) {
+        bucket.splice(i, 1);
+        if (bucket.length === 0) this.#map.delete(hash);
+        this.#size--;
+        return true;
+      }
     }
+    return false;
+  }
 
-    return hashes;
+  get size(): number {
+    return this.#size;
   }
 
-  /** @internal */
-  #setBits(hashes: number[]): void {
-    for (const hash of hashes) {
-      const index = Math.floor(hash / 8);
-      const bit = hash % 8;
-      this.#bitArray[index]! |= 1 << bit;
-    }
+  clear(): void {
+    this.#map.clear();
+    this.#size = 0;
   }
 
-  /** @internal */
-  #checkBits(hashes: number[]): boolean {
-    for (const hash of hashes) {
-      const index = Math.floor(hash / 8);
-      const bit = hash % 8;
-      if (!(this.#bitArray[index]! & (1 << bit))) {
-        return false;
+  forEach(
+    callback: (value: T, valueAgain: T, set: this) => void,
+    thisArg?: any
+  ): void {
+    for (const bucket of this.#map.values()) {
+      for (const value of bucket) {
+        callback.call(thisArg, value, value, this);
       }
     }
-    return true;
   }
-  /** Determines existence of an object in the BloomSet using the Bloom filter and deep equality */
-  has(o: T): boolean {
-    const hashes = this.#hashes(o);
-    if (!this.#checkBits(hashes)) {
-      return false; // Definitely not in the set
-    }
-    // Fall back to fast-deep-equal for false positives
-    for (const i of this) {
-      if (equal(o, i)) {
-        return true;
-      }
+
+  *values(): IterableIterator<T> {
+    for (const bucket of this.#map.values()) {
+      yield* bucket;
     }
-    return false;
   }
-  /** Adds a new object to the BloomSet if it is not already present.
-   * @returns The `BloomSet` instance, allowing for chaining.
-   */
-  add(o: T): this {
-    if (!this.has(o)) {
-      const hashes = this.#hashes(o);
-      this.#setBits(hashes);
-      super.add(o);
-    }
-    return this;
+
+  *[Symbol.iterator](): IterableIterator<T> {
+    yield* this.values();
   }
 }
+
+export { MapSet as UniqueSet };