ts-data-forge 3.3.0 → 3.3.1

package/dist/others/map-nullable.d.mts

@@ -1,144 +1,20 @@
 /**
- * Applies a function to a value if the value is not `null` or `undefined`.
- * If the value is `null` or `undefined`, it returns `undefined`.
+ * Applies a function to a value if the value is not `null` or `undefined`. If
+ * the value is `null` or `undefined`, it returns `undefined`.
  *
- * This function provides a safe way to transform nullable values without explicit null checks.
- * It's similar to Optional.map() but works directly with TypeScript's nullable types.
- * Supports both regular and curried usage for functional composition.
+ * This function provides a safe way to transform nullable values without
+ * explicit null checks. It's similar to Optional.map() but works directly with
+ * TypeScript's nullable types. Supports both regular and curried usage for
+ * functional composition.
  *
  * @template A - The type of the input value (excluding null/undefined)
  * @template B - The type of the value returned by the mapping function
- * @param value - The value to potentially transform (can be `A`, `null`, or `undefined`)
- * @param mapFn - A function that transforms a non-nullable value of type `A` to type `B`
- * @returns The result of applying `mapFn` to `value` if value is not null/undefined; otherwise `undefined`
- *
- * @example Basic usage with nullable values
- * ```typescript
- * // Safe string transformation
- * mapNullable("hello", s => s.toUpperCase()); // "HELLO"
- * mapNullable(null, s => s.toUpperCase()); // undefined
- * mapNullable(undefined, s => s.toUpperCase()); // undefined
- *
- * // Number operations
- * mapNullable(5, n => n * 2); // 10
- * mapNullable(0, n => n * 2); // 0 (note: 0 is not null/undefined)
- * mapNullable(null as number | null, n => n * 2); // undefined
- * ```
- *
- * @example Working with optional object properties
- * ```typescript
- * interface User {
- *   id: number;
- *   name?: string;
- *   email?: string;
- * }
- *
- * function formatUserDisplay(user: User): string {
- *   const displayName = mapNullable(user.name, name => name.toUpperCase()) ?? 'Anonymous';
- *   const emailDomain = mapNullable(user.email, email => email.split('@')[1]);
- *
- *   return `${displayName} ${emailDomain ? `(${emailDomain})` : ''}`;
- * }
- *
- * formatUserDisplay({ id: 1, name: 'John', email: 'john@example.com' }); // "JOHN (example.com)"
- * formatUserDisplay({ id: 2 }); // "Anonymous "
- * ```
- *
- * @example Curried usage for functional composition
- * ```typescript
- * // Create reusable transformers
- * const toUpperCase = mapNullable((s: string) => s.toUpperCase());
- * const addPrefix = mapNullable((s: string) => `PREFIX_${s}`);
- * const parseNumber = mapNullable((s: string) => parseInt(s, 10));
- *
- * // Use in different contexts
- * toUpperCase("hello"); // "HELLO"
- * toUpperCase(null); // undefined
- *
- * // Compose transformations
- * const processString = (s: string | null) => {
- *   const upper = toUpperCase(s);
- *   return addPrefix(upper);
- * };
- *
- * processString("test"); // "PREFIX_TEST"
- * processString(null); // undefined
- * ```
- *
- * @example Chaining nullable operations
- * ```typescript
- * // API response handling
- * interface ApiResponse {
- *   data?: {
- *     user?: {
- *       profile?: {
- *         displayName?: string;
- *       };
- *     };
- *   };
- * }
- *
- * function getDisplayName(response: ApiResponse): string | undefined {
- *   return mapNullable(
- *     response.data?.user?.profile?.displayName,
- *     name => name.trim().toUpperCase()
- *   );
- * }
- *
- * // Chain multiple transformations
- * function processNullableChain(value: string | null): string | undefined {
- *   const step1 = mapNullable(value, v => v.trim());
- *   const step2 = mapNullable(step1, v => v.length > 0 ? v : null);
- *   const step3 = mapNullable(step2, v => v.toUpperCase());
- *   return step3;
- * }
- * ```
- *
- * @example Integration with array methods
- * ```typescript
- * const nullableNumbers: (number | null | undefined)[] = [1, null, 3, undefined, 5];
- *
- * // Transform and filter in one step
- * const doubled = nullableNumbers
- *   .map(n => mapNullable(n, x => x * 2))
- *   .filter((n): n is number => n !== undefined);
- * // Result: [2, 6, 10]
- *
- * // Process optional array elements
- * const users: Array<{ name?: string }> = [
- *   { name: 'Alice' },
- *   { name: undefined },
- *   { name: 'Bob' }
- * ];
- *
- * const upperNames = users
- *   .map(u => mapNullable(u.name, n => n.toUpperCase()))
- *   .filter((n): n is string => n !== undefined);
- * // Result: ['ALICE', 'BOB']
- * ```
- *
- * @example Error handling patterns
- * ```typescript
- * // Safe JSON parsing
- * function parseJsonSafe<T>(json: string | null): T | undefined {
- *   return mapNullable(json, j => {
- *     try {
- *       return JSON.parse(j) as T;
- *     } catch {
- *       return null;
- *     }
- *   }) ?? undefined;
- * }
- *
- * // Safe property access with computation
- * function calculateAge(birthYear: number | null): string | undefined {
- *   return mapNullable(birthYear, year => {
- *     const age = new Date().getFullYear() - year;
- *     return age >= 0 ? `${age} years old` : null;
- *   }) ?? undefined;
- * }
- * ```
- *
+ * @param value - The value to potentially transform (can be `A`, `null`, or
+ *   `undefined`)
+ * @param mapFn - A function that transforms a non-nullable value of type `A` to
+ *   type `B`
+ * @returns The result of applying `mapFn` to `value` if value is not
+ *   null/undefined; otherwise `undefined`
  * @see Optional - For more complex optional value handling
  * @see Result - For error handling with detailed error information
  */

