feat: keySetAll and KeySetNone with key type

Both KeySetAll and KeySetNone classes now use a generic for the type of the elements of the universe they represent, same as Some and AllExceptSome BREAKING CHANGE: While KeySetAll and KeySetNone were before non typed, now they are. Most of the time no adaptation is needed but in some cases when using TypeScript it may be needed to specify the type of the universe when creating a desired All or None key sets.
eturino · Feb 29, 2020 · bb5b1c9 · bb5b1c9
1 parent 1d31a98
commit bb5b1c9
Show file tree

Hide file tree

Showing 29 changed files with 168 additions and 404 deletions.
diff --git a/.prettierrc.json b/.prettierrc.json
@@ -1,2 +1,3 @@
 {
+  "printWidth": 100
 }
diff --git a/src/lib/__tests__/check-element-type.spec.ts b/src/lib/__tests__/check-element-type.spec.ts
@@ -71,9 +71,7 @@ describe("isKeySetOfNumbers()", () => {
 
 describe("isKeySetOfStringKeyLabels()", () => {
   it("isKeySetOfStringKeyLabels(invalidKeySet): false", () => {
-    expect(
-      isKeySetOfStringKeyLabels(("blah" as unknown) as KeySet)
-    ).toBeFalsy();
+    expect(isKeySetOfStringKeyLabels(("blah" as unknown) as KeySet)).toBeFalsy();
   });
 
   it("isKeySetOfStringKeyLabels(all()): true", () => {
@@ -93,23 +91,17 @@ describe("isKeySetOfStringKeyLabels()", () => {
   });
 
   it("isKeySetOfStringKeyLabels(some([{ key: 1, label: 'A' }])): false", () => {
-    expect(
-      isKeySetOfStringKeyLabels(some([{ key: 1, label: "A" }]))
-    ).toBeFalsy();
+    expect(isKeySetOfStringKeyLabels(some([{ key: 1, label: "A" }]))).toBeFalsy();
   });
 
   it("isKeySetOfStringKeyLabels(some([{ key: '1', label: 'A' }])): true", () => {
-    expect(
-      isKeySetOfStringKeyLabels(some([{ key: "1", label: "A" }]))
-    ).toBeTruthy();
+    expect(isKeySetOfStringKeyLabels(some([{ key: "1", label: "A" }]))).toBeTruthy();
   });
 });
 
 describe("isKeySetOfNumberKeyLabels()", () => {
   it("isKeySetOfNumberKeyLabels(invalidKeySet): false", () => {
-    expect(
-      isKeySetOfNumberKeyLabels(("blah" as unknown) as KeySet)
-    ).toBeFalsy();
+    expect(isKeySetOfNumberKeyLabels(("blah" as unknown) as KeySet)).toBeFalsy();
   });
 
   it("isKeySetOfNumberKeyLabels(all()): true", () => {
@@ -129,14 +121,10 @@ describe("isKeySetOfNumberKeyLabels()", () => {
   });
 
   it("isKeySetOfNumberKeyLabels(some([{ key: 1, label: 'A' }])): true", () => {
-    expect(
-      isKeySetOfNumberKeyLabels(some([{ key: 1, label: "A" }]))
-    ).toBeTruthy();
+    expect(isKeySetOfNumberKeyLabels(some([{ key: 1, label: "A" }]))).toBeTruthy();
   });
 
   it("isKeySetOfNumberKeyLabels(some([{ key: '1', label: 'A' }])): false", () => {
-    expect(
-      isKeySetOfNumberKeyLabels(some([{ key: "1", label: "A" }]))
-    ).toBeFalsy();
+    expect(isKeySetOfNumberKeyLabels(some([{ key: "1", label: "A" }]))).toBeFalsy();
   });
 });
diff --git a/src/lib/__tests__/check-serialized-element-type.spec.ts b/src/lib/__tests__/check-serialized-element-type.spec.ts
@@ -29,21 +29,15 @@ describe("isKeySetSerializedOfStrings()", () => {
   });
 
   it("isKeySetSerializedOfStrings(some(['1', '2']).serialized()): true", () => {
-    expect(
-      isKeySetSerializedOfStrings(some(["1", "2"]).serialized())
-    ).toBeTruthy();
+    expect(isKeySetSerializedOfStrings(some(["1", "2"]).serialized())).toBeTruthy();
   });
 
   it("isKeySetSerializedOfStrings(some([{ key: 1, label: 'A' }]).serialized()): false", () => {
-    expect(
-      isKeySetSerializedOfStrings(some([{ key: 1, label: "A" }]).serialized())
-    ).toBeFalsy();
+    expect(isKeySetSerializedOfStrings(some([{ key: 1, label: "A" }]).serialized())).toBeFalsy();
   });
 
   it("isKeySetSerializedOfStrings(some([{ key: '1', label: 'A' }]).serialized()): false", () => {
-    expect(
-      isKeySetSerializedOfStrings(some([{ key: "1", label: "A" }]).serialized())
-    ).toBeFalsy();
+    expect(isKeySetSerializedOfStrings(some([{ key: "1", label: "A" }]).serialized())).toBeFalsy();
   });
 });
 
@@ -65,116 +59,82 @@ describe("isKeySetSerializedOfNumbers()", () => {
   });
 
   it("isKeySetSerializedOfNumbers(some(['1', '2']).serialized()): false", () => {
-    expect(
-      isKeySetSerializedOfNumbers(some(["1", "2"]).serialized())
-    ).toBeFalsy();
+    expect(isKeySetSerializedOfNumbers(some(["1", "2"]).serialized())).toBeFalsy();
   });
 
   it("isKeySetSerializedOfNumbers(some([{ key: 1, label: 'A' }]).serialized()): false", () => {
-    expect(
-      isKeySetSerializedOfNumbers(some([{ key: 1, label: "A" }]).serialized())
-    ).toBeFalsy();
+    expect(isKeySetSerializedOfNumbers(some([{ key: 1, label: "A" }]).serialized())).toBeFalsy();
   });
 
   it("isKeySetSerializedOfNumbers(some([{ key: '1', label: 'A' }]).serialized()): false", () => {
-    expect(
-      isKeySetSerializedOfNumbers(some([{ key: "1", label: "A" }]).serialized())
-    ).toBeFalsy();
+    expect(isKeySetSerializedOfNumbers(some([{ key: "1", label: "A" }]).serialized())).toBeFalsy();
   });
 });
 
 describe("isKeySetSerializedOfStringKeyLabels()", () => {
   it("isKeySetSerializedOfStringKeyLabels(invalidKeySetSerialized): false", () => {
-    expect(
-      isKeySetSerializedOfStringKeyLabels(invalidKeySetSerialized)
-    ).toBeFalsy();
+    expect(isKeySetSerializedOfStringKeyLabels(invalidKeySetSerialized)).toBeFalsy();
   });
 
   it("isKeySetSerializedOfStringKeyLabels(all().serialized()): true", () => {
-    expect(
-      isKeySetSerializedOfStringKeyLabels(all().serialized())
-    ).toBeTruthy();
+    expect(isKeySetSerializedOfStringKeyLabels(all().serialized())).toBeTruthy();
   });
 
   it("isKeySetSerializedOfStringKeyLabels(none().serialized()): true", () => {
-    expect(
-      isKeySetSerializedOfStringKeyLabels(none().serialized())
-    ).toBeTruthy();
+    expect(isKeySetSerializedOfStringKeyLabels(none().serialized())).toBeTruthy();
   });
 
   it("isKeySetSerializedOfStringKeyLabels(some([1, 2]).serialized()): false", () => {
-    expect(
-      isKeySetSerializedOfStringKeyLabels(some([1, 2]).serialized())
-    ).toBeFalsy();
+    expect(isKeySetSerializedOfStringKeyLabels(some([1, 2]).serialized())).toBeFalsy();
   });
 
   it("isKeySetSerializedOfStringKeyLabels(some(['1', '2']).serialized()): false", () => {
-    expect(
-      isKeySetSerializedOfStringKeyLabels(some(["1", "2"]).serialized())
-    ).toBeFalsy();
+    expect(isKeySetSerializedOfStringKeyLabels(some(["1", "2"]).serialized())).toBeFalsy();
   });
 
   it("isKeySetSerializedOfStringKeyLabels(some([{ key: 1, label: 'A' }]).serialized()): false", () => {
     expect(
-      isKeySetSerializedOfStringKeyLabels(
-        some([{ key: 1, label: "A" }]).serialized()
-      )
+      isKeySetSerializedOfStringKeyLabels(some([{ key: 1, label: "A" }]).serialized())
     ).toBeFalsy();
   });
 
   it("isKeySetSerializedOfStringKeyLabels(some([{ key: '1', label: 'A' }]).serialized()): true", () => {
     expect(
-      isKeySetSerializedOfStringKeyLabels(
-        some([{ key: "1", label: "A" }]).serialized()
-      )
+      isKeySetSerializedOfStringKeyLabels(some([{ key: "1", label: "A" }]).serialized())
     ).toBeTruthy();
   });
 });
 
 describe("isKeySetSerializedOfNumberKeyLabels()", () => {
   it("isKeySetSerializedOfNumberKeyLabels(invalidKeySetSerialized): false", () => {
-    expect(
-      isKeySetSerializedOfNumberKeyLabels(invalidKeySetSerialized)
-    ).toBeFalsy();
+    expect(isKeySetSerializedOfNumberKeyLabels(invalidKeySetSerialized)).toBeFalsy();
   });
 
   it("isKeySetSerializedOfNumberKeyLabels(all().serialized()): true", () => {
-    expect(
-      isKeySetSerializedOfNumberKeyLabels(all().serialized())
-    ).toBeTruthy();
+    expect(isKeySetSerializedOfNumberKeyLabels(all().serialized())).toBeTruthy();
   });
 
   it("isKeySetSerializedOfNumberKeyLabels(none().serialized()): true", () => {
-    expect(
-      isKeySetSerializedOfNumberKeyLabels(none().serialized())
-    ).toBeTruthy();
+    expect(isKeySetSerializedOfNumberKeyLabels(none().serialized())).toBeTruthy();
   });
 
   it("isKeySetSerializedOfNumberKeyLabels(some([1, 2]).serialized()): false", () => {
-    expect(
-      isKeySetSerializedOfNumberKeyLabels(some([1, 2]).serialized())
-    ).toBeFalsy();
+    expect(isKeySetSerializedOfNumberKeyLabels(some([1, 2]).serialized())).toBeFalsy();
   });
 
   it("isKeySetSerializedOfNumberKeyLabels(some(['1', '2']).serialized()): false", () => {
-    expect(
-      isKeySetSerializedOfNumberKeyLabels(some(["1", "2"]).serialized())
-    ).toBeFalsy();
+    expect(isKeySetSerializedOfNumberKeyLabels(some(["1", "2"]).serialized())).toBeFalsy();
   });
 
   it("isKeySetSerializedOfNumberKeyLabels(some([{ key: 1, label: 'A' }]).serialized()): true", () => {
     expect(
-      isKeySetSerializedOfNumberKeyLabels(
-        some([{ key: 1, label: "A" }]).serialized()
-      )
+      isKeySetSerializedOfNumberKeyLabels(some([{ key: 1, label: "A" }]).serialized())
     ).toBeTruthy();
   });
 
   it("isKeySetSerializedOfNumberKeyLabels(some([{ key: '1', label: 'A' }]).serialized()): false", () => {
     expect(
-      isKeySetSerializedOfNumberKeyLabels(
-        some([{ key: "1", label: "A" }]).serialized()
-      )
+      isKeySetSerializedOfNumberKeyLabels(some([{ key: "1", label: "A" }]).serialized())
     ).toBeFalsy();
   });
 });
diff --git a/src/lib/__tests__/serialize.spec.ts b/src/lib/__tests__/serialize.spec.ts
@@ -185,31 +185,23 @@ describe("serialize KeySet", () => {
     });
 
     it("isKeySetAllExceptSomeSerialized(allExceptSomeNumberSerialized): true", () => {
-      expect(
-        isKeySetAllExceptSomeSerialized(allExceptSomeNumberSerialized)
-      ).toBeTruthy();
+      expect(isKeySetAllExceptSomeSerialized(allExceptSomeNumberSerialized)).toBeTruthy();
     });
 
     it("isKeySetAllExceptSomeSerialized(allExceptSomeStringSerialized): true", () => {
-      expect(
-        isKeySetAllExceptSomeSerialized(allExceptSomeStringSerialized)
-      ).toBeTruthy();
+      expect(isKeySetAllExceptSomeSerialized(allExceptSomeStringSerialized)).toBeTruthy();
     });
 
     invalidSerialized.forEach(x => {
-      it(`isKeySetAllExceptSomeSerialized(${JSON.stringify(
-        x
-      )}) returns false`, () => {
+      it(`isKeySetAllExceptSomeSerialized(${JSON.stringify(x)}) returns false`, () => {
         expect(isKeySetAllExceptSomeSerialized(x)).toBeFalsy();
       });
     });
   });
 
   describe("isKeySetSerialized()", () => {
     validSerialized.forEach(x => {
-      it(`isKeySetSerialized(${JSON.stringify(
-        x
-      )}) returns true (and is a type predicate)`, () => {
+      it(`isKeySetSerialized(${JSON.stringify(x)}) returns true (and is a type predicate)`, () => {
         expect(isKeySetSerialized(x)).toBeTruthy();
       });
     });
@@ -224,9 +216,9 @@ describe("serialize KeySet", () => {
   describe("parseKeySet(invalidKeySetSerialized) throws error", () => {
     invalidSerialized.forEach(x => {
       it(`${JSON.stringify(x)}`, () => {
-        expect(() =>
-          parseKeySet((x as unknown) as KeySetSerialized)
-        ).toThrowError(InvalidKeySetError);
+        expect(() => parseKeySet((x as unknown) as KeySetSerialized)).toThrowError(
+          InvalidKeySetError
+        );
       });
     });
   });
@@ -271,9 +263,7 @@ describe("serialize KeySet", () => {
   describe("serializeKeySet(nonKeySetAndNotValidKeySetSerialized) throws error", () => {
     invalidSerialized.forEach(x => {
       it(`${JSON.stringify(x)}`, () => {
-        expect(() => serializeKeySet((x as unknown) as KeySet)).toThrowError(
-          InvalidKeySetError
-        );
+        expect(() => serializeKeySet((x as unknown) as KeySet)).toThrowError(InvalidKeySetError);
       });
     });
   });

diff --git a/src/lib/key-set.ts b/src/lib/key-set.ts
@@ -16,11 +16,7 @@ import {
   KeySetTypes
 } from "./key-set/-base";
 import { all, KeySetAll } from "./key-set/all";
-import {
-  allExceptSome,
-  allExceptSomeForced,
-  KeySetAllExceptSome
-} from "./key-set/all-except-some";
+import { allExceptSome, allExceptSomeForced, KeySetAllExceptSome } from "./key-set/all-except-some";
 import {
   isKeySetOfNumberKeyLabels,
   isKeySetOfNumbers,
@@ -46,12 +42,7 @@ import {
   serializeKeySet
 } from "./key-set/serialize";
 import { KeySetSome, some, someForced } from "./key-set/some";
-import {
-  EmptyArray,
-  isEmptyArray,
-  isNonEmptyArray,
-  NonEmptyArray
-} from "./util/array-types";
+import { EmptyArray, isEmptyArray, isNonEmptyArray, NonEmptyArray } from "./util/array-types";
 import { arraysEqual } from "./util/arrays-equal";
 import { IKeyLabel, isKeyLabel, isObject } from "./util/object-utils";
 import { uniqueArray, uniqueKeyLabelArray } from "./util/unique-array";

diff --git a/src/lib/key-set/-base.ts b/src/lib/key-set/-base.ts
@@ -19,14 +19,14 @@ export function isValidKey(x: any): x is Key {
 }
 
 export type KeySet<T extends Key = Key> =
-  | KeySetAll
-  | KeySetNone
+  | KeySetAll<T>
+  | KeySetNone<T>
   | KeySetSome<T>
   | KeySetAllExceptSome<T>;
 
 export type KeyLabelSet<T extends string | number = string | number> =
-  | KeySetAll
-  | KeySetNone
+  | KeySetAll<IKeyLabel<T>>
+  | KeySetNone<IKeyLabel<T>>
   | KeySetSome<IKeyLabel<T>>
   | KeySetAllExceptSome<IKeyLabel<T>>;
 
@@ -146,10 +146,5 @@ export function isKeySetAllExceptSome(x: any): x is KeySetAllExceptSome<Key> {
 }
 
 export function isKeySet(x: any): x is KeySet {
-  return (
-    isKeySetAll(x) ||
-    isKeySetNone(x) ||
-    isKeySetSome(x) ||
-    isKeySetAllExceptSome(x)
-  );
+  return isKeySetAll(x) || isKeySetNone(x) || isKeySetSome(x) || isKeySetAllExceptSome(x);
 }
diff --git a/src/lib/key-set/-by-keys.ts b/src/lib/key-set/-by-keys.ts
@@ -9,6 +9,7 @@ import {
   KeySetSomeSerialized,
   KeySetTypes
 } from "./-base";
+import { KeySetGlobal } from "./-global";
 import { KeySetAllExceptSome } from "./all-except-some";
 import { InvalidEmptySetError } from "./invalid-empty-set-error";
 import { KeySetSome } from "./some";
@@ -26,9 +27,7 @@ export abstract class KeySetByKeys<T extends Key> implements IKeySetClass {
     this._elements = elements as NonEmptyArray<T>;
   }
 
-  public abstract serialized():
-    | KeySetAllExceptSomeSerialized<T>
-    | KeySetSomeSerialized<T>;
+  public abstract serialized(): KeySetAllExceptSomeSerialized<T> | KeySetSomeSerialized<T>;
 
   public abstract representsAll(): boolean;
 
@@ -44,9 +43,9 @@ export abstract class KeySetByKeys<T extends Key> implements IKeySetClass {
 
   public abstract isEqual(other: KeySet): boolean;
 
-  public abstract remove(other: KeySet): KeySet;
+  public abstract remove(other: KeySet | KeySetGlobal<Key>): KeySet;
 
-  public abstract intersect(other: KeySet): KeySet;
+  public abstract intersect(other: KeySet | KeySetGlobal<Key>): KeySet;
 
   public get keys(): T[] {
     return this.elements;

diff --git a/src/lib/key-set/-global.ts b/src/lib/key-set/-global.ts
@@ -21,9 +21,7 @@ export abstract class KeySetGlobal<T extends Key> implements IKeySetClass {
     return [] as EmptyArray<T>;
   }
 
-  public abstract serialized():
-    | KeySetAllSerialized<T>
-    | KeySetNoneSerialized<T>;
+  public abstract serialized(): KeySetAllSerialized<T> | KeySetNoneSerialized<T>;
 
   public abstract representsAll(): boolean;
 
@@ -39,7 +37,7 @@ export abstract class KeySetGlobal<T extends Key> implements IKeySetClass {
 
   public abstract isEqual(other: KeySet): boolean;
 
-  public abstract remove(other: KeySet): KeySet;
+  public abstract remove(other: KeySet | KeySetGlobal<Key>): KeySet;
 
-  public abstract intersect(other: KeySet): KeySet;
+  public abstract intersect(other: KeySet | KeySetGlobal<Key>): KeySet;
 }