@tim-code/my-util 0.1.0 → 0.1.2

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.1.0",
+  "version": "0.1.2",
   "description": "",
   "type": "module",
   "author": "",

package/src/array.js

@@ -28,28 +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
-}
-
-/**
- * Creates a function that accesses an object's value at key.
- * @param {string} key
- * @returns {any}
- */
-export function via(key) {
-  return (object) => object[key]
-}
-
 // sorts undefined and null to the end if applicable
 function compareUndefinedNull(a, b) {
   if (b === undefined || b === null) {

package/src/array.test.js

@@ -2,9 +2,7 @@
 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", () => {
@@ -73,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]
@@ -258,32 +220,6 @@ 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")
-  })
-
-  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("findClosest", () => {
   it("returns the closest value by absolute difference (default comparator)", () => {
     expect(findClosest([1, 5, 10], 6)).toBe(5)

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 like(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 { deleteUndefinedValues, like, 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 = like(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 = like(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 = like(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 = like({})
+    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 = like(template)
+    expect(fn({ x: 5, y: 10 })).toBe(true)
+  })
+
+  it("uses strict equality (===) for comparison", () => {
+    const template = { a: 0 }
+    const fn = like(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 = like(template)
+    const proto = { foo: 1 }
+    const obj = Object.create(proto)
+    expect(fn(obj)).toBe(true)
+    obj.foo = 2
+    expect(fn(obj)).toBe(false)
+  })
+})