feat: Add asyncSome to Array

src/array.test.ts

@@ -190,4 +190,33 @@ describe("array", () => {
       ).toThrow();
     });
   });
+
+  describe("asyncSome", () => {
+    it("returns true if any element matches predicate (even number)", async () => {
+      // given an array of even and odd numbers
+      const a = [1, 2, 3, 4, 5];
+      // when we call asyncSome with a predicate that checks for even numbers
+      const result = await a.asyncSome((el) => Promise.resolve(el % 2 === 0));
+      // then expect asyncSome to return true
+      expect(result).toBe(true);
+    });
+
+    it("returns false if no elements match predicate (even number)", async () => {
+      // given an array of odd numbers
+      const a = [1, 3, 5];
+      // when we call asyncSome with a predicate that checks for even numbers
+      const result = await a.asyncSome((el) => Promise.resolve(el % 2 === 0));
+      // then expect asyncSome to return false
+      expect(result).toBe(false);
+    });
+
+    it("returns false if the array is empty", async () => {
+      // given an empty array
+      const a: number[] = [];
+      // when we call asyncSome with a predicate that checks for even numbers
+      const result = await a.asyncSome((el) => Promise.resolve(el % 2 === 0));
+      // then expect asyncSome to return false
+      expect(result).toBe(false);
+    });
+  });
 });

src/array.ts

@@ -29,6 +29,7 @@ declare global {
     each(f: (el: T, index: number, array: T[]) => any): T[];
     /** Helper for filtering arrays on async predicates. */
     asyncFilter(predicate: (v: T) => Promise<boolean>): Promise<Array<T>>;
+    asyncSome(predicate: (v: T) => boolean | Promise<boolean>): Promise<boolean>;
     asyncMap<V>(f: (el: T, index: number, array: T[]) => Promise<V>): Promise<V[]>;
     asyncForEach(f: (el: T, index: number, array: T[]) => Promise<any>): Promise<void>;
     sum(this: Array<number | undefined>): number;
@@ -97,6 +98,7 @@ declare global {
     each(f: (el: T, index: number, array: T[]) => any): T[];
     /** Helper for filtering arrays on async predicates. */
     asyncFilter(predicate: (v: T) => Promise<boolean>): Promise<Array<T>>;
+    asyncSome(predicate: (v: T) => boolean | Promise<boolean>): Promise<boolean>;
     asyncMap<V>(f: (el: T, index: number, array: T[]) => Promise<V>): Promise<V[]>;
     asyncForEach(f: (el: T, index: number, array: T[]) => Promise<any>): Promise<void>;
     sum(this: ReadonlyArray<number | undefined>): number;
@@ -219,6 +221,14 @@ Array.prototype.asyncFilter = async function <T>(
   return this.filter((_v, index) => results[index]);
 };
 
+Array.prototype.asyncSome = async function <T>(
+  this: Array<T>,
+  predicate: (v: T) => Promise<boolean>,
+): Promise<boolean> {
+  const asyncResults = this.map((el) => predicate(el).then((result) => result || Promise.reject()));
+  return await Promise.any(asyncResults).catch(() => false);
+};
+
 Array.prototype.asyncMap = async function <T, V>(
   this: Array<T>,
   f: (el: T, index: number, array: T[]) => Promise<V>,