feat: type predicates based on the element type

README.md

@@ -185,6 +185,17 @@ There are type predicates exposed, one for each KeySet type and the other for ea
 - `isKeySetNoneSerialized(x): x is KeySetNoneSerialized`
 - `isKeySetSomeSerialized(x): x is KeySetSomeSerialized`
 
+We also have type predicates based on the type of the elements, for serialized and KeySet.
+
+- `isKeySetOfNumbers`
+- `isKeySetOfStrings`
+- `isKeySetOfNumberKeyLabels`
+- `isKeySetOfStringKeyLabels`
+- `isKeySetSerializedOfNumbers`
+- `isKeySetSerializedOfStrings`
+- `isKeySetSerializedOfNumberKeyLabels`
+- `isKeySetSerializedOfStringKeyLabels`
+
 ## Util functions
 
 The lib also exports the 2 util functions used in the code

src/lib/__tests__/check-element-type.spec.ts

@@ -0,0 +1,142 @@
+import {
+  all,
+  isKeySetOfNumberKeyLabels,
+  isKeySetOfNumbers,
+  isKeySetOfStringKeyLabels,
+  isKeySetOfStrings,
+  KeySet,
+  none,
+  some
+} from "../..";
+
+describe("isKeySetOfStrings()", () => {
+  it("isKeySetOfStrings(invalidKeySet): false", () => {
+    expect(isKeySetOfStrings(("blah" as unknown) as KeySet)).toBeFalsy();
+  });
+
+  it("isKeySetOfStrings(all()): true", () => {
+    expect(isKeySetOfStrings(all())).toBeTruthy();
+  });
+
+  it("isKeySetOfStrings(none()): true", () => {
+    expect(isKeySetOfStrings(none())).toBeTruthy();
+  });
+
+  it("isKeySetOfStrings(some([1, 2])): false", () => {
+    expect(isKeySetOfStrings(some([1, 2]))).toBeFalsy();
+  });
+
+  it("isKeySetOfStrings(some(['1', '2'])): true", () => {
+    expect(isKeySetOfStrings(some(["1", "2"]))).toBeTruthy();
+  });
+
+  it("isKeySetOfStrings(some([{ key: 1, label: 'A' }])): false", () => {
+    expect(isKeySetOfStrings(some([{ key: 1, label: "A" }]))).toBeFalsy();
+  });
+
+  it("isKeySetOfStrings(some([{ key: '1', label: 'A' }])): false", () => {
+    expect(isKeySetOfStrings(some([{ key: "1", label: "A" }]))).toBeFalsy();
+  });
+});
+
+describe("isKeySetOfNumbers()", () => {
+  it("isKeySetOfNumbers(invalidKeySet): false", () => {
+    expect(isKeySetOfNumbers(("blah" as unknown) as KeySet)).toBeFalsy();
+  });
+
+  it("isKeySetOfNumbers(all()): true", () => {
+    expect(isKeySetOfNumbers(all())).toBeTruthy();
+  });
+
+  it("isKeySetOfNumbers(none()): true", () => {
+    expect(isKeySetOfNumbers(none())).toBeTruthy();
+  });
+
+  it("isKeySetOfNumbers(some([1, 2])): true", () => {
+    expect(isKeySetOfNumbers(some([1, 2]))).toBeTruthy();
+  });
+
+  it("isKeySetOfNumbers(some(['1', '2'])): false", () => {
+    expect(isKeySetOfNumbers(some(["1", "2"]))).toBeFalsy();
+  });
+
+  it("isKeySetOfNumbers(some([{ key: 1, label: 'A' }])): false", () => {
+    expect(isKeySetOfNumbers(some([{ key: 1, label: "A" }]))).toBeFalsy();
+  });
+
+  it("isKeySetOfNumbers(some([{ key: '1', label: 'A' }])): false", () => {
+    expect(isKeySetOfNumbers(some([{ key: "1", label: "A" }]))).toBeFalsy();
+  });
+});
+
+describe("isKeySetOfStringKeyLabels()", () => {
+  it("isKeySetOfStringKeyLabels(invalidKeySet): false", () => {
+    expect(
+      isKeySetOfStringKeyLabels(("blah" as unknown) as KeySet)
+    ).toBeFalsy();
+  });
+
+  it("isKeySetOfStringKeyLabels(all()): true", () => {
+    expect(isKeySetOfStringKeyLabels(all())).toBeTruthy();
+  });
+
+  it("isKeySetOfStringKeyLabels(none()): true", () => {
+    expect(isKeySetOfStringKeyLabels(none())).toBeTruthy();
+  });
+
+  it("isKeySetOfStringKeyLabels(some([1, 2])): false", () => {
+    expect(isKeySetOfStringKeyLabels(some([1, 2]))).toBeFalsy();
+  });
+
+  it("isKeySetOfStringKeyLabels(some(['1', '2'])): false", () => {
+    expect(isKeySetOfStringKeyLabels(some(["1", "2"]))).toBeFalsy();
+  });
+
+  it("isKeySetOfStringKeyLabels(some([{ key: 1, label: 'A' }])): false", () => {
+    expect(
+      isKeySetOfStringKeyLabels(some([{ key: 1, label: "A" }]))
+    ).toBeFalsy();
+  });
+
+  it("isKeySetOfStringKeyLabels(some([{ key: '1', label: 'A' }])): true", () => {
+    expect(
+      isKeySetOfStringKeyLabels(some([{ key: "1", label: "A" }]))
+    ).toBeTruthy();
+  });
+});
+
+describe("isKeySetOfNumberKeyLabels()", () => {
+  it("isKeySetOfNumberKeyLabels(invalidKeySet): false", () => {
+    expect(
+      isKeySetOfNumberKeyLabels(("blah" as unknown) as KeySet)
+    ).toBeFalsy();
+  });
+
+  it("isKeySetOfNumberKeyLabels(all()): true", () => {
+    expect(isKeySetOfNumberKeyLabels(all())).toBeTruthy();
+  });
+
+  it("isKeySetOfNumberKeyLabels(none()): true", () => {
+    expect(isKeySetOfNumberKeyLabels(none())).toBeTruthy();
+  });
+
+  it("isKeySetOfNumberKeyLabels(some([1, 2])): false", () => {
+    expect(isKeySetOfNumberKeyLabels(some([1, 2]))).toBeFalsy();
+  });
+
+  it("isKeySetOfNumberKeyLabels(some(['1', '2'])): false", () => {
+    expect(isKeySetOfNumberKeyLabels(some(["1", "2"]))).toBeFalsy();
+  });
+
+  it("isKeySetOfNumberKeyLabels(some([{ key: 1, label: 'A' }])): true", () => {
+    expect(
+      isKeySetOfNumberKeyLabels(some([{ key: 1, label: "A" }]))
+    ).toBeTruthy();
+  });
+
+  it("isKeySetOfNumberKeyLabels(some([{ key: '1', label: 'A' }])): false", () => {
+    expect(
+      isKeySetOfNumberKeyLabels(some([{ key: "1", label: "A" }]))
+    ).toBeFalsy();
+  });
+});

