@tim-code/my-util 0.5.0 → 0.5.2

package/package.json

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

package/src/find.js

@@ -1,4 +1,30 @@
-export function findClosestAbs(array, desired, { key, cutoff = Infinity } = {}) {
+export function findEq(array, desired, { key } = {}) {
+  if (typeof key === "function") {
+    for (let i = 0; i < array.length; i++) {
+      const element = array[i]
+      const value = key(element, i, array)
+      if (value === desired) {
+        return value
+      }
+    }
+  } else if (typeof key === "number" || typeof key === "string") {
+    for (const element of array) {
+      const value = element[key]
+      if (value === desired) {
+        return value
+      }
+    }
+  } else {
+    for (const value of array) {
+      if (value === desired) {
+        return value
+      }
+    }
+  }
+  return undefined
+}
+
+export function findSmallestDiff(array, desired, { key, cutoff = Infinity } = {}) {
   let closest
   if (typeof key === "function") {
     for (let i = 0; i < array.length; i++) {
@@ -163,14 +189,16 @@ export function findClosestGTE(array, desired, { key, cutoff = Infinity } = {})
  * @param {string|number|Function=} options.key
  *  If specified, will consider the value for each element's key instead of the element itself.
  *  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 {string=} options.comparator "diff", "lt", "lte", "gt", "gte", "eq". Default is "diff" 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 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.
+ *  If used with lt, lte, value must be greater than or equal to cutoff.
+ *  If used with gt, gte, value must be less than or equal to cutoff.
+ *  If used with diff, value's difference with desired must be less than or equal to cutoff.
+ *  No effect with eq.
  * @returns {T|undefined}
  */
 export function findClosest(array, value, options = {}) {
-  const { comparator = "abs" } = options
+  const { comparator = "diff" } = options
   switch (comparator) {
     case "lt":
       return findClosestLT(array, value, options)
@@ -180,15 +208,17 @@ export function findClosest(array, value, options = {}) {
       return findClosestGT(array, value, options)
     case "gte":
       return findClosestGTE(array, value, options)
-    case "abs":
-      return findClosestAbs(array, value, options)
+    case "diff":
+      return findSmallestDiff(array, value, options)
+    case "eq":
+      return findEq(array, value, options)
     default:
       throw new Error(`unknown comparator: ${comparator}`)
   }
 }
 
 /**
- * Find the minimum value in an array.
+ * Find the minimum value in an array. undefined or null values are ignored.
  * @template T, V
  * @param {Array<T>} array
  * @param {Object} $1
@@ -196,7 +226,7 @@ export function findClosest(array, value, options = {}) {
  *  If string, then accesses each element at that key to get value.
  *  If function, then calls the callback on each element to get value.
  * @param {V=} $1.cutoff Only values below cutoff will be considered.
- * @returns {T}
+ * @returns {T|undefined}
  */
 export function findMin(array, { key, cutoff = Infinity } = {}) {
   let closest
@@ -229,7 +259,7 @@ export function findMin(array, { key, cutoff = Infinity } = {}) {
 }
 
 /**
- * Find the maximum value in an array.
+ * Find the maximum value in an array. undefined or null values are ignored.
  * @template T, V
  * @param {Array<T>} array
  * @param {Object} $1
@@ -237,7 +267,7 @@ export function findMin(array, { key, cutoff = Infinity } = {}) {
  *  If string, then accesses each element at that key to get value.
  *  If function, then calls the callback on each element to get value.
  * @param {V=} $1.cutoff Only values above cutoff will be considered.
- * @returns {T}
+ * @returns {T|undefined}
  */
 export function findMax(array, { key, cutoff = -Infinity } = {}) {
   let closest

package/src/find.test.js

@@ -2,7 +2,8 @@
 import { describe, expect, it } from "@jest/globals"
 
 const {
-  findClosestAbs,
+  findEq,
+  findSmallestDiff,
   findClosestLT,
   findClosestLTE,
   findClosestGT,
@@ -13,40 +14,75 @@ const {
   findTruthy,
 } = await import("./find.js")
 
-describe("findClosestAbs", () => {
+describe("findEq", () => {
+  it("returns the first element equal to desired (no key)", () => {
+    expect(findEq([1, 2, 3, 2], 2)).toBe(2)
+    expect(findEq([1, 2, 3], 4)).toBeUndefined()
+  })
+
+  it("returns the first value from key function equal to desired", () => {
+    const arr = [{ v: 1 }, { v: 2 }, { v: 3 }]
+    expect(findEq(arr, 2, { key: (e) => e.v })).toBe(2)
+    expect(findEq(arr, 4, { key: (e) => e.v })).toBeUndefined()
+  })
+
+  it("returns the first value from key string equal to desired", () => {
+    const arr = [{ x: 1 }, { x: 2 }, { x: 3 }]
+    expect(findEq(arr, 2, { key: "x" })).toBe(2)
+    expect(findEq(arr, 4, { key: "x" })).toBeUndefined()
+  })
+
+  it("returns the first value from key number equal to desired", () => {
+    const arr = [[1], [2], [3]]
+    expect(findEq(arr, 2, { key: 0 })).toBe(2)
+    expect(findEq(arr, 4, { key: 0 })).toBeUndefined()
+  })
+
+  it("returns undefined for empty array", () => {
+    expect(findEq([], 1)).toBeUndefined()
+  })
+
+  it("returns first matching value if there are duplicates", () => {
+    expect(findEq([2, 2, 3], 2)).toBe(2)
+    const arr = [{ v: 2 }, { v: 2 }]
+    expect(findEq(arr, 2, { key: (e) => e.v })).toBe(2)
+  })
+})
+
+describe("findSmallestDiff", () => {
   it("returns the element closest in absolute value to desired", () => {
-    expect(findClosestAbs([1, 5, 9], 6)).toBe(5)
-    expect(findClosestAbs([1, 5, 9], 8)).toBe(9)
-    expect(findClosestAbs([1, 5, 9], 1)).toBe(1)
+    expect(findSmallestDiff([1, 5, 9], 6)).toBe(5)
+    expect(findSmallestDiff([1, 5, 9], 8)).toBe(9)
+    expect(findSmallestDiff([1, 5, 9], 1)).toBe(1)
   })
 
   it("returns the first element in case of tie", () => {
-    expect(findClosestAbs([4, 8], 6)).toBe(4)
+    expect(findSmallestDiff([4, 8], 6)).toBe(4)
   })
 
   it("returns undefined for empty array", () => {
-    expect(findClosestAbs([], 10)).toBeUndefined()
+    expect(findSmallestDiff([], 10)).toBeUndefined()
   })
 
   it("supports key as function", () => {
     const arr = [{ v: 2 }, { v: 8 }]
-    expect(findClosestAbs(arr, 5, { key: (e) => e.v })).toEqual({ v: 2 })
+    expect(findSmallestDiff(arr, 5, { key: (e) => e.v })).toEqual({ v: 2 })
   })
 
   it("supports key as string", () => {
     const arr = [{ x: 1 }, { x: 10 }]
-    expect(findClosestAbs(arr, 8, { key: "x" })).toEqual({ x: 10 })
+    expect(findSmallestDiff(arr, 8, { key: "x" })).toEqual({ x: 10 })
   })
 
   it("supports key as number", () => {
     const arr = [[2], [8]]
-    expect(findClosestAbs(arr, 7, { key: 0 })).toEqual([8])
+    expect(findSmallestDiff(arr, 7, { key: 0 })).toEqual([8])
   })
 
   it("respects cutoff", () => {
-    expect(findClosestAbs([1, 5, 9], 6, { cutoff: 2 })).toBe(5)
-    expect(findClosestAbs([1, 5, 9], 6, { cutoff: 1 })).toBe(5)
-    expect(findClosestAbs([1, 5, 9], 6, { cutoff: 0 })).toBeUndefined()
+    expect(findSmallestDiff([1, 5, 9], 6, { cutoff: 2 })).toBe(5)
+    expect(findSmallestDiff([1, 5, 9], 6, { cutoff: 1 })).toBe(5)
+    expect(findSmallestDiff([1, 5, 9], 6, { cutoff: 0 })).toBeUndefined()
   })
 })
 
@@ -200,7 +236,7 @@ describe("findClosestGTE", () => {
 })
 
 describe("findClosest", () => {
-  it("defaults to abs comparator", () => {
+  it("defaults to diff comparator", () => {
     expect(findClosest([1, 5, 9], 6)).toBe(5)
   })
 
@@ -209,7 +245,9 @@ describe("findClosest", () => {
     expect(findClosest([1, 5, 9], 6, { comparator: "lte" })).toBe(5)
     expect(findClosest([1, 5, 9], 6, { comparator: "gt" })).toBe(9)
     expect(findClosest([1, 5, 9], 6, { comparator: "gte" })).toBe(9)
-    expect(findClosest([1, 5, 9], 6, { comparator: "abs" })).toBe(5)
+    expect(findClosest([1, 5, 9], 6, { comparator: "diff" })).toBe(5)
+    expect(findClosest([1, 5, 9], 6, { comparator: "eq" })).toBeUndefined()
+    expect(findClosest([1, 5, 9], 5, { comparator: "eq" })).toBe(5)
   })
 
   it("throws on unknown comparator", () => {
@@ -220,7 +258,8 @@ describe("findClosest", () => {
 
   it("passes options to underlying function", () => {
     const arr = [{ x: 1 }, { x: 10 }]
-    expect(findClosest(arr, 8, { comparator: "abs", key: "x" })).toEqual({ x: 10 })
+    expect(findClosest(arr, 8, { comparator: "diff", key: "x" })).toEqual({ x: 10 })
+    expect(findClosest(arr, 10, { comparator: "eq", key: "x" })).toBe(10)
   })
 })
 

package/src/math.js

@@ -148,5 +148,5 @@ export function range(start, end, increment = 1) {
  * @returns {boolean}
  */
 export function isNumber(number) {
-  return typeof number === "number" && !isNaN(number)
+  return Number.isFinite(number)
 }

package/src/math.test.js

@@ -311,9 +311,9 @@ describe("isNumber", () => {
     expect(isNumber(Number.MIN_SAFE_INTEGER)).toBe(true)
   })
 
-  it("returns true for Infinity and -Infinity", () => {
-    expect(isNumber(Infinity)).toBe(true)
-    expect(isNumber(-Infinity)).toBe(true)
+  it("returns false for Infinity and -Infinity", () => {
+    expect(isNumber(Infinity)).toBe(false)
+    expect(isNumber(-Infinity)).toBe(false)
   })
 
   it("returns false for NaN", () => {