feat(Array): add countBy fn

.changeset/strange-comics-fail.md

@@ -0,0 +1,5 @@
+---
+"@opentf/utils": minor
+---
+
+Added arrIns, arrReplace, arrRm & countBy array util fns.

README.md

@@ -47,23 +47,37 @@ bun add @opentf/utils
 ## Usage
 
 ```ts
-import { isNum, pascalCase, sort, clone, isEql, isEqlArr, sleep } from "@opentf/utils";
+import {
+  isNum,
+  pascalCase,
+  sort,
+  clone,
+  isEql,
+  isEqlArr,
+  sleep,
+} from "@opentf/utils";
 
 isNum(NaN); //=> false
 
-pascalCase('pascal case'); //=> PascalCase
+pascalCase("pascal case"); //=> PascalCase
 
-sort([1, 10, 21, 2], 'desc'); //=> [ 21, 10, 2, 1 ]
+sort([1, 10, 21, 2], "desc"); //=> [ 21, 10, 2, 1 ]
 
 const obj = {
-  a: 1, 
-  b: 'abc', 
-  c: new Map([['key', 'val']])
+  a: 1,
+  b: "abc",
+  c: new Map([["key", "val"]]),
 };
 clone(obj); // It returns deeply cloned value.
 
-const mapA = new Map([ ['a', 1], ['b', 2] ])
-const mapB = new Map([ ['b', 2], ['a', 1] ])
+const mapA = new Map([
+  ["a", 1],
+  ["b", 2],
+]);
+const mapB = new Map([
+  ["b", 2],
+  ["a", 1],
+]);
 isEql(mapA, mapB); //=> false
 
 isEqlArr([1, 2, 3], [2, 3, 1]); //=> true
@@ -78,14 +92,21 @@ await sleep(1000); // It suspends the exection for 1 second.
 - [arrChunk](https://js-utils.pages.dev/Array/arrChunk)
 - [arrCompact](https://js-utils.pages.dev/Array/arrCompact)
 - [arrDiff](https://js-utils.pages.dev/Array/arrDiff)
-- [asyncFilter](https://js-utils.pages.dev/Array/asyncFilter)
+- [arrIns](https://js-utils.pages.dev/Array/arrIns)
+- [arrReplace](https://js-utils.pages.dev/Array/arrReplace)
+- [arrRm](https://js-utils.pages.dev/Array/arrRm)
+- [countBy](https://js-utils.pages.dev/Array/countBy)
 - [groupBy](https://js-utils.pages.dev/Array/groupBy)
 - [intersection](https://js-utils.pages.dev/Array/intersection)
 - [range](https://js-utils.pages.dev/Array/range)
 - [move](https://js-utils.pages.dev/Array/move)
 - [sort](https://js-utils.pages.dev/Array/sort)
 - [sortBy](https://js-utils.pages.dev/Array/sortBy)
 
+## Async
+
+- [asyncFilter](https://js-utils.pages.dev/Array/asyncFilter)
+
 ### Maths
 
 - [percentage](https://js-utils.pages.dev/Maths/percentage)

apps/docs/pages/Array/_meta.json

@@ -5,7 +5,7 @@
   "arrIns": "arrIns",
   "arrReplace": "arrReplace",
   "arrRm": "arrRm",
-  "asyncFilter": "asyncFilter",
+  "countBy": "countBy",
   "groupBy": "groupBy",
   "intersection": "intersection",
   "move": "move",

apps/docs/pages/Array/countBy.mdx

@@ -0,0 +1,60 @@
+import { Callout } from "nextra/components";
+import REPL from "../../components/REPL";
+
+> Counts the items in the given array and groups them by the name provided.
+
+## Syntax
+
+```ts
+import { countBy } from '@opentf/utils';
+
+countBy<T>(
+  arr: T[] = [],
+  by: ((val: T) => string) | string
+)
+```
+
+## Examples
+
+```ts
+countBy([]) //=> {}
+
+countBy([1, 2, 3, 4, 5, 6, 7, 8, 9], (v) =>
+  v % 2 === 0 ? 'Even' : 'Odd'
+)
+//=> { Even: 4, Odd: 5 });
+
+countBy(['Apple', 'Mango', 'Orange'], 'length')
+//=>
+// {
+//   '5': 2,
+//   '6': 1,
+// }
+
+const inventory = [
+  { name: 'asparagus', type: 'vegetables', qty: 5 },
+  { name: 'bananas', type: 'fruit', qty: 0 },
+  { name: 'goat', type: 'meat', qty: 23 },
+  { name: 'cherries', type: 'fruit', qty: 5 },
+  { name: 'fish', type: 'meat', qty: 22 },
+];
+countBy(inventory, ({ qty }) => (qty === 0 ? 'OutOfStock' : 'InStock'))
+//=> { OutOfStock: 1, InStock: 4 });
+
+const letters = ['a', 'b', 'A', 'a', 'B', 'c'];
+countBy(letters, (l) => l.toLowerCase())
+//=>
+// {
+//   a: 3,
+//   b: 2,
+//   c: 1,
+// }
+```
+
+## Try
+
+<REPL code={`const { countBy } = require('@opentf/utils');
+
+const letters = ['a', 'b', 'A', 'a', 'B', 'c'];
+countBy(letters, (l) => l.toLowerCase());
+`} />

apps/docs/pages/Async/_meta.json

@@ -0,0 +1,3 @@
+{
+  "asyncFilter": "asyncFilter"
+}

packages/utils/README.md

@@ -47,7 +47,15 @@ bun add @opentf/utils
 ## Usage
 
 ```ts