src/lib/__tests__/check-serialized-element-type.spec.ts

@@ -0,0 +1,180 @@
+import {
+  all,
+  isKeySetSerializedOfNumberKeyLabels,
+  isKeySetSerializedOfNumbers,
+  isKeySetSerializedOfStringKeyLabels,
+  isKeySetSerializedOfStrings,
+  KeySetSerialized,
+  none,
+  some
+} from "../..";
+
+const invalidKeySetSerialized = ("blah" as unknown) as KeySetSerialized;
+
+describe("isKeySetSerializedOfStrings()", () => {
+  it("isKeySetSerializedOfStrings(invalidKeySetSerialized): false", () => {
+    expect(isKeySetSerializedOfStrings(invalidKeySetSerialized)).toBeFalsy();
+  });
+
+  it("isKeySetSerializedOfStrings(all().serialized()): true", () => {
+    expect(isKeySetSerializedOfStrings(all().serialized())).toBeTruthy();
+  });
+
+  it("isKeySetSerializedOfStrings(none().serialized()): true", () => {
+    expect(isKeySetSerializedOfStrings(none().serialized())).toBeTruthy();
+  });
+
+  it("isKeySetSerializedOfStrings(some([1, 2]).serialized()): false", () => {
+    expect(isKeySetSerializedOfStrings(some([1, 2]).serialized())).toBeFalsy();
+  });
+
+  it("isKeySetSerializedOfStrings(some(['1', '2']).serialized()): true", () => {
+    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();
+  });
+
+  it("isKeySetSerializedOfStrings(some([{ key: '1', label: 'A' }]).serialized()): false", () => {
+    expect(
+      isKeySetSerializedOfStrings(some([{ key: "1", label: "A" }]).serialized())
+    ).toBeFalsy();
+  });
+});
+
+describe("isKeySetSerializedOfNumbers()", () => {
+  it("isKeySetSerializedOfNumbers(invalidKeySetSerialized): false", () => {
+    expect(isKeySetSerializedOfNumbers(invalidKeySetSerialized)).toBeFalsy();
+  });
+
+  it("isKeySetSerializedOfNumbers(all().serialized()): true", () => {
+    expect(isKeySetSerializedOfNumbers(all().serialized())).toBeTruthy();
+  });
+
+  it("isKeySetSerializedOfNumbers(none().serialized()): true", () => {
+    expect(isKeySetSerializedOfNumbers(none().serialized())).toBeTruthy();
+  });
+
+  it("isKeySetSerializedOfNumbers(some([1, 2]).serialized()): true", () => {
+    expect(isKeySetSerializedOfNumbers(some([1, 2]).serialized())).toBeTruthy();
+  });
+
+  it("isKeySetSerializedOfNumbers(some(['1', '2']).serialized()): false", () => {
+    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();
+  });
+
+  it("isKeySetSerializedOfNumbers(some([{ key: '1', label: 'A' }]).serialized()): false", () => {
+    expect(
+      isKeySetSerializedOfNumbers(some([{ key: "1", label: "A" }]).serialized())
+    ).toBeFalsy();
+  });
+});
+
+describe("isKeySetSerializedOfStringKeyLabels()", () => {
+  it("isKeySetSerializedOfStringKeyLabels(invalidKeySetSerialized): false", () => {
+    expect(
+      isKeySetSerializedOfStringKeyLabels(invalidKeySetSerialized)
+    ).toBeFalsy();
+  });
+
+  it("isKeySetSerializedOfStringKeyLabels(all().serialized()): true", () => {
+    expect(
+      isKeySetSerializedOfStringKeyLabels(all().serialized())
+    ).toBeTruthy();
+  });
+
+  it("isKeySetSerializedOfStringKeyLabels(none().serialized()): true", () => {
+    expect(
+      isKeySetSerializedOfStringKeyLabels(none().serialized())
+    ).toBeTruthy();
+  });
+
+  it("isKeySetSerializedOfStringKeyLabels(some([1, 2]).serialized()): false", () => {
+    expect(
+      isKeySetSerializedOfStringKeyLabels(some([1, 2]).serialized())
+    ).toBeFalsy();
+  });
+
+  it("isKeySetSerializedOfStringKeyLabels(some(['1', '2']).serialized()): false", () => {
+    expect(
+      isKeySetSerializedOfStringKeyLabels(some(["1", "2"]).serialized())
+    ).toBeFalsy();
+  });
+
+  it("isKeySetSerializedOfStringKeyLabels(some([{ key: 1, label: 'A' }]).serialized()): false", () => {
+    expect(
+      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()
+      )
+    ).toBeTruthy();
+  });
+});
+
+describe("isKeySetSerializedOfNumberKeyLabels()", () => {
+  it("isKeySetSerializedOfNumberKeyLabels(invalidKeySetSerialized): false", () => {
+    expect(
+      isKeySetSerializedOfNumberKeyLabels(invalidKeySetSerialized)
+    ).toBeFalsy();
+  });
+
+  it("isKeySetSerializedOfNumberKeyLabels(all().serialized()): true", () => {
+    expect(
+      isKeySetSerializedOfNumberKeyLabels(all().serialized())
+    ).toBeTruthy();
+  });
+
+  it("isKeySetSerializedOfNumberKeyLabels(none().serialized()): true", () => {
+    expect(
+      isKeySetSerializedOfNumberKeyLabels(none().serialized())
+    ).toBeTruthy();
+  });
+
+  it("isKeySetSerializedOfNumberKeyLabels(some([1, 2]).serialized()): false", () => {
+    expect(
+      isKeySetSerializedOfNumberKeyLabels(some([1, 2]).serialized())
+    ).toBeFalsy();
+  });
+
+  it("isKeySetSerializedOfNumberKeyLabels(some(['1', '2']).serialized()): false", () => {
+    expect(
+      isKeySetSerializedOfNumberKeyLabels(some(["1", "2"]).serialized())
+    ).toBeFalsy();
+  });
+
+  it("isKeySetSerializedOfNumberKeyLabels(some([{ key: 1, label: 'A' }]).serialized()): true", () => {
+    expect(
+      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()
+      )
+    ).toBeFalsy();
+  });
+});

