ts-data-forge 5.0.1 → 5.1.1

package/src/collections/iset-mapped.mts

@@ -64,7 +64,7 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    *
    * const set = ISetMapped.create<Point, string>(points, toKey, fromKey);
    *
-   * assert(set.size === 2);
+   * assert.isTrue(set.size === 2);
    * ```
    */
   size: SizeType.Arr;
@@ -83,14 +83,16 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    * const fromKey = (key: string) => JSON.parse(key) as Point;
    *
    * const empty = ISetMapped.create<Point, string>([], toKey, fromKey);
+   *
    * const points = ISetMapped.create<Point, string>(
    *   [{ x: 1, tag: 'a' }],
    *   toKey,
    *   fromKey,
    * );
    *
-   * assert.ok(empty.isEmpty);
-   * assert.notOk(points.isEmpty);
+   * assert.isTrue(empty.isEmpty);
+   *
+   * assert.isFalse(points.isEmpty);
    * ```
    */
   isEmpty: boolean;
@@ -114,8 +116,9 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    *   fromKey,
    * );
    *
-   * assert.ok(set.has({ x: 1, tag: 'a' }));
-   * assert.notOk(set.has({ x: 2, tag: 'b' }));
+   * assert.isTrue(set.has({ x: 1, tag: 'a' }));
+   *
+   * assert.isFalse(set.has({ x: 2, tag: 'b' }));
    * ```
    *
    * @param key The element to check.
@@ -148,12 +151,14 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    * );
    *
    * const allEven = set.every((point) => point.x % 2 === 0);
+   *
    * const narrowed = set.every(
    *   (point): point is Readonly<{ x: 2 | 4; tag: 'even' }> => point.x % 2 === 0,
    * );
    *
-   * assert.ok(allEven);
-   * assert.ok(narrowed);
+   * assert.isTrue(allEven);
+   *
+   * assert.isTrue(narrowed);
    * ```
    *
    * @param predicate A function to test each element.
@@ -195,8 +200,9 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    *   fromKey,
    * );
    *
-   * assert.ok(set.some((point) => point.x > 4));
-   * assert.notOk(set.some((point) => point.x > 10));
+   * assert.isTrue(set.some((point) => point.x > 4));
+   *
+   * assert.isFalse(set.some((point) => point.x > 10));
    * ```
    *
    * @param predicate A function to test each element.
@@ -227,13 +233,15 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    * );
    *
    * const withNew = base.add({ x: 2, tag: 'b' });
+   *
    * const unchanged = base.add({ x: 1, tag: 'a' });
    *
    * assert.deepStrictEqual(Array.from(withNew), [
    *   { x: 1, tag: 'a' },
    *   { x: 2, tag: 'b' },
    * ]);
-   * assert(unchanged === base);
+   *
+   * assert.isTrue(unchanged === base);
    * ```
    *
    * @param key The element to add.
@@ -264,10 +272,12 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    * );
    *
    * const withoutSecond = base.delete({ x: 2, tag: 'b' });
+   *
    * const unchanged = base.delete({ x: 3, tag: 'c' });
    *
    * assert.deepStrictEqual(Array.from(withoutSecond), [{ x: 1, tag: 'a' }]);
-   * assert(unchanged === base);
+   *
+   * assert.isTrue(unchanged === base);
    * ```
    *
    * @param key The element to delete.
@@ -310,6 +320,7 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    *   { x: 2, tag: 'b' },
    *   { x: 3, tag: 'c' },
    * ]);
+   *
    * assert.deepStrictEqual(Array.from(base), [
    *   { x: 1, tag: 'a' },
    *   { x: 2, tag: 'b' },
@@ -461,6 +472,7 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    * );
    *
    * const collected: Point[] = [];
+   *
    * for (const point of set) {
    *   collected.push(point);
    * }
@@ -495,6 +507,7 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    *   toKey,
    *   fromKey,
    * );
+   *
    * const superset = ISetMapped.create<Point, string>(
    *   [
    *     { x: 1, tag: 'a' },
@@ -504,8 +517,9 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    *   fromKey,
    * );
    *
-   * assert.ok(subset.isSubsetOf(superset));
-   * assert.notOk(superset.isSubsetOf(subset));
+   * assert.isTrue(subset.isSubsetOf(superset));
+   *
+   * assert.isFalse(superset.isSubsetOf(subset));
    * ```
    *
    * @param set The other set.
@@ -535,14 +549,16 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    *   toKey,
    *   fromKey,
    * );
+   *
    * const subset = ISetMapped.create<Point, string>(
    *   [{ x: 2, tag: 'b' }],
    *   toKey,
    *   fromKey,
    * );
    *
