• By analogy with how Array.prototype.map will map the elements of an array to transformed elements of an array of the same shape, objectMap will do likewise for the string-named own enumerable properties of an object.

    Typical usage applies objectMap to a CopyRecord, i.e., an object for which passStyleOf(original) === 'copyRecord'. For these, none of the following edge cases arise. The result will be a CopyRecord with exactly the same property names, whose values are the mapped form of the original's values.

    When the original is not a CopyRecord, some edge cases to be aware of

    • No matter how mutable the original object, the returned object is hardened.
    • Only the string-named enumerable own properties of the original are mapped. All other properties are ignored.
    • If any of the original properties were accessors, Object.entries will cause its getter to be called and will use the resulting value.
    • No matter whether the original property was an accessor, writable, or configurable, all the properties of the returned object will be non-writable, non-configurable, data properties.
    • No matter what the original object may have inherited from, and no matter whether it was a special kind of object such as an array, the returned object will always be a plain object inheriting directly from Object.prototype and whose state is only these new mapped own properties.

    With these differences, even if the original object was not a CopyRecord, if all the mapped values are Passable, then the returned object will be a CopyRecord.

    Type Parameters

    • O extends Record<string, any>
    • R

      map result

    Parameters

    • original: O
    • mapFn: ((value, key) => R)
        • (value, key): R
        • Parameters

          • value: O[keyof O]
          • key: keyof O

          Returns R

    Returns Record<keyof O, R>

Generated using TypeDoc