src/lib/key-set.ts

@@ -20,6 +20,18 @@ import {
   allExceptSomeForced,
   KeySetAllExceptSome
 } from "./key-set/all-except-some";
+import {
+  isKeySetOfNumberKeyLabels,
+  isKeySetOfNumbers,
+  isKeySetOfStringKeyLabels,
+  isKeySetOfStrings
+} from "./key-set/check-element-type";
+import {
+  isKeySetSerializedOfNumberKeyLabels,
+  isKeySetSerializedOfNumbers,
+  isKeySetSerializedOfStringKeyLabels,
+  isKeySetSerializedOfStrings
+} from "./key-set/check-serialized-element-type";
 import { InvalidEmptySetError } from "./key-set/invalid-empty-set-error";
 import { InvalidKeySetError } from "./key-set/invalid-key-set-error";
 import { KeySetNone, none } from "./key-set/none";
@@ -94,5 +106,14 @@ export {
   // utils
   isValidKey,
   isKeyLabel,
-  isObject
+  isObject,
+  // check elements
+  isKeySetOfStrings,
+  isKeySetOfNumbers,
+  isKeySetOfStringKeyLabels,
+  isKeySetOfNumberKeyLabels,
+  isKeySetSerializedOfNumberKeyLabels,
+  isKeySetSerializedOfNumbers,
+  isKeySetSerializedOfStringKeyLabels,
+  isKeySetSerializedOfStrings
 };