From d4b5e45bf09ac39a2e49f32784a618c5750cb535 Mon Sep 17 00:00:00 2001
From: Aybrea <wrenchou22@gmail.com>
Date: Sun, 3 Nov 2024 14:24:43 +0800
Subject: [PATCH] feat: extend collection methods

---
 src/collection.ts | 76 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)

diff --git a/src/collection.ts b/src/collection.ts
index 4bb69ca..47de1e3 100644
--- a/src/collection.ts
+++ b/src/collection.ts
@@ -15,6 +15,9 @@ import {
   isWeakMap,
 } from './general'
 
+type CollectionByKey<Member> = Record<number | string, Member>
+type AnyLiteral = Record<string, any>
+
 export function mergeWith<TObject extends Record<string, any>, TSource extends Record<string, any>>(
   object: TObject,
   source: TSource,
@@ -167,3 +170,76 @@ export function cloneDeepWith<T>(value: T, fn: (value: any) => any): T {
 
   return baseCloneDeep(value, cache)
 }
+
+export function buildCollection<T extends AnyLiteral, K extends keyof T | number | string, R = T>(
+  collection: T[],
+  keyOrCallback: keyof T | ((member: T) => [K, R]),
+): Record<K, R> {
+  return collection.reduce(
+    (byKey: Record<K, R>, member: T) => {
+      if (typeof keyOrCallback === 'function') {
+        const [key, value] = keyOrCallback(member)
+        byKey[key] = value
+      } else {
+        byKey[member[keyOrCallback] as K] = member as unknown as R
+      }
+
+      return byKey
+    },
+    {} as Record<K, R>,
+  )
+}
+
+export function mapValues<R, M>(
+  byKey: CollectionByKey<M>,
+  callback: (member: M, key: string, index: number, originalByKey: CollectionByKey<M>) => R,
+): CollectionByKey<R> {
+  return Object.keys(byKey).reduce((newByKey: CollectionByKey<R>, key, index) => {
+    newByKey[key] = callback(byKey[key], key, index, byKey)
+    return newByKey
+  }, {})
+}
+
+export function pick<T, K extends keyof T>(object: T, keys: K[]) {
+  return keys.reduce(
+    (result, key) => {
+      result[key] = object[key]
+      return result
+    },
+    {} as Pick<T, K>,
+  )
+}
+
+export function pickTruthy<T, K extends keyof T>(object: T, keys: K[]) {
+  return keys.reduce(
+    (result, key) => {
+      if (object[key]) {
+        result[key] = object[key]
+      }
+
+      return result
+    },
+    {} as Pick<T, K>,
+  )
+}
+
+export function omit<T extends object, K extends keyof T>(object: T, keys: K[]): Omit<T, K> {
+  const stringKeys = new Set(keys.map(String))
+  const savedKeys = Object.keys(object).filter((key) => !stringKeys.has(key)) as Array<Exclude<keyof T, K>>
+
+  return pick(object, savedKeys)
+}
+
+export function omitUndefined<T extends object>(object: T): T {
+  return Object.keys(object).reduce((result, stringKey) => {
+    const key = stringKey as keyof T
+    if (object[key] !== undefined) {
+      result[key as keyof T] = object[key]
+    }
+    return result
+  }, {} as T)
+}
+
+export function isLiteralObject(value: any): value is AnyLiteral {
+  return isObject(value) && !Array.isArray(value)
+}