ts-data-forge 14.6.1 → 14.6.3

package/dist/collections/iset-mapped.mjs

@@ -1,277 +1,460 @@
-import '../number/branded-types/finite-number.mjs';
-import '../number/branded-types/int.mjs';
-import '../number/branded-types/int16.mjs';
-import '../number/branded-types/int32.mjs';
-import '../number/branded-types/negative-finite-number.mjs';
-import '../number/branded-types/negative-int.mjs';
-import '../number/branded-types/negative-safe-int.mjs';
-import '../number/branded-types/non-negative-finite-number.mjs';
-import '../number/branded-types/non-negative-int16.mjs';
-import '../number/branded-types/non-negative-int32.mjs';
-import '../number/branded-types/non-positive-finite-number.mjs';
-import '../number/branded-types/non-positive-int.mjs';
-import '../number/branded-types/non-positive-safe-int.mjs';
-import '../number/branded-types/non-zero-finite-number.mjs';
-import '../number/branded-types/non-zero-int.mjs';
-import '../number/branded-types/non-zero-int16.mjs';
-import '../number/branded-types/non-zero-int32.mjs';
-import '../number/branded-types/non-zero-safe-int.mjs';
-import '../number/branded-types/non-zero-uint16.mjs';
-import '../number/branded-types/non-zero-uint32.mjs';
-import '../number/branded-types/positive-finite-number.mjs';
-import '../number/branded-types/positive-int.mjs';
-import '../number/branded-types/positive-int16.mjs';
-import '../number/branded-types/positive-int32.mjs';
-import '../number/branded-types/positive-safe-int.mjs';
-import '../number/branded-types/positive-uint16.mjs';
-import '../number/branded-types/positive-uint32.mjs';
-import '../number/branded-types/safe-int.mjs';
-import '../number/branded-types/safe-uint.mjs';
-import '../number/branded-types/uint.mjs';
-import '../number/branded-types/uint16.mjs';
-import { asUint32 } from '../number/branded-types/uint32.mjs';
-import '../number/enum/int8.mjs';
-import '../number/enum/uint8.mjs';
-import '../number/num.mjs';
-import '../number/refined-number-utils.mjs';
-import '@sindresorhus/is';
-import { unknownToString } from '../others/unknown-to-string.mjs';
-
-var ISetMapped;
-((ISetMapped2) => {
-  ISetMapped2.create = (iterable, toKey, fromKey) => new ISetMappedClass(iterable, toKey, fromKey);
-  ISetMapped2.equal = (a, b) => a.size === b.size && a.every((e) => b.has(e));
-  ISetMapped2.diff = (oldSet, newSet) => ({
-    deleted: oldSet.subtract(newSet),
-    added: newSet.subtract(oldSet)
-  });
-  ISetMapped2.intersection = (a, b) => a.intersect(b);
-  ISetMapped2.union = (a, b) => a.union(b);
+import { asUint32 } from '../number/index.mjs';
+import { unknownToString } from '../others/index.mjs';
+
+export var ISetMapped;
+(function (ISetMapped) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    ISetMapped.create = (iterable, toKey, fromKey) => new ISetMappedClass(iterable, toKey, fromKey);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    ISetMapped.equal = (a, b) => a.size === b.size && a.every((e) => b.has(e));
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    ISetMapped.diff = (oldSet, newSet) => ({
+        deleted: oldSet.subtract(newSet),
+        added: newSet.subtract(oldSet),
+    });
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    ISetMapped.intersection = (a, b) => a.intersect(b);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    ISetMapped.union = (a, b) => a.union(b);
 })(ISetMapped || (ISetMapped = {}));
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 class ISetMappedClass {
-  #set;
-  #toKey;
-  #fromKey;
-  #showNotFoundMessage;
-  /**
-   * Constructs an ISetMappedClass instance with custom element transformation.
-   *
-   * @param iterable An iterable of elements using the custom element type K.
-   * @param toKey A function that converts a custom element K to a primitive key
-   *   KM. Must be deterministic and produce unique values for unique elements.
-   * @param fromKey A function that converts a primitive key KM back to the
-   *   custom element K. Should be the inverse of the toKey function.
-   * @param showNotFoundMessage Whether to log warning messages when operations
-   *   are performed on non-existent elements. Useful for debugging. Defaults to
-   *   false for production use.
-   * @internal Use ISetMapped.create() instead of calling this constructor directly.
-   */
-  constructor(iterable, toKey, fromKey, showNotFoundMessage = false) {
-    this.#set = new Set(Array.from(iterable, toKey));
-    this.#toKey = toKey;
-    this.#fromKey = fromKey;
-    this.#showNotFoundMessage = showNotFoundMessage;
-  }
-  /** @inheritdoc */
-  get size() {
-    return asUint32(this.#set.size);
-  }
-  /** @inheritdoc */
-  get isEmpty() {
-    return this.size === 0;
-  }
-  /** @inheritdoc */
-  has(key) {
-    return this.#set.has(this.#toKey(key));
-  }
-  /** @inheritdoc */
-  every(predicate) {
-    for (const key of this.values()) {
-      if (!predicate(key)) return false;
+    #set;
+    #toKey;
+    #fromKey;
+    #showNotFoundMessage;
+
+
+
+
+
+
+
+
+
+
+
+
+
+    constructor(iterable, toKey, fromKey, showNotFoundMessage = false) {
+        this.#set = new Set(Array.from(iterable, toKey));
+        this.#toKey = toKey;
+        this.#fromKey = fromKey;
+        this.#showNotFoundMessage = showNotFoundMessage;
+    }
+
+    get size() {
+        return asUint32(this.#set.size);
+    }
+
+    get isEmpty() {
+        return this.size === 0;
+    }
+
+    has(key) {
+
+        return this.#set.has(this.#toKey(key));
+    }
+
+    every(predicate) {
+        for (const key of this.values()) {
+            if (!predicate(key))
+                return false;
+        }
+        return true;
     }
-    return true;
-  }
-  /** @inheritdoc */
-  some(predicate) {
-    for (const key of this.values()) {
-      if (predicate(key)) return true;
+
+    some(predicate) {
+        for (const key of this.values()) {
+            if (predicate(key))
+                return true;
+        }
+        return false;
     }
-    return false;
-  }
-  /** @inheritdoc */
-  add(key) {
-    if (this.has(key)) return this;
-    return ISetMapped.create(
-      [...this.#set, this.#toKey(key)].map(this.#fromKey),
-      this.#toKey,
-      this.#fromKey
-    );
-  }
-  /** @inheritdoc */
-  delete(key) {
-    if (!this.has(key)) {
-      if (this.#showNotFoundMessage) {
-        console.warn(
-          `ISetMapped.delete: key not found: ${unknownToString(this.#toKey(key))}`
-        );
-      }
-      return this;
+
+    add(key) {
+        if (this.has(key))
+            return this;
+        return ISetMapped.create([...this.#set, this.#toKey(key)].map(this.#fromKey), this.#toKey, this.#fromKey);
     }
-    const keyMapped = this.#toKey(key);
-    return ISetMapped.create(
-      Array.from(this.#set).filter((k) => !Object.is(k, keyMapped)).map(this.#fromKey),
-      this.#toKey,
-      this.#fromKey
-    );
-  }
-  /** @inheritdoc */
-  withMutations(actions) {
-    const mut_result = new Set(this.#set);
-    const updateFn = (action) => {
-      const key = this.#toKey(action.key);
-      switch (action.type) {
-        case "delete":
-          mut_result.delete(key);
-          break;
-        case "add":
-          mut_result.add(key);
-          break;
-      }
-    };
-    for (const action of actions) {
-      updateFn(action);
+
+    delete(key) {
+        if (!this.has(key)) {
+            if (this.#showNotFoundMessage) {
+                console.warn(`ISetMapped.delete: key not found: ${unknownToString(this.#toKey(key))}`);
+            }
+            return this;
+        }
+        const keyMapped = this.#toKey(key);
+        return ISetMapped.create(Array.from(this.#set)
+            .filter((k) => !Object.is(k, keyMapped))
+            .map(this.#fromKey), this.#toKey, this.#fromKey);
     }
-    return ISetMapped.create(
-      Array.from(mut_result, this.#fromKey),
-      this.#toKey,
-      this.#fromKey
-    );
-  }
-  /** @inheritdoc */
-  map(mapFn) {
-    return ISetMapped.create(
-      this.toArray().map(mapFn),
-      this.#toKey,
-      this.#fromKey
-    );
-  }
-  /** @inheritdoc */
-  filter(predicate) {
-    return ISetMapped.create(
-      this.toArray().filter(predicate),
-      this.#toKey,
-      this.#fromKey
-    );
-  }
-  /** @inheritdoc */
-  filterNot(predicate) {
-    return ISetMapped.create(
-      this.toArray().filter((k) => !predicate(k)),
-      this.#toKey,
-      this.#fromKey
-    );
-  }
-  /** @inheritdoc */
-  forEach(callbackfn) {
-    for (const km of this.#set) {
-      callbackfn(this.#fromKey(km));
+
+    withMutations(actions) {
+        const mut_result = new Set(this.#set);
+        const updateFn = (action) => {
+            const key = this.#toKey(action.key);
+            switch (action.type) {
+                case 'delete':
+                    mut_result.delete(key);
+                    break;
+                case 'add':
+                    mut_result.add(key);
+                    break;
+            }
+        };
+        for (const action of actions) {
+            updateFn(action);
+        }
+        return ISetMapped.create(Array.from(mut_result, this.#fromKey), this.#toKey, this.#fromKey);
     }
-  }
-  /** @inheritdoc */
-  isSubsetOf(set) {
-    return this.every((k) => set.has(k));
-  }
-  /** @inheritdoc */
-  isSupersetOf(set) {
-    return set.every((k) => this.has(k));
-  }
-  /** @inheritdoc */
-  subtract(set) {
-    return ISetMapped.create(
-      this.toArray().filter((k) => !set.has(k)),
-      this.#toKey,
-      this.#fromKey
-    );
-  }
-  /** @inheritdoc */
-  intersect(set) {
-    return ISetMapped.create(
-      this.toArray().filter((k) => set.has(k)),
-      this.#toKey,
-      this.#fromKey
-    );
-  }
-  /** @inheritdoc */
-  union(set) {
-    return ISetMapped.create(
-      [...this.values(), ...set.values()],
-      this.#toKey,
-      this.#fromKey
-    );
-  }
-  /**
-   * @example
-   *
-   * ```ts
-   * type Point = Readonly<{ x: number; tag: string }>;
-   *
-   * const toKey = (point: Point) => JSON.stringify(point);
-   *
-   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-   * const fromKey = (key: string) => JSON.parse(key) as Point;
-   *
-   * const set = ISetMapped.create<Point, string>(
-   *   [
-   *     { x: 1, tag: 'a' },
-   *     { x: 2, tag: 'b' },
-   *   ],
-   *   toKey,
-   *   fromKey,
-   * );
-   *
-   * const collected = Array.from(set);
-   *
-   * assert.deepStrictEqual(collected, [
-   *   { x: 1, tag: 'a' },
-   *   { x: 2, tag: 'b' },
-   * ]);
-   * ```
-   *
-   * @inheritdoc
-   */
-  *[Symbol.iterator]() {
-    for (const k of this.keys()) {
-      yield k;
+
+    map(mapFn) {
+        return ISetMapped.create(this.toArray().map(mapFn), this.#toKey, this.#fromKey);
     }
-  }
-  /** @inheritdoc */
-  *keys() {
-    for (const km of this.#set) {
-      yield this.#fromKey(km);
+
+    filter(predicate) {
+        return ISetMapped.create(this.toArray().filter(predicate), this.#toKey, this.#fromKey);
     }
-  }
-  /** @inheritdoc */
-  *values() {
-    for (const km of this.#set) {
-      yield this.#fromKey(km);
+
+    filterNot(predicate) {
+        return ISetMapped.create(this.toArray().filter((k) => !predicate(k)), this.#toKey, this.#fromKey);
     }
-  }
-  /** @inheritdoc */
-  *entries() {
-    for (const km of this.#set) {
-      const a = this.#fromKey(km);
-      yield [a, a];
+
+    forEach(callbackfn) {
+        for (const km of this.#set) {
+            callbackfn(this.#fromKey(km));
+        }
     }
-  }
-  /** @inheritdoc */
-  toArray() {
-    return Array.from(this.values());
-  }
-  /** @inheritdoc */
-  toRawSet() {
-    return this.#set;
-  }
-}
 
-export { ISetMapped };
-//# sourceMappingURL=iset-mapped.mjs.map
+    isSubsetOf(set) {
+        return this.every((k) => set.has(k));
+    }
+
+    isSupersetOf(set) {
+        return set.every((k) => this.has(k));
+    }
+
+    subtract(set) {
+        return ISetMapped.create(this.toArray().filter((k) => !set.has(k)), this.#toKey, this.#fromKey);
+    }
+
+    intersect(set) {
+        return ISetMapped.create(this.toArray().filter((k) => set.has(k)), this.#toKey, this.#fromKey);
+    }
+
+    union(set) {
+        return ISetMapped.create([...this.values(), ...set.values()], this.#toKey, this.#fromKey);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    *[Symbol.iterator]() {
+        for (const k of this.keys()) {
+            yield k;
+        }
+    }
+
+    *keys() {
+        for (const km of this.#set) {
+            yield this.#fromKey(km);
+        }
+    }
+
+    *values() {
+        for (const km of this.#set) {
+
+            yield this.#fromKey(km);
+        }
+    }
+
+    *entries() {
+        for (const km of this.#set) {
+
+            const a = this.#fromKey(km);
+            yield [a, a];
+        }
+    }
+
+    toArray() {
+        return Array.from(this.values());
+    }
+
+    toRawSet() {
+        return this.#set;
+    }
+}
+//# sourceMappingURL=iset-mapped.mjs.map