fix(utils): fixes collect implementation and types

src/collection/PureCollection.ts

@@ -24,10 +24,11 @@ import {
   Coerce,
   TakeStrategy,
   Take,
-  take
+  take,
+  CollectCollector,
+  Collect
 } from '../utils';
 import { PureCollectionInitial } from './types';
-import { CollectCollector, Collect } from '~/utils/collect/types';
 
 const internal = Symbol('PureCollection');
 
@@ -152,9 +153,7 @@ export class PureCollection<T extends Record<string, any>> {
   public select(property: keyof T, a: any, b?: any, c?: any): any {
     return select(this.get(property) as any, a, b, c);
   }
-  public collect<O extends Record<string, any>>(
-    collector: CollectCollector<FilterRecordByType<T, Type>, O>
-  ): Collect<O> {
+  public collect<O>(collector: CollectCollector<O>): Collect<O> {
     return collect(
       Object.entries(this.all()).reduce((acc, [key, value]) => {
         return isType(value) ? Object.assign(acc, { [key]: value }) : acc;

src/utils/collect/collect.ts

@@ -27,14 +27,15 @@ const functions: CollectorFunctions = {
   }
 };
 
-export function collect<
-  I extends Record<string, Type>,
-  O extends Record<string, any>
->(data: I, collector: CollectCollector<I, O>): Collect<O> {
-  const callbacks = collector(functions);
+export function collect<I extends Record<string, Type>, O>(
+  data: I,
+  collector: CollectCollector<O>
+): Collect<O> {
+  const response = collector(functions);
   const results: Partial<Collect<O>> = {};
-  for (const key of Object.keys(callbacks) as Array<keyof O & keyof I>) {
-    results[key] = callbacks[key](data[key]);
+  for (const key of Object.keys(response) as Array<keyof O & keyof I>) {
+    const value = response[key];
+    results[key] = typeof value === 'function' ? value(data[key]) : value;
   }
   return results as Collect<O>;
 }

src/utils/collect/types.ts

@@ -11,9 +11,7 @@ export type Collect<O extends Record<string, any>> = {
 };
 
 /* Input */
-export type CollectCollector<I extends Record<string, Type>, O = any> = (
-  fn: CollectorFunctions
-) => O & { [P in keyof I]?: Type | CollectCollectorCallback<Type, any> };
+export type CollectCollector<O> = (fn: CollectorFunctions) => O;
 
 export type CollectCollectorCallback<T extends Type, U> = (data: T) => U;
 

test/utils/collect.test.ts

@@ -25,6 +25,7 @@ test(`calls utils and returns values`, () => {
       f: 'barbaz'
     },
     ({ get, assert, take, ensure, coerce, select }) => ({
+      item: 'value',
       a: get(),
       b: assert(),
       c: take('c0arg' as any, 'c1arg' as any),
@@ -35,6 +36,7 @@ test(`calls utils and returns values`, () => {
   );
 
   expect(result).toEqual({
+    item: 'value',
     a: 'foo',
     b: { assert: 'bar' },
     c: { take: 'baz' },