ts-data-forge 14.3.0 → 14.4.0

package/dist/object/object.d.mts

@@ -1,4 +1,5 @@
 import { type ArrayElement, type Decrement, type DeepOmit, type DeepPick, type IsFixedLengthList, type IsUnion, type List, type ReadonlyRecord, type RelaxedExclude, type RelaxedOmit, type RelaxedPick, type StrictOmit, type StrictPick, type ToString, type TypeEq, type UnknownRecord } from 'ts-type-forge';
+import { Optional } from '../functional/index.mjs';
 /**
  * A collection of type-safe object utility functions providing functional
  * programming patterns for object manipulation, including pick, omit, shallow
@@ -235,6 +236,101 @@ export declare namespace Obj {
      * @returns A new record with the same keys as `record` and the mapped values
      */
     const map: <const R extends UnknownRecord, V2>(record: R, mapFn: (value: R[keyof R], key: TsDataForgeInternals.MappedRecordKey<R>) => V2) => TsDataForgeInternals.MappedRecord<R, V2>;
+    /**
+     * Keeps the entries whose value the predicate accepts, leaving the values
+     * themselves untouched.
+     *
+     * **Type Behavior**: the surviving keys are the keys of the source record,
+     * made optional — the predicate may reject any of them. A record keyed by an
+     * index signature stays total instead, because it names no specific key that
+     * could go missing.
+     *
+     * Passing a type guard narrows the value type of the result, which is what
+     * `Object.fromEntries(Object.entries(record).filter(guard))` loses.
+     *
+     * **Key handling**: keys reach the callback the way `Object.entries` yields
+     * them, so a numeric key `1` arrives as `'1'`. Symbol-keyed properties are
+     * not enumerated by `Object.entries`; they are dropped from both the result
+     * and its type.
+     *
+     * @example
+     *
+     * <!-- doc:embed:jsdoc:example:./samples/src/object/filter-example.mts -->
+     *
+     * ```ts
+     * const scores = { alice: 1, bob: 2 } as const;
+     *
+     * const passing = Obj.filter(scores, (value) => value > 1);
+     *
+     * assert.deepStrictEqual(passing, { bob: 2 });
+     *
+     * // The key is available as the second argument.
+     * const notAlice = Obj.filter(scores, (_value, key) => key !== 'alice');
+     *
+     * assert.deepStrictEqual(notAlice, { bob: 2 });
+     *
+     * // A type guard narrows the value type of the result.
+     * const mixed: UnknownRecord = { a: 1, b: 'x' } as const;
+     *
+     * const strings = Obj.filter(mixed, isString);
+     *
+     * assert.deepStrictEqual(strings, { b: 'x' });
+     * ```
+     *
+     * <!-- /doc:embed:jsdoc:example:./samples/src/object/filter-example.mts -->
+     *
+     * @template R - The type of the source record
+     * @template V2 - The type the guard narrows values to
+     * @param record - The record whose entries are filtered
+     * @param predicate - Called once per own enumerable string key, with the
+     *   value and the key
+     * @returns A new record holding only the accepted entries
+     */
+    function filter<const R extends UnknownRecord, V2 extends R[keyof R]>(record: R, predicate: (value: R[keyof R], key: TsDataForgeInternals.MappedRecordKey<R>) => value is V2): TsDataForgeInternals.FilteredRecord<TsDataForgeInternals.MappedRecord<R, V2>>;
+    function filter<const R extends UnknownRecord>(record: R, predicate: (value: R[keyof R], key: TsDataForgeInternals.MappedRecordKey<R>) => boolean): TsDataForgeInternals.FilteredRecord<R>;
+    /**
+     * Transforms and drops entries in one pass: the callback returns
+     * `Optional.some(value)` to keep an entry with a new value, or
+     * `Optional.none` to drop it.
+     *
+     * **Type Behavior**: as with {@link filter}, the surviving keys are the keys
+     * of the source record made optional, and a record keyed by an index
+     * signature stays total. Unlike {@link filter}, every kept value takes the
+     * type the callback returns.
+     *
+     * `Optional` rather than `undefined` marks the dropped entries, so a record
+     * whose values are legitimately `undefined` stays expressible.
+     *
+     * **Key handling**: keys reach the callback the way `Object.entries` yields
+     * them, so a numeric key `1` arrives as `'1'`. Symbol-keyed properties are
+     * not enumerated by `Object.entries`; they are dropped from both the result
+     * and its type.
+     *
+     * @example
+     *
+     * <!-- doc:embed:jsdoc:example:./samples/src/object/filter-map-example.mts -->
+     *
+     * ```ts
+     * const scores = { alice: 1, bob: 2 } as const;
+     *
+     * // `Optional.some` keeps an entry with a new value, `Optional.none` drops it.
+     * const labelled = Obj.filterMap(scores, (value, key) =>
+     *   value > 1 ? Optional.some(`${key}=${value}`) : Optional.none,
+     * );
+     *
+     * assert.deepStrictEqual(labelled, { bob: 'bob=2' });
+     * ```
+     *
+     * <!-- /doc:embed:jsdoc:example:./samples/src/object/filter-map-example.mts -->
+     *
+     * @template R - The type of the source record
+     * @template V2 - The type the callback returns for the entries it keeps
+     * @param record - The record whose entries are transformed and filtered
+     * @param mapFn - Called once per own enumerable string key, with the value
+     *   and the key
+     * @returns A new record holding only the kept entries, with mapped values
+     */
+    const filterMap: <const R extends UnknownRecord, V2>(record: R, mapFn: (value: R[keyof R], key: TsDataForgeInternals.MappedRecordKey<R>) => Optional<V2>) => TsDataForgeInternals.FilteredRecord<TsDataForgeInternals.MappedRecord<R, V2>>;
     /**
      * Merges multiple records into a single record using `Object.assign`.
      * Later records override properties from earlier records with the same key.
@@ -356,6 +452,23 @@ declare namespace TsDataForgeInternals {
     type MappedRecord<R, V2> = Readonly<{
         [K in keyof R as K extends symbol ? never : K]: V2;
     }>;
+    /** `R` without the symbol keys `Object.entries` never visits. */
+    type StringKeyedRecord<R> = Readonly<{
+        [K in keyof R as K extends symbol ? never : K]: R[K];
+    }>;
+    /**
+     * The result of dropping entries from `R`: symbol keys go away, and the
+     * remaining keys become optional because a predicate may reject any of them.
+     *
+     * A record keyed by an index signature stays total instead. It names no
+     * specific key that could go missing, and `noUncheckedIndexedAccess` already
+     * adds `| undefined` on access, so making it `Partial` would add nothing and
+     * would only stop the result from being assignable back to the record type it
+     * came from.
+     */
+    type FilteredRecord<R> = string extends keyof R ? StringKeyedRecord<R> : number extends keyof R ? StringKeyedRecord<R> : Readonly<{
+        [K in keyof R as K extends symbol ? never : K]?: R[K];
+    }>;
     /**
      * Merges two object types where keys in B override keys in A, preserving optional modifiers.
      *

package/dist/object/object.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"object.d.mts","sourceRoot":"","sources":["../../src/object/object.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"object.d.mts","sourceRoot":"","sources":["../../src/object/object.mts"],"names":[],"mappings":"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"}

package/dist/object/object.mjs

@@ -36,6 +36,7 @@ import '../number/num.mjs';
 import '../number/refined-number-utils.mjs';
 import { hasKey } from '../guard/has-key.mjs';
 import { isRecord } from '../guard/is-record.mjs';
+import { isSome } from '../functional/optional/impl/optional-is-some.mjs';
 import '@sindresorhus/is';
 import { isNonEmpty } from '../array/impl/array-utils-length-bounded-array-guard.mjs';
 import '../collections/imap-mapped.mjs';
@@ -114,6 +115,34 @@ var Obj;
       )
     );
   };
+  function filter(record, predicate) {
+    const predicateWidened = predicate;
+    return (
+      // `Object.entries` enumerates exactly the own enumerable string keys of
+      // `record`, and filtering only ever removes entries, so the result has a
+      // subset of those keys — which is what `FilteredRecord` claims.
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      Object.fromEntries(
+        Object.entries(record).filter(([k, v]) => predicateWidened(v, k))
+      )
+    );
+  }
+  Obj2.filter = filter;
+  Obj2.filterMap = (record, mapFn) => {
+    const mapFnWidened = mapFn;
+    return (
+      // `Object.entries` enumerates exactly the own enumerable string keys of
+      // `record`, and this only ever drops entries or replaces their values, so
+      // the result has a subset of those keys with `V2` values.
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      Object.fromEntries(
+        Object.entries(record).flatMap(([k, v]) => {
+          const mapped = mapFnWidened(v, k);
+          return isSome(mapped) ? [[k, mapped.value]] : [];
+        })
+      )
+    );
+  };
   Obj2.merge = (...records) => (
     // eslint-disable-next-line total-functions/no-unsafe-type-assertion
     Object.fromEntries(records.flatMap((r) => Object.entries(r)))

package/dist/object/object.mjs.map

@@ -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 { 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   * 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  /**\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","Arr.isNonEmpty"],"mappings":"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"}
+{"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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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "14.3.0",
+  "version": "14.4.0",
   "private": false,
   "keywords": [
     "typescript",
@@ -56,10 +56,10 @@
     "typedoc": "0.28.20",
     "typedoc-github-theme": "0.4.0",
     "vite": "8.2.1",
-    "eslint-config-typed": "5.9.2",
-    "eslint-plugin-ts-fortress": "1.0.3",
-    "eslint-plugin-ts-type-forge": "0.6.5",
-    "ts-repo-utils": "10.2.0"
+    "eslint-plugin-ts-fortress": "1.0.4",
+    "eslint-config-typed": "5.9.3",
+    "ts-repo-utils": "10.2.0",
+    "eslint-plugin-ts-type-forge": "0.6.6"
   },
   "peerDependencies": {
     "typescript": ">=4.8"

package/src/object/object.mts

@@ -17,6 +17,7 @@ import {
   type UnknownRecord,
 } from 'ts-type-forge';
 import { Arr } from '../array/index.mjs';
+import { Optional } from '../functional/index.mjs';
 import { hasKey, isRecord } from '../guard/index.mjs';
 
 /**
@@ -397,6 +398,171 @@ export namespace Obj {
     );
   };
 
+  /**
+   * Keeps the entries whose value the predicate accepts, leaving the values
+   * themselves untouched.
+   *
+   * **Type Behavior**: the surviving keys are the keys of the source record,
+   * made optional — the predicate may reject any of them. A record keyed by an
+   * index signature stays total instead, because it names no specific key that
+   * could go missing.
+   *
+   * Passing a type guard narrows the value type of the result, which is what
+   * `Object.fromEntries(Object.entries(record).filter(guard))` loses.
+   *
+   * **Key handling**: keys reach the callback the way `Object.entries` yields
+   * them, so a numeric key `1` arrives as `'1'`. Symbol-keyed properties are
+   * not enumerated by `Object.entries`; they are dropped from both the result
+   * and its type.
+   *
+   * @example
+   *
+   * <!-- doc:embed:jsdoc:example:./samples/src/object/filter-example.mts -->
+   *
+   * ```ts
+   * const scores = { alice: 1, bob: 2 } as const;
+   *
+   * const passing = Obj.filter(scores, (value) => value > 1);
+   *
+   * assert.deepStrictEqual(passing, { bob: 2 });
+   *
+   * // The key is available as the second argument.
+   * const notAlice = Obj.filter(scores, (_value, key) => key !== 'alice');
+   *
+   * assert.deepStrictEqual(notAlice, { bob: 2 });
+   *
+   * // A type guard narrows the value type of the result.
+   * const mixed: UnknownRecord = { a: 1, b: 'x' } as const;
+   *
+   * const strings = Obj.filter(mixed, isString);
+   *
+   * assert.deepStrictEqual(strings, { b: 'x' });
+   * ```
+   *
+   * <!-- /doc:embed:jsdoc:example:./samples/src/object/filter-example.mts -->
+   *
+   * @template R - The type of the source record
+   * @template V2 - The type the guard narrows values to
+   * @param record - The record whose entries are filtered
+   * @param predicate - Called once per own enumerable string key, with the
+   *   value and the key
+   * @returns A new record holding only the accepted entries
+   */
+  export function filter<const R extends UnknownRecord, V2 extends R[keyof R]>(
+    record: R,
+    predicate: (
+      value: R[keyof R],
+      key: TsDataForgeInternals.MappedRecordKey<R>,
+    ) => value is V2,
+  ): TsDataForgeInternals.FilteredRecord<
+    TsDataForgeInternals.MappedRecord<R, V2>
+  >;
+
+  export function filter<const R extends UnknownRecord>(
+    record: R,
+    predicate: (
+      value: R[keyof R],
+      key: TsDataForgeInternals.MappedRecordKey<R>,
+    ) => boolean,
+  ): TsDataForgeInternals.FilteredRecord<R>;
+
+  export function filter<const R extends UnknownRecord>(
+    record: R,
+    predicate: (
+      value: R[keyof R],
+      key: TsDataForgeInternals.MappedRecordKey<R>,
+    ) => boolean,
+  ): TsDataForgeInternals.FilteredRecord<R> {
+    // `Object.entries` erases both the key and the value type of `R`, so the
+    // callback is widened once here instead of asserting on every entry.
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    const predicateWidened = predicate as (
+      value: unknown,
+      key: string,
+    ) => boolean;
+
+    return (
+      // `Object.entries` enumerates exactly the own enumerable string keys of
+      // `record`, and filtering only ever removes entries, so the result has a
+      // subset of those keys — which is what `FilteredRecord` claims.
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      Object.fromEntries(
+        Object.entries(record).filter(([k, v]) => predicateWidened(v, k)),
+      ) as never
+    );
+  }
+
+  /**
+   * Transforms and drops entries in one pass: the callback returns
+   * `Optional.some(value)` to keep an entry with a new value, or
+   * `Optional.none` to drop it.
+   *
+   * **Type Behavior**: as with {@link filter}, the surviving keys are the keys
+   * of the source record made optional, and a record keyed by an index
+   * signature stays total. Unlike {@link filter}, every kept value takes the
+   * type the callback returns.
+   *
+   * `Optional` rather than `undefined` marks the dropped entries, so a record
+   * whose values are legitimately `undefined` stays expressible.
+   *
+   * **Key handling**: keys reach the callback the way `Object.entries` yields
+   * them, so a numeric key `1` arrives as `'1'`. Symbol-keyed properties are
+   * not enumerated by `Object.entries`; they are dropped from both the result
+   * and its type.
+   *
+   * @example
+   *
+   * <!-- doc:embed:jsdoc:example:./samples/src/object/filter-map-example.mts -->
+   *
+   * ```ts
+   * const scores = { alice: 1, bob: 2 } as const;
+   *
+   * // `Optional.some` keeps an entry with a new value, `Optional.none` drops it.
+   * const labelled = Obj.filterMap(scores, (value, key) =>
+   *   value > 1 ? Optional.some(`${key}=${value}`) : Optional.none,
+   * );
+   *
+   * assert.deepStrictEqual(labelled, { bob: 'bob=2' });
+   * ```
+   *
+   * <!-- /doc:embed:jsdoc:example:./samples/src/object/filter-map-example.mts -->
+   *
+   * @template R - The type of the source record
+   * @template V2 - The type the callback returns for the entries it keeps
+   * @param record - The record whose entries are transformed and filtered
+   * @param mapFn - Called once per own enumerable string key, with the value
+   *   and the key
+   * @returns A new record holding only the kept entries, with mapped values
+   */
+  export const filterMap = <const R extends UnknownRecord, V2>(
+    record: R,
+    mapFn: (
+      value: R[keyof R],
+      key: TsDataForgeInternals.MappedRecordKey<R>,
+    ) => Optional<V2>,
+  ): TsDataForgeInternals.FilteredRecord<
+    TsDataForgeInternals.MappedRecord<R, V2>
+  > => {
+    // `Object.entries` erases both the key and the value type of `R`, so the
+    // callback is widened once here instead of asserting on every entry.
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    const mapFnWidened = mapFn as (value: unknown, key: string) => Optional<V2>;
+
+    return (
+      // `Object.entries` enumerates exactly the own enumerable string keys of
+      // `record`, and this only ever drops entries or replaces their values, so
+      // the result has a subset of those keys with `V2` values.
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      Object.fromEntries(
+        Object.entries(record).flatMap(([k, v]) => {
+          const mapped = mapFnWidened(v, k);
+
+          return Optional.isSome(mapped) ? [[k, mapped.value] as const] : [];
+        }),
+      ) as never
+    );
+  };
+
   /**
    * Merges multiple records into a single record using `Object.assign`.
    * Later records override properties from earlier records with the same key.
@@ -691,6 +857,27 @@ declare namespace TsDataForgeInternals {
     [K in keyof R as K extends symbol ? never : K]: V2;
   }>;
 
+  /** `R` without the symbol keys `Object.entries` never visits. */
+  type StringKeyedRecord<R> = Readonly<{
+    [K in keyof R as K extends symbol ? never : K]: R[K];
+  }>;
+
+  /**
+   * The result of dropping entries from `R`: symbol keys go away, and the
+   * remaining keys become optional because a predicate may reject any of them.
+   *
+   * A record keyed by an index signature stays total instead. It names no
+   * specific key that could go missing, and `noUncheckedIndexedAccess` already
+   * adds `| undefined` on access, so making it `Partial` would add nothing and
+   * would only stop the result from being assignable back to the record type it
+   * came from.
+   */
+  export type FilteredRecord<R> = string extends keyof R
+    ? StringKeyedRecord<R>
+    : number extends keyof R
+      ? StringKeyedRecord<R>
+      : Readonly<{ [K in keyof R as K extends symbol ? never : K]?: R[K] }>;
+
   /**
    * Merges two object types where keys in B override keys in A, preserving optional modifiers.
    *

package/src/object/object.test.mts

@@ -5,7 +5,8 @@ import {
   type UnknownRecord,
 } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
-import { pipe } from '../functional/index.mjs';
+import { Optional, pipe } from '../functional/index.mjs';
+import { isString } from '../guard/index.mjs';
 import { Obj } from './object.mjs';
 
 describe('shallowEq', () => {
@@ -285,6 +286,124 @@ describe('map', () => {
   });
 });
 
+describe('filter', () => {
+  test('should keep the entries the predicate accepts', () => {
+    const result = Obj.filter({ a: 1, b: 2 }, (value) => value > 1);
+
+    expectType<typeof result, Readonly<{ a?: 1; b?: 2 }>>('=');
+
+    assert.deepStrictEqual(result, { b: 2 });
+  });
+
+  test('should keep a record with an index signature total', () => {
+    const scores: ReadonlyRecord<string, number> = {
+      alice: 1,
+      bob: 2,
+    } as const;
+
+    const result = Obj.filter(scores, (value) => value > 1);
+
+    expectType<typeof result, ReadonlyRecord<string, number>>('=');
+
+    assert.deepStrictEqual(result, { bob: 2 });
+  });
+
+  test('should pass the key as the second argument', () => {
+    const result = Obj.filter({ a: 1, b: 2 }, (_value, key) => {
+      expectType<typeof key, 'a' | 'b'>('=');
+
+      return key === 'a';
+    });
+
+    assert.deepStrictEqual(result, { a: 1 });
+  });
+
+  test('should narrow the value type through a type guard', () => {
+    const mixed: UnknownRecord = { a: 1, b: 'x' } as const;
+
+    const result = Obj.filter(mixed, isString);
+
+    expectType<typeof result, ReadonlyRecord<string, string>>('=');
+
+    assert.deepStrictEqual(result, { b: 'x' });
+  });
+
+  test('should drop symbol keys, as Object.entries does', () => {
+    const sym = Symbol('s');
+
+    const result = Obj.filter({ a: 1, [sym]: 2 }, () => true);
+
+    expectType<typeof result, Readonly<{ a?: 1 }>>('=');
+
+    assert.deepStrictEqual(result, { a: 1 });
+  });
+
+  test('should handle an empty record', () => {
+    const result = Obj.filter({}, () => true);
+
+    assert.deepStrictEqual(result, {});
+  });
+
+  test('should not mutate the source record', () => {
+    const source = { a: 1, b: 2 } as const;
+
+    Obj.filter(source, (value) => value > 1);
+
+    assert.deepStrictEqual(source, { a: 1, b: 2 });
+  });
+});
+
+describe('filterMap', () => {
+  test('should keep Optional.some and drop Optional.none', () => {
+    const result = Obj.filterMap({ a: 1, b: 2 }, (value) =>
+      value > 1 ? Optional.some(value * 10) : Optional.none,
+    );
+
+    expectType<typeof result, Readonly<{ a?: number; b?: number }>>('=');
+
+    assert.deepStrictEqual(result, { b: 20 });
+  });
+
+  test('should keep a record with an index signature total', () => {
+    const scores: ReadonlyRecord<string, number> = {
+      alice: 1,
+      bob: 2,
+    } as const;
+
+    const result = Obj.filterMap(scores, (value) =>
+      value > 1 ? Optional.some(value * 10) : Optional.none,
+    );
+
+    expectType<typeof result, ReadonlyRecord<string, number>>('=');
+
+    assert.deepStrictEqual(result, { bob: 20 });
+  });
+
+  test('should pass the key as the second argument', () => {
+    const result = Obj.filterMap({ a: 1, b: 2 }, (value, key) => {
+      expectType<typeof key, 'a' | 'b'>('=');
+
+      return key === 'a' ? Optional.some(value) : Optional.none;
+    });
+
+    assert.deepStrictEqual(result, { a: 1 });
+  });
+
+  test('should handle an empty record', () => {
+    const result = Obj.filterMap({}, () => Optional.none);
+
+    assert.deepStrictEqual(result, {});
+  });
+
+  test('should not mutate the source record', () => {
+    const source = { a: 1, b: 2 } as const;
+
+    Obj.filterMap(source, (value) => Optional.some(value * 2));
+
+    assert.deepStrictEqual(source, { a: 1, b: 2 });
+  });
+});
+
 describe('merge', () => {
   test('should merge two objects, later overriding earlier', () => {
     const a = { a: 0, b: 0 } as const;