Implement hasPresentKeys

README.md

@@ -21,6 +21,7 @@ In a nutshell:
  - `isDefined`: Removes `undefined` values via a `filter`.
  - `isFilled`: Removes `null` values via a `filter`.
  - `hasPresentKey`: Removes everything that is not an object with the expected key present via a `filter`.
+ - `hasPresentKeys`: Removes everything that is not an object with the expected keys present via a `filter`.
  - `hasValueAtKey`: The same as `hasPresentKey` but with an additional check for a particular value. 
 
 ## Short explanation
@@ -73,7 +74,7 @@ const definedResults: Array<TestData> = results.filter(isPresent);
 As you can see, `isPresent` can drop `undefined`, `null` and `void` values from an array (where `void` values are
 really just `undefined` in disguise). This makes it broadly applicable.
 
-## Use `hasPresentKey` and `hasValueAtKey` to filter objects
+## Use `hasPresentKey`, `hasPresentKeys` and `hasValueAtKey` to filter objects
 
 If you want to find all of the objects in an array that have a particular field present, you can use `hasPresentKey`. For example:
 
@@ -82,6 +83,13 @@ const filesWithUrl = files.filter(hasPresentKey("url"));
  files[0].url // TS will know that this is present
 ```
 
+If you want to find all of the objects in an array that have a particular number of fields present, you can use `hasPresentKeys`. For example:
+
+``` typescript
+const filesWithUrl = files.filter(hasPresentKey(["url", "name"]));
+ files[0].url || files[0].name // TS will know that this is present
+```
+
 If you want to find all of the objects with a particular field set to a particular value you can use `hasValueAtKey`:
 
 ``` typescript

src/index.test.ts

@@ -5,6 +5,7 @@ import {
   isFilled,
   hasPresentKey,
   hasValueAtKey,
+  hasPresentKeys,
 } from '.';
 
 type TestData = {
@@ -51,9 +52,7 @@ describe('Functions', () => {
 
   describe('isDefined', () => {
     it('should return true on defined', () => {
-      expect(
-        isDefined<TestData>({ data: 'hello world' })
-      ).toBeTruthy();
+      expect(isDefined<TestData>({ data: 'hello world' })).toBeTruthy();
     });
 
     it('should return false on undefined', () => {
@@ -97,9 +96,7 @@ describe('Functions', () => {
 
   describe('isFilled', () => {
     it('should return true on defined', () => {
-      expect(
-        isFilled<TestData>({ data: 'hello world' })
-      ).toBeTruthy();
+      expect(isFilled<TestData>({ data: 'hello world' })).toBeTruthy();
     });
 
     it('should return false on null', () => {
@@ -160,6 +157,45 @@ describe('Functions', () => {
     });
   });
 
+  describe('hasPresentKeys', () => {
+    it('returns true only for objects that have a defined non-null single value at the given key', () => {
+      expect(hasPresentKeys(['data'])({ data: undefined })).toEqual(false);
+      expect(hasPresentKeys(['data'])({ data: null })).toEqual(false);
+      expect(hasPresentKeys(['data'])({ data: '' })).toEqual(true);
+      expect(hasPresentKeys(['data'])({ data: 'hello' })).toEqual(true);
+
+      const items: Array<{ data?: string | null | undefined }> = [
+        {},
+        { data: undefined },
+        { data: null },
+        { data: '' },
+        { data: 'hello' },
+      ];
+      const result = items.filter(hasPresentKeys(['data']));
+      expect(result).toEqual([{ data: '' }, { data: 'hello' }]);
+    });
+
+
+    it('returns true only for objects that have a defined non-null multiple value at the given key', () => {
+      expect(hasPresentKeys(['data', 'fruit'])({ data: undefined, fruit: undefined })).toEqual(false);
+      expect(hasPresentKeys(['data', 'fruit'])({ data: null, fruit: null })).toEqual(false);
+      expect(hasPresentKeys(['data', 'fruit'])({ data: '', fruit: '' })).toEqual(true);
+      expect(hasPresentKeys(['data', 'fruit'])({ data: 'hello', fruit: 'banana' })).toEqual(true);
+
+      const items: Array<{ data?: string | null | undefined, fruit?: string | null | undefined }> = [
+        {},
+        { data: undefined, fruit: undefined },
+        { data: null, fruit: null },
+        { data: '', fruit: '' },
+        { data: 'hello', fruit: 'banana' },
+        { data: null, fruit: 'banana' },
+        { data: 'hello', fruit: null },
+      ];
+      const result = items.filter(hasPresentKeys(['data', 'fruit']));
+      expect(result).toEqual([{ data: '', fruit: '' }, { data: 'hello', fruit: 'banana' }]);
+    });
+  });
+
   describe('hasValueAtKey', () => {
     it('returns true only for objects that have a defined value at the given key', () => {
       expect(hasValueAtKey('data', 'a')({ data: undefined })).toEqual(false);
@@ -180,17 +216,17 @@ describe('Functions', () => {
 
       const fruits: Array<
         | {
-            type: 'apple';
-            isApple: true;
-          }
+          type: 'apple';
+          isApple: true;
+        }
         | {
-            type: 'banana';
-            isBanana: true;
-          }
+          type: 'banana';
+          isBanana: true;
+        }
       > = [
-        { type: 'apple', isApple: true },
-        { type: 'banana', isBanana: true },
-      ];
+          { type: 'apple', isApple: true },
+          { type: 'banana', isBanana: true },
+        ];
       const fruitsResult: Array<{
         type: 'apple';
         isApple: true;

src/index.ts

@@ -34,6 +34,35 @@ export function hasPresentKey<K extends string | number | symbol>(k: K) {
   };
 }
 
+/**
+ * Returns a function that can be used to filter down objects
+ * to the ones that have a defined non-null value under the keys `k`.
+ *
+ * @example
+ * ```ts
+ * const filesWithUrlAndName = files.filter(file => file.url && file.name);
+ * files[0].url || files[0].name // In this case, TS might still treat this as undefined/null
+ *
+ * const filesWithUrlAndName = files.filter(hasPresentKeys(["url", "name"]));
+ * files[0].url || files[0].name // TS will know that this is present
+ * ```
+ *
+ * See https://github.com/microsoft/TypeScript/issues/16069
+ * why is that useful.
+ */
+export function hasPresentKeys<K extends string | number | symbol>(k: K[]) {
+  return function <T, V>(
+    a: T & { [k in K]?: V | null }
+  ): a is T & { [k in K]: V } {
+    for (let i = 0; i < k.length; i++) {
+      if (a[k[i]] === undefined || a[k[i]] === null) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+
 /**
  * Returns a function that can be used to filter down objects
  * to the ones that have a specific value V under a key `k`.