-   * assert.ok(superset.isSupersetOf(subset));
-   * assert.notOk(subset.isSupersetOf(superset));
+   * assert.isTrue(superset.isSupersetOf(subset));
+   *
+   * assert.isFalse(subset.isSupersetOf(superset));
    * ```
    *
    * @param set The other set.
@@ -574,6 +590,7 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    *   toKey,
    *   fromKey,
    * );
+   *
    * const right = ISetMapped.create<Point, string>(
    *   [{ x: 2, tag: 'b' }],
    *   toKey,
@@ -615,6 +632,7 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    *   toKey,
    *   fromKey,
    * );
+   *
    * const right = ISetMapped.create<Point, string>(
    *   [{ x: 2, tag: 'b' }],
    *   toKey,
@@ -649,6 +667,7 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    *   toKey,
    *   fromKey,
    * );
+   *
    * const right = ISetMapped.create<Point, string>(
    *   [{ x: 2, tag: 'b' }],
    *   toKey,
@@ -827,8 +846,9 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    *
    * const raw = set.toRawSet();
    *
-   * assert.ok(is.set(raw));
-   * assert.ok(raw.has(toKey({ x: 1, tag: 'a' })));
+   * assert.isTrue(is.set(raw));
+   *
+   * assert.isTrue(raw.has(toKey({ x: 1, tag: 'a' })));
    * ```
    *
    * @returns The raw ReadonlySet instance.
@@ -955,6 +975,7 @@ export namespace ISetMapped {
    *   toKey,
    *   fromKey,
    * );
+   *
    * const second = ISetMapped.create<Point, string>(
    *   [
    *     { x: 2, tag: 'b' },
@@ -963,14 +984,16 @@ export namespace ISetMapped {
    *   toKey,
    *   fromKey,
    * );
+   *
    * const third = ISetMapped.create<Point, string>(
    *   [{ x: 3, tag: 'c' }],
    *   toKey,
    *   fromKey,
    * );
    *
-   * assert.ok(ISetMapped.equal(first, second));
-   * assert.notOk(ISetMapped.equal(first, third));
+   * assert.isTrue(ISetMapped.equal(first, second));
+   *
+   * assert.isFalse(ISetMapped.equal(first, third));
    * ```
    *
    * @template K The type of the custom elements.
@@ -1006,6 +1029,7 @@ export namespace ISetMapped {
    *   toKey,
    *   fromKey,
    * );
+   *
    * const current = ISetMapped.create<Point, string>(
    *   [
    *     { x: 2, tag: 'b' },
@@ -1018,6 +1042,7 @@ export namespace ISetMapped {
    * const { added, deleted } = ISetMapped.diff(previous, current);
    *
    * assert.deepStrictEqual(Array.from(added), [{ x: 3, tag: 'c' }]);
+   *
    * assert.deepStrictEqual(Array.from(deleted), [{ x: 1, tag: 'a' }]);
    * ```
    *
@@ -1056,6 +1081,7 @@ export namespace ISetMapped {
    *   toKey,
    *   fromKey,
    * );
+   *
    * const right = ISetMapped.create<Point, string>(
    *   [{ x: 2, tag: 'b' }],
    *   toKey,
@@ -1096,6 +1122,7 @@ export namespace ISetMapped {
    *   toKey,
    *   fromKey,
    * );
+   *
    * const right = ISetMapped.create<Point, string>(
    *   [{ x: 2, tag: 'b' }],
    *   toKey,
@@ -1173,8 +1200,11 @@ class ISetMappedClass<K, KM extends MapSetKeyType>
     showNotFoundMessage: boolean = false,
   ) {
     this.#set = new Set(Array.from(iterable, toKey));
+
     this.#toKey = toKey;
+
     this.#fromKey = fromKey;
+
     this.#showNotFoundMessage = showNotFoundMessage;
   }
 
@@ -1238,8 +1268,10 @@ class ISetMappedClass<K, KM extends MapSetKeyType>
           `ISetMapped.delete: key not found: ${String(this.#toKey(key))}`,
         );
       }
+
       return this;
     }
+
     const keyMapped = this.#toKey(key);
 
     return ISetMapped.create(
@@ -1265,10 +1297,12 @@ class ISetMappedClass<K, KM extends MapSetKeyType>
       switch (action.type) {
         case 'delete':
           mut_result.delete(key);
+
           break;
 
         case 'add':
           mut_result.add(key);
+
           break;
       }
     }
@@ -1407,6 +1441,7 @@ class ISetMappedClass<K, KM extends MapSetKeyType>
     for (const km of this.#set.keys()) {
       // JavaScript Set's entries() yields [value, value]
       const a = this.#fromKey(km);
+
       yield [a, a];
     }
   }