@tim-code/my-util 0.4.9 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tim-code/my-util",
-  "version": "0.4.9",
+  "version": "0.5.0",
   "description": "",
   "type": "module",
   "author": "Tim Sprowl",

package/src/find.js

@@ -5,7 +5,7 @@ export function findClosestAbs(array, desired, { key, cutoff = Infinity } = {})
       const element = array[i]
       const value = key(element, i, array)
       const diff = Math.abs(value - desired)
-      if (diff < cutoff) {
+      if (diff < cutoff || (diff === cutoff && !closest)) {
         closest = element
         cutoff = diff
       }
@@ -14,7 +14,7 @@ export function findClosestAbs(array, desired, { key, cutoff = Infinity } = {})
     for (const element of array) {
       const value = element[key]
       const diff = Math.abs(value - desired)
-      if (diff < cutoff) {
+      if (diff < cutoff || (diff === cutoff && !closest)) {
         closest = element
         cutoff = diff
       }
@@ -22,7 +22,7 @@ export function findClosestAbs(array, desired, { key, cutoff = Infinity } = {})
   } else {
     for (const value of array) {
       const diff = Math.abs(value - desired)
-      if (diff < cutoff) {
+      if (diff < cutoff || (diff === cutoff && !closest)) {
         closest = value
         cutoff = diff
       }
@@ -37,7 +37,7 @@ export function findClosestLT(array, desired, { key, cutoff = -Infinity } = {})
     for (let i = 0; i < array.length; i++) {
       const element = array[i]
       const value = key(element, i, array)
-      if (value < desired && value > cutoff) {
+      if (value < desired && (value > cutoff || (value === cutoff && !closest))) {
         closest = element
         cutoff = value
       }
@@ -45,14 +45,14 @@ export function findClosestLT(array, desired, { key, cutoff = -Infinity } = {})
   } else if (typeof key === "number" || typeof key === "string") {
     for (const element of array) {
       const value = element[key]
-      if (value < desired && value > cutoff) {
+      if (value < desired && (value > cutoff || (value === cutoff && !closest))) {
         closest = element
         cutoff = value
       }
     }
   } else {
     for (const value of array) {
-      if (value < desired && value > cutoff) {
+      if (value < desired && (value > cutoff || (value === cutoff && !closest))) {
         closest = value
         cutoff = value
       }
@@ -67,7 +67,7 @@ export function findClosestLTE(array, desired, { key, cutoff = -Infinity } = {})
     for (let i = 0; i < array.length; i++) {
       const element = array[i]
       const value = key(element, i, array)
-      if (value <= desired && value > cutoff) {
+      if (value <= desired && (value > cutoff || (value === cutoff && !closest))) {
         closest = element
         cutoff = value
       }
@@ -75,14 +75,14 @@ export function findClosestLTE(array, desired, { key, cutoff = -Infinity } = {})
   } else if (typeof key === "number" || typeof key === "string") {
     for (const element of array) {
       const value = element[key]
-      if (value <= desired && value > cutoff) {
+      if (value <= desired && (value > cutoff || (value === cutoff && !closest))) {
         closest = element
         cutoff = value
       }
     }
   } else {
     for (const value of array) {
-      if (value <= desired && value > cutoff) {
+      if (value <= desired && (value > cutoff || (value === cutoff && !closest))) {
         closest = value
         cutoff = value
       }
@@ -97,7 +97,7 @@ export function findClosestGT(array, desired, { key, cutoff = Infinity } = {}) {
     for (let i = 0; i < array.length; i++) {
       const element = array[i]
       const value = key(element, i, array)
-      if (value > desired && value < cutoff) {
+      if (value > desired && (value < cutoff || (value === cutoff && !closest))) {
         closest = element
         cutoff = value
       }
@@ -105,14 +105,14 @@ export function findClosestGT(array, desired, { key, cutoff = Infinity } = {}) {
   } else if (typeof key === "number" || typeof key === "string") {
     for (const element of array) {
       const value = element[key]
-      if (value > desired && value < cutoff) {
+      if (value > desired && (value < cutoff || (value === cutoff && !closest))) {
         closest = element
         cutoff = value
       }
     }
   } else {
     for (const value of array) {
-      if (value > desired && value < cutoff) {
+      if (value > desired && (value < cutoff || (value === cutoff && !closest))) {
         closest = value
         cutoff = value
       }
@@ -127,7 +127,7 @@ export function findClosestGTE(array, desired, { key, cutoff = Infinity } = {})
     for (let i = 0; i < array.length; i++) {
       const element = array[i]
       const value = key(element, i, array)
-      if (value >= desired && value < cutoff) {
+      if (value >= desired && (value < cutoff || (value === cutoff && !closest))) {
         closest = element
         cutoff = value
       }
@@ -135,14 +135,14 @@ export function findClosestGTE(array, desired, { key, cutoff = Infinity } = {})
   } else if (typeof key === "number" || typeof key === "string") {
     for (const element of array) {
       const value = element[key]
-      if (value >= desired && value < cutoff) {
+      if (value >= desired && (value < cutoff || (value === cutoff && !closest))) {
         closest = element
         cutoff = value
       }
     }
   } else {
     for (const value of array) {
-      if (value >= desired && value < cutoff) {
+      if (value >= desired && (value < cutoff || (value === cutoff && !closest))) {
         closest = value
         cutoff = value
       }
@@ -165,7 +165,7 @@ export function findClosestGTE(array, desired, { key, cutoff = Infinity } = {})
  *  If a function, called with the element, index and array (same as .map() callback) to produce the value to sort on.
  * @param {string=} options.comparator "abs", "lt", "lte", "gt", "gte", "abs". Default is "abs" which implies T is number.
  * @param {V=} options.cutoff If specified, sets a initial constraint on how close the found value must be.
- *  For example, if used with "lt", the found element would need to be greater than the cutoff but still less than the desired value.
+ *  For example, if used with "lt", the found element would need to be greater than or equal to the cutoff but still less than the desired value.
  *  If used with "abs", the found element would need to have a difference with the desired value less than the cutoff.
  * @returns {T|undefined}
  */

package/src/find.test.js

@@ -45,7 +45,8 @@ describe("findClosestAbs", () => {
 
   it("respects cutoff", () => {
     expect(findClosestAbs([1, 5, 9], 6, { cutoff: 2 })).toBe(5)
-    expect(findClosestAbs([1, 5, 9], 6, { cutoff: 1 })).toBeUndefined()
+    expect(findClosestAbs([1, 5, 9], 6, { cutoff: 1 })).toBe(5)
+    expect(findClosestAbs([1, 5, 9], 6, { cutoff: 0 })).toBeUndefined()
   })
 })
 
@@ -81,7 +82,8 @@ describe("findClosestLT", () => {
 
   it("respects cutoff", () => {
     expect(findClosestLT([1, 5, 9], 6, { cutoff: 4 })).toBe(5)
-    expect(findClosestLT([1, 5, 9], 6, { cutoff: 5 })).toBeUndefined()
+    expect(findClosestLT([1, 5, 9], 6, { cutoff: 5 })).toBe(5)
+    expect(findClosestLT([1, 5, 9], 6, { cutoff: 6 })).toBe(undefined)
   })
 })
 
@@ -118,7 +120,8 @@ describe("findClosestLTE", () => {
 
   it("respects cutoff", () => {
     expect(findClosestLTE([1, 5, 9], 6, { cutoff: 4 })).toBe(5)
-    expect(findClosestLTE([1, 5, 9], 6, { cutoff: 5 })).toBeUndefined()
+    expect(findClosestLTE([1, 5, 9], 6, { cutoff: 5 })).toBe(5)
+    expect(findClosestLTE([1, 5, 9], 6, { cutoff: 6 })).toBe(undefined)
   })
 })
 
@@ -153,8 +156,9 @@ describe("findClosestGT", () => {
   })
 
   it("respects cutoff", () => {
-    expect(findClosestGT([1, 5, 9], 6, { cutoff: 8 })).toBeUndefined()
-    expect(findClosestGT([1, 5, 9], 4, { cutoff: 8 })).toBe(5)
+    expect(findClosestGTE([1, 5, 9], 6, { cutoff: 10 })).toBe(9)
+    expect(findClosestGTE([1, 5, 9], 6, { cutoff: 9 })).toBe(9)
+    expect(findClosestGTE([1, 5, 9], 6, { cutoff: 8 })).toBeUndefined()
   })
 })
 
@@ -189,8 +193,9 @@ describe("findClosestGTE", () => {
   })
 
   it("respects cutoff", () => {
+    expect(findClosestGTE([1, 5, 9], 6, { cutoff: 10 })).toBe(9)
+    expect(findClosestGTE([1, 5, 9], 6, { cutoff: 9 })).toBe(9)
     expect(findClosestGTE([1, 5, 9], 6, { cutoff: 8 })).toBeUndefined()
-    expect(findClosestGTE([1, 5, 9], 4, { cutoff: 8 })).toBe(5)
   })
 })
 

package/src/object.js

@@ -89,3 +89,37 @@ export function deepMerge(target, ...sources) {
   }
   return target
 }
+
+/**
+ * Deeply compares two values to determine if they are equal.
+ * Objects and arrays are compared recursively by their properties and elements.
+ * Primitives are compared with strict equality.
+ * Caveats:
+ *  Does not check class: [1] is considered equal to {0: 1}.
+ *  Any Symbol keys in the arguments are ignored (Object.keys only returns string keys).
+ * @param {any} a The first value to compare.
+ * @param {any} b The second value to compare.
+ * @returns {boolean} True if the values are deeply equal, false otherwise.
+ */
+export function deepEqual(a, b) {
+  if (a === b) {
+    return true
+  }
+  if (typeof a !== "object" || typeof b !== "object" || !a || !b) {
+    return false
+  }
+  const keysA = Object.keys(a)
+  const keysB = Object.keys(b)
+  if (keysA.length !== keysB.length) {
+    return false
+  }
+  for (const key of keysA) {
+    if (!Object.hasOwn(b, key)) {
+      return false
+    }
+    if (!deepEqual(a[key], b[key])) {
+      return false
+    }
+  }
+  return true
+}

package/src/object.test.js

@@ -1,6 +1,13 @@
 /* eslint-disable no-restricted-syntax */
 import { jest } from "@jest/globals"
-import { deepMerge, deleteUndefinedValues, like, mutateValues, via } from "./object.js"
+import {
+  deepEqual,
+  deepMerge,
+  deleteUndefinedValues,
+  like,
+  mutateValues,
+  via,
+} from "./object.js"
 
 describe("mutateValues", () => {
   it("mutates values in the object using the callback", () => {
@@ -257,3 +264,106 @@ describe("deepMerge", () => {
     expect(result).toBe(target)
   })
 })
+
+describe("deepEqual", () => {
+  it("returns true for strictly equal primitives", () => {
+    expect(deepEqual(1, 1)).toBe(true)
+    expect(deepEqual("foo", "foo")).toBe(true)
+    expect(deepEqual(true, true)).toBe(true)
+    expect(deepEqual(null, null)).toBe(true)
+    expect(deepEqual(undefined, undefined)).toBe(true)
+  })
+
+  it("returns false for different primitives", () => {
+    expect(deepEqual(1, 2)).toBe(false)
+    expect(deepEqual("foo", "bar")).toBe(false)
+    expect(deepEqual(true, false)).toBe(false)
+    expect(deepEqual(null, undefined)).toBe(false)
+  })
+
+  it("returns true for deeply equal objects", () => {
+    expect(deepEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true)
+    expect(deepEqual({ a: { b: 2 } }, { a: { b: 2 } })).toBe(true)
+    expect(deepEqual({}, {})).toBe(true)
+  })
+
+  it("returns false for objects with different keys or values", () => {
+    expect(deepEqual({ a: 1 }, { a: 2 })).toBe(false)
+    expect(deepEqual({ a: 1 }, { b: 1 })).toBe(false)
+    expect(deepEqual({ a: 1 }, {})).toBe(false)
+    expect(deepEqual({}, { a: 1 })).toBe(false)
+  })
+
+  it("returns true for deeply equal arrays", () => {
+    expect(deepEqual([1, 2, 3], [1, 2, 3])).toBe(true)
+    expect(deepEqual([], [])).toBe(true)
+    expect(deepEqual([[1], [2]], [[1], [2]])).toBe(true)
+  })
+
+  it("returns false for arrays with different elements or lengths", () => {
+    expect(deepEqual([1, 2], [1, 2, 3])).toBe(false)
+    expect(deepEqual([1, 2, 3], [1, 2])).toBe(false)
+    expect(deepEqual([1, 2, 3], [3, 2, 1])).toBe(false)
+  })
+
+  it("returns true if one is array and one is object", () => {
+    expect(deepEqual([1, 2], { 0: 1, 1: 2 })).toBe(true)
+    expect(deepEqual({ 0: 1, 1: 2 }, [1, 2])).toBe(true)
+  })
+
+  it("returns true for objects with same keys in different order", () => {
+    expect(deepEqual({ a: 1, b: 2 }, { b: 2, a: 1 })).toBe(true)
+  })
+
+  it("returns true for nested objects and arrays", () => {
+    const a = { foo: [1, { bar: 2 }], baz: { qux: [3] } }
+    const b = { foo: [1, { bar: 2 }], baz: { qux: [3] } }
+    expect(deepEqual(a, b)).toBe(true)
+  })
+
+  it("returns false for nested difference", () => {
+    const a = { foo: [1, { bar: 2 }], baz: { qux: [3] } }
+    const b = { foo: [1, { bar: 3 }], baz: { qux: [3] } }
+    expect(deepEqual(a, b)).toBe(false)
+  })
+
+  it("returns false if keys differ in nested objects", () => {
+    expect(deepEqual({ a: { b: 1 } }, { a: { c: 1 } })).toBe(false)
+  })
+
+  it("returns false if one is null or undefined and the other is object", () => {
+    expect(deepEqual(null, {})).toBe(false)
+    expect(deepEqual({}, null)).toBe(false)
+    expect(deepEqual(undefined, {})).toBe(false)
+    expect(deepEqual({}, undefined)).toBe(false)
+  })
+
+  it("returns true for self-references (same object)", () => {
+    const obj = { a: 1 }
+    expect(deepEqual(obj, obj)).toBe(true)
+    const arr = [1, 2]
+    expect(deepEqual(arr, arr)).toBe(true)
+  })
+
+  it("returns false for objects with different number of keys", () => {
+    expect(deepEqual({ a: 1, b: 2 }, { a: 1 })).toBe(false)
+    expect(deepEqual({ a: 1 }, { a: 1, b: 2 })).toBe(false)
+  })
+
+  it("returns true if object keys match but values are objects of different types", () => {
+    expect(deepEqual({ a: [1, 2] }, { a: { 0: 1, 1: 2 } })).toBe(true)
+  })
+
+  it("returns false for objects with missing keys", () => {
+    expect(deepEqual({ a: 1, b: 2 }, { a: 1 })).toBe(false)
+  })
+
+  it("returns true for objects with undefined values if both have them", () => {
+    expect(deepEqual({ a: undefined }, { a: undefined })).toBe(true)
+  })
+
+  it("returns false if one object has undefined key and the other doesn't", () => {
+    expect(deepEqual({ a: undefined }, {})).toBe(false)
+    expect(deepEqual({}, { a: undefined })).toBe(false)
+  })
+})