npm - ts-data-forge - Versions diffs - 14.6.1 → 14.6.2 - Mend

ts-data-forge 14.6.1 → 14.6.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (393) hide show

package/dist/object/object.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"object.mjs","sources":["../../src/object/object.mts"],"sourcesContent":["import {\n type ArrayElement,\n type Decrement,\n type DeepOmit,\n type DeepPick,\n type IsFixedLengthList,\n type IsUnion,\n type List,\n type ReadonlyRecord,\n type RelaxedExclude,\n type RelaxedOmit,\n type RelaxedPick,\n type StrictOmit,\n type StrictPick,\n type ToString,\n type TypeEq,\n type UnknownRecord,\n} from 'ts-type-forge';\nimport { Arr } from '../array/index.mjs';\nimport { Optional } from '../functional/index.mjs';\nimport { hasKey, isRecord } from '../guard/index.mjs';\n\n/*\n A collection of type-safe object utility functions providing functional\n * programming patterns for object manipulation, including pick, omit, shallow\n * equality checks, and more.\n \n All functions maintain TypeScript type safety and support both direct and\n * curried usage patterns for better composition with pipe operations.\n /\nexport namespace Obj {\n /\n Performs a shallow equality check on two records using a configurable\n * equality function. Verifies that both records have the same number of\n * entries and that for every key in the first record, the corresponding value\n * passes the equality test with the value in the second record.\n \n @example\n \n ```ts\n * const obj1 = { name: 'Alice', age: 30 } as const;\n \n const obj2 = { name: 'Alice', age: 30 } as const;\n \n const obj3 = { name: 'Alice', age: 31 } as const;\n \n assert.isTrue(Obj.shallowEq(obj1, obj2));\n \n assert.isFalse(Obj.shallowEq(obj1, obj3));\n \n // Custom equality function\n * const obj4 = { value: 1 } as const;\n \n const obj5 = { value: 1.00001 } as const;\n \n const closeEnough = (a: unknown, b: unknown): boolean => {\n * if (typeof a === 'number' && typeof b === 'number') {\n * return Math.abs(a - b) < 0.001;\n * }\n \n return Object.is(a, b);\n * };\n \n assert.isTrue(Obj.shallowEq(obj4, obj5, closeEnough));\n * ```\n \n @param a - The first record to compare\n * @param b - The second record to compare\n * @param eq - Optional equality function (defaults to Object.is for strict\n * equality)\n * @returns `true` if the records are shallowly equal according to the\n * equality function, `false` otherwise\n /\n export const shallowEq = (\n a: UnknownRecord,\n b: UnknownRecord,\n eq: (x: unknown, y: unknown) => boolean = Object.is,\n ): boolean => {\n const aEntries = Object.entries(a);\n\n const bEntries = Object.entries(b);\n\n if (aEntries.length !== bEntries.length) return false;\n\n return aEntries.every(([k, v]) => eq(b[k], v));\n };\n\n /\n Creates a new record that contains only the specified keys from the source\n * record. This function supports both direct usage and curried form for\n * functional composition.\n \n Type Safety: Only keys that exist in the source record type are\n * allowed, preventing runtime errors from accessing non-existent properties.\n \n @example\n \n ```ts\n * const user = {\n * id: 1,\n * name: 'Bob',\n * email: 'bob@example.com',\n * password: 'secret',\n * role: 'admin',\n * } as const;\n \n // Direct usage\n * const publicInfo = Obj.pick(user, ['id', 'name', 'role']);\n \n assert.deepStrictEqual(publicInfo, {\n * id: 1,\n * name: 'Bob',\n * role: 'admin',\n * });\n \n // Curried usage with pipe\n * const nameAndEmail = pipe(user).map(Obj.pick(['name', 'email'])).value;\n \n assert.deepStrictEqual(nameAndEmail, {\n * name: 'Bob',\n * email: 'bob@example.com',\n * });\n * ```\n \n @template R - The type of the input record\n * @template Keys - The readonly array type of keys to pick from the record\n * @param record - The source record to pick properties from\n * @param keys - A readonly array of keys to include in the result\n * @returns A new record containing only the specified keys and their values\n /\n export function pick<\n const R extends UnknownRecord,\n const Keys extends readonly (keyof R)[],\n >(record: R, keys: Keys): StrictPick<R, ArrayElement<Keys>>;\n\n // Curried version\n export function pick<const Keys extends readonly PropertyKey[]>(\n keys: Keys,\n ): <const R extends UnknownRecord>(\n record: R,\n ) => RelaxedPick<R, ArrayElement<Keys>>;\n\n export function pick<\n const R extends UnknownRecord,\n const Keys extends readonly (keyof R)[],\n >(\n ...args: readonly [record: R, keys: Keys] \| readonly [keys: Keys]\n ):\n \| StrictPick<R, ArrayElement<Keys>>\n \| ((record: R) => RelaxedPick<R, ArrayElement<Keys>>) {\n switch (args.length) {\n case 2: {\n const [record, keys] = args;\n\n const keysSet = new Set<keyof R>(keys);\n\n return (\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n Object.fromEntries(\n Object.entries(record).filter(([k, _v]) => keysSet.has(k)),\n ) as never\n );\n }\n\n case 1: {\n const [keys] = args;\n\n return (record: R) => pick(record, keys);\n }\n }\n }\n\n /\n Creates a new record that excludes the specified keys from the source\n * record. This function supports both direct usage and curried form for\n * functional composition.\n \n Type Safety: Only keys that exist in the source record type are\n * allowed, and the return type precisely reflects which properties remain\n * after omission.\n \n @example\n \n ```ts\n * const user = {\n * id: 1,\n * name: 'Charlie',\n * email: 'charlie@example.com',\n * password: 'secret123',\n * internalNote: 'VIP customer',\n * } as const;\n \n // Direct usage - remove sensitive fields\n * const safeUser = Obj.omit(user, ['password', 'internalNote']);\n \n assert.deepStrictEqual(safeUser, {\n * id: 1,\n * name: 'Charlie',\n * email: 'charlie@example.com',\n * });\n \n // Curried usage with pipe\n * const withoutEmail = pipe(user).map(Obj.omit(['email', 'password'])).value;\n \n assert.deepStrictEqual(withoutEmail, {\n * id: 1,\n * name: 'Charlie',\n * internalNote: 'VIP customer',\n * });\n * ```\n \n @template R - The type of the input record\n * @template Keys - The readonly array type of keys to omit from the record\n * @param record - The source record to omit properties from\n * @param keys - A readonly array of keys to exclude from the result\n * @returns A new record containing all properties except the specified keys\n /\n export function omit<\n const R extends UnknownRecord,\n const Keys extends readonly (keyof R)[],\n >(record: R, keys: Keys): StrictOmit<R, ArrayElement<Keys>>;\n\n // Curried version\n export function omit<const Keys extends readonly PropertyKey[]>(\n keys: Keys,\n ): <const R extends UnknownRecord>(\n record: R,\n ) => RelaxedOmit<R, ArrayElement<Keys>>;\n\n export function omit<\n const R extends UnknownRecord,\n const Keys extends readonly (keyof R)[],\n >(\n ...args:\n readonly [record: R, keys: Keys] \| readonly [keys: readonly PropertyKey[]]\n ):\n \| StrictOmit<R, ArrayElement<Keys>>\n \| ((record: R) => StrictOmit<R, ArrayElement<Keys>>) {\n switch (args.length) {\n case 2: {\n const [record, keys] = args;\n\n const keysSet = new Set<keyof R>(keys);\n\n return (\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n Object.fromEntries(\n Object.entries(record).filter(([k, _v]) => !keysSet.has(k)),\n ) as never\n );\n }\n\n case 1: {\n const [keys] = args;\n\n return <R2 extends UnknownRecord>(record: R2) => {\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n const result = omit(\n record,\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n keys as readonly (keyof R2)[],\n ) as RelaxedOmit<R2, ArrayElement<Keys>>;\n\n return result;\n };\n }\n }\n }\n\n /\n Creates an object from an array of key-value pairs with precise TypeScript\n * typing. This is a type-safe wrapper around `Object.fromEntries` that\n * provides better type inference and compile-time guarantees about the\n * resulting object structure.\n \n Type Behavior:\n \n - When entries is a fixed-length tuple, the exact object type is inferred\n * - When entries has dynamic length with union key types, `Partial` is applied\n * to prevent incorrect assumptions about which keys will be present\n \n @example\n \n ```ts\n * // Fixed-length tuple - exact type inferred\n * const entries1 = [\n * ['name', 'David'],\n * ['age', 25],\n * ['active', true],\n * ] as const;\n \n const obj1 = Obj.fromEntries(entries1);\n \n assert.deepStrictEqual(obj1, {\n * name: 'David',\n * age: 25,\n * active: true,\n * });\n \n // Dynamic length array - Partial type applied\n * const dynamicEntries: readonly (readonly ['x' \| 'y', number])[] = [\n * ['x', 10],\n * ['y', 20],\n * ] as const;\n \n const obj2 = Obj.fromEntries(dynamicEntries);\n \n assert.deepStrictEqual(obj2, { x: 10, y: 20 });\n * ```\n \n @template Entries - The readonly array type of key-value entry tuples\n * @param entries - An array of readonly key-value entry tuples `[key, value]`\n * @returns An object created from the entries with precise typing\n /\n export const fromEntries = <\n const Entries extends readonly (readonly [PropertyKey, unknown])[],\n >(\n entries: Entries,\n ): IsFixedLengthList<Entries> extends true\n ? TsDataForgeInternals.EntriesToObject<Entries>\n : TsDataForgeInternals.PartialIfKeyIsUnion<\n TsDataForgeInternals.KeysOfEntries<Entries>,\n ReadonlyRecord<\n TsDataForgeInternals.KeysOfEntries<Entries>,\n TsDataForgeInternals.ValuesOfEntries<Entries>\n >\n > =>\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n Object.fromEntries(entries) as never;\n\n /\n Transforms every value of a record, leaving the key set untouched.\n \n Type Behavior: the result is a mapped type over `keyof R`, so the keys\n * — and their optional modifiers — survive verbatim:\n * `{ a: number; b?: number }` maps to `{ a: V2; b?: V2 }`, and a record with\n * an index signature stays total rather than becoming `Partial`.\n \n This is what `Object.fromEntries(Object.entries(record).map(...))` cannot\n * express: an entries array carries no evidence that it still covers every\n * key of the record it came from, so its element type is all the return type\n * can be built from. Going through a mapped type instead states the\n * invariant that a value-only transform preserves the key set.\n \n Key handling: keys reach the callback the way `Object.entries` yields\n * them, so a numeric key `1` arrives as `'1'`. Symbol-keyed properties are\n * not enumerated by `Object.entries`; they are dropped from both the result\n * and its type.\n \n @example\n \n <!-- doc:embed:jsdoc:example:./samples/src/object/map-example.mts -->\n \n ```ts\n * const scores = { alice: 1, bob: 2 } as const;\n \n const doubled = Obj.map(scores, (value) => value * 2);\n \n assert.deepStrictEqual(doubled, { alice: 2, bob: 4 });\n \n // The key is available as the second argument.\n * const labelled = Obj.map(scores, (value, key) => `${key}=${value}`);\n \n assert.deepStrictEqual(labelled, { alice: 'alice=1', bob: 'bob=2' });\n * ```\n \n <!-- /doc:embed:jsdoc:example:./samples/src/object/map-example.mts -->\n \n @template R - The type of the source record\n * @template V2 - The type the callback returns for every key\n * @param record - The record whose values are transformed\n * @param mapFn - Called once per own enumerable string key, with the value\n * and the key\n * @returns A new record with the same keys as `record` and the mapped values\n /\n export const map = <const R extends UnknownRecord, V2>(\n record: R,\n mapFn: (\n value: R[keyof R],\n key: TsDataForgeInternals.MappedRecordKey<R>,\n ) => V2,\n ): TsDataForgeInternals.MappedRecord<R, V2> => {\n // `Object.entries` erases both the key and the value type of `R`, so the\n // callback is widened once here instead of asserting on every entry.\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n const mapFnWidened = mapFn as (value: unknown, key: string) => V2;\n\n return (\n // `Object.entries` enumerates exactly the own enumerable string keys of\n // `record`, and nothing here adds or removes an entry, so the result has\n // the key set `MappedRecord` claims.\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n Object.fromEntries(\n Object.entries(record).map(\n ([k, v]) => [k, mapFnWidened(v, k)] as const,\n ),\n ) as never\n );\n };\n\n /\n Keeps the entries whose value the predicate accepts, leaving the values\n * themselves untouched.\n \n Type Behavior: the surviving keys are the keys of the source record,\n * made optional — the predicate may reject any of them. A record keyed by an\n * index signature stays total instead, because it names no specific key that\n * could go missing.\n \n Passing a type guard narrows the value type of the result, which is what\n * `Object.fromEntries(Object.entries(record).filter(guard))` loses.\n \n Key handling: keys reach the callback the way `Object.entries` yields\n * them, so a numeric key `1` arrives as `'1'`. Symbol-keyed properties are\n * not enumerated by `Object.entries`; they are dropped from both the result\n * and its type.\n \n @example\n \n <!-- doc:embed:jsdoc:example:./samples/src/object/filter-example.mts -->\n \n ```ts\n * const scores = { alice: 1, bob: 2 } as const;\n \n const passing = Obj.filter(scores, (value) => value > 1);\n \n assert.deepStrictEqual(passing, { bob: 2 });\n \n // The key is available as the second argument.\n * const notAlice = Obj.filter(scores, (_value, key) => key !== 'alice');\n \n assert.deepStrictEqual(notAlice, { bob: 2 });\n \n // A type guard narrows the value type of the result.\n * const mixed: UnknownRecord = { a: 1, b: 'x' } as const;\n \n const strings = Obj.filter(mixed, isString);\n \n assert.deepStrictEqual(strings, { b: 'x' });\n * ```\n \n <!-- /doc:embed:jsdoc:example:./samples/src/object/filter-example.mts -->\n \n @template R - The type of the source record\n * @template V2 - The type the guard narrows values to\n * @param record - The record whose entries are filtered\n * @param predicate - Called once per own enumerable string key, with the\n * value and the key\n * @returns A new record holding only the accepted entries\n /\n export function filter<const R extends UnknownRecord, V2 extends R[keyof R]>(\n record: R,\n predicate: (\n value: R[keyof R],\n key: TsDataForgeInternals.MappedRecordKey<R>,\n ) => value is V2,\n ): TsDataForgeInternals.FilteredRecord<\n TsDataForgeInternals.MappedRecord<R, V2>\n >;\n\n export function filter<const R extends UnknownRecord>(\n record: R,\n predicate: (\n value: R[keyof R],\n key: TsDataForgeInternals.MappedRecordKey<R>,\n ) => boolean,\n ): TsDataForgeInternals.FilteredRecord<R>;\n\n export function filter<const R extends UnknownRecord>(\n record: R,\n predicate: (\n value: R[keyof R],\n key: TsDataForgeInternals.MappedRecordKey<R>,\n ) => boolean,\n ): TsDataForgeInternals.FilteredRecord<R> {\n // `Object.entries` erases both the key and the value type of `R`, so the\n // callback is widened once here instead of asserting on every entry.\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n const predicateWidened = predicate as (\n value: unknown,\n key: string,\n ) => boolean;\n\n return (\n // `Object.entries` enumerates exactly the own enumerable string keys of\n // `record`, and filtering only ever removes entries, so the result has a\n // subset of those keys — which is what `FilteredRecord` claims.\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n Object.fromEntries(\n Object.entries(record).filter(([k, v]) => predicateWidened(v, k)),\n ) as never\n );\n }\n\n /\n Transforms and drops entries in one pass: the callback returns\n * `Optional.some(value)` to keep an entry with a new value, or\n * `Optional.none` to drop it.\n \n Type Behavior: as with {@link filter}, the surviving keys are the keys\n * of the source record made optional, and a record keyed by an index\n * signature stays total. Unlike {@link filter}, every kept value takes the\n * type the callback returns.\n \n `Optional` rather than `undefined` marks the dropped entries, so a record\n * whose values are legitimately `undefined` stays expressible.\n \n Key handling: keys reach the callback the way `Object.entries` yields\n * them, so a numeric key `1` arrives as `'1'`. Symbol-keyed properties are\n * not enumerated by `Object.entries`; they are dropped from both the result\n * and its type.\n \n @example\n \n <!-- doc:embed:jsdoc:example:./samples/src/object/filter-map-example.mts -->\n \n ```ts\n * const scores = { alice: 1, bob: 2 } as const;\n \n // `Optional.some` keeps an entry with a new value, `Optional.none` drops it.\n * const labelled = Obj.filterMap(scores, (value, key) =>\n * value > 1 ? Optional.some(`${key}=${value}`) : Optional.none,\n * );\n \n assert.deepStrictEqual(labelled, { bob: 'bob=2' });\n * ```\n \n <!-- /doc:embed:jsdoc:example:./samples/src/object/filter-map-example.mts -->\n \n @template R - The type of the source record\n * @template V2 - The type the callback returns for the entries it keeps\n * @param record - The record whose entries are transformed and filtered\n * @param mapFn - Called once per own enumerable string key, with the value\n * and the key\n * @returns A new record holding only the kept entries, with mapped values\n /\n export const filterMap = <const R extends UnknownRecord, V2>(\n record: R,\n mapFn: (\n value: R[keyof R],\n key: TsDataForgeInternals.MappedRecordKey<R>,\n ) => Optional<V2>,\n ): TsDataForgeInternals.FilteredRecord<\n TsDataForgeInternals.MappedRecord<R, V2>\n > => {\n // `Object.entries` erases both the key and the value type of `R`, so the\n // callback is widened once here instead of asserting on every entry.\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n const mapFnWidened = mapFn as (value: unknown, key: string) => Optional<V2>;\n\n return (\n // `Object.entries` enumerates exactly the own enumerable string keys of\n // `record`, and this only ever drops entries or replaces their values, so\n // the result has a subset of those keys with `V2` values.\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n Object.fromEntries(\n Object.entries(record).flatMap(([k, v]) => {\n const mapped = mapFnWidened(v, k);\n\n return Optional.isSome(mapped) ? [[k, mapped.value] as const] : [];\n }),\n ) as never\n );\n };\n\n /\n Merges multiple records into a single record using `Object.assign`.\n * Later records override properties from earlier records with the same key.\n \n @example\n \n <!-- doc:embed:jsdoc:example:./samples/src/object/merge-example.mts -->\n \n ```ts\n * const a = { a: 0, b: 0 } as const;\n \n const b = { b: 1, c: 0 } as const;\n \n const result = Obj.merge(a, b);\n \n assert.deepStrictEqual(result, { a: 0, b: 1, c: 0 });\n * ```\n \n <!-- /doc:embed:jsdoc:example:./samples/src/object/merge-example.mts -->\n \n @param records - The records to merge\n * @returns A new record with all properties merged\n /\n export const merge = <const Records extends readonly UnknownRecord[]>(\n ...records: Records\n ): TsDataForgeInternals.MergeAll<Records> =>\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n Object.fromEntries(records.flatMap((r) => Object.entries(r))) as never;\n\n /\n Deeply picks a nested property from an object along the specified key path.\n * Supports both direct and curried usage.\n \n @example\n \n ```ts\n * const data = { a: { b: { c: 1, d: 2 }, e: 3 }, f: 4 } as const;\n \n // Direct usage\n * const result = Obj.deepPick(data, ['a', 'b', 'c']);\n \n assert.deepStrictEqual(result, { a: { b: { c: 1 } } });\n \n // Curried usage with pipe\n * const pickAB = Obj.deepPick(['a', 'b']);\n \n const result2 = pipe(data).map(pickAB).value;\n \n assert.deepStrictEqual(result2, { a: { b: { c: 1, d: 2 } } });\n * ```\n \n @template R - The type of the input record\n * @template Path - The key path tuple\n * @param record - The source record\n * @param path - A readonly tuple of keys representing the nested path\n * @returns A new record containing only the nested property at the path\n /\n export function deepPick<\n const R extends UnknownRecord,\n const Path extends readonly (string \| number)[],\n >(record: R, path: Path): DeepPick<R, Path>;\n\n // Curried version\n export function deepPick<const Path extends readonly (string \| number)[]>(\n path: Path,\n ): <const R extends UnknownRecord>(record: R) => DeepPick<R, Path>;\n\n export function deepPick<\n const R extends UnknownRecord,\n const Path extends readonly (string \| number)[],\n >(\n ...args: readonly [record: R, path: Path] \| readonly [path: Path]\n ): DeepPick<R, Path> \| ((record: R) => DeepPick<R, Path>) {\n switch (args.length) {\n case 2: {\n const [record, path] = args;\n\n return (\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n deepPickImpl(record, path) as never\n );\n }\n\n case 1: {\n const [path] = args;\n\n return (record: R) => deepPick(record, path);\n }\n }\n }\n\n /\n Deeply omits a nested property from an object along the specified key path.\n * Supports both direct and curried usage.\n \n @example\n \n ```ts\n * const data = { a: { b: { c: 1, d: 2 }, e: 3 }, f: 4 } as const;\n \n // Direct usage\n * const result = Obj.deepOmit(data, ['a', 'b', 'c']);\n \n assert.deepStrictEqual(result, { a: { b: { d: 2 }, e: 3 }, f: 4 });\n \n // Curried usage with pipe\n * const omitAB = Obj.deepOmit(['a', 'b']);\n \n const result2 = pipe(data).map(omitAB).value;\n \n assert.deepStrictEqual(result2, { a: { e: 3 }, f: 4 });\n * ```\n \n @template R - The type of the input record\n * @template Path - The key path tuple\n * @param record - The source record\n * @param path - A readonly tuple of keys representing the nested path to omit\n * @returns A new record with the nested property at the path removed\n /\n export function deepOmit<\n const R extends UnknownRecord,\n const Path extends readonly (string \| number)[],\n >(record: R, path: Path): DeepOmit<R, Path>;\n\n // Curried version\n export function deepOmit<const Path extends readonly (string \| number)[]>(\n path: Path,\n ): <const R extends UnknownRecord>(record: R) => DeepOmit<R, Path>;\n\n export function deepOmit<\n const R extends UnknownRecord,\n const Path extends readonly (string \| number)[],\n >(\n ...args: readonly [record: R, path: Path] \| readonly [path: Path]\n ): DeepOmit<R, Path> \| ((record: R) => DeepOmit<R, Path>) {\n switch (args.length) {\n case 2: {\n const [record, path] = args;\n\n return (\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n deepOmitImpl(record, path) as never\n );\n }\n\n case 1: {\n const [path] = args;\n\n return (record: R) => deepOmit(record, path);\n }\n }\n }\n}\n\nconst deepPickImpl = (\n record: UnknownRecord,\n path: readonly (string \| number)[],\n): UnknownRecord => {\n if (!Arr.isNonEmpty(path)) return record;\n\n const head = path[0];\n\n if (!hasKey(record, head)) return {};\n\n const value = record[head];\n\n const tail = path.slice(1);\n\n if (!Arr.isNonEmpty(tail)) return { [head]: value };\n\n if (!isRecord(value)) return { [head]: {} };\n\n return {\n [head]: deepPickImpl(value, tail),\n };\n};\n\nconst deepOmitImpl = (\n record: UnknownRecord,\n path: readonly (string \| number)[],\n): UnknownRecord => {\n if (!Arr.isNonEmpty(path)) return record;\n\n const head = path[0];\n\n if (!hasKey(record, head)) return record;\n\n const tail = path.slice(1);\n\n if (!Arr.isNonEmpty(tail)) {\n return Object.fromEntries(\n Object.entries(record).filter(([k]) => k !== head),\n );\n }\n\n const value = record[head];\n\n if (!isRecord(value)) return record;\n\n return {\n ...record,\n [head]: deepOmitImpl(value, tail),\n };\n};\n\n/\n @internal\n * Internal type utilities for the Obj module.\n /\ndeclare namespace TsDataForgeInternals {\n type RecursionLimit = 20;\n\n /* - `[['x', 1], ['y', 3]]` -> `{ x: 1, y: 3 }` /\n export type EntriesToObject<\n Entries extends readonly (readonly [PropertyKey, unknown])[],\n // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n > = Readonly<EntriesToObjectImpl<{}, Entries>>;\n\n /* @internal /\n type EntriesToObjectImpl<\n R,\n Entries extends readonly (readonly [PropertyKey, unknown])[],\n > =\n TypeEq<Entries['length'], 0> extends true\n ? R\n : EntriesToObjectImpl<\n R & ReadonlyRecord<Entries[0][0], Entries[0][1]>,\n List.Tail<Entries>\n >;\n\n /\n - `['x' \| 'y' \| 'z', number][]]` -> `'x' \| 'y' \| 'z'`\n * - `[['a' \| 'b' \| 'c', number], ...['x' \| 'y' \| 'z', number][]]` -> `'a' \|\n * 'b' \| 'c' \| 'x' \| 'y' \| 'z'`\n \n @note To handle the second example above, recursion needs to be performed on infinite-length Entries,\n * but since the timing to stop cannot be determined, a recursion limit is set.\n /\n export type KeysOfEntries<\n Entries extends readonly (readonly [PropertyKey, unknown])[],\n > = KeysOfEntriesImpl<never, Entries, RecursionLimit>;\n\n type KeysOfEntriesImpl<\n K,\n Entries extends readonly (readonly [PropertyKey, unknown])[],\n RemainingNumRecursions extends number,\n > =\n TypeEq<RemainingNumRecursions, 0> extends true\n ? K\n : TypeEq<Entries['length'], 0> extends true\n ? K\n : KeysOfEntriesImpl<\n K \| Entries[0][0],\n List.Tail<Entries>,\n Decrement<RemainingNumRecursions>\n >;\n\n export type ValuesOfEntries<\n Entries extends readonly (readonly [PropertyKey, unknown])[],\n > = ValuesOfEntriesImpl<never, Entries, RecursionLimit>;\n\n type ValuesOfEntriesImpl<\n K,\n Entries extends readonly (readonly [PropertyKey, unknown])[],\n RemainingNumRecursions extends number,\n > =\n TypeEq<RemainingNumRecursions, 0> extends true\n ? K\n : TypeEq<Entries['length'], 0> extends true\n ? K\n : ValuesOfEntriesImpl<\n K \| Entries[0][1],\n List.Tail<Entries>,\n Decrement<RemainingNumRecursions>\n >;\n\n export type PartialIfKeyIsUnion<K, T> =\n IsUnion<K> extends true ? Partial<T> : T;\n\n /\n The keys `Object.entries` yields for `R`: symbol keys are not enumerated,\n * and a numeric key `1` arrives as the string `'1'`.\n /\n export type MappedRecordKey<R> = ToString<RelaxedExclude<keyof R, symbol>>;\n\n /\n `R` with every value replaced by `V2`. Homomorphic over `keyof R`, so\n * optional modifiers and index signatures are preserved; the key remapping\n * drops the symbol keys that `Object.entries` would not have visited.\n /\n export type MappedRecord<R, V2> = Readonly<{\n [K in keyof R as K extends symbol ? never : K]: V2;\n }>;\n\n /* `R` without the symbol keys `Object.entries` never visits. /\n type StringKeyedRecord<R> = Readonly<{\n [K in keyof R as K extends symbol ? never : K]: R[K];\n }>;\n\n /\n The result of dropping entries from `R`: symbol keys go away, and the\n * remaining keys become optional because a predicate may reject any of them.\n \n A record keyed by an index signature stays total instead. It names no\n * specific key that could go missing, and `noUncheckedIndexedAccess` already\n * adds `\| undefined` on access, so making it `Partial` would add nothing and\n * would only stop the result from being assignable back to the record type it\n * came from.\n /\n export type FilteredRecord<R> = string extends keyof R\n ? StringKeyedRecord<R>\n : number extends keyof R\n ? StringKeyedRecord<R>\n : Readonly<{ [K in keyof R as K extends symbol ? never : K]?: R[K] }>;\n\n /\n Merges two object types where keys in B override keys in A, preserving optional modifiers.\n \n This implementation uses a sophisticated technique to preserve optional property modifiers (`?`)\n * during the merge operation, which would otherwise be lost in a naive mapped type implementation.\n \n ## Core Technique: Optional Property Detection\n \n Uses `{} extends Pick<T, K>` to determine if a property is optional:\n * - Required property: `Pick<T, 'x'>` = `{ x: number }` → `{}` does NOT extend it (false)\n * - Optional property: `Pick<T, 'y'>` = `{ y?: string }` → `{}` DOES extend it (true)\n \n This works because `{}` (empty object) is assignable to objects with only optional properties\n * but not to objects with required properties.\n \n ## Implementation Strategy\n \n The type is constructed as an intersection of five mapped types:\n \n 1. Required properties from B - Properties in B that are required (override A completely)\n * 2. Optional properties from B (not in A) - New optional properties from B\n * 3. Optional properties from B (in A) - Union of A[K] \| B[K] to preserve both possibilities\n * 4. Required properties only in A - Properties in A but not in B that are required\n * 5. Optional properties only in A - Properties in A but not in B that are optional (with `?` modifier)\n \n Finally, the intersection is flattened using an optional-preserving identity mapping that\n * re-applies the optional detection logic to maintain the `?` modifiers in the final type.\n \n @example\n * ```ts\n * type A = Readonly<{ x: number; y?: string }>;\n \n type B = Readonly<{ y?: number; z?: boolean }>;\n \n type Result = MergeTwo<A, B>;\n * // Result: Readonly<{ x: number; y?: string \| number; z?: boolean }>\n * ```\n /\n // transformer-ignore-next-line\n type MergeTwo<A extends UnknownRecord, B extends UnknownRecord> = {\n // 1. Required properties from B (override A completely)\n // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n readonly [K in keyof B as {} extends StrictPick<B, K> ? never : K]: B[K];\n } & {\n // 2. Optional properties from B that are NOT in A\n readonly [\n // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n K in keyof B as {} extends StrictPick<B, K>\n ? K extends keyof A\n ? never\n : K\n : never\n ]?: B[K];\n } & {\n // 3. Optional properties from B that ARE in A (create union)\n readonly [\n // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n K in keyof B as {} extends StrictPick<B, K>\n ? K extends keyof A\n ? K\n : never\n : never\n ]?: K extends keyof A ? A[K] \| B[K] : never;\n } & {\n // 4. Required properties only in A (not overridden by B)\n readonly [\n // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n K in RelaxedExclude<keyof A, keyof B> as {} extends StrictPick<A, K>\n ? never\n : K\n ]: A[K];\n } & {\n // 5. Optional properties only in A (not overridden by B)\n readonly [\n // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n K in RelaxedExclude<keyof A, keyof B> as {} extends StrictPick<A, K>\n ? K\n : never\n ]?: A[K];\n } extends infer O\n ? Readonly<\n {\n // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n [K in keyof O as {} extends StrictPick<O, K> ? never : K]: O[K];\n } & {\n // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n [K in keyof O as {} extends StrictPick<O, K> ? K : never]?: O[K];\n }\n >\n : never;\n\n /* Sequentially merges a tuple of object types from left to right. */\n export type MergeAll<\n Records extends readonly UnknownRecord[],\n // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n Acc extends UnknownRecord = {},\n > =\n IsFixedLengthList<Records> extends false\n ? ArrayElement<Records>\n : Records extends readonly [\n infer First extends UnknownRecord,\n ...infer Rest extends readonly UnknownRecord[],\n ]\n ? MergeAll<Rest, MergeTwo<Acc, First>>\n : Acc;\n}\n"],"names":["Obj","Optional.isSome","Arr.isNonEmpty"],"mappings":"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"}
1	+ {"version":3,"file":"object.mjs","sourceRoot":"","sources":["../../src/object/object.mts"],"names":[],"mappings":"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"}

