feat(array): unanimous

src/array.test.ts

@@ -96,4 +96,41 @@ describe("array", () => {
       expect(result).toEqual([{ foo: 1, bar: 2 }, { foo: 2 }]);
     });
   });
+
+  describe("unanimous", () => {
+    it("returns true if all elements match", () => {
+      // given everything has the same 'name' property
+      const a = [{ name: "Homebound" }, { name: "Homebound" }, { name: "Homebound" }];
+      // then expect them to unanimously match
+      expect(a.unanimous((el) => el.name)).toBe(true);
+    });
+
+    it("returns false if elements don't match", () => {
+      // given 1 item has a different name
+      const a = [{ name: "Homebound" }, { name: "Homebound" }, { name: "Nikki" }];
+      // then expect them NOT to be unanimous
+      expect(a.unanimous((el) => el.name)).toBe(false);
+    });
+
+    it("works for simple data", () => {
+      // given even numbers
+      const a = [0, 2, 4, 6, 8];
+      // then a check against each of them is unanimous
+      expect(a.unanimous((el) => el % 2 === 0)).toBe(true);
+    });
+
+    it("returns true for arrays-of-1", () => {
+      // given 1 item
+      const a = [1];
+      // then it is unanimous with itself
+      expect(a.unanimous((el) => el)).toBe(true);
+    });
+
+    it("returns true for empty array", () => {
+      // given an empty array
+      const a = [];
+      // then it's unanimously silent
+      expect(a.unanimous((el) => el)).toBe(true);
+    });
+  });
 });

src/array.ts

@@ -65,6 +65,7 @@ declare global {
     min(this: number[] | Date[]): T;
     min<R extends number | Date>(this: Array<T>, f: (el: T, index: number, array: Array<T>) => R): R;
     count(f: (el: T, index: number, array: T[]) => boolean): number;
+    unanimous(f: (el: T) => unknown): boolean;
   }
 
   interface ReadonlyArray<T> {
@@ -132,6 +133,7 @@ declare global {
     min(this: readonly number[] | readonly Date[]): T;
     min<R extends number | Date>(f: (el: T, index: number, array: readonly T[]) => R): R;
     count(f: (el: T, index: number, array: readonly T[]) => boolean): number;
+    unanimous(f: (el: T) => unknown): boolean;
   }
 }
 
@@ -401,6 +403,12 @@ Array.prototype.count = function <T>(this: T[], f: (el: T, index: number, array:
   return this.reduce((count, ...args) => (f(...args) ? count + 1 : count), 0);
 };
 
+Array.prototype.unanimous = function <T>(this: T[], f: (el: T) => unknown): boolean {
+  const [first, ...rest] = this;
+  const comparator = f(first);
+  return rest.every((el) => f(el) === comparator);
+};
+
 Object.defineProperty(Array.prototype, "isEmpty", {
   enumerable: false,
   get: function () {