@design-edito/tools 0.4.5 → 0.4.11

package/agnostic/objects/deep-get-property/index.test.js

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import { deepGetProperty } from './index.js';
+describe('deepGetProperty', () => {
+    it('retrieves a top-level property', () => {
+        const obj = { a: 1, b: 2 };
+        expect(deepGetProperty(obj, 'a')).toBe(1);
+        expect(deepGetProperty(obj, 'b')).toBe(2);
+    });
+    it('retrieves a nested property', () => {
+        const obj = { a: { b: { c: 42 } } };
+        expect(deepGetProperty(obj, 'a.b.c')).toBe(42);
+    });
+    it('handles paths with extra spaces', () => {
+        const obj = { a: { b: { c: 'value' } } };
+        expect(deepGetProperty(obj, 'a. b . c')).toBe('value');
+    });
+    it('handles empty path segments', () => {
+        const obj = { a: { b: 5 } };
+        expect(deepGetProperty(obj, 'a..b')).toBe(5);
+    });
+    it('returns the entire object for empty path', () => {
+        const obj = { a: 1, b: 2 };
+        expect(deepGetProperty(obj, '')).toBe(obj);
+    });
+    it('returns the entire object for path with only dots', () => {
+        const obj = { a: 1, b: 2 };
+        expect(deepGetProperty(obj, '...')).toBe(obj);
+    });
+    it('throws PROPERTY_UNREACHABLE when path goes through non-object', () => {
+        const obj = { a: 42 };
+        expect(() => deepGetProperty(obj, 'a.b')).toThrow('PROPERTY_UNREACHABLE');
+    });
+    it('throws PROPERTY_UNREACHABLE when accessing property on null', () => {
+        const obj = { a: null };
+        expect(() => deepGetProperty(obj, 'a.b')).toThrow('PROPERTY_UNREACHABLE');
+    });
+    it('throws PROPERTY_UNREACHABLE when accessing property on undefined', () => {
+        const obj = { a: undefined };
+        expect(() => deepGetProperty(obj, 'a.b')).toThrow('PROPERTY_UNREACHABLE');
+    });
+    it('throws PROPERTY_UNREACHABLE when accessing property on primitive', () => {
+        const obj = { a: 'string' };
+        expect(() => deepGetProperty(obj, 'a.b')).toThrow('PROPERTY_UNREACHABLE');
+    });
+    it('throws PROPERTY_UNREACHABLE when input is not a record', () => {
+        expect(() => deepGetProperty(null, 'a')).toThrow('PROPERTY_UNREACHABLE');
+        expect(() => deepGetProperty(42, 'a')).toThrow('PROPERTY_UNREACHABLE');
+        expect(() => deepGetProperty('string', 'a')).toThrow('PROPERTY_UNREACHABLE');
+    });
+    it('returns undefined for non-existent property', () => {
+        const obj = { a: 1 };
+        expect(deepGetProperty(obj, 'b')).toBeUndefined();
+    });
+    it('handles arrays as intermediate values', () => {
+        const obj = { a: [1, 2, 3] };
+        expect(deepGetProperty(obj, 'a')).toEqual([1, 2, 3]);
+        expect(deepGetProperty(obj, 'a.1')).toEqual(2);
+    });
+});

package/agnostic/objects/enums/is-in-enum/index.js