package/dist/others/cast-mutable.mjs CHANGED Viewed

@@ -1,11 +1,38 @@
-const castMutable = (readonlyValue) => (
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-  readonlyValue
-);
-const castDeepMutable = (readonlyValue) => (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  readonlyValue
-);
-export { castDeepMutable, castMutable };
-//# sourceMappingURL=cast-mutable.mjs.map
+/**
+ * Casts a readonly type `T` to its `Mutable<T>` equivalent.
+ *
+ * **⚠️ Safety Warning**: This is a type assertion that bypasses TypeScript's
+ * immutability guarantees. The runtime value remains unchanged - only the type
+ * system's view of it changes. Use with caution as it can lead to unexpected
+ * mutations of data that was intended to be immutable.
+ *
+ * @template T - The type of the readonly value
+ * @param readonlyValue - The readonly value to cast to mutable
+ * @returns The same value with readonly modifiers removed from its type
+ * @see castDeepMutable - For deeply nested readonly structures
+ * @see castReadonly - For the opposite operation
+ */
+export const castMutable = (readonlyValue) =>
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+readonlyValue;
+/**
+ * Casts a readonly type `T` to its `DeepMutable<T>` equivalent, recursively
+ * removing all readonly modifiers.
+ *
+ * **⚠️ Safety Warning**: This recursively bypasses ALL immutability guarantees
+ * in nested structures. Extremely dangerous for complex data structures as it
+ * allows mutation at any depth. The runtime value is unchanged - only
+ * TypeScript's type checking is affected.
+ *
+ * @template T - The type of the deeply readonly value
+ * @param readonlyValue - The deeply readonly value to cast to deeply mutable
+ * @returns The same value with all readonly modifiers recursively removed from
+ *   its type
+ * @see castMutable - For shallow mutability casting
+ * @see castDeepReadonly - For the opposite operation
+ * @see structuredClone - Recommended for creating safe copies before mutation
+ */
+export const castDeepMutable = (readonlyValue) =>
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+readonlyValue;
+//# sourceMappingURL=cast-mutable.mjs.map