-import { isNum, pascalCase, sort, clone, isEql, isEqlArr, sleep } from "@opentf/utils";
+import {
+  isNum,
+  pascalCase,
+  sort,
+  clone,
+  isEql,
+  isEqlArr,
+  sleep,
+} from '@opentf/utils';
 
 isNum(NaN); //=> false
 
@@ -56,14 +64,20 @@ pascalCase('pascal case'); //=> PascalCase
 sort([1, 10, 21, 2], 'desc'); //=> [ 21, 10, 2, 1 ]
 
 const obj = {
-  a: 1, 
-  b: 'abc', 
-  c: new Map([['key', 'val']])
+  a: 1,
+  b: 'abc',
+  c: new Map([['key', 'val']]),
 };
 clone(obj); // It returns deeply cloned value.
 
-const mapA = new Map([ ['a', 1], ['b', 2] ])
-const mapB = new Map([ ['b', 2], ['a', 1] ])
+const mapA = new Map([
+  ['a', 1],
+  ['b', 2],
+]);
+const mapB = new Map([
+  ['b', 2],
+  ['a', 1],
+]);
 isEql(mapA, mapB); //=> false
 
 isEqlArr([1, 2, 3], [2, 3, 1]); //=> true
@@ -78,14 +92,21 @@ await sleep(1000); // It suspends the exection for 1 second.
 - [arrChunk](https://js-utils.pages.dev/Array/arrChunk)
 - [arrCompact](https://js-utils.pages.dev/Array/arrCompact)
 - [arrDiff](https://js-utils.pages.dev/Array/arrDiff)
-- [asyncFilter](https://js-utils.pages.dev/Array/asyncFilter)
+- [arrIns](https://js-utils.pages.dev/Array/arrIns)
+- [arrReplace](https://js-utils.pages.dev/Array/arrReplace)
+- [arrRm](https://js-utils.pages.dev/Array/arrRm)
+- [countBy](https://js-utils.pages.dev/Array/countBy)
 - [groupBy](https://js-utils.pages.dev/Array/groupBy)
 - [intersection](https://js-utils.pages.dev/Array/intersection)
 - [range](https://js-utils.pages.dev/Array/range)
 - [move](https://js-utils.pages.dev/Array/move)
 - [sort](https://js-utils.pages.dev/Array/sort)
 - [sortBy](https://js-utils.pages.dev/Array/sortBy)
 
+## Async
+
+- [asyncFilter](https://js-utils.pages.dev/Array/asyncFilter)
+
 ### Maths
 
 - [percentage](https://js-utils.pages.dev/Maths/percentage)

packages/utils/__tests__/array/countBy.spec.ts

@@ -0,0 +1,36 @@
+import { countBy } from '../../src';
+
+describe('Array', () => {
+  test('countBy', () => {
+    expect(countBy([])).toEqual({});
+    expect(
+      countBy([1, 2, 3, 4, 5, 6, 7, 8, 9], (v) =>
+        v % 2 === 0 ? 'Even' : 'Odd'
+      )
+    ).toEqual({ Even: 4, Odd: 5 });
+
+    expect(countBy(['Apple', 'Mango', 'Orange'], 'length')).toEqual({
+      '5': 2,
+      '6': 1,
+    });
+
+    const inventory = [
+      { name: 'asparagus', type: 'vegetables', qty: 5 },
+      { name: 'bananas', type: 'fruit', qty: 0 },
+      { name: 'goat', type: 'meat', qty: 23 },
+      { name: 'cherries', type: 'fruit', qty: 5 },
+      { name: 'fish', type: 'meat', qty: 22 },
+    ];
+    expect(
+      countBy(inventory, ({ qty }) => (qty === 0 ? 'OutOfStock' : 'InStock'))
+    ).toEqual({ OutOfStock: 1, InStock: 4 });
+
+    const letters = ['a', 'b', 'A', 'a', 'B', 'c'];
+
+    expect(countBy(letters, (l) => l.toLowerCase())).toEqual({
+      a: 3,
+      b: 2,
+      c: 1,
+    });
+  });
+});

packages/utils/src/array/arrDiff.ts

@@ -1,4 +1,4 @@
-import isEql from '../common/isEql';
+import isEql from '../assert/isEql';
 
 /**
  *  It creates an array with the values, not included in the other array by deep comparison.

packages/utils/src/array/countBy.ts

@@ -0,0 +1,19 @@
+import isFn from '../types/isFn';
+
+/**
+ *  Counts the items in the given array and groups them by the name provided.
+ *
+ * @example
+ *
+ * countBy([1, 2, 3, 4, 5], n => n % 2 === 0 ? 'Even' : 'Odd') //=> { Odd: 3, Even: 2 }
+ */
+export default function countBy<T>(
+  arr: T[] = [],
+  by: ((val: T) => string) | string
+) {
+  return arr.reduce((acc: Record<string, number>, cur: T) => {
+    const k = isFn(by) ? by(cur) : (cur[by as keyof T] as string);
+    const count = acc[k] ? acc[k] + 1 : 1;
+    return { ...acc, [k]: count };
+  }, {});
+}

packages/utils/src/array/groupBy.ts

@@ -1,5 +1,9 @@
 export type GroupKey<T> = ((a: T) => string) | string;
 
+/**
+ * It groups the elements of a given array according to the given key.
+ *
+ */
 export default function groupBy<T>(
   arr: T[],
   key: GroupKey<T>

packages/utils/src/index.ts

@@ -10,7 +10,6 @@ export { default as strReplace } from './string/strReplace';
 // Array
 export { default as arrDiff } from './array/arrDiff';
 export { default as range } from './array/range';
-export { default as asyncFilter } from './array/asyncFilter';
 export { default as groupBy } from './array/groupBy';
 export { default as move } from './array/move';
 export { default as sort } from './array/sort';
@@ -21,6 +20,10 @@ export { default as intersection } from './array/intersection';
 export { default as arrIns } from './array/arrIns';
 export { default as arrReplace } from './array/arrReplace';
 export { default as arrRm } from './array/arrRm';
+export { default as countBy } from './array/countBy';
+
+// Async
+export { default as asyncFilter } from './async/asyncFilter';
 
 // Maths
 export { default as percentage } from './maths/percentage';