@homedev/object-utils 1.0.4 → 1.0.6

package/dist/index.d.ts

@@ -1,36 +1,96 @@
 /**
+ * Maps an array asynchronously using Promise.all for parallel execution
+ * @typeParam T - Type of input array items
+ * @typeParam U - Type of async result items
+ * @param arr - Array to map
+ * @param fn - Async mapping function
+ * @returns Promise of mapped array
  * @public
  */
 export declare const asyncMap: <T, U>(arr: T[], fn: (item: T, index: number, array: T[]) => Promise<U>) => Promise<U[]>;
 
 /**
+ * Deep clones an object using structuredClone (faster) with JSON fallback
+ * - Uses structuredClone for better performance and broader type support (Date, RegExp, etc.)
+ * - Falls back to JSON serialization if structuredClone fails or is unavailable
+ * - Note: Functions, symbols, and undefined values are lost in JSON fallback
+ * @typeParam T - Type of object to clone
+ * @param model - Object to clone
+ * @returns Deep clone of the object
  * @public
  */
-export declare const defined: <T>(value: T | undefined, msg?: string) => T;
+export declare const deepClone: <T>(model: T) => T;
 
 /**
+ * Asserts that a value is defined, throwing an error if undefined
+ * @typeParam T - Type of the value
+ * @param value - Value to check
+ * @param msg - Error message to throw if value is undefined or null
+ * @returns The value if defined
+ * @throws Error if value is undefined
+ * @public
+ */
+export declare const defined: <T>(value: T | undefined | null, msg?: string) => T;
+
+/**
+ * Maps an array while filtering out null/undefined values (performance optimized)
+ * Combines filter and map operations to avoid double iteration
+ * @typeParam T - Type of input array items
+ * @typeParam U - Type of mapped result items
+ * @param arr - Array to map (can be undefined)
+ * @param fn - Mapping function
+ * @returns Mapped array with nulls/undefined filtered out, or empty array if input is undefined
  * @public
  */
 export declare const nonNullMap: <T, U>(arr: T[] | undefined, fn: (item: T, index: number, array: T[]) => U) => U[];
 
 /**
+ * Sorts an array by a selector function with custom comparison
+ * Uses a shallow copy to avoid mutating the original array
+ * @typeParam T - Type of array items
+ * @typeParam U - Type of comparison values
+ * @param arr - Array to sort
+ * @param selector - Function to extract comparison value from item
+ * @param compare - Comparison function (default: numeric comparison)
+ * @returns New sorted array
  * @public
  */
 export declare const sortBy: <T, U>(arr: T[], selector: (item: T) => U, compare?: (a: U, b: U) => number) => T[];
 
 /**
+ * Converts an object's entries into an array of objects with a key property
+ * @typeParam T - The type of items in the resulting array
+ * @param from - Object to convert
+ * @param key - Property name to use for keys (default: 'name')
+ * @returns Array of objects with key properties
+ * @example
+ * toList({ a: { value: 1 }, b: { value: 2 } }) // [{ name: 'a', value: 1 }, { name: 'b', value: 2 }]
  * @public
  */
-export declare const toList: <T>(from: any, key?: string) => T[];
+export declare const toList: <T>(from: Record<string, unknown>, key?: string) => T[];
 
 /**
+ * Converts an array into an object indexed by a key property, excluding the key from items
+ * @typeParam T - The type of the resulting object values
+ * @param from - Array to convert
+ * @param key - Property name to use as key (default: 'name')
+ * @returns Object indexed by key values, without the key property in values
+ * @example
+ * toObject([{ name: 'a', value: 1 }]) // { a: { value: 1 } }
  * @public
  */
-export declare const toObject: <T>(from: any[], key?: string) => T;
+export declare const toObject: <T extends Record<string, unknown>>(from: T[], key?: string) => Record<string, Omit<T, typeof key>>;
 
 /**
+ * Converts an array into an object indexed by a key property, keeping the full items
+ * @typeParam T - The type of the resulting object
+ * @param from - Array to convert
+ * @param key - Property name to use as key (default: 'name')
+ * @returns Object indexed by key values
+ * @example
+ * toObjectWithKey([{ name: 'a', value: 1 }]) // { a: { name: 'a', value: 1 } }
  * @public
  */
-export declare const toObjectWithKey: <T>(from: any[], key?: string) => T;
+export declare const toObjectWithKey: <T extends Record<string, unknown>>(from: T[], key?: string) => Record<string, T>;
 
 export { }

package/dist/index.js

@@ -1 +1 @@
-var o=(e,n="name")=>Object.entries(e).map(([t,r])=>({[n]:t,...r})),s=(e,n="name")=>Object.fromEntries(e.map((t)=>[t[n],t])),T=(e,n="name")=>Object.fromEntries(e.map((t)=>{let{[n]:r,...a}=t;return[r,a]})),i=(e,n)=>e?.filter((t)=>t!==null&&t!==void 0).map(n)??[],m=(e,n="Value is undefined")=>{if(e===void 0)throw Error(n);return e},c=(e,n,t=(r,a)=>r-a)=>e.slice().sort((r,a)=>t(n(r),n(a))),p=async(e,n)=>Promise.all(e.map(n));export{s as toObjectWithKey,T as toObject,o as toList,c as sortBy,i as nonNullMap,m as defined,p as asyncMap};
+var A=(h,j="name")=>Object.entries(h).map(([q,w])=>({[j]:q,...w})),B=(h,j="name")=>Object.fromEntries(h.map((q)=>[q[j],q])),D=(h,j="name")=>Object.fromEntries(h.map((q)=>{let{[j]:w,...z}=q;return[w,z]})),E=(h,j)=>{if(!h)return[];let q=[],w=0;for(let z of h)if(z!==null&&z!==void 0)q.push(j(z,w,h)),w++;return q},F=(h,j="Value is undefined")=>{if(h===void 0||h===null)throw Error(j);return h},G=(h,j,q=(w,z)=>w-z)=>h.slice().sort((w,z)=>q(j(w),j(z))),H=async(h,j)=>Promise.all(h.map(j)),I=(h)=>{if(typeof structuredClone<"u")try{return structuredClone(h)}catch{}return JSON.parse(JSON.stringify(h))};export{B as toObjectWithKey,D as toObject,A as toList,G as sortBy,E as nonNullMap,F as defined,I as deepClone,H as asyncMap};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homedev/object-utils",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "object utilities",
   "author": "julzor",
   "license": "ISC",