package/dist/others/map-nullable.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"map-nullable.d.mts","sourceRoot":"","sources":["../../src/others/map-nullable.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+IG;AACH,wBAAgB,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAC1C,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAC3B,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GACjB,CAAC,GAAG,SAAS,CAAC;AAGjB,wBAAgB,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAC1C,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GACjB,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,KAAK,CAAC,GAAG,SAAS,CAAC"}
+{"version":3,"file":"map-nullable.d.mts","sourceRoot":"","sources":["../../src/others/map-nullable.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAC1C,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAC3B,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GACjB,CAAC,GAAG,SAAS,CAAC;AAGjB,wBAAgB,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAC1C,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GACjB,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,KAAK,CAAC,GAAG,SAAS,CAAC"}

package/dist/others/map-nullable.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"map-nullable.mjs","sources":["../../src/others/map-nullable.mts"],"sourcesContent":[null],"names":[],"mappings":"AA0JM,SAAU,WAAW,CACzB,GAAG,IAE8B,EAAA;AAEjC,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,IAAI;AAC3B,YAAA,OAAO,KAAK,IAAI,IAAI,GAAG,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC;QACjD;QACA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI;YACpB,OAAO,CAAC,KAA2B,KAAK,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC;QACnE;;AAEJ;;;;"}
+{"version":3,"file":"map-nullable.mjs","sources":["../../src/others/map-nullable.mts"],"sourcesContent":[null],"names":[],"mappings":"AA8BM,SAAU,WAAW,CACzB,GAAG,IAE8B,EAAA;AAEjC,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,IAAI;AAC3B,YAAA,OAAO,KAAK,IAAI,IAAI,GAAG,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC;QACjD;QACA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI;YACpB,OAAO,CAAC,KAA2B,KAAK,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC;QACnE;;AAEJ;;;;"}

package/dist/others/memoize-function.d.mts

