chore: adjust types to handle empty collections

Author: chrisbbreuer

src/collect.ts

@@ -385,33 +385,34 @@ function createCollectionOperations<T>(collection: Collection<T>): CollectionOpe
       })
     },
 
-    pad(size: number, value: T) {
-      const result = [...collection.items]
+    pad<U = T>(size: number, value: U): CollectionOperations<T | U> {
+      const result: Array<T | U> = collection.items.map(item => item as T | U)
       const padSize = Math.abs(size)
-      const padValue = value
 
       while (result.length < padSize) {
-        size > 0 ? result.push(padValue) : result.unshift(padValue)
+        size > 0 ? result.push(value) : result.unshift(value)
       }
 
-      return collect(result)
+      return collect<T | U>(result)
     },
 
     pop() {
       return collection.items.pop()
     },
 
-    prepend(value: T) {
-      return collect([value, ...collection.items])
+    prepend<U = T>(value: U): CollectionOperations<T | U> {
+      const result: Array<T | U> = [value, ...collection.items.map(item => item as T | U)]
+      return collect<T | U>(result)
     },
 
     pull<K extends keyof T>(key: K) {
       const item = collection.items[0]
       return item ? item[key] : undefined
     },
 
-    push(value: T) {
-      return collect([...collection.items, value])
+    push<U = T>(value: U): CollectionOperations<T | U> {
+      const result: Array<T | U> = [...collection.items.map(item => item as T | U), value]
+      return collect<T | U>(result)
     },
 
     put<K extends string, V>(key: K, value: V): CollectionOperations<any> {

src/types.ts

@@ -207,8 +207,8 @@ export interface CollectionOperations<T> extends Collection<T> {
   }
   containsOneItem: () => boolean
   containsAll: {
-    (items: Array<T | undefined>): boolean;  // Handle direct items check with optional undefined
-    <K extends keyof T>(key: K, values: Array<T[K] | undefined>): boolean;  // Handle key/value check
+    (items: Array<T | undefined>): boolean // Handle direct items check with optional undefined
+    <K extends keyof T>(key: K, values: Array<T[K] | undefined>): boolean // Handle key/value check
   }
   countBy: {
     <K extends keyof T>(key: K): Map<T[K], number>
@@ -246,11 +246,14 @@ export interface CollectionOperations<T> extends Collection<T> {
   only: <K extends string>(...keys: K[]) => CollectionOperations<{
     [P in K & keyof T]?: T[P]
   }>
-  pad: (size: number, value: T) => CollectionOperations<T>
+  // eslint-disable-next-line ts/method-signature-style
+  pad<U = T>(size: number, value: U): CollectionOperations<T | U>
   pop: () => T | undefined
-  prepend: (value: T) => CollectionOperations<T>
+  // eslint-disable-next-line ts/method-signature-style
+  prepend<U = T>(value: U): CollectionOperations<T | U>
   pull: <K extends keyof T>(key: K) => T[K] | undefined
-  push: (value: T) => CollectionOperations<T>
+  // eslint-disable-next-line ts/method-signature-style
+  push<U = T>(value: U): CollectionOperations<T | U>
   // First overload handles existing keys
   // eslint-disable-next-line ts/method-signature-style
   put<K extends keyof T>(key: K, value: T[K]): CollectionOperations<T>