@tim-code/my-util 0.4.1 → 0.4.3

package/package.json

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

package/src/find.js

@@ -268,3 +268,83 @@ export function findMax(array, { key, cutoff = -Infinity } = {}) {
   }
   return closest
 }
+
+/**
+ * Like Array.prototype.findIndex but starts from given index.
+ * @template T
+ * @param {Array<T>} array
+ * @param {number} fromIndex
+ * @param {(value: T, index: number, array: Array<T>) => boolean} callback
+ * @returns {number}
+ */
+export function findIndexFrom(array, fromIndex, callback) {
+  for (let i = fromIndex; i < array.length; i++) {
+    if (callback(array[i], i, array)) {
+      return i
+    }
+  }
+  return -1
+}
+
+/**
+ * Like Array.prototype.find but starts from given index.
+ * @template T
+ * @param {Array<T>} array
+ * @param {number} fromIndex
+ * @param {(value: T, index: number, array: Array<T>) => boolean} callback
+ * @returns {T|undefined}
+ */
+export function findFrom(array, fromIndex, callback) {
+  const foundIndex = findIndexFrom(array, fromIndex, callback)
+  if (foundIndex < 0) {
+    return undefined
+  }
+  return array[foundIndex]
+}
+
+/**
+ * Like Array.prototype.findLastIndex but starts from given index.
+ * @template T
+ * @param {Array<T>} array
+ * @param {number} fromIndex If greater or equal to length, coerces to last index in array.
+ * @param {(value: T, index: number, array: Array<T>) => boolean} callback
+ * @returns {number}
+ */
+export function findLastIndexFrom(array, fromIndex, callback) {
+  if (fromIndex >= array.length) {
+    fromIndex = array.length - 1
+  }
+  for (let i = fromIndex; i >= 0; i--) {
+    if (callback(array[i], i, array)) {
+      return i
+    }
+  }
+  return -1
+}
+
+/**
+ * Like Array.prototype.findLast but starts from given index.
+ * @template T
+ * @param {Array<T>} array
+ * @param {number} fromIndex
+ * @param {(value: T, index: number, array: Array<T>) => boolean} callback
+ * @returns {T|undefined}
+ */
+export function findLastFrom(array, fromIndex, callback) {
+  const foundIndex = findLastIndexFrom(array, fromIndex, callback)
+  if (foundIndex < 0) {
+    return undefined
+  }
+  return array[foundIndex]
+}
+
+/**
+ * Returns truthy if argument is truthy and falsy otherwise.
+ * Meant to used with find(): `array.find(isTruthy)`
+ * @template T
+ * @param {T} anything
+ * @returns {T}
+ */
+export function isTruthy(anything) {
+  return anything
+}