@@ -1,172 +1,29 @@
 /**
- * Creates a memoized version of a function that caches results based on input arguments.
+ * Creates a memoized version of a function that caches results based on input
+ * arguments.
  *
- * The memoized function stores results in an internal Map and returns cached values
- * for repeated calls with the same arguments. This can significantly improve performance
- * for expensive computations or I/O operations.
+ * The memoized function stores results in an internal Map and returns cached
+ * values for repeated calls with the same arguments. This can significantly
+ * improve performance for expensive computations or I/O operations.
  *
  * **Important considerations:**
- * - The cache grows unbounded - consider memory implications for long-running applications
- * - Cache keys must be primitives (string, number, boolean, symbol, null, undefined, bigint)
+ *
+ * - The cache grows unbounded - consider memory implications for long-running
+ *   applications
+ * - Cache keys must be primitives (string, number, boolean, symbol, null,
+ *   undefined, bigint)
  * - Object arguments require careful key generation to ensure uniqueness
  * - Pure functions only - memoizing functions with side effects can lead to bugs
  *
  * @template A - The tuple type of the function arguments
  * @template R - The return type of the function
- * @template K - The primitive type used as the cache key (must be valid Map key)
+ * @template K - The primitive type used as the cache key (must be valid Map
+ *   key)
  * @param fn - The pure function to memoize
- * @param argsToCacheKey - Function that converts arguments to a unique cache key
+ * @param argsToCacheKey - Function that converts arguments to a unique cache
+ *   key
  * @returns A memoized version of the input function with the same signature
  *
- * @example Basic memoization for expensive calculations
- * ```typescript
- * // Fibonacci calculation (exponential time complexity)
- * const fibonacci = (n: number): number => {
- *   console.log(`Computing fib(${n})`);
- *   if (n <= 1) return n;
- *   return fibonacci(n - 1) + fibonacci(n - 2);
- * };
- *
- * const memoizedFib = memoizeFunction(
- *   fibonacci,
- *   (n) => n // Number itself as key
- * );
- *
- * memoizedFib(40); // Much faster than unmemoized version
- * memoizedFib(40); // Returns instantly from cache
- * ```
- *
- * @example Multi-argument functions with composite keys
- * ```typescript
- * // Grid calculation with x,y coordinates
- * const calculateGridValue = (x: number, y: number, scale: number): number => {
- *   console.log(`Computing grid(${x},${y},${scale})`);
- *   // Expensive computation...
- *   return Math.sin(x * scale) * Math.cos(y * scale);
- * };
- *
- * const memoizedGrid = memoizeFunction(
- *   calculateGridValue,
- *   (x, y, scale) => `${x},${y},${scale}` // String concatenation for composite key
- * );
- *
- * // Alternative: Using bit manipulation for integer coordinates
- * const memoizedGrid2 = memoizeFunction(
- *   calculateGridValue,
- *   (x, y, scale) => (x << 20) | (y << 10) | scale // Assuming small positive integers
- * );
- * ```
- *
- * @example Object arguments with selective memoization
- * ```typescript
- * interface User {
- *   id: number;
- *   name: string;
- *   email: string;
- *   metadata?: Record<string, unknown>;
- * }
- *
- * const fetchUserPermissions = async (user: User): Promise<string[]> => {
- *   console.log(`Fetching permissions for user ${user.id}`);
- *   const response = await api.get(`/permissions/${user.id}`);
- *   return response.data;
- * };
- *
- * // Memoize based only on user ID, ignoring other fields
- * const memoizedFetchPermissions = memoizeFunction(
- *   fetchUserPermissions,
- *   (user) => user.id // Only cache by ID
- * );
- *
- * // For multiple identifying fields
- * const processUserData = (user: User, orgId: number): ProcessedData => {
- *   // Complex processing...
- * };
- *
- * const memoizedProcess = memoizeFunction(
- *   processUserData,
- *   (user, orgId) => `${user.id}:${orgId}` // Composite key with separator
- * );
- * ```
- *
- * @example Memoizing recursive functions
- * ```typescript
- * // Recursive path finding
- * const findPaths = (start: string, end: string, visited: Set<string> = new Set()): string[][] => {
- *   if (start === end) return [[end]];
- *   // ... complex recursive logic
- * };
- *
- * // Use sorted, serialized visited set for consistent keys
- * const memoizedFindPaths = memoizeFunction(
- *   findPaths,
- *   (start, end, visited = new Set()) =>
- *     `${start}->${end}:[${[...visited].toSorted().join(',')}]`
- * );
- * ```
- *
- * @example Cache key strategies
- * ```typescript
- * // 1. Simple primitive argument
- * memoizeFunction(fn, (x: number) => x);
- *
- * // 2. Multiple arguments with separator
- * memoizeFunction(fn, (a: string, b: number) => `${a}|${b}`);
- *
- * // 3. Object with specific fields
- * memoizeFunction(fn, (obj: { id: number; version: number }) =>
- *   `${obj.id}:v${obj.version}`
- * );
- *
- * // 4. Array argument with JSON serialization
- * memoizeFunction(fn, (arr: number[]) => JSON.stringify(arr));
- *
- * // 5. Boolean flags as bit field
- * memoizeFunction(fn, (a: boolean, b: boolean, c: boolean) =>
- *   (a ? 4 : 0) | (b ? 2 : 0) | (c ? 1 : 0)
- * );
- * ```
- *
- * @example Memory-conscious memoization with weak references
- * ```typescript
- * // For object keys, consider using WeakMap externally
- * const cache = new WeakMap<object, Result>();
- *
- * function memoizeWithWeakMap<T extends object, R>(
- *   fn: (obj: T) => R
- * ): (obj: T) => R {
- *   return (obj: T): R => {
- *     if (cache.has(obj)) {
- *       return cache.get(obj)!;
- *     }
- *     const result = fn(obj);
- *     cache.set(obj, result);
- *     return result;
- *   };
- * }
- * ```
- *
- * @example Anti-patterns to avoid
- * ```typescript
- * // ❌ Bad: Memoizing impure functions
- * const memoizedRandom = memoizeFunction(
- *   () => Math.random(),
- *   () => 'key' // Always returns cached random value!
- * );
- *
- * // ❌ Bad: Memoizing functions with side effects
- * const memoizedLog = memoizeFunction(
- *   (msg: string) => { console.log(msg); return msg; },
- *   (msg) => msg // Logs only on first call!
- * );
- *
- * // ❌ Bad: Non-unique cache keys
- * const memoizedProcess = memoizeFunction(
- *   (user: User) => processUser(user),
- *   (user) => user.name // Multiple users can have same name!
- * );
- * ```
- *
  * @see https://en.wikipedia.org/wiki/Memoization
  */
 export declare const memoizeFunction: <const A extends readonly unknown[], R, K extends Primitive>(fn: (...args: A) => R, argsToCacheKey: (...args: A) => K) => ((...args: A) => R);

