@design-edito/tools 0.4.5 → 0.4.11

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

@@ -1,72 +1,89 @@
-// src/agnostic/numbers/approximate-rational/index.ts
-function approximateRationalDumb(target, maxRounds) {
-  let numerator = 0;
-  let denominator = 1;
-  let currentRound = 0;
-  let foundExact = false;
-  const closestFound = {
-    numerator,
-    denominator,
-    found: 0
-  };
-  const positiveTarget = Math.abs(target);
-  while (currentRound < maxRounds && !foundExact) {
-    currentRound++;
-    const roundResult = numerator / denominator;
-    if (roundResult === positiveTarget) {
-      closestFound.numerator = numerator;
-      closestFound.denominator = denominator;
-      closestFound.found = roundResult;
-      foundExact = true;
-    } else {
-      const roundAbsDiff = Math.abs(roundResult - positiveTarget);
-      const closestAbsDiff = Math.abs(closestFound.found - positiveTarget);
-      if (roundAbsDiff < closestAbsDiff) {
-        closestFound.numerator = numerator;
-        closestFound.denominator = denominator;
-        closestFound.found = roundResult;
-      }
-      if (roundResult < positiveTarget) {
-        numerator++;
-      } else {
-        denominator++;
-      }
+/**
+ * Approximates a decimal number as a rational number using a simple iterative approach.
+ *
+ * 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.
+ */
+export function approximateRationalDumb(target, maxRounds) {
+    let numerator = 0;
+    let denominator = 1;
+    let currentRound = 0;
+    let foundExact = false;
+    const closestFound = {
+        numerator,
+        denominator,
+        found: 0
+    };
+    const positiveTarget = Math.abs(target);
+    while (currentRound < maxRounds && !foundExact) {
+        currentRound++;
+        const roundResult = numerator / denominator;
+        if (roundResult === positiveTarget) {
+            closestFound.numerator = numerator;
+            closestFound.denominator = denominator;
+            closestFound.found = roundResult;
+            foundExact = true;
+        }
+        else {
+            const roundAbsDiff = Math.abs(roundResult - positiveTarget);
+            const closestAbsDiff = Math.abs(closestFound.found - positiveTarget);
+            if (roundAbsDiff < closestAbsDiff) {
+                closestFound.numerator = numerator;
+                closestFound.denominator = denominator;
+                closestFound.found = roundResult;
+            }
+            if (roundResult < positiveTarget) {
+                numerator++;
+            }
+            else {
+                denominator++;
+            }
+        }
     }
-  }
-  if (target < 0) {
-    closestFound.numerator = closestFound.numerator * -1;
-  }
-  return [
-    closestFound.numerator,
-    closestFound.denominator
-  ];
-}
-function approximateRational(target, maxDenominator = 1e3) {
-  const sign = target < 0 ? -1 : 1;
-  const absTarget = Math.abs(target);
-  let h1 = 1;
-  let h2 = 0;
-  let k1 = 0;
-  let k2 = 1;
-  let b = absTarget;
-  do {
-    const a = Math.floor(b);
-    let temp = h1;
-    h1 = a * h1 + h2;
-    h2 = temp;
-    temp = k1;
-    k1 = a * k1 + k2;
-    k2 = temp;
-    if (k1 > maxDenominator) {
-      k1 = k2;
-      h1 = h2;
-      break;
+    if (target < 0) {
+        closestFound.numerator = closestFound.numerator * -1;
     }
-    b = 1 / (b - a);
-  } while (Math.abs(absTarget - h1 / k1) > 1e-10 && Number.isFinite(b));
-  return [sign * h1, k1];
+    return [
+        closestFound.numerator,
+        closestFound.denominator
+    ];
+}
+/**
+ * Approximates a decimal number as a rational number (fraction) using continued fractions.
+ *
+ * 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.
+ */
+export function approximateRational(target, maxDenominator = 1000) {
+    const sign = target < 0 ? -1 : 1;
+    const absTarget = Math.abs(target);
+    let h1 = 1;
+    let h2 = 0; // numerator convergents
+    let k1 = 0;
+    let k2 = 1; // denominator convergents
+    let b = absTarget;
+    do {
+        const a = Math.floor(b);
+        let temp = h1;
+        h1 = a * h1 + h2;
+        h2 = temp;
+        temp = k1;
+        k1 = a * k1 + k2;
+        k2 = temp;
+        if (k1 > maxDenominator) {
+            k1 = k2;
+            h1 = h2;
+            break;
+        }
+        b = 1 / (b - a);
+    } while (Math.abs(absTarget - h1 / k1) > 1e-10 && Number.isFinite(b));
+    return [sign * h1, k1];
 }
-export {
-  approximateRational,
-  approximateRationalDumb
-};

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

@@ -0,0 +1,90 @@
+import { describe, it, expect } from 'vitest';
+import { approximateRational, approximateRationalDumb } from './index.js';
+describe('approximateRational', () => {
+    it('approximates simple fractions', () => {
+        const [num, den] = approximateRational(0.5);
+        expect(num / den).toBeCloseTo(0.5, 10);
+        expect(den).toBeLessThanOrEqual(1000);
+    });
+    it('approximates 0.333... as 1/3', () => {
+        const [num, den] = approximateRational(1 / 3);
+        expect(num).toBe(1);
+        expect(den).toBe(3);
+    });
+    it('approximates 0.25 as 1/4', () => {
+        const [num, den] = approximateRational(0.25);
+        expect(num).toBe(1);
+        expect(den).toBe(4);
+    });
+    it('approximates negative numbers', () => {
+        const [num, den] = approximateRational(-0.5);
+        expect(num / den).toBeCloseTo(-0.5, 10);
+        expect(num).toBeLessThan(0);
+    });
+    it('respects maxDenominator limit', () => {
+        const [num, den] = approximateRational(Math.PI, 100);
+        expect(den).toBeLessThanOrEqual(100);
+        expect(num / den).toBeCloseTo(Math.PI, 2);
+    });
+    it('uses default maxDenominator of 1000', () => {
+        const [, den] = approximateRational(Math.PI);
+        expect(den).toBeLessThanOrEqual(1000);
+    });
+    it('handles zero', () => {
+        const [num, den] = approximateRational(0);
+        expect(num).toBe(0);
+        expect(den).toBeGreaterThan(0);
+    });
+    it('handles integers', () => {
+        const [num, den] = approximateRational(5);
+        expect(num / den).toBe(5);
+    });
+    it('returns valid fraction for irrational numbers', () => {
+        const [num, den] = approximateRational(Math.sqrt(2));
+        expect(den).toBeGreaterThan(0);
+        expect(num / den).toBeCloseTo(Math.sqrt(2), 5);
+    });
+    it('approximates small decimals', () => {
+        const [num, den] = approximateRational(0.001);
+        expect(num / den).toBeCloseTo(0.001, 5);
+    });
+});
+describe('approximateRationalDumb', () => {
+    it('approximates simple fractions', () => {
+        const [num, den] = approximateRationalDumb(0.5, 100);
+        expect(num / den).toBeCloseTo(0.5, 5);
+    });
+    it('finds exact matches when possible', () => {
+        const [num, den] = approximateRationalDumb(0.5, 100);
+        expect(num / den).toBe(0.5);
+    });
+    it('approximates 0.25', () => {
+        const [num, den] = approximateRationalDumb(0.25, 100);
+        expect(num / den).toBeCloseTo(0.25, 5);
+    });
+    it('approximates negative numbers', () => {
+        const [num, den] = approximateRationalDumb(-0.5, 100);
+        expect(num / den).toBeCloseTo(-0.5, 5);
+        expect(num).toBeLessThan(0);
+    });
+    it('respects maxRounds limit', () => {
+        const [num, den] = approximateRationalDumb(Math.PI, 29);
+        expect(num / den).toBeCloseTo(Math.PI, 2);
+    });
+    it('handles zero', () => {
+        const [num, den] = approximateRationalDumb(0, 100);
+        expect(num).toBe(0);
+        expect(den).toBeGreaterThan(0);
+    });
+    it('handles integers', () => {
+        const [num, den] = approximateRationalDumb(5, 100);
+        expect(num / den).toBe(5);
+    });
+    it('improves approximation with more rounds', () => {
+        const [num1, den1] = approximateRationalDumb(0.333, 10);
+        const [num2, den2] = approximateRationalDumb(0.333, 100);
+        const diff1 = Math.abs(num1 / den1 - 0.333);
+        const diff2 = Math.abs(num2 / den2 - 0.333);
+        expect(diff2).toBeLessThanOrEqual(diff1);
+    });
+});

package/agnostic/numbers/clamp/index.js

@@ -1,9 +1,13 @@
-// src/agnostic/numbers/clamp/index.ts
-function clamp(num, bound1, bound2) {
-  const min = Math.min(bound1, bound2);
-  const max = Math.max(bound1, bound2);
-  return Math.min(Math.max(num, min), max);
+/**
+ * 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.
+ */
+export function clamp(num, bound1, bound2) {
+    const min = Math.min(bound1, bound2);
+    const max = Math.max(bound1, bound2);
+    return Math.min(Math.max(num, min), max);
 }
-export {
-  clamp
-};

package/agnostic/numbers/clamp/index.test.js

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import { clamp } from './index.js';
+describe('clamp', () => {
+    it('returns number when within bounds', () => {
+        expect(clamp(5, 0, 10)).toBe(5);
+        expect(clamp(5, 10, 0)).toBe(5);
+    });
+    it('clamps to minimum when below lower bound', () => {
+        expect(clamp(-5, 0, 10)).toBe(0);
+        expect(clamp(-5, 10, 0)).toBe(0);
+    });
+    it('clamps to maximum when above upper bound', () => {
+        expect(clamp(15, 0, 10)).toBe(10);
+        expect(clamp(15, 10, 0)).toBe(10);
+    });
+    it('handles bounds in any order', () => {
+        expect(clamp(5, 10, 0)).toBe(5);
+        expect(clamp(5, 0, 10)).toBe(5);
+    });
+    it('handles equal bounds', () => {
+        expect(clamp(5, 10, 10)).toBe(10);
+        expect(clamp(5, 0, 0)).toBe(0);
+    });
+});

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

@@ -1,17 +1,26 @@
-// src/agnostic/numbers/geometric-progressions/index.ts
-function getGeometricStep(min, max, level, steps) {
-  if (min === 0) {
-    console.warn("Cannot generate values if min value is zero");
-    return NaN;
-  }
-  if (steps < 1) {
-    console.warn("Cannot generate values if steps is lower than one");
-    return NaN;
-  }
-  const maxOverMin = max / min;
-  const factor = Math.pow(maxOverMin, 1 / steps);
-  return min * Math.pow(factor, level);
+/**
+ * Computes the value at a specific level in a geometric progression
+ * between a minimum and maximum over a given number of steps.
+ *
+ * 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.
+ */
+export function getGeometricStep(min, max, level, steps) {
+    if (min === 0) {
+        console.warn('Cannot generate values if min value is zero');
+        return NaN;
+    }
+    if (steps < 1) {
+        console.warn('Cannot generate values if steps is lower than one');
+        return NaN;
+    }
+    const maxOverMin = max / min;
+    const factor = Math.pow(maxOverMin, 1 / steps);
+    return min * Math.pow(factor, level);
 }
-export {
-  getGeometricStep
-};

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

@@ -0,0 +1,45 @@
+import { describe, it, expect, vi } from 'vitest';
+import { getGeometricStep } from './index.js';
+describe('getGeometricStep', () => {
+    it('returns the minimum value at level 0', () => {
+        expect(getGeometricStep(2, 32, 0, 5)).toBeCloseTo(2);
+    });
+    it('returns the maximum value at the last level', () => {
+        const steps = 5;
+        const min = 2;
+        const max = 32;
+        const result = getGeometricStep(min, max, steps, steps);
+        expect(result).toBeCloseTo(max);
+    });
+    it('returns intermediate geometric values for levels in between', () => {
+        const min = 1;
+        const max = 16;
+        const steps = 4;
+        const values = Array.from({ length: steps + 1 }, (_, i) => getGeometricStep(min, max, i, steps));
+        expect(values[0]).toBeCloseTo(1);
+        expect(values[1]).toBeCloseTo(2);
+        expect(values[2]).toBeCloseTo(4);
+        expect(values[3]).toBeCloseTo(8);
+        expect(values[4]).toBeCloseTo(16);
+    });
+    it('returns NaN if min is zero', () => {
+        const spy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        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(() => { });
+        expect(getGeometricStep(1, 10, 1, 0)).toBeNaN();
+        expect(spy).toHaveBeenCalledWith('Cannot generate values if steps is lower than one');
+        spy.mockRestore();
+    });
+    it('handles min greater than max', () => {
+        const min = 16;
+        const max = 1;
+        const steps = 4;
+        const values = Array.from({ length: steps + 1 }, (_, i) => getGeometricStep(min, max, i, steps));
+        expect(values[0]).toBeCloseTo(16);
+        expect(values[steps]).toBeCloseTo(1);
+    });
+});

package/agnostic/numbers/index.d.ts

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

package/agnostic/numbers/index.js

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

package/agnostic/numbers/interpolate/index.js

@@ -1,12 +1,27 @@
-// src/agnostic/numbers/interpolate/index.ts
-function interpolate(ratio, bound1, bound2) {
-  return bound1 + ratio * (bound2 - bound1);
+/**
+ * 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`.
+ */
+export function interpolate(ratio, bound1, bound2) {
+    return bound1 + ratio * (bound2 - bound1);
 }
-function unlerp(value, bound1, bound2) {
-  if (bound2 === void 0) return value / bound1;
-  return (value - bound1) / (bound2 - bound1);
+/**
+ * Performs inverse linear interpolation (also called "unlerp") of a value relative to one or two bounds.
+ *
+ * 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`.
+ */
+export function unlerp(value, bound1, bound2) {
+    if (bound2 === undefined)
+        return value / bound1;
+    return (value - bound1) / (bound2 - bound1);
 }
-export {
-  interpolate,
-  unlerp
-};

package/agnostic/numbers/interpolate/index.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { interpolate, unlerp } from './index.js';
+describe('interpolate', () => {
+    it('returns bound1 when ratio is 0', () => {
+        expect(interpolate(0, 10, 20)).toBe(10);
+    });
+    it('returns bound2 when ratio is 1', () => {
+        expect(interpolate(1, 10, 20)).toBe(20);
+    });
+    it('interpolates between bounds', () => {
+        expect(interpolate(0.5, 10, 20)).toBe(15);
+        expect(interpolate(0.25, 0, 100)).toBe(25);
+    });
+    it('handles negative ratios', () => {
+        expect(interpolate(-0.5, 10, 20)).toBe(5);
+    });
+    it('handles ratios greater than 1', () => {
+        expect(interpolate(1.5, 10, 20)).toBe(25);
+    });
+});
+describe('unlerp', () => {
+    it('returns ratio of value to bound1 when bound2 is omitted', () => {
+        expect(unlerp(5, 10)).toBe(0.5);
+        expect(unlerp(20, 10)).toBe(2);
+    });
+    it('returns 0 when value equals bound1', () => {
+        expect(unlerp(10, 10, 20)).toBe(0);
+    });
+    it('returns 1 when value equals bound2', () => {
+        expect(unlerp(20, 10, 20)).toBe(1);
+    });
+    it('calculates ratio between bounds', () => {
+        expect(unlerp(15, 10, 20)).toBe(0.5);
+        expect(unlerp(12.5, 10, 20)).toBe(0.25);
+    });
+    it('handles values outside bounds', () => {
+        expect(unlerp(25, 10, 20)).toBe(1.5);
+        expect(unlerp(5, 10, 20)).toBe(-0.5);
+    });
+});

package/agnostic/numbers/round/index.js

@@ -1,18 +1,33 @@
-// src/agnostic/numbers/round/index.ts
-function round(number, nbDecimals = 0) {
-  const multiplier = Math.pow(10, nbDecimals);
-  return Math.round(number * multiplier) / multiplier;
+/**
+ * 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.
+ */
+export function round(number, nbDecimals = 0) {
+    const multiplier = Math.pow(10, nbDecimals);
+    return Math.round(number * multiplier) / multiplier;
 }
-function ceil(number, nbDecimals = 0) {
-  const multiplier = Math.pow(10, nbDecimals);
-  return Math.ceil(number * multiplier) / multiplier;
+/**
+ * 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.
+ */
+export function ceil(number, nbDecimals = 0) {
+    const multiplier = Math.pow(10, nbDecimals);
+    return Math.ceil(number * multiplier) / multiplier;
 }
-function floor(number, nbDecimals = 0) {
-  const multiplier = Math.pow(10, nbDecimals);
-  return Math.floor(number * multiplier) / multiplier;
+/**
+ * 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.
+ */
+export function floor(number, nbDecimals = 0) {
+    const multiplier = Math.pow(10, nbDecimals);
+    return Math.floor(number * multiplier) / multiplier;
 }
-export {
-  ceil,
-  floor,
-  round
-};

package/agnostic/numbers/round/index.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect } from 'vitest';
+import { round, ceil, floor } from './index.js';
+describe('round', () => {
+    it('rounds to integer by default', () => {
+        expect(round(3.7)).toBe(4);
+        expect(round(3.2)).toBe(3);
+    });
+    it('rounds to specified decimal places', () => {
+        expect(round(3.14159, 2)).toBe(3.14);
+        expect(round(3.14159, 3)).toBe(3.142);
+    });
+    it('handles zero', () => {
+        expect(round(0)).toBe(0);
+        expect(round(0, 2)).toBe(0);
+    });
+    it('handles negative numbers', () => {
+        expect(round(-3.7)).toBe(-4);
+        expect(round(-3.2)).toBe(-3);
+    });
+});
+describe('ceil', () => {
+    it('rounds up to integer by default', () => {
+        expect(ceil(3.1)).toBe(4);
+        expect(ceil(3.9)).toBe(4);
+    });
+    it('rounds up to specified decimal places', () => {
+        expect(ceil(3.14159, 2)).toBe(3.15);
+        expect(ceil(3.14159, 3)).toBe(3.142);
+    });
+    it('handles zero', () => {
+        expect(ceil(0)).toBe(0);
+        expect(ceil(0, 2)).toBe(0);
+    });
+    it('handles negative numbers', () => {
+        expect(ceil(-3.1)).toBe(-3);
+        expect(ceil(-3.9)).toBe(-3);
+    });
+});
+describe('floor', () => {
+    it('rounds down to integer by default', () => {
+        expect(floor(3.1)).toBe(3);
+        expect(floor(3.9)).toBe(3);
+    });
+    it('rounds down to specified decimal places', () => {
+        expect(floor(3.14159, 2)).toBe(3.14);
+        expect(floor(3.14159, 3)).toBe(3.141);
+    });
+    it('handles zero', () => {
+        expect(floor(0)).toBe(0);
+        expect(floor(0, 2)).toBe(0);
+    });
+    it('handles negative numbers', () => {
+        expect(floor(-3.1)).toBe(-4);
+        expect(floor(-3.9)).toBe(-4);
+    });
+});

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

@@ -1,28 +1,31 @@
-// 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");
+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.
+ * @throws {string} `'PROPERTY_UNREACHABLE'` if any part of the path is inaccessible or not an object.
+ */
+export function deepGetProperty(anythingThatHasProperties, pathString) {
+    const pathChunks = pathString.split('.').map(e => e.trim()).filter(e => e !== '');
+    let currentObject = anythingThatHasProperties;
+    let returned = currentObject;
+    pathChunks.forEach((chunk, pos) => {
+        const isLast = pos === pathChunks.length - 1;
+        if (!isRecord(currentObject))
+            throw new Error('PROPERTY_UNREACHABLE');
+        if (isLast) {
+            const val = currentObject[chunk];
+            returned = val;
+        }
+        else {
+            const found = currentObject[chunk];
+            if (isRecord(found))
+                currentObject = found;
+            else
+                throw new Error('PROPERTY_UNREACHABLE');
+        }
+    });
+    return returned;
 }
-
-// src/agnostic/objects/deep-get-property/index.ts
-function deepGetProperty(anythingThatHasProperties, pathString) {
-  const pathChunks = pathString.split(".").map((e) => e.trim()).filter((e) => e !== "");
-  let currentObject = anythingThatHasProperties;
-  let returned = currentObject;
-  pathChunks.forEach((chunk, pos) => {
-    const isLast = pos === pathChunks.length - 1;
-    if (!isRecord(currentObject)) throw new Error("PROPERTY_UNREACHABLE");
-    if (isLast) {
-      const val = currentObject[chunk];
-      returned = val;
-    } else {
-      const found = currentObject[chunk];
-      if (isRecord(found)) currentObject = found;
-      else throw new Error("PROPERTY_UNREACHABLE");
-    }
-  });
-  return returned;
-}
-export {
-  deepGetProperty
-};