@@ -1,12 +1,18 @@
-// src/agnostic/objects/enums/is-in-enum/index.ts
-function isInEnum(enumObj, value) {
-  const keys = Object.keys(enumObj);
-  const values = Object.values(enumObj);
-  const numericValues = values.filter((val) => typeof val === "number");
-  const cleanKeys = keys.filter((key) => !numericValues.includes(parseInt(key, 10)));
-  const cleanValues = cleanKeys.map((cleanKey) => enumObj[cleanKey]);
-  return cleanValues.includes(value);
+/**
+ * Checks whether a value exists in a TypeScript enum.
+ *
+ * Works with both string and numeric enums, ignoring reverse mappings in numeric enums.
+ *
+ * @template E - The enum type.
+ * @param {E} enumObj - The enum object to check against.
+ * @param {string | number} value - The value to test.
+ * @returns {value is E[keyof E]} `true` if the value is a valid enum member, otherwise `false`.
+ */
+export function isInEnum(enumObj, value) {
+    const keys = Object.keys(enumObj);
+    const values = Object.values(enumObj);
+    const numericValues = values.filter(val => typeof val === 'number');
+    const cleanKeys = keys.filter(key => !numericValues.includes(parseInt(key, 10)));
+    const cleanValues = cleanKeys.map(cleanKey => enumObj[cleanKey]);
+    return cleanValues.includes(value);
 }
-export {
-  isInEnum
-};

package/agnostic/objects/enums/is-in-enum/index.test.js

@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import { isInEnum } from './index.js';
+describe('isInEnum', () => {
+    it('returns true for valid string enum values', () => {
+        let StringEnum;
+        (function (StringEnum) {
+            StringEnum["A"] = "a";
+            StringEnum["B"] = "b";
+            StringEnum["C"] = "c";
+        })(StringEnum || (StringEnum = {}));
+        expect(isInEnum(StringEnum, 'a')).toBe(true);
+        expect(isInEnum(StringEnum, 'b')).toBe(true);
+        expect(isInEnum(StringEnum, 'c')).toBe(true);
+    });
+    it('returns false for invalid string enum values', () => {
+        let StringEnum;
+        (function (StringEnum) {
+            StringEnum["A"] = "a";
+            StringEnum["B"] = "b";
+        })(StringEnum || (StringEnum = {}));
+        expect(isInEnum(StringEnum, 'c')).toBe(false);
+        expect(isInEnum(StringEnum, 'invalid')).toBe(false);
+    });
+    it('returns true for valid numeric enum values', () => {
+        let NumericEnum;
+        (function (NumericEnum) {
+            NumericEnum[NumericEnum["A"] = 0] = "A";
+            NumericEnum[NumericEnum["B"] = 1] = "B";
+            NumericEnum[NumericEnum["C"] = 2] = "C";
+        })(NumericEnum || (NumericEnum = {}));
+        expect(isInEnum(NumericEnum, 0)).toBe(true);
+        expect(isInEnum(NumericEnum, 1)).toBe(true);
+        expect(isInEnum(NumericEnum, 2)).toBe(true);
+    });
+    it('returns false for invalid numeric enum values', () => {
+        let NumericEnum;
+        (function (NumericEnum) {
+            NumericEnum[NumericEnum["A"] = 0] = "A";
+            NumericEnum[NumericEnum["B"] = 1] = "B";
+        })(NumericEnum || (NumericEnum = {}));
+        expect(isInEnum(NumericEnum, 2)).toBe(false);
+        expect(isInEnum(NumericEnum, 99)).toBe(false);
+    });
+    it('ignores reverse mappings in numeric enums', () => {
+        let NumericEnum;
+        (function (NumericEnum) {
+            NumericEnum[NumericEnum["A"] = 0] = "A";
+            NumericEnum[NumericEnum["B"] = 1] = "B";
+        })(NumericEnum || (NumericEnum = {}));
+        // Numeric enums have reverse mappings, but we should only check forward values
+        expect(isInEnum(NumericEnum, 'A')).toBe(false); // 'A' is a key, not a value
+        expect(isInEnum(NumericEnum, 0)).toBe(true); // 0 is a value
+        expect(isInEnum(NumericEnum, 1)).toBe(true); // 1 is a value
+    });
+    it('handles mixed string and number values in enum', () => {
+        let MixedEnum;
+        (function (MixedEnum) {
+            MixedEnum["A"] = "a";
+            MixedEnum[MixedEnum["B"] = 1] = "B";
+            MixedEnum["C"] = "c";
+        })(MixedEnum || (MixedEnum = {}));
+        expect(isInEnum(MixedEnum, 'a')).toBe(true);
+        expect(isInEnum(MixedEnum, 1)).toBe(true);
+        expect(isInEnum(MixedEnum, 'c')).toBe(true);
+        expect(isInEnum(MixedEnum, 'b')).toBe(false);
+        expect(isInEnum(MixedEnum, 0)).toBe(false);
+    });
+    it('handles enum with single value', () => {
+        let SingleEnum;
+        (function (SingleEnum) {
+            SingleEnum["A"] = "a";
+        })(SingleEnum || (SingleEnum = {}));
+        expect(isInEnum(SingleEnum, 'a')).toBe(true);
+        expect(isInEnum(SingleEnum, 'b')).toBe(false);
+    });
+    it('handles empty enum', () => {
+        let EmptyEnum;
+        (function (EmptyEnum) {
+        })(EmptyEnum || (EmptyEnum = {}));
+        expect(isInEnum(EmptyEnum, 'anything')).toBe(false);
+        expect(isInEnum(EmptyEnum, 0)).toBe(false);
+    });
+    it('handles enum with computed values', () => {
+        let ComputedEnum;
+        (function (ComputedEnum) {
+            ComputedEnum["A"] = "a";
+            ComputedEnum["B"] = "b";
+        })(ComputedEnum || (ComputedEnum = {}));
+        expect(isInEnum(ComputedEnum, 'a')).toBe(true);
+        expect(isInEnum(ComputedEnum, 'b')).toBe(true);
+    });
+    it('distinguishes between string and number types', () => {
+        let StringEnum;
+        (function (StringEnum) {
+            StringEnum["A"] = "1";
+        })(StringEnum || (StringEnum = {}));
+        expect(isInEnum(StringEnum, '1')).toBe(true);
+        expect(isInEnum(StringEnum, 1)).toBe(false); // number 1 is not string '1'
+    });
+});

package/agnostic/objects/flatten-getters/index.js

@@ -1,15 +1,16 @@
-// src/agnostic/objects/flatten-getters/index.ts
-function flattenGetters(obj) {
-  const getters = Object.entries(
-    Object.getOwnPropertyDescriptors(obj)
-  ).filter(([_, desc]) => typeof desc.get === "function").map(([key]) => key);
-  const returned = { ...obj };
-  getters.forEach((getter) => {
-    const key = getter;
-    returned[getter] = obj[key];
-  });
-  return returned;
+/**
+ * Returns a shallow copy of an object including values from its getter properties.
+ *
+ * @param {object} obj - The object to flatten.
+ * @returns {Record<string, unknown>} A new object containing all own properties and evaluated getter values.
+ */
+export function flattenGetters(obj) {
+    const getters = Object.entries(Object.getOwnPropertyDescriptors(obj)).filter(([_, desc]) => (typeof desc.get === 'function'))
+        .map(([key]) => key);
+    const returned = { ...obj };
+    getters.forEach(getter => {
+        const key = getter;
+        returned[getter] = obj[key];
+    });
+    return returned;
 }
-export {
-  flattenGetters
-};

package/agnostic/objects/flatten-getters/index.test.js

@@ -0,0 +1,78 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import { describe, it, expect } from 'vitest';
+import { flattenGetters } from './index.js';
+describe('flattenGetters', () => {
+    it('returns a shallow copy of plain objects', () => {
+        const obj = { a: 1, b: 2, c: 3 };
+        const result = flattenGetters(obj);
+        expect(result).toEqual({ a: 1, b: 2, c: 3 });
+        expect(result).not.toBe(obj);
+    });
+    it('includes getter values in the result', () => {
+        const obj = {
+            a: 1,
+            get b() { return this.a * 2; }
+        };
+        const result = flattenGetters(obj);
+        expect(result).toEqual({ a: 1, b: 2 });
+    });
+    it('handles multiple getters', () => {
+        const obj = {
+            base: 10,
+            get doubled() { return this.base * 2; },
+            get tripled() { return this.base * 3; }
+        };
+        const result = flattenGetters(obj);
+        expect(result).toEqual({ base: 10, doubled: 20, tripled: 30 });
+    });
+    it('evaluates getters with current context', () => {
+        const obj = {
+            value: 5,
+            get squared() { return this.value * this.value; }
+        };
+        obj.value = 10;
+        const result = flattenGetters(obj);
+        expect(result).toEqual({ value: 10, squared: 100 });
+    });
+    it('handles objects with both regular properties and getters', () => {
+        const obj = {
+            regular: 'value',
+            get computed() { return 'computed'; },
+            number: 42
+        };
+        const result = flattenGetters(obj);
+        expect(result).toEqual({ regular: 'value', computed: 'computed', number: 42 });
+    });
+    it('throws on null and undefined', () => {
+        expect(() => flattenGetters(null)).toThrow();
+        expect(() => flattenGetters(undefined)).toThrow();
+    });
+    it('handles strings and numbers', () => {
+        expect(flattenGetters(42)).toEqual({});
+        expect(flattenGetters('abc')).toEqual({ '0': 'a', '1': 'b', '2': 'c' });
+    });
+    it('handles objects with no properties', () => {
+        expect(flattenGetters({})).toEqual({});
+    });
+    it('handles objects with only getters', () => {
+        const obj = {
+            get value() { return 42; }
+        };
+        const result = flattenGetters(obj);
+        expect(result).toEqual({ value: 42 });
+    });
+    it('handles getters that return objects', () => {
+        const obj = {
+            get nested() { return { a: 1, b: 2 }; }
+        };
+        const result = flattenGetters(obj);
+        expect(result).toEqual({ nested: { a: 1, b: 2 } });
+    });
+    it('handles getters that throw errors', () => {
+        const obj = {
+            a: 1,
+            get error() { throw new Error('test'); }
+        };
+        expect(() => flattenGetters(obj)).toThrow('test');
+    });
+});

package/agnostic/objects/index.d.ts

@@ -1,9 +1,9 @@
-export * as deepGetProperty from './deep-get-property/index.js'
 export * as enums from './enums/index.js'
-export * as flattenGetters from './flatten-getters/index.js'
 export * as isObject from './is-object/index.js'
-export * as sortKeys from './sort-keys/index.js'
+export * as flattenGetters from './flatten-getters/index.js'
 export * as isRecord from './is-record/index.js'
-export * as recordMap from './record-map/index.js'
+export * as deepGetProperty from './deep-get-property/index.js'
 export * as recordFormat from './record-format/index.js'
+export * as recordMap from './record-map/index.js'
+export * as sortKeys from './sort-keys/index.js'
 export * as validation from './validation/index.js'

package/agnostic/objects/index.js

@@ -1,9 +1,9 @@
-export * as deepGetProperty from './deep-get-property/index.js'
 export * as enums from './enums/index.js'
-export * as flattenGetters from './flatten-getters/index.js'
 export * as isObject from './is-object/index.js'
-export * as sortKeys from './sort-keys/index.js'
+export * as flattenGetters from './flatten-getters/index.js'
 export * as isRecord from './is-record/index.js'
-export * as recordMap from './record-map/index.js'
+export * as deepGetProperty from './deep-get-property/index.js'
 export * as recordFormat from './record-format/index.js'
+export * as recordMap from './record-map/index.js'
+export * as sortKeys from './sort-keys/index.js'
 export * as validation from './validation/index.js'

package/agnostic/objects/is-object/index.js

@@ -1,11 +1,18 @@
-// src/agnostic/objects/is-object/index.ts
-function isObject(unk) {
-  return typeof unk === "object";
+/**
+ * Checks if a value is of type "object", including `null`.
+ *
+ * @param {unknown} unk - The value to check.
+ * @returns {unk is object | null} `true` if the value is an object or `null`, otherwise `false`.
+ */
+export function isObject(unk) {
+    return typeof unk === 'object';
 }
-function isNonNullObject(unk) {
-  return unk !== null && isObject(unk);
+/**
+ * Checks if a value is a non-null object.
+ *
+ * @param {unknown} unk - The value to check.
+ * @returns {unk is object} `true` if the value is a non-null object, otherwise `false`.
+ */
+export function isNonNullObject(unk) {
+    return unk !== null && isObject(unk);
 }
-export {
-  isNonNullObject,
-  isObject
-};

package/agnostic/objects/is-object/index.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { isObject, isNonNullObject } from './index.js';
+describe('isObject', () => {
+    it('returns true for plain objects', () => {
+        expect(isObject({})).toBe(true);
+        expect(isObject({ a: 1 })).toBe(true);
+    });
+    it('returns true for null', () => {
+        expect(isObject(null)).toBe(true);
+    });
+    it('returns true for arrays', () => {
+        expect(isObject([])).toBe(true);
+        expect(isObject([1, 2, 3])).toBe(true);
+    });
+    it('returns true for Date objects', () => {
+        expect(isObject(new Date())).toBe(true);
+    });
+    it('returns true for RegExp objects', () => {
+        expect(isObject(/test/)).toBe(true);
+    });
+    it('returns false for primitives', () => {
+        expect(isObject(42)).toBe(false);
+        expect(isObject('string')).toBe(false);
+        expect(isObject(true)).toBe(false);
+        expect(isObject(undefined)).toBe(false);
+    });
+    it('returns false for functions', () => {
+        expect(isObject(() => { })).toBe(false);
+        expect(isObject(function () { })).toBe(false);
+    });
+});
+describe('isNonNullObject', () => {
+    it('returns true for plain objects', () => {
+        expect(isNonNullObject({})).toBe(true);
+        expect(isNonNullObject({ a: 1 })).toBe(true);
+    });
+    it('returns false for null', () => {
+        expect(isNonNullObject(null)).toBe(false);
+    });
+    it('returns true for arrays', () => {
+        expect(isNonNullObject([])).toBe(true);
+        expect(isNonNullObject([1, 2, 3])).toBe(true);
+    });
+    it('returns true for Date objects', () => {
+        expect(isNonNullObject(new Date())).toBe(true);
+    });
+    it('returns true for RegExp objects', () => {
+        expect(isNonNullObject(/test/)).toBe(true);
+    });
+    it('returns false for primitives', () => {
+        expect(isNonNullObject(42)).toBe(false);
+        expect(isNonNullObject('string')).toBe(false);
+        expect(isNonNullObject(true)).toBe(false);
+        expect(isNonNullObject(undefined)).toBe(false);
+    });
+    it('returns false for functions', () => {
+        expect(isNonNullObject(() => { })).toBe(false);
+        expect(isNonNullObject(function () { })).toBe(false);
+    });
+});

package/agnostic/objects/is-record/index.js

@@ -1,8 +1,13 @@
-// src/agnostic/objects/is-record/index.ts
-function isRecord(input) {
-  if (typeof input !== "object" || input === null) return false;
-  return Object.keys(input).every((key) => typeof key === "string");
+/**
+ * Checks if a value is a plain object with string keys.
+ *
+ * @param {unknown} input - The value to check.
+ * @returns {input is Record<string, unknown>} `true` if the value is an object with string keys, otherwise `false`.
+ */
+export function isRecord(input) {
+    if (typeof input !== 'object' || input === null)
+        return false;
+    return Object
+        .keys(input)
+        .every(key => typeof key === 'string');
 }
-export {
-  isRecord
-};

package/agnostic/objects/is-record/index.test.js

@@ -0,0 +1,48 @@
+import { describe, it, expect } from 'vitest';
+import { isRecord } from './index.js';
+describe('isRecord', () => {
+    it('returns true for plain objects', () => {
+        expect(isRecord({})).toBe(true);
+        expect(isRecord({ a: 1 })).toBe(true);
+        expect(isRecord({ a: 1, b: 'string' })).toBe(true);
+    });
+    it('returns true for objects with string keys', () => {
+        expect(isRecord({ 'key': 'value' })).toBe(true);
+        expect(isRecord({ '0': 0, '1': 1 })).toBe(true);
+    });
+    it('returns false for null', () => {
+        expect(isRecord(null)).toBe(false);
+    });
+    it('returns true for arrays', () => {
+        expect(isRecord([])).toBe(true);
+        expect(isRecord([1, 2, 3])).toBe(true);
+    });
+    it('returns false for primitives', () => {
+        expect(isRecord(42)).toBe(false);
+        expect(isRecord('string')).toBe(false);
+        expect(isRecord(true)).toBe(false);
+        expect(isRecord(undefined)).toBe(false);
+    });
+    it('returns true for Date objects', () => {
+        expect(isRecord(new Date())).toBe(true);
+    });
+    it('returns true for RegExp objects', () => {
+        expect(isRecord(/test/)).toBe(true);
+    });
+    it('returns false for functions', () => {
+        expect(isRecord(() => { })).toBe(false);
+        expect(isRecord(function () { })).toBe(false);
+    });
+    it('returns true for objects created with Object.create(null)', () => {
+        const obj = Object.create(null);
+        obj.key = 'value';
+        expect(isRecord(obj)).toBe(true);
+    });
+    it('returns true for class instances with string keys', () => {
+        class MyClass {
+            prop = 'value';
+        }
+        const instance = new MyClass();
+        expect(isRecord(instance)).toBe(true);
+    });
+});

package/agnostic/objects/record-format/index.js

@@ -1,13 +1,19 @@
-// src/agnostic/objects/record-format/index.ts
-async function recordFormat(input, format) {
-  const result = {};
-  for (const key in format) {
-    const formatter = format[key];
-    if (formatter === void 0) continue;
-    result[key] = await formatter(input[key]);
-  }
-  return result;
+/**
+ * Applies a set of formatter functions to the corresponding properties of an input object.
+ *
+ * @template InputObject - The type of the input object.
+ * @template FormatObject - The type of the format object mapping keys to formatter functions.
+ * @param {InputObject} input - The object whose properties are to be formatted.
+ * @param {FormatObject} format - An object containing formatter functions for each key.
+ * @returns {Promise<Formatted<FormatObject>>} A Promise resolving to the formatted object with all promises unwrapped.
+ */
+export async function recordFormat(input, format) {
+    const result = {};
+    for (const key in format) {
+        const formatter = format[key];
+        if (formatter === undefined)
+            continue;
+        result[key] = await formatter(input[key]);
+    }
+    return result;
 }
-export {
-  recordFormat
-};

package/agnostic/objects/record-format/index.test.js

@@ -0,0 +1,92 @@
+import { describe, it, expect } from 'vitest';
+import { recordFormat } from './index.js';
+describe('recordFormat', () => {
+    it('applies formatters to all properties', async () => {
+        const input = { a: 1, b: 2, c: 3 };
+        const format = {
+            a: (val) => val * 2,
+            b: (val) => val * 3,
+            c: (val) => val * 4
+        };
+        const result = await recordFormat(input, format);
+        expect(result).toEqual({ a: 2, b: 6, c: 12 });
+    });
+    it('handles async formatters', async () => {
+        const input = { a: 1, b: 2 };
+        const format = {
+            a: async (val) => val * 2,
+            b: (val) => val * 3
+        };
+        const result = await recordFormat(input, format);
+        expect(result).toEqual({ a: 2, b: 6 });
+    });
+    it('handles formatters that return different types', async () => {
+        const input = { num: 5, str: 'hello' };
+        const format = {
+            num: (val) => val.toString(),
+            str: (val) => val.toUpperCase()
+        };
+        const result = await recordFormat(input, format);
+        expect(result).toEqual({ num: '5', str: 'HELLO' });
+    });
+    it('handles undefined values', async () => {
+        const input = { a: 1, b: undefined };
+        const format = {
+            a: (val) => val * 2,
+            b: (val) => 'missing'
+        };
+        const result = await recordFormat(input, format);
+        expect(result).toEqual({ a: 2, b: 'missing' });
+    });
+    it('handles formatters that access other properties', async () => {
+        const input = { base: 10, multiplier: 2 };
+        const format = {
+            base: (val) => val,
+            multiplier: (val) => val * input.base
+        };
+        const result = await recordFormat(input, format);
+        expect(result).toEqual({ base: 10, multiplier: 20 });
+    });
+    it('handles empty input object', async () => {
+        const input = {};
+        const format = {};
+        const result = await recordFormat(input, format);
+        expect(result).toEqual({});
+    });
+    it('handles format with fewer keys than input', async () => {
+        const input = { a: 1, b: 2, c: 3 };
+        const format = {
+            a: (val) => val * 2
+        };
+        const result = await recordFormat(input, format);
+        expect(result).toEqual({ a: 2 });
+    });
+    it('handles format with more keys than input', async () => {
+        const input = { a: 1 };
+        const format = {
+            a: (val) => val * 2,
+            b: (val) => 'default'
+        };
+        const result = await recordFormat(input, format);
+        expect(result).toEqual({ a: 2, b: 'default' });
+    });
+    it('handles complex nested transformations', async () => {
+        const input = { items: [1, 2, 3] };
+        const format = {
+            items: (val) => val.map(x => x * 2)
+        };
+        const result = await recordFormat(input, format);
+        expect(result).toEqual({ items: [2, 4, 6] });
+    });
+    it('handles formatters that return promises', async () => {
+        const input = { value: 5 };
+        const format = {
+            value: async (val) => {
+                await new Promise(resolve => setTimeout(resolve, 10));
+                return val * 2;
+            }
+        };
+        const result = await recordFormat(input, format);
+        expect(result).toEqual({ value: 10 });
+    });
+});

package/agnostic/objects/record-map/index.js

@@ -1,13 +1,18 @@
-// src/agnostic/objects/record-map/index.ts
-function recordMap(record, mapper) {
-  const result = {};
-  for (const key in record) {
-    if (Object.prototype.hasOwnProperty.call(record, key)) {
-      result[key] = mapper(record[key], key);
+/**
+ * Maps the values of a record using a provided mapper function, returning a new record with the same keys.
+ *
+ * @template Input - The type of the input record.
+ * @template MappedValue - The type of the mapped values.
+ * @param {Input} record - The record whose values will be mapped.
+ * @param {(value: Input[keyof Input], key: keyof Input) => MappedValue} mapper - Function to transform each value.
+ * @returns {{ [K in keyof Input]: MappedValue }} A new record with the same keys and mapped values.
+ */
+export function recordMap(record, mapper) {
+    const result = {};
+    for (const key in record) {
+        if (Object.prototype.hasOwnProperty.call(record, key)) {
+            result[key] = mapper(record[key], key);
+        }
     }
-  }
-  return result;
+    return result;
 }
-export {
-  recordMap
-};