fix(object/groupBy): add types overload for arrays (#58)

Co-authored-by: o.drapeza <o.drapeza@tinkoff.ru>

Author: SuperOleg39

package.json

@@ -50,6 +50,7 @@
     "react": "^16.9.0",
     "react-is": "^16.9.0",
     "recursive-readdir-sync": "^1.0.6",
+    "ts-expect": "^1.1.0",
     "ts-jest": "^24.1.0",
     "typescript": "^3.6.3",
     "walker": "^1.0.7"

src/object/__tests__/groupBy.ts

@@ -1,16 +1,103 @@
+import { expectType } from "ts-expect";
 import groupBy from '../groupBy';
+import { ArrValues, ObjValues } from '../../typings/types';
 
 describe('utils/object/groupBy', () => {
     it('group object values by function', () => {
         const obj = { a: { b: 1, c: 2 }, b: { b: 3 }, c: { b: 1, d: 5 } };
-        const fn = jest.fn((x) => x.b);
 
-        expect(groupBy(fn, obj)).toEqual({
+        expect(groupBy((x) => x.b, obj)).toEqual({
             1: [{ b: 1, c: 2 }, { b: 1, d: 5 }],
             3: [{ b: 3 }],
         });
-        expect(fn).toBeCalledWith({ b: 1, c: 2 }, 'a', obj);
-        expect(fn).toBeCalledWith({ b: 3 }, 'b', obj);
-        expect(fn).toBeCalledWith({ b: 1, d: 5 }, 'c', obj);
+    });
+
+    it('group array values by function', () => {
+        const arr = [{ b: 1, c: 2 }, { b: 3 }, { b: 1, d: 5 }];
+
+        expect(groupBy((x) => x.b, arr)).toEqual({
+            1: [{ b: 1, c: 2 }, { b: 1, d: 5 }],
+            3: [{ b: 3 }],
+        })
+    });
+
+    it('group object values by function through currying', () => {
+        const obj = { a: { b: 1, c: 2 }, b: { b: 3 }, c: { b: 1, d: 5 } };
+
+        expect(groupBy((x: ObjValues<typeof obj>) => x.b)(obj)).toEqual({
+            1: [{ b: 1, c: 2 }, { b: 1, d: 5 }],
+            3: [{ b: 3 }],
+        });
+    });
+
+    it('group array values by function through currying', () => {
+        const arr = [{ b: 1, c: 2 }, { b: 3 }, { b: 1, d: 5 }];
+
+        expect(groupBy((x: ArrValues<typeof arr>) => x.b)(arr)).toEqual({
+            1: [{ b: 1, c: 2 }, { b: 1, d: 5 }],
+            3: [{ b: 3 }],
+        })
+    });
+
+    it('check grouped object type', () => {
+        const obj = { a: { b: 1, c: 2 }, b: { b: 3 }, c: { b: 1, d: 5 } };
+        const result = groupBy((x) => x.b, obj);
+        const curriedResult = groupBy((x) => x.b)(obj);
+        const typedCurriedResult = groupBy((x: ObjValues<typeof obj>) => x.b)(obj);
+
+        type ValuesType = { b: number, c: number } | { b: number } | { b: number, d: number };
+
+        type ExpectedType = Record<number, Array<ValuesType>>;
+        type CurriedExpectedType = Record<any, Array<ValuesType>>;
+        type TypedCurriedExpectedType = Record<number, Array<ValuesType>>;
+
+        expectType<ExpectedType>(result);
+        expectType<CurriedExpectedType>(curriedResult);
+        expectType<TypedCurriedExpectedType>(typedCurriedResult);
+    });
+
+    it('check grouped array type', () => {
+        const arr = [{ b: 1, c: 2 }, { b: 3 }, { b: 1, d: 5 }];
+        const result = groupBy((x) => x.b, arr);
+        const curriedResult = groupBy((x) => x.b)(arr);
+        const typedCurriedResult = groupBy((x: ArrValues<typeof arr>) => x.b)(arr);
+
+        type ValuesType = { b: number, c: number } | { b: number } | { b: number, d: number };
+
+        type ExpectedType = Record<number, Array<ValuesType>>;
+        type CurriedExpectedType = Record<any, Array<ValuesType>>;
+        type TypedCurriedExpectedType = Record<number, Array<ValuesType>>;
+
+        expectType<ExpectedType>(result);
+        expectType<CurriedExpectedType>(curriedResult);
+        expectType<TypedCurriedExpectedType>(typedCurriedResult);
+    });
+
+    it('check grouped const object type', () => {
+        const obj = { a: { b: 1, c: 2 }, b: { b: 3 }, c: { b: 1, d: 5 } } as const;
+        const result = groupBy((x) => x.b, obj);
+
+        type ValuesType = { b: number, c: number } | { b: number } | { b: number, d: number };
+
+        type ExpectedType = {
+            [1]: Array<ValuesType>;
+            [3]: Array<ValuesType>;
+        };
+
+        expectType<ExpectedType>(result);
+    });
+
+    it('check grouped const array type', () => {
+        const arr = [{ b: 1, c: 2 }, { b: 3 }, { b: 1, d: 5 }] as const;
+        const result = groupBy((x) => x.b, arr);
+
+        type ValuesType = { b: number, c: number } | { b: number } | { b: number, d: number };
+
+        type ExpectedType = {
+            [1]: ReadonlyArray<ValuesType>;
+            [3]: ReadonlyArray<ValuesType>;
+        };
+
+        expectType<ExpectedType>(result);
     });
 });

src/object/groupBy.ts

@@ -1,12 +1,16 @@
 import curryN from '../function/curryN';
 import objectKeys from './keys';
-import { ObjBaseBy, ObjBase } from '../typings/types';
+import { ObjBaseBy, ObjOrArrBaseBy, ObjValues, AnyObjOrArr, AnyArr } from '../typings/types';
 
 interface GroupBy {
-    <O, KT extends string>(fn: ObjBaseBy<O, KT>, obj: O): Record<KT, O[keyof O][]>;
-    <K extends string, V, KT extends string>(fn: ObjBase<K, V, KT>): <O extends Record<K, V>>(
-        obj: O
-    ) => Record<KT, O[keyof O][]>;
+    <Fn extends ObjOrArrBaseBy<AnyObjOrArr, any>>(fn: Fn):
+        <Input extends AnyObjOrArr>(obj: Input) => Input extends AnyArr
+            ? Record<ReturnType<Fn>, Input>
+            : Record<ReturnType<Fn>, ObjValues<Input>[]>;
+
+    <Input extends AnyObjOrArr, Fn extends ObjOrArrBaseBy<Input, any>>(fn: Fn, obj: Input): Input extends AnyArr
+        ? Record<ReturnType<Fn>, Input>
+        : Record<ReturnType<Fn>, ObjValues<Input>[]>;
 }
 
 /**

src/typings/types.ts

@@ -1,8 +1,15 @@
 export type Ord = number | string | boolean;
 
+export type AnyObj = Record<any, any>;
+export type AnyArr = any[] | readonly any[];
+export type AnyObjOrArr = AnyObj | AnyArr;
+
 export type ArrBase<T, R> = (value: T, index: number, arr: ArrayLike<T>) => R;
 export type ObjBase<K extends Prop | Paths, V, R> = (value: V, key: K, obj: Record<K extends Prop ? K : any, V>) => R;
 export type ObjBaseBy<O extends Record<any, any>, R> = (value: O[keyof O], key: keyof O & string, obj: O) => R;
+export type ObjOrArrBaseBy<Input extends AnyObjOrArr, R> = Input extends AnyArr
+    ? (value: ArrValues<Input>, key: number, obj: Input) => R
+    : (value: ObjValues<Input>, key: keyof Input, obj: Input) => R;
 
 export type CompareFunc<T, R extends Ord> = (a: T, b: T) => R;
 export type OrdFunc<T, R extends Ord> = (item: T) => R;
@@ -35,6 +42,16 @@ export type Pattern = RegExp | string;
 
 export type ReplaceType<O, K extends Prop, V> = Pick<O, Exclude<keyof O, K>> & { [p in K]: V };
 
+/**
+ * Obtain the values type of a array
+ */
+export type ArrValues<A extends AnyArr> = A[number];
+
+/**
+ * Obtain the values type of a object
+ */
+export type ObjValues<O extends AnyObj> = O[keyof O];
+
 // @see https://gist.github.com/donnut/fd56232da58d25ceecf1, comment by @albrow
 export interface CurriedTypeGuard2<T1, T2, R extends T2> {
     (t1: T1): (t2: T2) => t2 is R;