@design-edito/tools 0.4.22 → 0.5.0

package/agnostic/numbers/approximate-rational/index.js

@@ -4,9 +4,9 @@
  * Uses a naive algorithm that increments the numerator or denominator each round
  * to find the closest approximation. Stops early if an exact match is found.
  *
- * @param {number} target - The decimal number to approximate.
- * @param {number} maxRounds - The maximum number of iterations to perform.
- * @returns {[number, number]} A tuple `[numerator, denominator]` representing the rational approximation.
+ * @param target - The decimal number to approximate.
+ * @param maxRounds - The maximum number of iterations to perform.
+ * @returns A tuple `[numerator, denominator]` representing the rational approximation.
  */
 export function approximateRationalDumb(target, maxRounds) {
     let numerator = 0;
@@ -20,7 +20,7 @@ export function approximateRationalDumb(target, maxRounds) {
     };
     const positiveTarget = Math.abs(target);
     while (currentRound < maxRounds && !foundExact) {
-        currentRound++;
+        currentRound = currentRound + 1;
         const roundResult = numerator / denominator;
         if (roundResult === positiveTarget) {
             closestFound.numerator = numerator;
@@ -37,10 +37,10 @@ export function approximateRationalDumb(target, maxRounds) {
                 closestFound.found = roundResult;
             }
             if (roundResult < positiveTarget) {
-                numerator++;
+                numerator = numerator + 1;
             }
             else {
-                denominator++;
+                denominator = denominator + 1;
             }
         }
     }
@@ -58,9 +58,9 @@ export function approximateRationalDumb(target, maxRounds) {
  * Uses the continued fractions algorithm to find the best rational approximation
  * of a decimal number within the specified maximum denominator limit.
  *
- * @param {number} target - The decimal number to approximate.
- * @param {number} [maxDenominator=1000] - The maximum allowed denominator value.
- * @returns {[number, number]} A tuple `[numerator, denominator]` representing the rational approximation.
+ * @param target - The decimal number to approximate.
+ * @param [maxDenominator=1000] - The maximum allowed denominator value.
+ * @returns A tuple `[numerator, denominator]` representing the rational approximation.
  */
 export function approximateRational(target, maxDenominator = 1000) {
     const sign = target < 0 ? -1 : 1;

package/agnostic/numbers/clamp/index.d.ts

@@ -1,9 +1,9 @@
 /**
  * Restricts a number to lie within a specified range.
  *
- * @param {number} num - The number to clamp.
- * @param {number} bound1 - One end of the range.
- * @param {number} bound2 - The other end of the range.
- * @returns {number} The number constrained between the minimum and maximum of the two bounds.
+ * @param num - The number to clamp.
+ * @param bound1 - One end of the range.
+ * @param bound2 - The other end of the range.
+ * @returns The number constrained between the minimum and maximum of the two bounds.
  */
 export declare function clamp(num: number, bound1: number, bound2: number): number;

package/agnostic/numbers/clamp/index.js

@@ -1,10 +1,10 @@
 /**
  * Restricts a number to lie within a specified range.
  *
- * @param {number} num - The number to clamp.
- * @param {number} bound1 - One end of the range.
- * @param {number} bound2 - The other end of the range.
- * @returns {number} The number constrained between the minimum and maximum of the two bounds.
+ * @param num - The number to clamp.
+ * @param bound1 - One end of the range.
+ * @param bound2 - The other end of the range.
+ * @returns The number constrained between the minimum and maximum of the two bounds.
  */
 export function clamp(num, bound1, bound2) {
     const min = Math.min(bound1, bound2);

package/agnostic/numbers/geometric-progressions/index.d.ts

@@ -5,10 +5,10 @@
  * This function divides the range [min, max] multiplicatively (logarithmically)
  * across `steps` and returns the value corresponding to `level` (1-based).
  *
- * @param {number} min - The minimum value (must be non-zero).
- * @param {number} max - The maximum value.
- * @param {number} level - The current level (1-based, typically 1 ≤ level ≤ steps).
- * @param {number} steps - Total number of steps (must be ≥ 1).
- * @returns {number} The computed value at the specified level, or `NaN` if input is invalid.
+ * @param min - The minimum value (must be non-zero).
+ * @param max - The maximum value.
+ * @param level - The current level (1-based, typically 1 ≤ level ≤ steps).
+ * @param steps - Total number of steps (must be ≥ 1).
+ * @returns The computed value at the specified level, or `NaN` if input is invalid.
  */
 export declare function getGeometricStep(min: number, max: number, level: number, steps: number): number;

package/agnostic/numbers/geometric-progressions/index.js

@@ -5,18 +5,20 @@
  * This function divides the range [min, max] multiplicatively (logarithmically)
  * across `steps` and returns the value corresponding to `level` (1-based).
  *
- * @param {number} min - The minimum value (must be non-zero).
- * @param {number} max - The maximum value.
- * @param {number} level - The current level (1-based, typically 1 ≤ level ≤ steps).
- * @param {number} steps - Total number of steps (must be ≥ 1).
- * @returns {number} The computed value at the specified level, or `NaN` if input is invalid.
+ * @param min - The minimum value (must be non-zero).
+ * @param max - The maximum value.
+ * @param level - The current level (1-based, typically 1 ≤ level ≤ steps).
+ * @param steps - Total number of steps (must be ≥ 1).
+ * @returns The computed value at the specified level, or `NaN` if input is invalid.
  */
 export function getGeometricStep(min, max, level, steps) {
     if (min === 0) {
+        // eslint-disable-next-line no-console
         console.warn('Cannot generate values if min value is zero');
         return NaN;
     }
     if (steps < 1) {
+        // eslint-disable-next-line no-console
         console.warn('Cannot generate values if steps is lower than one');
         return NaN;
     }

package/agnostic/numbers/geometric-progressions/index.test.js

@@ -23,13 +23,13 @@ describe('getGeometricStep', () => {
         expect(values[4]).toBeCloseTo(16);
     });
     it('returns NaN if min is zero', () => {
-        const spy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const spy = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
         expect(getGeometricStep(0, 10, 1, 5)).toBeNaN();
         expect(spy).toHaveBeenCalledWith('Cannot generate values if min value is zero');
         spy.mockRestore();
     });
     it('returns NaN if steps is less than 1', () => {
-        const spy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const spy = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
         expect(getGeometricStep(1, 10, 1, 0)).toBeNaN();
         expect(spy).toHaveBeenCalledWith('Cannot generate values if steps is lower than one');
         spy.mockRestore();

package/agnostic/numbers/index.d.ts

@@ -2,5 +2,5 @@ export * as absoluteModulo from './absolute-modulo/index.js'
 export * as approximateRational from './approximate-rational/index.js'
 export * as clamp from './clamp/index.js'
 export * as geometricProgressions from './geometric-progressions/index.js'
-export * as round from './round/index.js'
 export * as interpolate from './interpolate/index.js'
+export * as round from './round/index.js'

package/agnostic/numbers/index.js

@@ -2,5 +2,5 @@ export * as absoluteModulo from './absolute-modulo/index.js'
 export * as approximateRational from './approximate-rational/index.js'
 export * as clamp from './clamp/index.js'
 export * as geometricProgressions from './geometric-progressions/index.js'
-export * as round from './round/index.js'
 export * as interpolate from './interpolate/index.js'
+export * as round from './round/index.js'

package/agnostic/numbers/interpolate/index.d.ts

@@ -1,10 +1,10 @@
 /**
  * Performs linear interpolation between two bounds based on a ratio.
  *
- * @param {number} ratio - The interpolation factor, typically between 0 and 1.
- * @param {number} bound1 - The start value.
- * @param {number} bound2 - The end value.
- * @returns {number} The interpolated value between `bound1` and `bound2`.
+ * @param ratio - The interpolation factor, typically between 0 and 1.
+ * @param bound1 - The start value.
+ * @param bound2 - The end value.
+ * @returns The interpolated value between `bound1` and `bound2`.
  */
 export declare function interpolate(ratio: number, bound1: number, bound2: number): number;
 /**
@@ -13,9 +13,9 @@ export declare function interpolate(ratio: number, bound1: number, bound2: numbe
  * If only `bound1` is provided, returns the ratio of `value / bound1`.
  * If both bounds are provided, returns the normalized position of `value` between `bound1` and `bound2`.
  *
- * @param {number} value - The value to normalize.
- * @param {number} bound1 - The lower bound (or single reference value if `bound2` is omitted).
- * @param {number} [bound2] - The upper bound (optional).
- * @returns {number} A ratio representing the relative position of `value`.
+ * @param value - The value to normalize.
+ * @param bound1 - The lower bound (or single reference value if `bound2` is omitted).
+ * @param [bound2] - The upper bound (optional).
+ * @returns A ratio representing the relative position of `value`.
  */
 export declare function unlerp(value: number, bound1: number, bound2?: number): number;

package/agnostic/numbers/interpolate/index.js

@@ -1,10 +1,10 @@
 /**
  * Performs linear interpolation between two bounds based on a ratio.
  *
- * @param {number} ratio - The interpolation factor, typically between 0 and 1.
- * @param {number} bound1 - The start value.
- * @param {number} bound2 - The end value.
- * @returns {number} The interpolated value between `bound1` and `bound2`.
+ * @param ratio - The interpolation factor, typically between 0 and 1.
+ * @param bound1 - The start value.
+ * @param bound2 - The end value.
+ * @returns The interpolated value between `bound1` and `bound2`.
  */
 export function interpolate(ratio, bound1, bound2) {
     return bound1 + ratio * (bound2 - bound1);
@@ -15,10 +15,10 @@ export function interpolate(ratio, bound1, bound2) {
  * If only `bound1` is provided, returns the ratio of `value / bound1`.
  * If both bounds are provided, returns the normalized position of `value` between `bound1` and `bound2`.
  *
- * @param {number} value - The value to normalize.
- * @param {number} bound1 - The lower bound (or single reference value if `bound2` is omitted).
- * @param {number} [bound2] - The upper bound (optional).
- * @returns {number} A ratio representing the relative position of `value`.
+ * @param value - The value to normalize.
+ * @param bound1 - The lower bound (or single reference value if `bound2` is omitted).
+ * @param [bound2] - The upper bound (optional).
+ * @returns A ratio representing the relative position of `value`.
  */
 export function unlerp(value, bound1, bound2) {
     if (bound2 === undefined)

package/agnostic/numbers/round/index.d.ts

@@ -1,24 +1,24 @@
 /**
  * Rounds a number to/down a specified number of decimal places.
  *
- * @param {number} number - The number to round.
- * @param {number} nbDecimals - Number of decimal places. Defaults to 0
- * @returns {number} The rounded number.
+ * @param number - The number to round.
+ * @param nbDecimals - Number of decimal places. Defaults to 0
+ * @returns The rounded number.
  */
 export declare function round(number: number, nbDecimals?: number): number;
 /**
  * Ceils a number up to a specified number of decimal places.
  *
- * @param {number} number - The number to round up.
- * @param {number} nbDecimals - Number of decimal places. Defaults to 0
- * @returns {number} The ceiled-up number.
+ * @param number - The number to round up.
+ * @param nbDecimals - Number of decimal places. Defaults to 0
+ * @returns The ceiled-up number.
  */
 export declare function ceil(number: number, nbDecimals?: number): number;
 /**
  * Floors a number down to a specified number of decimal places.
  *
- * @param {number} number - The number to round down.
- * @param {number} nbDecimals - Number of decimal places. Defaults to 0
- * @returns {number} The floored-down number.
+ * @param number - The number to round down.
+ * @param nbDecimals - Number of decimal places. Defaults to 0
+ * @returns The floored-down number.
  */
 export declare function floor(number: number, nbDecimals?: number): number;

package/agnostic/numbers/round/index.js

@@ -1,9 +1,9 @@
 /**
  * Rounds a number to/down a specified number of decimal places.
  *
- * @param {number} number - The number to round.
- * @param {number} nbDecimals - Number of decimal places. Defaults to 0
- * @returns {number} The rounded number.
+ * @param number - The number to round.
+ * @param nbDecimals - Number of decimal places. Defaults to 0
+ * @returns The rounded number.
  */
 export function round(number, nbDecimals = 0) {
     const multiplier = Math.pow(10, nbDecimals);
@@ -12,9 +12,9 @@ export function round(number, nbDecimals = 0) {
 /**
  * Ceils a number up to a specified number of decimal places.
  *
- * @param {number} number - The number to round up.
- * @param {number} nbDecimals - Number of decimal places. Defaults to 0
- * @returns {number} The ceiled-up number.
+ * @param number - The number to round up.
+ * @param nbDecimals - Number of decimal places. Defaults to 0
+ * @returns The ceiled-up number.
  */
 export function ceil(number, nbDecimals = 0) {
     const multiplier = Math.pow(10, nbDecimals);
@@ -23,9 +23,9 @@ export function ceil(number, nbDecimals = 0) {
 /**
  * Floors a number down to a specified number of decimal places.
  *
- * @param {number} number - The number to round down.
- * @param {number} nbDecimals - Number of decimal places. Defaults to 0
- * @returns {number} The floored-down number.
+ * @param number - The number to round down.
+ * @param nbDecimals - Number of decimal places. Defaults to 0
+ * @returns The floored-down number.
  */
 export function floor(number, nbDecimals = 0) {
     const multiplier = Math.pow(10, nbDecimals);

package/agnostic/objects/deep-get-property/index.d.ts

@@ -1,9 +1,9 @@
 /**
  * Safely retrieves a nested property from an object using a dot-separated path string.
  *
- * @param {unknown} anythingThatHasProperties - The object (or record) to traverse.
- * @param {string} pathString - Dot-separated path of the property to retrieve (e.g., `'a.b.c'`).
- * @returns {any} The value at the specified path.
+ * @param anythingThatHasProperties - The object (or record) to traverse.
+ * @param pathString - Dot-separated path of the property to retrieve (e.g., `'a.b.c'`).
+ * @returns The value at the specified path.
  * @throws {string} `'PROPERTY_UNREACHABLE'` if any part of the path is inaccessible or not an object.
  */
-export declare function deepGetProperty(anythingThatHasProperties: unknown, pathString: string): any;
+export declare function deepGetProperty(anythingThatHasProperties: unknown, pathString: string): unknown;

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

@@ -2,9 +2,9 @@ import { isRecord } from '../is-record/index.js';
 /**
  * Safely retrieves a nested property from an object using a dot-separated path string.
  *
- * @param {unknown} anythingThatHasProperties - The object (or record) to traverse.
- * @param {string} pathString - Dot-separated path of the property to retrieve (e.g., `'a.b.c'`).
- * @returns {any} The value at the specified path.
+ * @param anythingThatHasProperties - The object (or record) to traverse.
+ * @param pathString - Dot-separated path of the property to retrieve (e.g., `'a.b.c'`).
+ * @returns The value at the specified path.
  * @throws {string} `'PROPERTY_UNREACHABLE'` if any part of the path is inaccessible or not an object.
  */
 export function deepGetProperty(anythingThatHasProperties, pathString) {

package/agnostic/objects/enums/is-in-enum/index.d.ts

@@ -4,8 +4,8 @@
  * 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`.
+ * @param enumObj - The enum object to check against.
+ * @param value - The value to test.
+ * @returns `true` if the value is a valid enum member, otherwise `false`.
  */
 export declare function isInEnum<E extends Record<string, string | number>>(enumObj: E, value: string | number): value is E[keyof E];

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

@@ -4,9 +4,9 @@
  * 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`.
+ * @param enumObj - The enum object to check against.
+ * @param value - The value to test.
+ * @returns `true` if the value is a valid enum member, otherwise `false`.
  */
 export function isInEnum(enumObj, value) {
     const keys = Object.keys(enumObj);

package/agnostic/objects/flatten-getters/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * 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.
+ * @param obj - The object to flatten.
+ * @returns A new object containing all own properties and evaluated getter values.
  */
 export declare function flattenGetters(obj: object): Record<string, unknown>;

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

@@ -1,14 +1,15 @@
 /**
  * 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.
+ * @param obj - The object to flatten.
+ * @returns 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 => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- getter came from Object.getOwnPropertyDescriptors(obj)'s own keys, so it's always a key of obj
         const key = getter;
         returned[getter] = obj[key];
     });

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 isRecord from './is-record/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'
-export * as isObject from './is-object/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 isRecord from './is-record/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'
-export * as isObject from './is-object/index.js'

package/agnostic/objects/is-object/index.d.ts

@@ -1,14 +1,14 @@
 /**
  * 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`.
+ * @param unk - The value to check.
+ * @returns `true` if the value is an object or `null`, otherwise `false`.
  */
 export declare function isObject(unk: unknown): unk is object | null;
 /**
  * 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`.
+ * @param unk - The value to check.
+ * @returns `true` if the value is a non-null object, otherwise `false`.
  */
 export declare function isNonNullObject(unk: unknown): unk is object;

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

@@ -1,8 +1,8 @@
 /**
  * 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`.
+ * @param unk - The value to check.
+ * @returns `true` if the value is an object or `null`, otherwise `false`.
  */
 export function isObject(unk) {
     return typeof unk === 'object';
@@ -10,8 +10,8 @@ export function 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`.
+ * @param unk - The value to check.
+ * @returns `true` if the value is a non-null object, otherwise `false`.
  */
 export function isNonNullObject(unk) {
     return unk !== null && isObject(unk);

package/agnostic/objects/is-record/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * 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`.
+ * @param input - The value to check.
+ * @returns `true` if the value is an object with string keys, otherwise `false`.
  */
 export declare function isRecord(input: unknown): input is Record<string, unknown>;

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

@@ -1,8 +1,8 @@
 /**
  * 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`.
+ * @param input - The value to check.
+ * @returns `true` if the value is an object with string keys, otherwise `false`.
  */
 export function isRecord(input) {
     if (typeof input !== 'object' || input === null)

package/agnostic/objects/record-format/index.d.ts

@@ -4,8 +4,8 @@ import type { UnwrapPromise } from '../../typescript/types.js';
  *
  * @template InputType - The type of the input value the formatter receives.
  * @template OutputType - The type of the value the formatter returns (or resolves to if Promise).
- * @param {InputType} val - The input value to transform.
- * @returns {OutputType | Promise<OutputType>} The transformed value or a Promise resolving to it.
+ * @param val - The input value to transform.
+ * @returns The transformed value or a Promise resolving to it.
  */
 export type FormatterFunc<InputType, OutputType> = (val: InputType) => OutputType | Promise<OutputType>;
 /**
@@ -14,8 +14,8 @@ export type FormatterFunc<InputType, OutputType> = (val: InputType) => OutputTyp
  *
  * @template InputObject - The type of the input object being formatted.
  */
-export type Format<InputObject extends Record<PropertyKey, any>> = {
-    [Key in keyof InputObject]?: FormatterFunc<InputObject[Key], any>;
+export type Format<InputObject extends Record<PropertyKey, unknown>> = {
+    [Key in keyof InputObject]?: FormatterFunc<InputObject[Key], unknown>;
 };
 /**
  * The resulting object after applying all formatters and unwrapping any returned Promises.
@@ -23,15 +23,15 @@ export type Format<InputObject extends Record<PropertyKey, any>> = {
  * @template FormatObject - The type of the format object mapping keys to formatter functions.
  */
 export type Formatted<FormatObject> = {
-    [Key in keyof FormatObject]: FormatObject[Key] extends FormatterFunc<any, any> ? UnwrapPromise<ReturnType<FormatObject[Key]>> : never;
+    [Key in keyof FormatObject]: FormatObject[Key] extends FormatterFunc<unknown, unknown> ? UnwrapPromise<ReturnType<FormatObject[Key]>> : never;
 };
 /**
  * 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.
+ * @param input - The object whose properties are to be formatted.
+ * @param format - An object containing formatter functions for each key.
+ * @returns A Promise resolving to the formatted object with all promises unwrapped.
  */
-export declare function recordFormat<InputObject extends Record<PropertyKey, any>, FormatObject extends Format<InputObject>>(input: InputObject, format: FormatObject): Promise<Formatted<FormatObject>>;
+export declare function recordFormat<InputObject extends Record<PropertyKey, unknown>, FormatObject extends Format<InputObject>>(input: InputObject, format: FormatObject): Promise<Formatted<FormatObject>>;

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

@@ -3,17 +3,22 @@
  *
  * @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.
+ * @param input - The object whose properties are to be formatted.
+ * @param format - An object containing formatter functions for each key.
+ * @returns A Promise resolving to the formatted object with all promises unwrapped.
  */
 export async function recordFormat(input, format) {
     const result = {};
     for (const key in format) {
+        // eslint-disable-next-line prefer-object-has-own
+        if (!Object.prototype.hasOwnProperty.call(format, key))
+            continue;
         const formatter = format[key];
         if (formatter === undefined)
             continue;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-explicit-any
         result[key] = await formatter(input[key]);
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- result was populated with a formatted value for every key of format in the loop above
     return result;
 }

package/agnostic/objects/record-map/index.d.ts

@@ -3,10 +3,10 @@
  *
  * @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.
+ * @param record - The record whose values will be mapped.
+ * @param mapper - Function to transform each value.
+ * @returns A new record with the same keys and mapped values.
  */
-export declare function recordMap<Input extends Record<string, any>, MappedValue>(record: Input, mapper: (value: Input[keyof Input], key: keyof Input) => MappedValue): {
+export declare function recordMap<Input extends Record<string, unknown>, MappedValue>(record: Input, mapper: (value: Input[keyof Input], key: keyof Input) => MappedValue): {
     [K in keyof Input]: MappedValue;
 };

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

@@ -3,16 +3,18 @@
  *
  * @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.
+ * @param record - The record whose values will be mapped.
+ * @param mapper - Function to transform each value.
+ * @returns A new record with the same keys and mapped values.
  */
 export function recordMap(record, mapper) {
     const result = {};
     for (const key in record) {
+        // eslint-disable-next-line prefer-object-has-own
         if (Object.prototype.hasOwnProperty.call(record, key)) {
             result[key] = mapper(record[key], key);
         }
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- result was populated with a mapped value for every key of Input in the loop above
     return result;
 }

package/agnostic/objects/sort-keys/index.d.ts

@@ -2,9 +2,9 @@
  * Returns a new object with the keys sorted according to the provided sorter.
  *
  * @template T - The type of the input object.
- * @param {T} obj - The object whose keys should be sorted.
- * @param {(a: keyof T, b: keyof T) => number} [sorter] - Optional function used to compare keys for sorting. Defaults to alphabetical order.
- * @returns {{ [K in keyof T]: T[K] }} A new object with the same keys and values as the input, but sorted by key.
+ * @param obj - The object whose keys should be sorted.
+ * @param [sorter] - Optional function used to compare keys for sorting. Defaults to alphabetical order.
+ * @returns A new object with the same keys and values as the input, but sorted by key.
  */
 export declare function sortKeys<T extends Record<string, unknown>>(obj: T, sorter?: (a: keyof T, b: keyof T) => number): {
     [K in keyof T]: T[K];

package/agnostic/objects/sort-keys/index.js

@@ -2,9 +2,9 @@
  * Returns a new object with the keys sorted according to the provided sorter.
  *
  * @template T - The type of the input object.
- * @param {T} obj - The object whose keys should be sorted.
- * @param {(a: keyof T, b: keyof T) => number} [sorter] - Optional function used to compare keys for sorting. Defaults to alphabetical order.
- * @returns {{ [K in keyof T]: T[K] }} A new object with the same keys and values as the input, but sorted by key.
+ * @param obj - The object whose keys should be sorted.
+ * @param [sorter] - Optional function used to compare keys for sorting. Defaults to alphabetical order.
+ * @returns A new object with the same keys and values as the input, but sorted by key.
  */
 export function sortKeys(obj, sorter = (a, b) => String(a).localeCompare(String(b))) {
     const out = {};
@@ -12,5 +12,6 @@ export function sortKeys(obj, sorter = (a, b) => String(a).localeCompare(String(
     for (const key of keys.sort(sorter)) {
         out[key] = obj[key];
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- out was populated with every key of T in the loop above
     return out;
 }

package/agnostic/objects/validation/index.d.ts

@@ -4,8 +4,8 @@
  * Performs a shallow equality check for each property in `partial`.
  *
  * @template T - The type of the full object.
- * @param {T} obj - The object to validate.
- * @param {Partial<T>} partial - The partial object with key-value pairs to check.
- * @returns {boolean} `true` if all entries in `partial` match those in `obj`, otherwise `false`.
+ * @param obj - The object to validate.
+ * @param partial - The partial object with key-value pairs to check.
+ * @returns `true` if all entries in `partial` match those in `obj`, otherwise `false`.
  */
 export declare function fromPartial<T extends object>(obj: T, partial: Partial<T>): boolean;