package/src/find.test.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-restricted-syntax */
 import { describe, expect, it } from "@jest/globals"
 
 const {
@@ -9,6 +10,11 @@ const {
   findClosest,
   findMin,
   findMax,
+  findIndexFrom,
+  findFrom,
+  findLastIndexFrom,
+  findLastFrom,
+  isTruthy,
 } = await import("./find.js")
 
 describe("findClosestAbs", () => {
@@ -284,3 +290,141 @@ describe("findMax", () => {
     expect(findMax([3, 1, 4, 2], { cutoff: 4 })).toBeUndefined()
   })
 })
+
+describe("findIndexFrom", () => {
+  it("returns the index of the first matching element from fromIndex", () => {
+    expect(findIndexFrom([1, 2, 3, 4], 1, (x) => x > 2)).toBe(2)
+    expect(findIndexFrom([1, 2, 3, 4], 2, (x) => x > 2)).toBe(2)
+    expect(findIndexFrom([1, 2, 3, 4], 3, (x) => x > 2)).toBe(3)
+  })
+
+  it("returns -1 if no element matches", () => {
+    expect(findIndexFrom([1, 2, 3, 4], 2, (x) => x > 10)).toBe(-1)
+  })
+
+  it("returns -1 for empty array", () => {
+    expect(findIndexFrom([], 0, () => true)).toBe(-1)
+  })
+
+  it("passes correct arguments to callback", () => {
+    const arr = [10, 20, 30]
+    const called = []
+    findIndexFrom(arr, 1, (value, index, array) => {
+      called.push([value, index, array])
+      return false
+    })
+    expect(called[0][0]).toBe(20)
+    expect(called[0][1]).toBe(1)
+    expect(called[0][2]).toBe(arr)
+  })
+})
+
+describe("findFrom", () => {
+  it("returns the first matching element from fromIndex", () => {
+    expect(findFrom([1, 2, 3, 4], 1, (x) => x > 2)).toBe(3)
+    expect(findFrom([1, 2, 3, 4], 2, (x) => x > 2)).toBe(3)
+    expect(findFrom([1, 2, 3, 4], 3, (x) => x > 2)).toBe(4)
+  })
+
+  it("returns undefined if no element matches", () => {
+    expect(findFrom([1, 2, 3, 4], 2, (x) => x > 10)).toBeUndefined()
+  })
+
+  it("returns undefined for empty array", () => {
+    expect(findFrom([], 0, () => true)).toBeUndefined()
+  })
+
+  it("passes correct arguments to callback", () => {
+    const arr = [10, 20, 30]
+    const called = []
+    findFrom(arr, 1, (value, index, array) => {
+      called.push([value, index, array])
+      return false
+    })
+    expect(called[0][0]).toBe(20)
+    expect(called[0][1]).toBe(1)
+    expect(called[0][2]).toBe(arr)
+  })
+})
+
+describe("findLastIndexFrom", () => {
+  it("returns the index of the last matching element from fromIndex (backwards)", () => {
+    expect(findLastIndexFrom([1, 2, 3, 4], 2, (x) => x < 3)).toBe(1)
+    expect(findLastIndexFrom([1, 2, 3, 4], 3, (x) => x < 3)).toBe(1)
+    expect(findLastIndexFrom([1, 2, 3, 4], 1, (x) => x < 3)).toBe(1)
+    expect(findLastIndexFrom([1, 2, 3, 4], 0, (x) => x < 3)).toBe(0)
+  })
+
+  it("returns -1 if no element matches", () => {
+    expect(findLastIndexFrom([1, 2, 3, 4], 3, (x) => x > 10)).toBe(-1)
+  })
+
+  it("returns -1 for empty array", () => {
+    expect(findLastIndexFrom([], 0, () => true)).toBe(-1)
+  })
+
+  it("passes correct arguments to callback", () => {
+    const arr = [10, 20, 30]
+    const called = []
+    findLastIndexFrom(arr, 2, (value, index, array) => {
+      called.push([value, index, array])
+      return false
+    })
+    expect(called[0][0]).toBe(30)
+    expect(called[0][1]).toBe(2)
+    expect(called[0][2]).toBe(arr)
+  })
+})
+
+describe("findLastFrom", () => {
+  it("returns the last matching element from fromIndex (backwards)", () => {
+    expect(findLastFrom([1, 2, 3, 4], 2, (x) => x < 3)).toBe(2)
+    expect(findLastFrom([1, 2, 3, 4], 3, (x) => x < 3)).toBe(2)
+    expect(findLastFrom([1, 2, 3, 4], 1, (x) => x < 3)).toBe(2)
+    expect(findLastFrom([1, 2, 3, 4], 0, (x) => x < 3)).toBe(1)
+  })
+
+  it("returns undefined if no element matches", () => {
+    expect(findLastFrom([1, 2, 3, 4], 3, (x) => x > 10)).toBeUndefined()
+  })
+
+  it("returns undefined for empty array", () => {
+    expect(findLastFrom([], 0, () => true)).toBeUndefined()
+  })
+
+  it("passes correct arguments to callback", () => {
+    const arr = [10, 20, 30]
+    const called = []
+    findLastFrom(arr, 2, (value, index, array) => {
+      called.push([value, index, array])
+      return false
+    })
+    expect(called[0][0]).toBe(30)
+    expect(called[0][1]).toBe(2)
+    expect(called[0][2]).toBe(arr)
+  })
+})
+
+describe("isTruthy", () => {
+  it("returns the argument if it is truthy", () => {
+    expect(isTruthy(1)).toBe(1)
+    expect(isTruthy("foo")).toBe("foo")
+    expect(isTruthy({})).toEqual({})
+    expect(isTruthy([])).toEqual([])
+    expect(isTruthy(true)).toBe(true)
+  })
+
+  it("returns the argument if it is falsy", () => {
+    expect(isTruthy(0)).toBe(0)
+    expect(isTruthy("")).toBe("")
+    expect(isTruthy(null)).toBe(null)
+    expect(isTruthy(undefined)).toBe(undefined)
+    expect(isTruthy(false)).toBe(false)
+    expect(isTruthy(NaN)).toBe(NaN)
+  })
+
+  it("can be used with Array.prototype.find to filter out falsy values", () => {
+    const arr = [0, null, undefined, false, "", "hello", 42]
+    expect(arr.find(isTruthy)).toBe("hello")
+  })
+})