package/dist/others/cast-mutable.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"cast-mutable.mjs","sources":["../../src/others/cast-mutable.mts"],"sourcesContent":["import { type DeepMutable, type Mutable } from 'ts-type-forge';\n\n/*\n Casts a readonly type `T` to its `Mutable<T>` equivalent.\n \n ⚠️ Safety Warning: This is a type assertion that bypasses TypeScript's\n * immutability guarantees. The runtime value remains unchanged - only the type\n * system's view of it changes. Use with caution as it can lead to unexpected\n * mutations of data that was intended to be immutable.\n \n @template T - The type of the readonly value\n * @param readonlyValue - The readonly value to cast to mutable\n * @returns The same value with readonly modifiers removed from its type\n * @see castDeepMutable - For deeply nested readonly structures\n * @see castReadonly - For the opposite operation\n /\nexport const castMutable = <T,>(readonlyValue: T): Mutable<T> =>\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n readonlyValue as Mutable<T>;\n\n/\n Casts a readonly type `T` to its `DeepMutable<T>` equivalent, recursively\n * removing all readonly modifiers.\n \n ⚠️ Safety Warning: This recursively bypasses ALL immutability guarantees\n * in nested structures. Extremely dangerous for complex data structures as it\n * allows mutation at any depth. The runtime value is unchanged - only\n * TypeScript's type checking is affected.\n \n @template T - The type of the deeply readonly value\n * @param readonlyValue - The deeply readonly value to cast to deeply mutable\n * @returns The same value with all readonly modifiers recursively removed from\n * its type\n * @see castMutable - For shallow mutability casting\n * @see castDeepReadonly - For the opposite operation\n * @see structuredClone - Recommended for creating safe copies before mutation\n */\nexport const castDeepMutable = <T,>(readonlyValue: T): DeepMutable<T> =>\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n readonlyValue as DeepMutable<T>;\n"],"names":[],"mappings":"~~AAgBO~~,MAAM,~~cAAc~~,CAAK,~~aAAA~~;~~AAAA~~;~~AAAA~~,~~EAE9B~~;~~AAAA~~;~~AAmBK~~,MAAM,~~kBAAkB~~,CAAK,~~aAAA~~;~~AAAA~~;~~AAAA~~,~~EAElC;AAAA;;;;~~"}
1	+ {"version":3,"file":"cast-mutable.mjs","sourceRoot":"","sources":["../../src/others/cast-mutable.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAK,aAAgB,EAAc,EAAE;AAC9D,4EAA4E;AAC5E,aAA2B,CAAC;AAE9B;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAK,aAAgB,EAAkB,EAAE;AACtE,oEAAoE;AACpE,aAA+B,CAAC"}

package/dist/others/cast-readonly.mjs CHANGED Viewed

@@ -1,11 +1,37 @@
-const castReadonly = (mutable) => (
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-  mutable
-);
-const castDeepReadonly = (mutable) => (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  mutable
-);
-export { castDeepReadonly, castReadonly };
-//# sourceMappingURL=cast-readonly.mjs.map
+/**
+ * Casts a mutable type `T` to its `Readonly<T>` equivalent.
+ *
+ * This is a safe type assertion that adds immutability constraints at the type
+ * level. The runtime value remains unchanged - only TypeScript's view of it
+ * becomes readonly. This helps prevent accidental mutations and makes code
+ * intentions clearer.
+ *
+ * @template T - The type of the mutable value
+ * @param mutable - The mutable value to cast to readonly
+ * @returns The same value with readonly modifiers added to its type
+ * @see castDeepReadonly - For deeply nested structures
+ * @see castMutable - For the opposite operation (use with caution)
+ */
+export const castReadonly = (mutable) =>
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+mutable;
+/**
+ * Casts a mutable type `T` to its `DeepReadonly<T>` equivalent, recursively
+ * adding readonly modifiers.
+ *
+ * This is a safe type assertion that adds immutability constraints at ALL
+ * levels of nesting. Provides complete protection against mutations in complex
+ * data structures. The runtime value is unchanged - only TypeScript's type
+ * checking is enhanced.
+ *
+ * @template T - The type of the mutable value
+ * @param mutable - The mutable value to cast to deeply readonly
+ * @returns The same value with readonly modifiers recursively added to all
+ *   properties
+ * @see castReadonly - For shallow readonly casting
+ * @see castDeepMutable - For the opposite operation (use with extreme caution)
+ */
+export const castDeepReadonly = (mutable) =>
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+mutable;
+//# sourceMappingURL=cast-readonly.mjs.map

package/dist/others/cast-readonly.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"cast-readonly.mjs","sources":["../../src/others/cast-readonly.mts"],"sourcesContent":["import { type DeepReadonly } from 'ts-type-forge';\n\n/*\n Casts a mutable type `T` to its `Readonly<T>` equivalent.\n \n This is a safe type assertion that adds immutability constraints at the type\n * level. The runtime value remains unchanged - only TypeScript's view of it\n * becomes readonly. This helps prevent accidental mutations and makes code\n * intentions clearer.\n \n @template T - The type of the mutable value\n * @param mutable - The mutable value to cast to readonly\n * @returns The same value with readonly modifiers added to its type\n * @see castDeepReadonly - For deeply nested structures\n * @see castMutable - For the opposite operation (use with caution)\n /\nexport const castReadonly = <T,>(mutable: T): Readonly<T> =>\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n mutable as Readonly<T>;\n\n/\n Casts a mutable type `T` to its `DeepReadonly<T>` equivalent, recursively\n * adding readonly modifiers.\n \n This is a safe type assertion that adds immutability constraints at ALL\n * levels of nesting. Provides complete protection against mutations in complex\n * data structures. The runtime value is unchanged - only TypeScript's type\n * checking is enhanced.\n \n @template T - The type of the mutable value\n * @param mutable - The mutable value to cast to deeply readonly\n * @returns The same value with readonly modifiers recursively added to all\n * properties\n * @see castReadonly - For shallow readonly casting\n * @see castDeepMutable - For the opposite operation (use with extreme caution)\n */\nexport const castDeepReadonly = <T,>(mutable: T): DeepReadonly<T> =>\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n mutable as DeepReadonly<T>;\n"],"names":[],"mappings":"~~AAgBO~~,MAAM,~~eAAe~~,CAAK,~~OAAA~~;~~AAAA~~;~~AAAA~~,~~EAE/B~~;~~AAAA~~;~~AAkBK~~,MAAM,~~mBAAmB~~,CAAK,~~OAAA~~;~~AAAA~~;~~AAAA~~,~~EAEnC;AAAA;;;;~~"}
1	+ {"version":3,"file":"cast-readonly.mjs","sourceRoot":"","sources":["../../src/others/cast-readonly.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAK,OAAU,EAAe,EAAE;AAC1D,4EAA4E;AAC5E,OAAsB,CAAC;AAEzB;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAK,OAAU,EAAmB,EAAE;AAClE,oEAAoE;AACpE,OAA0B,CAAC"}

package/dist/others/debounce-function.mjs CHANGED Viewed

@@ -1,12 +1,23 @@
-const debounce = (func, waitMilliseconds) => {
-  let mut_timeoutId;
-  return (...args) => {
-    clearTimeout(mut_timeoutId);
-    mut_timeoutId = setTimeout(() => {
-      func(...args);
-    }, waitMilliseconds);
-  };
+/**
+ * Creates a debounced function that delays invoking `func` until after `waitMilliseconds`
+ * have elapsed since the last time the debounced function was invoked.
+ *
+ * @template F The type of the function to debounce.
+ * @param func The function to debounce.
+ * @param waitMilliseconds The number of milliseconds to delay.
+ * @returns The new debounced function.
+ */
+export const debounce = (func, waitMilliseconds) => {
+    // Not `ReturnType<typeof setTimeout>`: with both the DOM and Node
+    // declarations in scope that resolves to `unknown`, which `clearTimeout`
+    // will not take. Naming what `clearTimeout` accepts says the same thing and
+    // stays true in either environment.
+    let mut_timeoutId;
+    return (...args) => {
+        clearTimeout(mut_timeoutId);
+        mut_timeoutId = setTimeout(() => {
+            func(...args);
+        }, waitMilliseconds);
+    };
 };
-export { debounce };
-//# sourceMappingURL=debounce-function.mjs.map
+//# sourceMappingURL=debounce-function.mjs.map

package/dist/others/debounce-function.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"debounce-function.mjs","sources":["../../src/others/debounce-function.mts"],"sourcesContent":["/*\n Creates a debounced function that delays invoking `func` until after `waitMilliseconds`\n * have elapsed since the last time the debounced function was invoked.\n \n @template F The type of the function to debounce.\n * @param func The function to debounce.\n * @param waitMilliseconds The number of milliseconds to delay.\n * @returns The new debounced function.\n */\nexport const debounce = <Args extends readonly unknown[]>(\n func: (...args: Args) => void,\n waitMilliseconds: number,\n): ((...args: Args) => void) => {\n // Not `ReturnType<typeof setTimeout>`: with both the DOM and Node\n // declarations in scope that resolves to `unknown`, which `clearTimeout`\n // will not take. Naming what `clearTimeout` accepts says the same thing and\n // stays true in either environment.\n let mut_timeoutId: Parameters<typeof clearTimeout>[0];\n\n return (...args: Args): void => {\n clearTimeout(mut_timeoutId);\n\n mut_timeoutId = setTimeout(() => {\n func(...args);\n }, waitMilliseconds);\n };\n};\n"],"names":[],"mappings":"~~AASO~~,MAAM,~~QAAA~~,~~GAAW~~,CACtB,~~IAAA~~,~~EACA~~,~~gBAAA~~,~~KAC8B~~;~~AAK9B~~,~~EAAA~~,~~IAAI~~,~~aAAA~~;~~AAEJ~~,~~EAAA~~,~~OAAO,~~IAAI,~~IAAA~~,~~KAAqB~~;~~AAC9B~~,~~IAAA~~,~~YAAA~~,~~CAAa~~,~~aAAa~~,~~CAAA~~;~~AAE1B~~,~~IAAA~~,~~aAAA~~,~~GAAgB~~,~~WAAW~~,~~MAAM~~;~~AAC/B~~,~~MAAA~~,~~IAAA~~,~~CAAK~~,GAAG,IAAI,~~CAAA~~;~~AAAA~~,~~IACd~~,~~GAAG~~,gBAAgB,~~CAAA~~;~~AAAA~~,~~EACrB~~,~~CAAA~~;~~AACF;;;;~~"}
1	+ {"version":3,"file":"debounce-function.mjs","sourceRoot":"","sources":["../../src/others/debounce-function.mts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,IAA6B,EAC7B,gBAAwB,EACG,EAAE;IAC7B,kEAAkE;IAClE,yEAAyE;IACzE,4EAA4E;IAC5E,oCAAoC;IACpC,IAAI,aAAiD,CAAC;IAEtD,OAAO,CAAC,GAAG,IAAU,EAAQ,EAAE;QAC7B,YAAY,CAAC,aAAa,CAAC,CAAC;QAE5B,aAAa,GAAG,UAAU,CAAC,GAAG,EAAE;YAC9B,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QAChB,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC,CAAC;AACJ,CAAC,CAAC"}

package/dist/others/fast-deep-equal.mjs CHANGED Viewed

@@ -1,56 +1,75 @@
-import { isMap, isSet, isTypedArray, isRegExp } from '@sindresorhus/is';
-import { hasKey } from '../guard/has-key.mjs';
-import { isRecord } from '../guard/is-record.mjs';
-const fastDeepEqual = (a, b) => {
-  if (a === b) {
-    return true;
-  }
-  if (typeof a !== typeof b) {
-    return false;
-  }
-  if (Array.isArray(a)) {
-    return Array.isArray(b) && a.constructor === b.constructor && a.length === b.length && a.every((ai, index) => fastDeepEqual(ai, b[index]));
-  }
-  if (isRecord(a)) {
-    if (!isRecord(b)) {
-      return false;
+import { isMap, isRegExp, isSet, isTypedArray } from '@sindresorhus/is';
+import { hasKey, isRecord } from '../guard/index.mjs';
+/**
+ * The fastest deep equal with ES6 Map, Set and Typed arrays support.
+ * Checks equality of Date and RegExp objects by value.
+ *
+ * Forked from https://github.com/epoberezkin/fast-deep-equal/blob/v3.1.3/src/index.jst
+ */
+export const fastDeepEqual = (a, b) => {
+    if (a === b) {
+        return true;
     }
-    if (a.constructor !== b.constructor) {
-      return false;
+    if (typeof a !== typeof b) {
+        return false;
     }
-    if (isMap(a)) {
-      return isMap(b) && a.size === b.size && a.entries().every(
-        ([key, value]) => b.has(key) && fastDeepEqual(value, b.get(key))
-      );
+    // Arrays are handled before `isRecord`, which excludes them.
+    if (Array.isArray(a)) {
+        return (Array.isArray(b) &&
+            a.constructor === b.constructor &&
+            a.length === b.length &&
+            a.every((ai, index) => fastDeepEqual(ai, b[index])));
     }
-    if (isSet(a)) {
-      return isSet(b) && a.size === b.size && a.entries().every(([value]) => b.has(value));
+    if (isRecord(a)) {
+        if (!isRecord(b)) {
+            return false;
+        }
+        if (a.constructor !== b.constructor) {
+            return false;
+        }
+        if (isMap(a)) {
+            return (isMap(b) &&
+                a.size === b.size &&
+                a
+                    .entries()
+                    .every(([key, value]) => b.has(key) && fastDeepEqual(value, b.get(key))));
+        }
+        if (isSet(a)) {
+            return (isSet(b) &&
+                a.size === b.size &&
+                a.entries().every(([value]) => b.has(value)));
+        }
+        if (isTypedArray(a)) {
+            return (isTypedArray(b) &&
+                a.length === b.length &&
+                a.every((value, index) => value === b[index]));
+        }
+        if (isRegExp(a)) {
+            return isRegExp(b) && a.source === b.source && a.flags === b.flags;
+        }
+        if (a.valueOf !== Object.prototype.valueOf) {
+            return a.valueOf() === b.valueOf();
+        }
+        if (a.toString !== Object.prototype.toString) {
+            return a.toString() === b.toString();
+        }
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        return (aKeys.length === bKeys.length &&
+            aKeys.every((key) => hasKey(b, key) &&
+                // React-specific: avoid traversing React elements' _owner.
+                //  _owner contains circular references
+                // and is not needed when comparing the actual elements (and not their owners)
+                // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                !(key === '_owner' && a['$$typeof']) &&
+                fastDeepEqual(a[key], b[key])));
     }
-    if (isTypedArray(a)) {
-      return isTypedArray(b) && a.length === b.length && a.every((value, index) => value === b[index]);
-    }
-    if (isRegExp(a)) {
-      return isRegExp(b) && a.source === b.source && a.flags === b.flags;
-    }
-    if (a.valueOf !== Object.prototype.valueOf) {
-      return a.valueOf() === b.valueOf();
-    }
-    if (a.toString !== Object.prototype.toString) {
-      return a.toString() === b.toString();
-    }
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    return aKeys.length === bKeys.length && aKeys.every(
-      (key) => hasKey(b, key) && // React-specific: avoid traversing React elements' _owner.
-      //  _owner contains circular references
-      // and is not needed when comparing the actual elements (and not their owners)
-      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-      !(key === "_owner" && a["$$typeof"]) && fastDeepEqual(a[key], b[key])
-    );
-  }
-  return typeof a === "number" && typeof b === "number" && Number.isNaN(a) && Number.isNaN(b);
+    // true if both NaN, false otherwise. `Number.isNaN` takes a number: called
+    // with anything else it is always false, so the check belongs behind a
+    // `typeof` guard rather than relying on that.
+    return (typeof a === 'number' &&
+        typeof b === 'number' &&
+        Number.isNaN(a) &&
+        Number.isNaN(b));
 };
-export { fastDeepEqual };
-//# sourceMappingURL=fast-deep-equal.mjs.map
+//# sourceMappingURL=fast-deep-equal.mjs.map

package/dist/others/fast-deep-equal.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"fast-deep-equal.mjs","sources":["../../src/others/fast-deep-equal.mts"],"~~sourcesContent~~":["~~import { isMap~~, ~~isRegExp~~, ~~isSet~~, ~~isTypedArray } from '@sindresorhus/is';\nimport { hasKey~~, ~~isRecord } from '../guard/index.mjs';\n\n/*\n The fastest deep equal with ES6 Map~~, Set and Typed arrays support.\n * Checks equality of Date and RegExp objects by value.\n \n Forked from https://github.com/epoberezkin/fast-deep-equal/blob/v3.1.3/src/index.jst\n */\nexport const fastDeepEqual = <T,>(a: T, b: T): boolean => {\n if (a === b) {\n return true;\n }\n\n if (typeof a !== typeof b) {\n return false;\n }\n\n // Arrays are handled before `isRecord`, which excludes them.\n if (Array.isArray(a)) {\n return (\n Array.isArray(b) &&\n a.constructor === b.constructor &&\n a.length === b.length &&\n a.every((ai, ~~index) => fastDeepEqual(ai~~, b[index]))\n );\n }\n\n if (isRecord(a)) {\n if (!isRecord(b)) {\n return false;\n }\n\n if (a.constructor !== b.constructor) {\n return false;\n }\n\n if (isMap(a)) {\n return (\n isMap(b) &&\n a.size === b.size &&\n a\n .entries()\n .every(\n ([key, ~~value]) => b.has(key) && fastDeepEqual(value~~, b.get(key)),\n )\n );\n }\n\n if (isSet(a)) {\n return (\n isSet(b) &&\n a.size === b.size &&\n a.entries().every(([value]) => b.has(value))\n );\n }\n\n if (isTypedArray(a)) {\n return (\n isTypedArray(b) &&\n a.length === b.length &&\n a.every((value, index) => value === b[index])\n );\n }\n\n if (isRegExp(a)) {\n return isRegExp(b) && a.source === b.source && a.flags === b.flags;\n }\n\n if (a.valueOf !== Object.prototype.valueOf) {\n return a.valueOf() === b.valueOf();\n }\n\n if (a.toString !== Object.prototype.toString) {\n return a.toString() === b.toString();\n }\n\n const aKeys: readonly string[] = Object.keys(a);\n\n const bKeys: readonly string[] = Object.keys(b);\n\n return (\n aKeys.length === bKeys.length &&\n aKeys.every(\n (key) =>\n hasKey(b, key) &&\n // React-specific: avoid traversing React elements' _owner.\n // _owner contains circular references\n // and is not needed when comparing the actual elements (and not their owners)\n // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions\n !(key === '_owner' && a['$$typeof']) &&\n fastDeepEqual(a[key], ~~b[key]),\n )\n );\n }\n\n // true if both NaN~~, ~~false otherwise. `Number.isNaN` takes a number: called\n // with anything else it is always false~~, so the check belongs behind a\n // `typeof` guard rather than relying on that.\n return (\n typeof a === 'number' &&\n typeof b === 'number' &&\n Number.isNaN(a) &&\n Number.isNaN(b)\n );\n};\n"],~~"names":[]~~,~~"mappings":";;;;AASO~~,MAAM,~~aAAA~~,~~GAAgB~~,CAAK,~~CAAA~~,~~EAAM~~,~~CAAA~~,~~KAAkB~~;~~AACxD~~,~~EAAA,~~IAAI,~~MAAM~~,~~CAAA~~,~~EAAG~~;~~AACX~~,~~IAAA,~~OAAO,~~IAAA~~;~~AAAA~~,~~EACT~~;~~AAEA~~,~~EAAA,~~IAAI,OAAO,~~CAAA~~,~~KAAM~~,OAAO,~~CAAA~~,~~EAAG~~;~~AACzB~~,~~IAAA,~~OAAO,~~KAAA~~;~~AAAA~~,~~EACT~~;~~AAGA~~,~~EAAA~~,IAAI,~~KAAA~~,~~CAAM~~,~~OAAA~~,~~CAAQ~~,CAAC,~~CAAA~~,~~EAAG~~;~~AACpB~~,~~IAAA~~,~~OACE~~,~~KAAA~~,~~CAAM~~,~~QAAQ~~,CAAC,~~CAAA~~,~~IACf~~,~~EAAE~~,~~WAAA~~,~~KAAgB~~,~~CAAA~~,~~CAAE~~,~~WAAA~~,~~IACpB~~,~~CAAA~~,~~CAAE~~,~~MAAA~~,~~KAAW~~,~~CAAA~~,~~CAAE~~,~~UACf~~,~~CAAA~~,~~CAAE~~,~~KAAA~~,~~CAAM~~,CAAC,~~EAAA~~,~~EAAI~~,~~KAAA~~,~~KAAU~~,~~cAAc~~,~~EAAA~~,~~EAAI~~,~~CAAA~~,~~CAAE~~,KAAK,CAAC,CAAC,~~CAAA~~;~~AAAA~~,~~EAEtD~~;~~AAEA~~,~~EAAA,~~IAAI,~~QAAA~~,~~CAAS~~,CAAC,~~CAAA~~,~~EAAG~~;~~AACf~~,~~IAAA,~~IAAI,CAAC,~~QAAA~~,~~CAAS~~,CAAC,~~CAAA~~,~~EAAG~~;~~AAChB~~,~~MAAA,~~OAAO,~~KAAA~~;~~AAAA~~,~~IACT~~;~~AAEA~~,~~IAAA,~~IAAI,~~CAAA~~,~~CAAE~~,~~WAAA~~,~~KAAgB~~,~~CAAA~~,~~CAAE~~,~~WAAA~~,~~EAAa~~;~~AACnC~~,~~MAAA,~~OAAO,~~KAAA~~;~~AAAA~~,~~IACT~~;~~AAEA~~,~~IAAA,~~IAAI,~~KAAA~~,~~CAAM~~,CAAC,~~CAAA~~,~~EAAG~~;~~AACZ~~,~~MAAA~~,~~OACE~~,~~KAAA~~,~~CAAM~~,CAAC,~~CAAA~~,~~IACP~~,~~CAAA~~,~~CAAE~~,~~SAAS~~,~~CAAA~~,~~CAAE~~,~~IAAA~~,~~IACb~~,~~CAAA~~,~~CACG~~,~~OAAA~~,~~EAAQ~~,~~CACR,KAAA;AAAA,QACC,~~CAAC,CAAC,~~GAAA~~,~~EAAK~~,KAAK,~~MAAM~~,~~CAAA~~,~~CAAE~~,~~GAAA~~,~~CAAI~~,GAAG,~~CAAA~~,~~IAAK~~,~~aAAA~~,~~CAAc~~,~~KAAA~~,~~EAAO~~,~~CAAA~~,~~CAAE~~,~~GAAA~~,~~CAAI~~,GAAG,CAAC~~;AAAA~~,~~OACjE~~;~~AAAA~~,~~IAEN~~;~~AAEA~~,~~IAAA,~~IAAI,~~KAAA~~,~~CAAM~~,CAAC,~~CAAA~~,~~EAAG~~;~~AACZ~~,~~MAAA~~,~~OACE~~,~~MAAM~~,CAAC,~~CAAA~~,~~IACP~~,~~EAAE~~,~~IAAA~~,~~KAAS~~,~~CAAA~~,~~CAAE~~,~~QACb~~,~~CAAA~~,~~CAAE~~,~~OAAA~~,~~EAAQ~~,~~CAAE~~,~~KAAA~~,~~CAAM~~,CAAC,CAAC,KAAK,~~MAAM~~,~~CAAA~~,~~CAAE~~,~~GAAA~~,~~CAAI~~,KAAK,CAAC,~~CAAA~~;~~AAAA~~,~~IAE/C~~;~~AAEA~~,~~IAAA,~~IAAI,~~YAAA~~,~~CAAa~~,CAAC,~~CAAA~~,~~EAAG~~;~~AACnB~~,~~MAAA~~,~~OACE~~,~~YAAA~~,~~CAAa~~,CAAC,~~CAAA~~,~~IACd~~,~~CAAA~~,~~CAAE~~,~~WAAW~~,~~CAAA~~,~~CAAE~~,~~MAAA~~,~~IACf~~,~~CAAA~~,~~CAAE~~,~~KAAA~~,~~CAAM,~~CAAC,~~KAAA~~,~~EAAO~~,~~KAAA~~,~~KAAU~~,~~KAAA~~,~~KAAU~~,~~CAAA~~,~~CAAE~~,KAAK,CAAC,~~CAAA~~;~~AAAA~~,~~IAEhD~~;~~AAEA~~,~~IAAA,~~IAAI,~~QAAA~~,~~CAAS~~,CAAC,~~CAAA~~,~~EAAG~~;~~AACf~~,~~MAAA,~~OAAO,~~QAAA~~,~~CAAS~~,CAAC,~~CAAA~~,~~IAAK~~,~~CAAA~~,~~CAAE~~,~~WAAW~~,~~CAAA~~,~~CAAE~~,~~MAAA~~,~~IAAU~~,~~CAAA~~,~~CAAE~~,~~KAAA~~,~~KAAU~~,~~CAAA~~,~~CAAE~~,~~KAAA~~;~~AAAA~~,~~IAC/D~~;~~AAEA~~,~~IAAA,~~IAAI,~~CAAA~~,~~CAAE~~,~~OAAA~~,~~KAAY~~,~~MAAA~~,~~CAAO~~,~~SAAA~~,~~CAAU~~,~~OAAA~~,~~EAAS~~;~~AAC1C~~,~~MAAA,~~OAAO,~~CAAA~~,~~CAAE~~,~~OAAA~~,~~EAAQ~~,~~KAAM~~,~~CAAA~~,~~CAAE~~,~~OAAA~~,~~EAAQ~~;~~AAAA~~,~~IACnC~~;~~AAEA~~,~~IAAA,~~IAAI,~~CAAA~~,~~CAAE~~,~~QAAA~~,~~KAAa~~,~~MAAA~~,~~CAAO~~,~~SAAA~~,~~CAAU~~,~~QAAA~~,~~EAAU~~;~~AAC5C~~,~~MAAA,~~OAAO,~~CAAA~~,~~CAAE~~,~~QAAA~~,~~EAAS~~,~~KAAM~~,~~CAAA~~,~~CAAE~~,~~QAAA~~,~~EAAS~~;~~AAAA~~,~~IACrC~~;~~AAEA~~,~~IAAA,~~MAAM,~~KAAA~~,~~GAA2B~~,~~MAAA~~,~~CAAO~~,~~IAAA~~,~~CAAK~~,CAAC,~~CAAA~~;~~AAE9C~~,~~IAAA,~~MAAM,~~KAAA~~,~~GAA2B~~,~~MAAA~~,~~CAAO~~,~~IAAA~~,~~CAAK~~,CAAC,~~CAAA~~;~~AAE9C~~,~~IAAA~~,~~OACE~~,~~KAAA~~,~~CAAM~~,~~MAAA~~,~~KAAW~~,~~KAAA~~,~~CAAM~~,~~MAAA~~,~~IACvB~~,~~KAAA~~,~~CAAM~~,~~KAAA;AAAA~~,~~MACJ,~~CAAC,~~GAAA~~,~~KACC~~,~~MAAA~~,~~CAAO~~,~~CAAA~~,~~EAAG~~,GAAG,~~CAAA~~;~~AAAA~~;~~AAAA~~;~~AAAA~~;~~AAAA~~,~~MAKb~~,~~EAAE~~,~~GAAA~~,~~KAAQ~~,~~QAAA~~,~~IAAY~~,~~CAAA~~,~~CAAE~~,UAAU,~~CAAA~~,~~CAAA~~,~~IAClC~~,~~aAAA~~,~~CAAc~~,~~CAAA~~,~~CAAE,~~GAAG,~~CAAA~~,~~EAAG~~,~~CAAA~~,~~CAAE~~,GAAG,CAAC;~~AAAA~~,~~KAChC~~;~~AAAA~~,~~EAEJ~~;~~AAKA~~,~~EAAA~~,~~OACE~~,OAAO,~~CAAA~~,~~KAAM~~,~~QAAA~~,~~IACb~~,OAAO,~~CAAA~~,~~KAAM~~,~~QAAA~~,~~IACb~~,~~MAAA~~,~~CAAO~~,~~KAAA~~,~~CAAM~~,CAAC,~~CAAA~~,~~IACd~~,~~MAAA~~,~~CAAO~~,~~KAAA~~,~~CAAM~~,CAAC,~~CAAA;AAElB;;;;~~"}
1	+ {"version":3,"file":"fast-deep-equal.mjs","sourceRoot":"","sources":["../../src/others/fast-deep-equal.mts"],"names":[],"mappings":"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"}

package/dist/others/if-then.mjs CHANGED Viewed

@@ -1,5 +1,32 @@
-const ifThen = (antecedent, consequent) => !antecedent || consequent;
-const implies = ifThen;
-export { ifThen, implies };
-//# sourceMappingURL=if-then.mjs.map
+/**
+ * Implements the logical implication (if-then) operator.
+ *
+ * Returns `true` if the antecedent is `false` or the consequent is `true`. In
+ * logical terms: `antecedent → consequent` is equivalent to `¬antecedent ∨
+ * consequent`.
+ *
+ * **Truth table:**
+ *
+ * - `true → true` = `true` (valid implication)
+ * - `true → false` = `false` (invalid implication)
+ * - `false → true` = `true` (vacuously true)
+ * - `false → false` = `true` (vacuously true)
+ *
+ * @param antecedent - The condition (if part)
+ * @param consequent - The result that should hold if the condition is true
+ *   (then part)
+ * @returns `true` if the implication holds, `false` otherwise
+ */
+export const ifThen = (antecedent, consequent) => !antecedent || consequent;
+/**
+ * Alias for {@link ifThen}.
+ *
+ * Implements the logical implication (if-then) operator.
+ *
+ * @param antecedent - The condition (if part)
+ * @param consequent - The result that should hold if the condition is true
+ *   (then part)
+ * @returns `true` if the implication holds, `false` otherwise
+ */
+export const implies = ifThen;
+//# sourceMappingURL=if-then.mjs.map

package/dist/others/if-then.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"if-then.mjs","sources":["../../src/others/if-then.mts"],"sourcesContent":["/*\n Implements the logical implication (if-then) operator.\n \n Returns `true` if the antecedent is `false` or the consequent is `true`. In\n * logical terms: `antecedent → consequent` is equivalent to `¬antecedent ∨\n * consequent`.\n \n Truth table:\n \n - `true → true` = `true` (valid implication)\n * - `true → false` = `false` (invalid implication)\n * - `false → true` = `true` (vacuously true)\n * - `false → false` = `true` (vacuously true)\n \n @param antecedent - The condition (if part)\n * @param consequent - The result that should hold if the condition is true\n * (then part)\n * @returns `true` if the implication holds, `false` otherwise\n /\nexport const ifThen = (antecedent: boolean, consequent: boolean): boolean =>\n !antecedent \|\| consequent;\n\n/\n Alias for {@link ifThen}.\n \n Implements the logical implication (if-then) operator.\n \n @param antecedent - The condition (if part)\n * @param consequent - The result that should hold if the condition is true\n * (then part)\n * @returns `true` if the implication holds, `false` otherwise\n */\nexport const implies = ifThen;\n"],"names":[],"mappings":"~~AAmBO~~,MAAM,~~MAAA~~,~~GAAS~~,CAAC,~~UAAA~~,~~EAAqB~~,~~UAAA~~,~~KAC1C~~,CAAC,~~UAAA~~,~~IAAc~~;~~AAYV~~,MAAM,~~OAAA~~,~~GAAU;;;;~~"}
1	+ {"version":3,"file":"if-then.mjs","sourceRoot":"","sources":["../../src/others/if-then.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,UAAmB,EAAE,UAAmB,EAAW,EAAE,CAC1E,CAAC,UAAU,IAAI,UAAU,CAAC;AAE5B;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC"}

package/dist/others/index.mjs CHANGED Viewed

@@ -1,10 +1,10 @@
-export { castDeepMutable, castMutable } from './cast-mutable.mjs';
-export { castDeepReadonly, castReadonly } from './cast-readonly.mjs';
-export { debounce } from './debounce-function.mjs';
-export { fastDeepEqual } from './fast-deep-equal.mjs';
-export { ifThen, implies } from './if-then.mjs';
-export { mapNullable } from './map-nullable.mjs';
-export { memoizeFunction } from './memoize-function.mjs';
-export { tp } from './tuple.mjs';
-export { unknownToString } from './unknown-to-string.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './cast-mutable.mjs';
+export * from './cast-readonly.mjs';
+export * from './debounce-function.mjs';
+export * from './fast-deep-equal.mjs';
+export * from './if-then.mjs';
+export * from './map-nullable.mjs';
+export * from './memoize-function.mjs';
+export * from './tuple.mjs';
+export * from './unknown-to-string.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/others/index.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.mjs","~~sources~~":[],"~~sourcesContent~~":[],"names":[],"mappings":"~~;;;;;;;;~~"}
1	+ {"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/others/index.mts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,aAAa,CAAC;AAC5B,cAAc,yBAAyB,CAAC"}

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

@@ -1,15 +1,13 @@
-function mapNullable(...args) {
-  switch (args.length) {
-    case 2: {
-      const [value, mapFn] = args;
-      return value == null ? void 0 : mapFn(value);
+export function mapNullable(...args) {
+    switch (args.length) {
+        case 2: {
+            const [value, mapFn] = args;
+            return value == null ? undefined : mapFn(value);
+        }
+        case 1: {
+            const [mapFn] = args;
+            return (value) => mapNullable(value, mapFn);
+        }
     }
-    case 1: {
-      const [mapFn] = args;
-      return (value) => mapNullable(value, mapFn);
-    }
-  }
 }
-export { mapNullable };
-//# sourceMappingURL=map-nullable.mjs.map
+//# sourceMappingURL=map-nullable.mjs.map

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

	@@ -1 +1 @@
1	- {"version":3,"file":"map-nullable.mjs","sources":["../../src/others/map-nullable.mts"],"sourcesContent":["/*\n Applies a function to a value if the value is not `null` or `undefined`. If\n * the value is `null` or `undefined`, it returns `undefined`.\n \n This function provides a safe way to transform nullable values without\n * explicit null checks. It's similar to Optional.map() but works directly with\n * TypeScript's nullable types. Supports both regular and curried usage for\n * functional composition.\n \n @template A - The type of the input value (excluding null/undefined)\n * @template B - The type of the value returned by the mapping function\n * @param value - The value to potentially transform (can be `A`, `null`, or\n * `undefined`)\n * @param mapFn - A function that transforms a non-nullable value of type `A` to\n * type `B`\n * @returns The result of applying `mapFn` to `value` if value is not\n * null/undefined; otherwise `undefined`\n * @see Optional - For more complex optional value handling\n * @see Result - For error handling with detailed error information\n */\nexport function mapNullable<const A, const B>(\n value: A \| null \| undefined,\n mapFn: (v: A) => B,\n): B \| undefined;\n\n// Curried version\nexport function mapNullable<const A, const B>(\n mapFn: (v: A) => B,\n): (value: A \| null \| undefined) => B \| undefined;\n\nexport function mapNullable<const A, const B>(\n ...args:\n \| readonly [value: A \| null \| undefined, mapFn: (v: A) => B]\n \| readonly [mapFn: (v: A) => B]\n): (B \| undefined) \| ((value: A \| null \| undefined) => B \| undefined) {\n switch (args.length) {\n case 2: {\n const [value, mapFn] = args;\n\n return value == null ? undefined : mapFn(value);\n }\n\n case 1: {\n const [mapFn] = args;\n\n return (value: A \| null \| undefined) => mapNullable(value, mapFn);\n }\n }\n}\n"],"names":[],"mappings":"~~AA8BO~~,~~SAAS~~,~~eACX~~,~~IAAA~~,~~EAGiE~~;~~AACpE~~,~~EAAA,~~QAAQ,~~KAAK~~,~~MAAA~~;~~AAAQ~~,~~IACnB,~~KAAK,~~CAAA~~,~~EAAG~~;~~AACN~~,~~MAAA,~~MAAM,CAAC,~~KAAA~~,~~EAAO~~,KAAK,~~CAAA~~,~~GAAI~~,~~IAAA~~;~~AAEvB~~,~~MAAA,~~OAAO,~~KAAA~~,~~IAAS~~,~~IAAA~~,~~GAAO~~,~~MAAA~~,~~GAAY~~,~~KAAA~~,~~CAAM~~,KAAK,~~CAAA~~;~~AAAA~~,~~IAChD~~;~~AAAA~~,~~IAEA,~~KAAK,~~CAAA~~,~~EAAG~~;~~AACN~~,~~MAAA,~~MAAM,CAAC,KAAK,~~CAAA~~,~~GAAI~~,~~IAAA~~;~~AAEhB~~,~~MAAA,~~OAAO,CAAC,~~KAAA~~,~~KAAgC~~,~~WAAA~~,~~CAAY~~,~~KAAA~~,~~EAAO~~,KAAK,~~CAAA~~;~~AAAA~~,~~IAClE~~;~~AAAA~~;~~AAEJ;;;;~~"}
1	+ {"version":3,"file":"map-nullable.mjs","sourceRoot":"","sources":["../../src/others/map-nullable.mts"],"names":[],"mappings":"AA8BA,MAAM,UAAU,WAAW,CACzB,GAAG,IAE8B;IAEjC,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;YAE5B,OAAO,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;YAErB,OAAO,CAAC,KAA2B,EAAE,EAAE,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/others/memoize-function.mjs CHANGED Viewed

@@ -1,17 +1,15 @@
-function memoizeFunction(fn, argsToCacheKey) {
-  const mut_cache = /* @__PURE__ */ new Map();
-  const defaultKey = /* @__PURE__ */ Symbol("memoize-default-key");
-  return (...args) => {
-    const key = argsToCacheKey === void 0 ? defaultKey : argsToCacheKey(...args);
-    const cached = mut_cache.get(key);
-    if (cached !== void 0) {
-      return cached.value;
-    }
-    const result = fn(...args);
-    mut_cache.set(key, { value: result });
-    return result;
-  };
+export function memoizeFunction(fn, argsToCacheKey) {
+    const mut_cache = new Map();
+    const defaultKey = Symbol('memoize-default-key');
+    return (...args) => {
+        const key = argsToCacheKey === undefined ? defaultKey : argsToCacheKey(...args);
+        const cached = mut_cache.get(key);
+        if (cached !== undefined) {
+            return cached.value;
+        }
+        const result = fn(...args);
+        mut_cache.set(key, { value: result });
+        return result;
+    };
 }
-export { memoizeFunction };
-//# sourceMappingURL=memoize-function.mjs.map
+//# sourceMappingURL=memoize-function.mjs.map

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

	@@ -1 +1 @@
1	- {"version":3,"file":"memoize-function.mjs","sources":["../../src/others/memoize-function.mts"],"~~sourcesContent~~":["import { type Primitive } from 'ts-type-forge';\n\n/*\n Creates a memoized version of a function that caches results based on input\n * arguments.\n \n The memoized function stores results in an internal Map and returns cached\n * values for repeated calls with the same arguments. This can significantly\n * improve performance for expensive computations or I/O operations.\n \n Important considerations:\n \n - The cache grows unbounded - consider memory implications for long-running\n * applications\n * - Cache keys must be primitives (string, ~~number~~, ~~boolean~~, ~~symbol~~, ~~null,\n * undefined~~, bigint)\n * - Object arguments require careful key generation to ensure uniqueness\n * - Pure functions only - memoizing functions with side effects can lead to bugs\n \n @template A - The tuple type of the function arguments\n * @template R - The return type of the function\n * @template K - The primitive type used as the cache key (must be valid Map\n * key)\n * @param fn - The pure function to memoize\n * @param argsToCacheKey - Function that converts arguments to a unique cache\n * key. Optional for zero-argument functions.\n * @returns A memoized version of the input function with the same signature\n \n @see https://en.wikipedia.org/wiki/Memoization\n */\nexport function memoizeFunction<R>(fn: () => R): () => R;\n\nexport function memoizeFunction<\n Arg0,\n const RestArgs extends readonly unknown[],\n R,\n K extends Primitive,\n>(\n fn: (arg0: Arg0, ~~...args: RestArgs) => R,\n argsToCacheKey: (arg0: Arg0~~, ~~...args: RestArgs) => K,\n): (arg0: Arg0~~, ...args: RestArgs) => R;\n\nexport function memoizeFunction<\n const Args extends readonly unknown[],\n R,\n K extends Primitive,\n>(\n fn: (...args: Args) => R,\n argsToCacheKey?: (...args: Args) => K,\n): (...args: Args) => R {\n type CacheEntry = Readonly<{ value: R }>;\n\n const mut_cache = new Map<K \| symbol, CacheEntry>();\n\n const defaultKey = Symbol('memoize-default-key');\n\n return (...args: Args): R => {\n const key: K \| symbol =\n argsToCacheKey === undefined ? defaultKey : argsToCacheKey(...args);\n\n const cached = mut_cache.get(key);\n\n if (cached !== undefined) {\n return cached.value;\n }\n\n const result = fn(...args);\n\n mut_cache.set(key, ~~{ value: result });\n\n return result;\n };\n}\n"]~~,~~"names":[]~~,~~"mappings":"AA0CO~~,~~SAAS~~,~~eAAA~~,~~CAKd~~,~~IACA~~,~~cAAA~~,~~EACsB;AAGtB,EAAA,~~MAAM,~~SAAA~~,~~uBAAgB~~,~~GAAA~~,~~EAA4B~~;~~AAElD~~,~~EAAA~~,~~MAAM~~,~~UAAA~~,~~0BAAoB~~,~~qBAAqB~~,~~CAAA~~;~~AAE/C~~,~~EAAA~~,~~OAAO~~,~~IAAI~~,~~IAAA~~,~~KAAkB;AAC3B~~,~~IAAA~~,~~MAAM~~,~~MACJ~~,~~cAAA~~,~~KAAmB~~,~~MAAA~~,~~GAAY~~,~~UAAA~~,~~GAAa~~,~~cAAA~~,~~CAAe,~~GAAG,IAAI,~~CAAA~~;~~AAEpE~~,~~IAAA~~,MAAM,~~MAAA~~,~~GAAS~~,~~SAAA~~,~~CAAU~~,~~GAAA~~,~~CAAI,~~GAAG,~~CAAA~~;~~AAEhC~~,~~IAAA,~~IAAI,~~WAAW~~,~~MAAA~~,~~EAAW~~;~~AACxB~~,~~MAAA,~~OAAO,~~MAAA~~,~~CAAO~~,~~KAAA~~;~~AAAA~~,~~IAChB~~;~~AAEA~~,~~IAAA~~,MAAM,~~MAAA~~,~~GAAS~~,~~EAAA~~,~~CAAG,~~GAAG,IAAI,~~CAAA~~;~~AAEzB~~,~~IAAA~~,~~SAAA~~,~~CAAU~~,~~GAAA~~,~~CAAI~~,~~GAAA~~,~~EAAK~~,EAAE,~~KAAA~~,~~EAAO~~,~~QAAQ~~,~~CAAA~~;~~AAEpC~~,~~IAAA,~~OAAO,~~MAAA~~;~~AAAA~~,~~EACT~~,~~CAAA~~;~~AACF;;;;~~"}
1	+ {"version":3,"file":"memoize-function.mjs","sourceRoot":"","sources":["../../src/others/memoize-function.mts"],"names":[],"mappings":"AA0CA,MAAM,UAAU,eAAe,CAK7B,EAAwB,EACxB,cAAqC;IAIrC,MAAM,SAAS,GAAG,IAAI,GAAG,EAA0B,CAAC;IAEpD,MAAM,UAAU,GAAG,MAAM,CAAC,qBAAqB,CAAC,CAAC;IAEjD,OAAO,CAAC,GAAG,IAAU,EAAK,EAAE;QAC1B,MAAM,GAAG,GACP,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;QAEtE,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAElC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,OAAO,MAAM,CAAC,KAAK,CAAC;QACtB,CAAC;QAED,MAAM,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;QAE3B,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;QAEtC,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC"}