feature: the filter functions can take a bunch of elements

Author: lmarvaud

filter.spec.ts

@@ -1,57 +1,78 @@
-import { isSet, notNullable, requiredIsNotNullable, requiredIsSet } from './filter';
+import {
+  isSet,
+  notNullable,
+  requiredIsNotNullable,
+  requiredIsSet,
+} from "./filter";
 
-type T = { readonly key?: string | null | number | boolean };
+type T = {
+  readonly key?: string | null | number | boolean;
+  readonly key2?: string | null | number | boolean;
+};
 
-describe('array.filter(requiredIsSet)', () => {
-    it('return true if element is set', () => {
-        const test_array: readonly T[] = [
-            { key: 'valid' },
-            { key: null },
-            { key: undefined },
-            {},
-            { key: 0 },
-            { key: false },
-        ] as const;
+describe("array.filter(requiredIsSet)", () => {
+  it("return true if element is set", () => {
+    const test_array: readonly T[] = [
+      { key: "valid", key2: true },
+      { key: null, key2: true },
+      { key: undefined, key2: true },
+      { key2: true },
+      { key: 0, key2: true },
+      { key: false, key2: true },
+      { key: false, key2: true },
+    ] as const;
 
-        const result = test_array.filter(requiredIsSet('key'));
+    const result = test_array.filter(requiredIsSet("key", "key2"));
 
-        expect(result).toStrictEqual([{ key: 'valid' }, { key: null }, { key: 0 }, { key: false }]);
-    });
+    expect(result).toStrictEqual([
+      { key: "valid", key2: true },
+      { key: null, key2: true },
+      { key: 0, key2: true },
+      { key: false, key2: true },
+      { key: false, key2: true },
+    ]);
+  });
 });
 
-describe('array.filter(requiredIsNotNullable)', () => {
-    it('return true if element is set and not null', () => {
-        const test_array: readonly T[] = [
-            { key: 'valid' },
-            { key: null },
-            { key: undefined },
-            {},
-            { key: 0 },
-            { key: false },
-        ] as const;
-
-        const result = test_array.filter(requiredIsNotNullable('key'));
-
-        expect(result).toStrictEqual([{ key: 'valid' }, { key: 0 }, { key: false }]);
-    });
+describe("array.filter(requiredIsNotNullable)", () => {
+  it("return true if element is set and not null", () => {
+    const test_array: readonly T[] = [
+      { key: "valid", key2: true },
+      { key: null, key2: true },
+      { key: undefined, key2: true },
+      { key2: true },
+      { key: 0, key2: true },
+      { key: false, key2: true },
+      { key: false, key2: true },
+    ] as const;
+
+    const result = test_array.filter(requiredIsNotNullable("key"));
+
+    expect(result).toStrictEqual([
+      { key: "valid", key2: true },
+      { key: 0, key2: true },
+      { key: false, key2: true },
+      { key: false, key2: true },
+    ]);
+  });
 });
 
-describe('array.filter(isSet)', () => {
-    it('remove undefined elements', () => {
-        const testArray = ['valid', null, undefined, 0, false] as const;
+describe("array.filter(isSet)", () => {
+  it("remove undefined elements", () => {
+    const testArray = ["valid", null, undefined, 0, false] as const;
 
-        const result = testArray.filter(isSet);
+    const result = testArray.filter(isSet);
 
-        expect(result).toStrictEqual(['valid', null, 0, false]);
-    });
+    expect(result).toStrictEqual(["valid", null, 0, false]);
+  });
 });
 
-describe('array.filter(notNullable)', () => {
-    it('remove null and undefined elements', () => {
-        const testArray = ['valid', null, undefined, 0, false] as const;
+describe("array.filter(notNullable)", () => {
+  it("remove null and undefined elements", () => {
+    const testArray = ["valid", null, undefined, 0, false] as const;
 
-        const result = testArray.filter(notNullable);
+    const result = testArray.filter(notNullable);
 
-        expect(result).toStrictEqual(['valid', 0, false]);
-    });
+    expect(result).toStrictEqual(["valid", 0, false]);
+  });
 });

filter.ts

@@ -9,33 +9,33 @@ export type WithNonNullable<T, K extends keyof T> = Omit<T, K> &
   Record<K, NonNullable<T[K]>>;
 
 /**
- * filter function to check if the object key is defined
+ * filter function to check if the object keys are defined
  *
  * ```ts
- * const array: Array<{key?: string}> = [{}, {key: "ok"}]
- * const result: Array<{key: string}> = array.filter(requiredIsSet('key')) // [{key: "ok"}]
+ * const array: Array<{keys?: string}> = [{}, {keys: "ok"}]
+ * const result: Array<{keys: string}> = array.filter(requiredIsSet('keys')) // [{keys: "ok"}]
  * ```
- * @param key key of the filter element to check
- * @returns a function to use in filter returning true if the row's key isSet
+ * @param keys keys of the filter element to check
+ * @returns a function to use in filter returning true if the row's keys are setSet
  */
-export function requiredIsSet<T, K extends keyof T>(key: K) {
+export function requiredIsSet<T, K extends keyof T>(...keys: K[]) {
   return (row: T | WithRequired<T, K>): row is WithRequired<T, K> =>
-    isSet(row[key]);
+    keys.every((key) => isSet(row[key]));
 }
 
 /**
- * filter function to check if the object key is defined and not null
+ * filter function to check if the object keys are defined and not null
  *
  * ```ts
- * const array: Array<{key?: string}> = [{}, {key: null}, {key: "ok"}]
- * const result: Array<{key: string}> = array.filter(requiredIsNotNullable('key')) // [{key: "ok"}]
+ * const array: Array<{keys?: string}> = [{}, {keys: null}, {keys: "ok"}]
+ * const result: Array<{keys: string}> = array.filter(requiredIsNotNullable('keys')) // [{keys: "ok"}]
  * ```
- * @param key key of the filter element to check
- * @returns a function to use in filter returning true if the row's key is notNullable
+ * @param keys keys of the filter element to check
+ * @returns a function to use in filter returning true if the row's keys is notNullable
  */
-export function requiredIsNotNullable<T, K extends keyof T>(key: K) {
+export function requiredIsNotNullable<T, K extends keyof T>(...keys: K[]) {
   return (row: T | WithNonNullable<T, K>): row is WithNonNullable<T, K> =>
-    notNullable(row[key]);
+    keys.every((key) => notNullable(row[key]));
 }
 
 /**