@tim-code/my-util 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tim-code/my-util",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "",
   "type": "module",
   "author": "",

package/src/find.js

@@ -159,14 +159,20 @@ export function findClosestGTE(array, desired, { key, map, threshold = Infinity
  * @param {Array<T>} array
  * @param {V} value The desired value to search for
  * @param {Object} options
- * @param {string=} options.key If specified, will consider the value for each element's key instead of the element itself.
+ * @param {string|number=} options.key If specified, will consider the value for each element's key instead of the element itself.
  * @param {Function=} options.map If specified, will compute value by calling provided function on the element. Takes precedence over key.
+ * @param {string|number|Function=} options.transform Allows combining key and map as one parameter. Useful for piping in passed values.
  * @param {string=} options.comparator "abs", "lt", "lte", "gt", "gte", "abs". Default is "abs" which implies T is number.
  * @param {V=} options.threshold If specified, uses a different initial min/max/difference than positive or negative infinity.
  * @returns {T|undefined}
  */
 export function findClosest(array, value, options = {}) {
-  const { comparator = "abs" } = options
+  const { comparator = "abs", transform } = options
+  if (typeof transform === "function") {
+    options = { ...options, map: transform }
+  } else if (typeof transform === "string" || typeof transform === "number") {
+    options = { ...options, key: transform }
+  }
   switch (comparator) {
     case "lt":
       return findClosestLT(array, value, options)

package/src/find.test.js

@@ -156,6 +156,40 @@ describe("findClosest", () => {
       findClosest(arr, 4, { comparator: "abs", key: "length", threshold: -1 })
     ).toBeUndefined()
   })
+
+  it("uses transform as a function (same as map)", () => {
+    const arr = [{ v: 1 }, { v: 5 }, { v: 10 }]
+    const mapFn = (el) => el.v
+    expect(findClosest(arr, 6, { transform: mapFn })).toEqual({ v: 5 })
+    // Should take precedence over key if both are present
+    expect(findClosest(arr, 6, { key: "notUsed", transform: mapFn })).toEqual({ v: 5 })
+  })
+
+  it("uses transform as a string (same as key)", () => {
+    const arr = [{ v: 1 }, { v: 5 }, { v: 10 }]
+    expect(findClosest(arr, 6, { transform: "v" })).toEqual({ v: 5 })
+    // Should take precedence over key if both are present
+    expect(findClosest(arr, 6, { key: "notUsed", transform: "v" })).toEqual({ v: 5 })
+  })
+
+  it("uses transform as a number (same as key)", () => {
+    const arr = [[1], [5], [10]]
+    expect(findClosest(arr, 6, { transform: 0 })).toEqual([5])
+    // Should take precedence over key if both are present
+    expect(findClosest(arr, 6, { key: "notUsed", transform: 0 })).toEqual([5])
+  })
+
+  it("transform does not override key if key is already present and transform is not provided", () => {
+    const arr = [{ v: 1 }, { v: 5 }, { v: 10 }]
+    expect(findClosest(arr, 6, { key: "v" })).toEqual({ v: 5 })
+  })
+
+  it("transform is ignored if not a function, string, or number", () => {
+    const arr = [{ v: 1 }, { v: 5 }, { v: 10 }]
+    // eslint-disable-next-line no-restricted-syntax
+    expect(findClosest(arr, 6, { transform: null, key: "v" })).toEqual({ v: 5 })
+    expect(findClosest(arr, 6, { transform: {}, key: "v" })).toEqual({ v: 5 })
+  })
 })
 
 describe("findClosestAbs", () => {