package/dist/others/memoize-function.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"memoize-function.d.mts","sourceRoot":"","sources":["../../src/others/memoize-function.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0KG;AACH,eAAO,MAAM,eAAe,GAC1B,KAAK,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAClC,CAAC,EACD,CAAC,SAAS,SAAS,EAEnB,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,EACrB,gBAAgB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,KAChC,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,CAiBpB,CAAC"}
+{"version":3,"file":"memoize-function.d.mts","sourceRoot":"","sources":["../../src/others/memoize-function.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,eAAe,GAC1B,KAAK,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAClC,CAAC,EACD,CAAC,SAAS,SAAS,EAEnB,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,EACrB,gBAAgB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,KAChC,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,CAiBpB,CAAC"}

package/dist/others/memoize-function.mjs

@@ -1,172 +1,29 @@
 /**
- * Creates a memoized version of a function that caches results based on input arguments.
+ * Creates a memoized version of a function that caches results based on input
+ * arguments.
  *
- * The memoized function stores results in an internal Map and returns cached values
- * for repeated calls with the same arguments. This can significantly improve performance
- * for expensive computations or I/O operations.
+ * The memoized function stores results in an internal Map and returns cached
+ * values for repeated calls with the same arguments. This can significantly
+ * improve performance for expensive computations or I/O operations.
  *
  * **Important considerations:**
- * - The cache grows unbounded - consider memory implications for long-running applications
- * - Cache keys must be primitives (string, number, boolean, symbol, null, undefined, bigint)
+ *
+ * - The cache grows unbounded - consider memory implications for long-running
+ *   applications
+ * - Cache keys must be primitives (string, number, boolean, symbol, null,
+ *   undefined, bigint)
  * - Object arguments require careful key generation to ensure uniqueness
  * - Pure functions only - memoizing functions with side effects can lead to bugs
  *
  * @template A - The tuple type of the function arguments
  * @template R - The return type of the function
- * @template K - The primitive type used as the cache key (must be valid Map key)
+ * @template K - The primitive type used as the cache key (must be valid Map
+ *   key)
  * @param fn - The pure function to memoize
- * @param argsToCacheKey - Function that converts arguments to a unique cache key
+ * @param argsToCacheKey - Function that converts arguments to a unique cache
+ *   key
  * @returns A memoized version of the input function with the same signature
  *
- * @example Basic memoization for expensive calculations
- * ```typescript
- * // Fibonacci calculation (exponential time complexity)
- * const fibonacci = (n: number): number => {
- *   console.log(`Computing fib(${n})`);
- *   if (n <= 1) return n;
- *   return fibonacci(n - 1) + fibonacci(n - 2);
- * };
- *
- * const memoizedFib = memoizeFunction(
- *   fibonacci,
- *   (n) => n // Number itself as key
- * );
- *
- * memoizedFib(40); // Much faster than unmemoized version
- * memoizedFib(40); // Returns instantly from cache
- * ```
- *
- * @example Multi-argument functions with composite keys
- * ```typescript
- * // Grid calculation with x,y coordinates
- * const calculateGridValue = (x: number, y: number, scale: number): number => {
- *   console.log(`Computing grid(${x},${y},${scale})`);
- *   // Expensive computation...
- *   return Math.sin(x * scale) * Math.cos(y * scale);
- * };
- *
- * const memoizedGrid = memoizeFunction(
- *   calculateGridValue,
- *   (x, y, scale) => `${x},${y},${scale}` // String concatenation for composite key
- * );
- *
- * // Alternative: Using bit manipulation for integer coordinates
- * const memoizedGrid2 = memoizeFunction(
- *   calculateGridValue,
- *   (x, y, scale) => (x << 20) | (y << 10) | scale // Assuming small positive integers
- * );
- * ```
- *
- * @example Object arguments with selective memoization
- * ```typescript
- * interface User {
- *   id: number;
- *   name: string;
- *   email: string;
- *   metadata?: Record<string, unknown>;
- * }
- *
- * const fetchUserPermissions = async (user: User): Promise<string[]> => {
- *   console.log(`Fetching permissions for user ${user.id}`);
- *   const response = await api.get(`/permissions/${user.id}`);
- *   return response.data;
- * };
- *
- * // Memoize based only on user ID, ignoring other fields
- * const memoizedFetchPermissions = memoizeFunction(
- *   fetchUserPermissions,
- *   (user) => user.id // Only cache by ID
- * );
- *
- * // For multiple identifying fields
- * const processUserData = (user: User, orgId: number): ProcessedData => {
- *   // Complex processing...
- * };
- *
- * const memoizedProcess = memoizeFunction(
- *   processUserData,
- *   (user, orgId) => `${user.id}:${orgId}` // Composite key with separator
- * );
- * ```
- *
- * @example Memoizing recursive functions
- * ```typescript
- * // Recursive path finding
- * const findPaths = (start: string, end: string, visited: Set<string> = new Set()): string[][] => {
- *   if (start === end) return [[end]];
- *   // ... complex recursive logic
- * };
- *
- * // Use sorted, serialized visited set for consistent keys
- * const memoizedFindPaths = memoizeFunction(
- *   findPaths,
- *   (start, end, visited = new Set()) =>
- *     `${start}->${end}:[${[...visited].toSorted().join(',')}]`
- * );
- * ```
- *
- * @example Cache key strategies
- * ```typescript
- * // 1. Simple primitive argument
- * memoizeFunction(fn, (x: number) => x);
- *
- * // 2. Multiple arguments with separator
- * memoizeFunction(fn, (a: string, b: number) => `${a}|${b}`);
- *
- * // 3. Object with specific fields
- * memoizeFunction(fn, (obj: { id: number; version: number }) =>
- *   `${obj.id}:v${obj.version}`
- * );
- *
- * // 4. Array argument with JSON serialization
- * memoizeFunction(fn, (arr: number[]) => JSON.stringify(arr));
- *
- * // 5. Boolean flags as bit field
- * memoizeFunction(fn, (a: boolean, b: boolean, c: boolean) =>
- *   (a ? 4 : 0) | (b ? 2 : 0) | (c ? 1 : 0)
- * );
- * ```
- *
- * @example Memory-conscious memoization with weak references
- * ```typescript
- * // For object keys, consider using WeakMap externally
- * const cache = new WeakMap<object, Result>();
- *
- * function memoizeWithWeakMap<T extends object, R>(
- *   fn: (obj: T) => R
- * ): (obj: T) => R {
- *   return (obj: T): R => {
- *     if (cache.has(obj)) {
- *       return cache.get(obj)!;
- *     }
- *     const result = fn(obj);
- *     cache.set(obj, result);
- *     return result;
- *   };
- * }
- * ```
- *
- * @example Anti-patterns to avoid
- * ```typescript
- * // ❌ Bad: Memoizing impure functions
- * const memoizedRandom = memoizeFunction(
- *   () => Math.random(),
- *   () => 'key' // Always returns cached random value!
- * );
- *
- * // ❌ Bad: Memoizing functions with side effects
- * const memoizedLog = memoizeFunction(
- *   (msg: string) => { console.log(msg); return msg; },
- *   (msg) => msg // Logs only on first call!
- * );
- *
- * // ❌ Bad: Non-unique cache keys
- * const memoizedProcess = memoizeFunction(
- *   (user: User) => processUser(user),
- *   (user) => user.name // Multiple users can have same name!
- * );
- * ```
- *
  * @see https://en.wikipedia.org/wiki/Memoization
  */
 const memoizeFunction = (fn, argsToCacheKey) => {

package/dist/others/memoize-function.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"memoize-function.mjs","sources":["../../src/others/memoize-function.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0KG;MACU,eAAe,GAAG,CAK7B,EAAqB,EACrB,cAAiC,KACV;AACvB,IAAA,MAAM,SAAS,GAAG,IAAI,GAAG,EAAQ;AAEjC,IAAA,OAAO,CAAC,GAAG,IAAO,KAAO;AACvB,QAAA,MAAM,GAAG,GAAG,cAAc,CAAC,GAAG,IAAI,CAAC;AAEnC,QAAA,IAAI,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;;AAEtB,YAAA,OAAO,SAAS,CAAC,GAAG,CAAC,GAAG,CAAE;QAC5B;aAAO;AACL,YAAA,MAAM,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC;AAE1B,YAAA,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC;AAE1B,YAAA,OAAO,MAAM;QACf;AACF,IAAA,CAAC;AACH;;;;"}
+{"version":3,"file":"memoize-function.mjs","sources":["../../src/others/memoize-function.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;MACU,eAAe,GAAG,CAK7B,EAAqB,EACrB,cAAiC,KACV;AACvB,IAAA,MAAM,SAAS,GAAG,IAAI,GAAG,EAAQ;AAEjC,IAAA,OAAO,CAAC,GAAG,IAAO,KAAO;AACvB,QAAA,MAAM,GAAG,GAAG,cAAc,CAAC,GAAG,IAAI,CAAC;AAEnC,QAAA,IAAI,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;;AAEtB,YAAA,OAAO,SAAS,CAAC,GAAG,CAAC,GAAG,CAAE;QAC5B;aAAO;AACL,YAAA,MAAM,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC;AAE1B,YAAA,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC;AAE1B,YAAA,OAAO,MAAM;QACf;AACF,IAAA,CAAC;AACH;;;;"}