@tim-code/my-util 0.0.24 → 0.1.1

package/README.md

@@ -2,8 +2,8 @@
 
 This library includes common util functions. It does not have any dependencies.
 
-This may include rewritten functionality from Lodash in the future (i.e. orderBy). groupBy should be available when using Node 22.
+In combination with Object.groupBy (available when using Node 22), this should be sufficient for replacing the most useful functionality from lodash.
 
 ## First Time Setup
 
-`npm install`
+`npm install @tim-code/my-util`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tim-code/my-util",
-  "version": "0.0.24",
+  "version": "0.1.1",
   "description": "",
   "type": "module",
   "author": "",
@@ -22,7 +22,7 @@
     ]
   },
   "devDependencies": {
-    "@tim-code/eslint-config": "^1.1.7",
+    "@tim-code/eslint-config": "^1.3.3",
     "@jest/globals": "^29.7.0",
     "jest": "^29.7.0"
   },

package/src/array.js

@@ -28,19 +28,6 @@ export function unique(array) {
   return [...new Set(array)]
 }
 
-/**
- * Mutates the passed in object by calling callback on each of its values.
- * @param {Object} object
- * @param {Function} callback (value, key, object) => newValue // note if not changing value, should return value
- * @returns {Object}
- */
-export function mutateValues(object, callback) {
-  for (const key in object) {
-    object[key] = callback(object[key], key, object)
-  }
-  return object
-}
-
 // sorts undefined and null to the end if applicable
 function compareUndefinedNull(a, b) {
   if (b === undefined || b === null) {
@@ -109,30 +96,139 @@ export function multilevel(...comparators) {
   }
 }
 
-/**
- * Creates a function that accesses an object's value at key.
- * @param {string} key
- * @returns {any}
- */
-export function via(key) {
-  return (object) => object[key]
+function findClosestAbs(array, value, { key, threshold = Infinity } = {}) {
+  let closest
+  if (key) {
+    for (const element of array) {
+      const _value = element[key]
+      const diff = Math.abs(_value - value)
+      if (diff < threshold) {
+        closest = element
+        threshold = diff
+      }
+    }
+  } else {
+    for (const _value of array) {
+      const diff = Math.abs(_value - value)
+      if (diff < threshold) {
+        closest = _value
+        threshold = diff
+      }
+    }
+  }
+  return closest
 }
 
-// export function contains(template) {
-//   return (object) => {
-//     for (const key in template) {
-//       if (object[key] !== template[key]) {
-//         return false
-//       }
-//     }
-//     return true
-//   }
-// }
+function findClosestLT(array, value, { key, threshold = -Infinity } = {}) {
+  let closest
+  if (key) {
+    for (const element of array) {
+      const _value = element[key]
+      if (_value < value && _value > threshold) {
+        closest = element
+        threshold = _value
+      }
+    }
+  } else {
+    for (const _value of array) {
+      if (_value < value && _value > threshold) {
+        closest = _value
+        threshold = _value
+      }
+    }
+  }
+  return closest
+}
 
-// not sure how far we want to go down "key" rabbit hole:
-// export function sum(array, key) {}
-// or maybe
-// export function add(key) {
-//  if(!key) return (acc, value) => acc + value
-//  return (acc, obj) => acc + obj[key]
-// }
+function findClosestLTE(array, value, { key, threshold = -Infinity } = {}) {
+  let closest
+  if (key) {
+    for (const element of array) {
+      const _value = element[key]
+      if (_value <= value && _value > threshold) {
+        closest = element
+        threshold = _value
+      }
+    }
+  } else {
+    for (const _value of array) {
+      if (_value <= value && _value > threshold) {
+        closest = _value
+        threshold = _value
+      }
+    }
+  }
+  return closest
+}
+
+function findClosestGT(array, value, { key, threshold = Infinity } = {}) {
+  let closest
+  if (key) {
+    for (const element of array) {
+      const _value = element[key]
+      if (_value > value && _value < threshold) {
+        closest = element
+        threshold = _value
+      }
+    }
+  } else {
+    for (const _value of array) {
+      if (_value > value && _value < threshold) {
+        closest = _value
+        threshold = _value
+      }
+    }
+  }
+  return closest
+}
+
+function findClosestGTE(array, value, { key, threshold = Infinity } = {}) {
+  let closest
+  if (key) {
+    for (const element of array) {
+      const _value = element[key]
+      if (_value >= value && _value < threshold) {
+        closest = element
+        threshold = _value
+      }
+    }
+  } else {
+    for (const _value of array) {
+      if (_value >= value && _value < threshold) {
+        closest = _value
+        threshold = _value
+      }
+    }
+  }
+  return closest
+}
+
+/**
+ * Find the closest element in an array.
+ * If using for strings, need to specify different values for "threshold" and "comparator".
+ * "~" and "" are good threshold string values for gt/gte and lt/lte respectively.
+ * @param {Array<T>} array
+ * @param {T} value
+ * @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=} options.comparator "abs", "lt", "lte", "gt", "gte", "abs". Default is "abs" which implies T is number.
+ * @param {T=} 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
+  switch (comparator) {
+    case "lt":
+      return findClosestLT(array, value, options)
+    case "lte":
+      return findClosestLTE(array, value, options)
+    case "gt":
+      return findClosestGT(array, value, options)
+    case "gte":
+      return findClosestGTE(array, value, options)
+    case "abs":
+      return findClosestAbs(array, value, options)
+    default:
+      throw new Error(`Unknown comparator: ${comparator}`)
+  }
+}

package/src/array.test.js

@@ -1,7 +1,8 @@
 /* eslint-disable no-restricted-syntax */
 import { describe, expect, it, jest } from "@jest/globals"
+import { findClosest } from "./array.js"
 
-const { chunk, unique, mutateValues, ascending, descending, multilevel, via } = await import("./array.js")
+const { chunk, unique, ascending, descending, multilevel } = await import("./array.js")
 
 describe("chunk", () => {
   it("splits array into chunks of specified size", () => {
@@ -70,42 +71,6 @@ describe("unique", () => {
   })
 })
 
-describe("mutateValues", () => {
-  it("mutates values in the object using the callback", () => {
-    const obj = { a: 1, b: 2 }
-    const result = mutateValues(obj, (v) => v * 2)
-    expect(result).toEqual({ a: 2, b: 4 })
-    expect(obj).toBe(result) // should mutate in place
-  })
-
-  it("callback receives value, key, and object", () => {
-    const obj = { x: 1 }
-    const cb = jest.fn((v) => v + 1)
-    mutateValues(obj, cb)
-    expect(cb).toHaveBeenCalledWith(1, "x", obj)
-  })
-
-  it("returns the same object reference", () => {
-    const obj = { foo: "bar" }
-    const returned = mutateValues(obj, (v) => v)
-    expect(returned).toBe(obj)
-  })
-
-  it("handles empty object", () => {
-    const obj = {}
-    expect(mutateValues(obj, (v) => v)).toEqual({})
-  })
-
-  it("mutates inherited enumerable properties", () => {
-    const proto = { inherited: 1 }
-    const obj = Object.create(proto)
-    obj.own = 2
-    const result = mutateValues(obj, (v) => v + 1)
-    expect(result.own).toBe(3)
-    expect(result.inherited).toBe(2)
-  })
-})
-
 describe("ascending", () => {
   it("sorts primitives ascending, undefined/null at end", () => {
     const arr = [undefined, null, 3, 1, 2]
@@ -231,9 +196,18 @@ describe("multilevel", () => {
 
   it("short-circuits after first non-zero comparator", () => {
     const calls = []
-    const cmp1 = jest.fn(() => { calls.push("cmp1"); return 0 })
-    const cmp2 = jest.fn(() => { calls.push("cmp2"); return -1 })
-    const cmp3 = jest.fn(() => { calls.push("cmp3"); return 1 })
+    const cmp1 = jest.fn(() => {
+      calls.push("cmp1")
+      return 0
+    })
+    const cmp2 = jest.fn(() => {
+      calls.push("cmp2")
+      return -1
+    })
+    const cmp3 = jest.fn(() => {
+      calls.push("cmp3")
+      return 1
+    })
     const cmp = multilevel(cmp1, cmp2, cmp3)
     expect(cmp({}, {})).toBe(-1)
     expect(calls).toEqual(["cmp1", "cmp2"])
@@ -246,28 +220,152 @@ describe("multilevel", () => {
   })
 })
 
-describe("via", () => {
-  it("returns a function that accesses the given key", () => {
-    const getFoo = via("foo")
-    expect(getFoo({ foo: 42 })).toBe(42)
-    expect(getFoo({ foo: "bar" })).toBe("bar")
+describe("findClosest", () => {
+  it("returns the closest value by absolute difference (default comparator)", () => {
+    expect(findClosest([1, 5, 10], 6)).toBe(5)
+    expect(findClosest([1, 5, 10], 8)).toBe(10)
+    expect(findClosest([1, 5, 10], 1)).toBe(1)
+  })
+
+  it("returns undefined if array is empty", () => {
+    expect(findClosest([], 10)).toBeUndefined()
+  })
+
+  it("returns the closest object by key (abs)", () => {
+    const arr = [{ v: 1 }, { v: 5 }, { v: 10 }]
+    expect(findClosest(arr, 6, { key: "v" })).toEqual({ v: 5 })
+  })
+
+  it("returns the closest value less than input (lt comparator)", () => {
+    expect(findClosest([1, 3, 5, 7], 6, { comparator: "lt" })).toBe(5)
+    expect(findClosest([1, 3, 5, 7], 1, { comparator: "lt" })).toBeUndefined()
+  })
+
+  it("returns the closest value less than or equal to input (lte comparator)", () => {
+    expect(findClosest([1, 3, 5, 7], 5, { comparator: "lte" })).toBe(5)
+    expect(findClosest([1, 3, 5, 7], 2, { comparator: "lte" })).toBe(1)
+    expect(findClosest([1, 3, 5, 7], 0, { comparator: "lte" })).toBeUndefined()
+  })
+
+  it("returns the closest value greater than input (gt comparator)", () => {
+    expect(findClosest([1, 3, 5, 7], 5, { comparator: "gt" })).toBe(7)
+    expect(findClosest([1, 3, 5, 7], 7, { comparator: "gt" })).toBeUndefined()
   })
 
-  it("returns undefined if the key does not exist", () => {
-    const getX = via("x")
-    expect(getX({})).toBeUndefined()
-    expect(getX({ y: 1 })).toBeUndefined()
+  it("returns the closest value greater than or equal to input (gte comparator)", () => {
+    expect(findClosest([1, 3, 5, 7], 5, { comparator: "gte" })).toBe(5)
+    expect(findClosest([1, 3, 5, 7], 6, { comparator: "gte" })).toBe(7)
+    expect(findClosest([1, 3, 5, 7], 8, { comparator: "gte" })).toBeUndefined()
   })
 
-  it("works with numeric keys", () => {
-    const get0 = via(0)
-    expect(get0([10, 20])).toBe(10)
-    expect(get0({ 0: "zero" })).toBe("zero")
+  it("returns the closest object by key for lt/lte/gt/gte", () => {
+    const arr = [{ v: 1 }, { v: 5 }, { v: 10 }]
+    expect(findClosest(arr, 6, { comparator: "lt", key: "v" })).toEqual({ v: 5 })
+    expect(findClosest(arr, 6, { comparator: "lte", key: "v" })).toEqual({ v: 5 })
+    expect(findClosest(arr, 6, { comparator: "gt", key: "v" })).toEqual({ v: 10 })
+    expect(findClosest(arr, 10, { comparator: "gte", key: "v" })).toEqual({ v: 10 })
+  })
+
+  it("respects the threshold option for abs comparator", () => {
+    expect(findClosest([1, 5, 10], 6, { threshold: 0.5 })).toBeUndefined()
+    expect(findClosest([1, 5, 10], 6, { threshold: 2 })).toBe(5)
+  })
+
+  it("respects the threshold option for lt/lte/gt/gte", () => {
+    expect(findClosest([1, 3, 5, 7], 6, { comparator: "lt", threshold: 4 })).toBe(5)
+    expect(findClosest([1, 3, 5, 7], 6, { comparator: "lt", threshold: 5 })).toBeUndefined()
+    expect(findClosest([1, 3, 5, 7], 6, { comparator: "gt", threshold: 7 })).toBeUndefined()
+    expect(findClosest([1, 3, 5, 7], 6, { comparator: "gt", threshold: 10 })).toBe(7)
+  })
+
+  it("throws for unknown comparator", () => {
+    expect(() => findClosest([1, 2, 3], 2, { comparator: "foo" })).toThrow(
+      "Unknown comparator: foo"
+    )
   })
 
-  it("returns undefined if object is missing", () => {
-    const getFoo = via("foo")
-    expect(() => getFoo(undefined)).toThrow(TypeError)
-    expect(() => getFoo(null)).toThrow(TypeError)
+  it("returns undefined if no element matches threshold/key criteria", () => {
+    expect(
+      findClosest([{ v: 1 }], 10, { comparator: "gt", key: "v", threshold: 1 })
+    ).toBeUndefined()
+    expect(
+      findClosest([{ v: 1 }], 0, { comparator: "lt", key: "v", threshold: 1 })
+    ).toBeUndefined()
+  })
+
+  it("works with negative numbers and zero", () => {
+    expect(findClosest([-10, -5, 0, 5, 10], -7)).toBe(-5)
+    expect(findClosest([-10, -5, 0, 5, 10], 0)).toBe(0)
+    expect(findClosest([-10, -5, 0, 5, 10], 7)).toBe(5)
+  })
+
+  it("skips NaN values in abs comparator", () => {
+    expect(findClosest([1, NaN, 5], 4)).toBe(5)
+  })
+
+  it("skips objects missing the key in key-based comparators", () => {
+    const arr = [{ v: 1 }, {}, { v: 5 }]
+    expect(findClosest(arr, 2, { key: "v" })).toEqual({ v: 1 })
+  })
+
+  it("finds the closest string using abs comparator and a custom threshold/comparator", () => {
+    // Since abs comparator expects numbers, we need to provide a custom comparator for strings.
+    // We'll use threshold and comparator: "lt", "lte", "gt", "gte" for string comparisons.
+    const arr = ["apple", "banana", "cherry", "date"]
+    // Find the closest string less than "carrot" (alphabetically)
+    expect(findClosest(arr, "carrot", { comparator: "lt", threshold: "" })).toBe("banana")
+    // Find the closest string less than or equal to "banana"
+    expect(findClosest(arr, "banana", { comparator: "lte", threshold: "" })).toBe("banana")
+    // Find the closest string greater than "carrot"
+    expect(findClosest(arr, "carrot", { comparator: "gt", threshold: "~" })).toBe("cherry")
+    // Find the closest string greater than or equal to "date"
+    expect(findClosest(arr, "date", { comparator: "gte", threshold: "~" })).toBe("date")
+    // If nothing matches, returns undefined
+    expect(findClosest(arr, "aardvark", { comparator: "lt", threshold: "" })).toBeUndefined()
+    expect(findClosest(arr, "zebra", { comparator: "gt", threshold: "~" })).toBeUndefined()
+  })
+
+  it("finds the closest string by key in array of objects", () => {
+    const arr = [{ name: "apple" }, { name: "banana" }, { name: "cherry" }]
+    expect(
+      findClosest(arr, "blueberry", { comparator: "lt", key: "name", threshold: "" })
+    ).toEqual({
+      name: "banana",
+    })
+    expect(
+      findClosest(arr, "banana", { comparator: "lte", key: "name", threshold: "" })
+    ).toEqual({
+      name: "banana",
+    })
+    expect(
+      findClosest(arr, "banana", { comparator: "gt", key: "name", threshold: "~" })
+    ).toEqual({
+      name: "cherry",
+    })
+    expect(
+      findClosest(arr, "cherry", { comparator: "gte", key: "name", threshold: "~" })
+    ).toEqual({
+      name: "cherry",
+    })
+    expect(
+      findClosest(arr, "aardvark", { comparator: "lt", key: "name", threshold: "" })
+    ).toBeUndefined()
+  })
+
+  it("returns undefined if no string matches threshold/key criteria", () => {
+    const arr = ["apple", "banana", "cherry"]
+    expect(findClosest(arr, "apple", { comparator: "lt", threshold: "" })).toBeUndefined()
+    expect(findClosest(arr, "cherry", { comparator: "gt" })).toBeUndefined()
+  })
+
+  it("can use abs comparator with string lengths", () => {
+    // This is a reasonable use-case for abs: find string with length closest to 4
+    const arr = ["a", "bb", "ccc", "dddd", "eeeee"]
+    // Map to string lengths using key
+    expect(findClosest(arr, 4, { comparator: "abs", key: "length" })).toEqual("dddd")
+    // If threshold is set so no string length is close enough
+    expect(
+      findClosest(arr, 4, { comparator: "abs", key: "length", threshold: -1 })
+    ).toBeUndefined()
   })
 })

package/src/index.js

@@ -1,4 +1,5 @@
 export * from "./array.js"
 export * from "./math.js"
+export * from "./object.js"
 export * from "./promise.js"
 export * from "./time.js"

package/src/math.js

@@ -9,6 +9,20 @@ export function mod(number, modulus) {
   return ((number % modulus) + modulus) % modulus
 }
 
+/**
+ * Given two points, returns a function
+ * This function, given an "x" value, returns a "y" value that is on the same line as the first two points.
+ * @param {[number, number]} firstPoint
+ * @param {[number, number]} secondPoint
+ * @returns {Function}
+ */
+export function line([x1, y1], [x2, y2]) {
+  const m = (y2 - y1) / (x2 - x1)
+  // m * x1 + b = y1
+  const b = y1 - m * x1
+  return (x) => m * x + b
+}
+
 /**
  * Prepend a plus to a number or string if positive.
  * @param {number|string} number Or string

package/src/math.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "@jest/globals"
-const { mod, formatPlus } = await import("./math.js")
+const { mod, formatPlus, line } = await import("./math.js")
 
 describe("mod", () => {
   it("returns n when n is less than m and n is non-negative", () => {
@@ -58,6 +58,52 @@ describe("mod", () => {
   })
 })
 
+describe("line", () => {
+  it("returns a function that produces y for given x on the line through two points", () => {
+    const f = line([0, 0], [1, 1])
+    expect(f(0)).toBe(0)
+    expect(f(1)).toBe(1)
+    expect(f(2)).toBe(2)
+    expect(f(-1)).toBe(-1)
+  })
+
+  it("handles non-origin, non-unit slope", () => {
+    const f = line([1, 2], [3, 6]) // slope 2, intercept 0
+    expect(f(1)).toBe(2)
+    expect(f(2)).toBe(4)
+    expect(f(3)).toBe(6)
+    expect(f(0)).toBe(0)
+  })
+
+  it("handles negative slope", () => {
+    const f = line([0, 0], [2, -2]) // slope -1
+    expect(f(1)).toBe(-1)
+    expect(f(2)).toBe(-2)
+    expect(f(-2)).toBe(2)
+  })
+
+  it("handles horizontal line", () => {
+    const f = line([1, 5], [3, 5]) // slope 0
+    expect(f(0)).toBe(5)
+    expect(f(100)).toBe(5)
+    expect(f(-100)).toBe(5)
+  })
+
+  it("handles vertical line by returning NaN", () => {
+    const f = line([2, 1], [2, 5])
+    expect(f(2)).toBeNaN()
+    expect(f(3)).toBeNaN()
+    expect(f(1)).toBeNaN()
+  })
+
+  it("works with negative coordinates", () => {
+    const f = line([-1, -2], [1, 2]) // slope 2
+    expect(f(-1)).toBe(-2)
+    expect(f(0)).toBe(0)
+    expect(f(1)).toBe(2)
+  })
+})
+
 describe("formatPlus", () => {
   it("prepends a plus for positive numbers", () => {
     expect(formatPlus(1)).toBe("+1")

package/src/object.js

@@ -0,0 +1,57 @@
+/**
+ * Mutates the passed in object by calling callback on each of its values.
+ * @param {Object} object
+ * @param {Function} callback (value, key, object) => newValue // note if not changing value, should return value
+ * @returns {Object}
+ */
+export function mutateValues(object, callback) {
+  const keys = Object.keys(object)
+  for (const key of keys) {
+    object[key] = callback(object[key], key, object)
+  }
+  return object
+}
+
+/**
+ * Mutates the passed object by removing any keys (`key in object`) that have a value of undefined.
+ * This is useful when the presence of a key alone causes something else to happen, but an undefined value is unexpected.
+ * In general, having objects with undefined values should not be encouraged but can happen as a byproduct of a code flow.
+ * @param {Object} object
+ * @returns {Object}
+ */
+export function deleteUndefinedValues(object) {
+  const keys = Object.keys(object)
+  for (const key of keys) {
+    if (key in object && object[key] === undefined) {
+      delete object[key]
+    }
+  }
+  return object
+}
+
+/**
+ * Creates a function that accesses an object's value at key.
+ * @param {string} key
+ * @returns {Function}
+ */
+export function via(key) {
+  return (object) => object[key]
+}
+
+/**
+ * Creates a function that checks if the passed object contains the initial template.
+ * This means for each key in the template, the passed object has the same (===) value.
+ * @param {Object} template
+ * @returns {Function}
+ */
+export function contains(template) {
+  const keys = Object.keys(template)
+  return (object) => {
+    for (const key of keys) {
+      if (object[key] !== template[key]) {
+        return false
+      }
+    }
+    return true
+  }
+}

package/src/object.test.js

@@ -0,0 +1,161 @@
+/* eslint-disable no-restricted-syntax */
+import { jest } from "@jest/globals"
+import { contains, deleteUndefinedValues, mutateValues, via } from "./object.js"
+
+describe("mutateValues", () => {
+  it("mutates values in the object using the callback", () => {
+    const obj = { a: 1, b: 2 }
+    const result = mutateValues(obj, (v) => v * 2)
+    expect(result).toEqual({ a: 2, b: 4 })
+    expect(obj).toBe(result) // should mutate in place
+  })
+
+  it("callback receives value, key, and object", () => {
+    const obj = { x: 1 }
+    const cb = jest.fn((v) => v + 1)
+    mutateValues(obj, cb)
+    expect(cb).toHaveBeenCalledWith(1, "x", obj)
+  })
+
+  it("returns the same object reference", () => {
+    const obj = { foo: "bar" }
+    const returned = mutateValues(obj, (v) => v)
+    expect(returned).toBe(obj)
+  })
+
+  it("handles empty object", () => {
+    const obj = {}
+    expect(mutateValues(obj, (v) => v)).toEqual({})
+  })
+
+  it("does not mutate inherited enumerable properties", () => {
+    const proto = { inherited: 1 }
+    const obj = Object.create(proto)
+    obj.own = 2
+    const result = mutateValues(obj, (v) => v + 1)
+    expect(result.own).toBe(3)
+    expect(result.inherited).toBe(1)
+  })
+})
+
+describe("deleteUndefinedValues", () => {
+  it("removes keys with undefined values", () => {
+    const obj = { a: 1, b: undefined, c: 3 }
+    const result = deleteUndefinedValues(obj)
+    expect(result).toEqual({ a: 1, c: 3 })
+    expect(obj).toBe(result)
+    expect("b" in result).toBe(false)
+  })
+
+  it("does not remove keys with null or falsy non-undefined values", () => {
+    const obj = { a: null, b: 0, c: false, d: "", e: undefined }
+    deleteUndefinedValues(obj)
+    expect(obj).toEqual({ a: null, b: 0, c: false, d: "" })
+  })
+
+  it("does nothing if no undefined values are present", () => {
+    const obj = { a: 1, b: 2 }
+    const result = deleteUndefinedValues(obj)
+    expect(result).toEqual({ a: 1, b: 2 })
+  })
+
+  it("handles empty object", () => {
+    const obj = {}
+    expect(deleteUndefinedValues(obj)).toEqual({})
+  })
+
+  it("removes own properties set to undefined but not inherited ones", () => {
+    const proto = { inherited: undefined }
+    const obj = Object.create(proto)
+    obj.own = undefined
+    deleteUndefinedValues(obj)
+    expect("own" in obj).toBe(false)
+    // inherited property remains accessible via prototype
+    expect(obj.inherited).toBeUndefined()
+    // but is not an own property
+    expect(Object.hasOwn(obj, "inherited")).toBe(false)
+  })
+})
+
+describe("via", () => {
+  it("returns a function that accesses the given key", () => {
+    const getFoo = via("foo")
+    expect(getFoo({ foo: 42 })).toBe(42)
+    expect(getFoo({ foo: "bar" })).toBe("bar")
+  })
+
+  it("returns undefined if the key does not exist", () => {
+    const getX = via("x")
+    expect(getX({})).toBeUndefined()
+    expect(getX({ y: 1 })).toBeUndefined()
+  })
+
+  it("works with numeric keys", () => {
+    const get0 = via(0)
+    expect(get0([10, 20])).toBe(10)
+    expect(get0({ 0: "zero" })).toBe("zero")
+  })
+
+  it("returns undefined if object is missing", () => {
+    const getFoo = via("foo")
+    expect(() => getFoo(undefined)).toThrow(TypeError)
+    expect(() => getFoo(null)).toThrow(TypeError)
+  })
+})
+
+describe("contains", () => {
+  it("returns true when object contains all template keys with same values", () => {
+    const template = { a: 1, b: 2 }
+    const fn = contains(template)
+    expect(fn({ a: 1, b: 2, c: 3 })).toBe(true)
+    expect(fn({ a: 1, b: 2 })).toBe(true)
+  })
+
+  it("returns false if any template key is missing", () => {
+    const template = { a: 1, b: 2 }
+    const fn = contains(template)
+    expect(fn({ a: 1 })).toBe(false)
+    expect(fn({ b: 2 })).toBe(false)
+    expect(fn({})).toBe(false)
+  })
+
+  it("returns false if any template key has a different value", () => {
+    const template = { a: 1, b: 2 }
+    const fn = contains(template)
+    expect(fn({ a: 1, b: 3 })).toBe(false)
+    expect(fn({ a: 2, b: 2 })).toBe(false)
+    expect(fn({ a: 2, b: 3 })).toBe(false)
+  })
+
+  it("works with empty template (always true)", () => {
+    const fn = contains({})
+    expect(fn({})).toBe(true)
+    expect(fn({ a: 1 })).toBe(true)
+    expect(fn({ a: undefined })).toBe(true)
+  })
+
+  it("does not require object to have only template keys", () => {
+    const template = { x: 5 }
+    const fn = contains(template)
+    expect(fn({ x: 5, y: 10 })).toBe(true)
+  })
+
+  it("uses strict equality (===) for comparison", () => {
+    const template = { a: 0 }
+    const fn = contains(template)
+    expect(fn({ a: false })).toBe(false)
+    expect(fn({ a: "0" })).toBe(false)
+    expect(fn({ a: 0 })).toBe(true)
+  })
+
+  // ISSUE: contains() does not check for own properties only; it will match inherited properties.
+  it("matches inherited properties in the object", () => {
+    const template = { foo: 1 }
+    const fn = contains(template)
+    const proto = { foo: 1 }
+    const obj = Object.create(proto)
+    expect(fn(obj)).toBe(true)
+    obj.foo = 2
+    expect(fn(obj)).toBe(false)
+  })
+})