@tim-code/my-util 0.0.6 → 0.0.8

package/package.json

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

package/src/array.js

@@ -92,6 +92,23 @@ export function descending(key) {
   }
 }
 
+/**
+ * Combines multiple ascending and descending comparators.
+ * @param  {...Function} comparators
+ * @returns {Function}
+ */
+export function multilevel(...comparators) {
+  return (a, b) => {
+    for (const comparator of comparators) {
+      const result = comparator(a, b)
+      if (result) {
+        return result
+      }
+    }
+    return 0
+  }
+}
+
 /**
  * Creates a function that accesses an object's value at key.
  * @param {string} key

package/src/array.test.js

@@ -1,7 +1,7 @@
 /* eslint-disable no-restricted-syntax */
 import { describe, expect, it, jest } from "@jest/globals"
 
-const { chunk, unique, mutateValues, ascending, descending, via } = await import("./array.js")
+const { chunk, unique, mutateValues, ascending, descending, multilevel, via } = await import("./array.js")
 
 describe("chunk", () => {
   it("splits array into chunks of specified size", () => {
@@ -188,6 +188,64 @@ describe("descending", () => {
   })
 })
 
+describe("multilevel", () => {
+  it("returns 0 if all comparators return 0", () => {
+    const cmp = multilevel(
+      () => 0,
+      () => 0
+    )
+    expect(cmp(1, 2)).toBe(0)
+    expect(cmp("a", "b")).toBe(0)
+  })
+
+  it("returns first non-zero comparator result", () => {
+    const cmp = multilevel(
+      () => 0,
+      () => -1,
+      () => 1
+    )
+    expect(cmp(1, 2)).toBe(-1)
+    const cmp2 = multilevel(
+      () => 0,
+      () => 0,
+      () => 1
+    )
+    expect(cmp2(1, 2)).toBe(1)
+  })
+
+  it("works with ascending and descending comparators", () => {
+    const arr = [
+      { a: 1, b: 2 },
+      { a: 2, b: 1 },
+      { a: 1, b: 1 },
+      { a: 2, b: 2 },
+    ]
+    arr.sort(multilevel(ascending("a"), descending("b")))
+    expect(arr).toEqual([
+      { a: 1, b: 2 },
+      { a: 1, b: 1 },
+      { a: 2, b: 2 },
+      { a: 2, b: 1 },
+    ])
+  })
+
+  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 cmp = multilevel(cmp1, cmp2, cmp3)
+    expect(cmp({}, {})).toBe(-1)
+    expect(calls).toEqual(["cmp1", "cmp2"])
+  })
+
+  it("returns 0 if no comparators are provided", () => {
+    const cmp = multilevel()
+    expect(cmp(1, 2)).toBe(0)
+    expect(cmp("a", "b")).toBe(0)
+  })
+})
+
 describe("via", () => {
   it("returns a function that accesses the given key", () => {
     const getFoo = via("foo")

package/src/time.js

@@ -79,7 +79,7 @@ export function isUnixTimestamp(ts, { max = 9999999999 } = {}) {
  * @param {number} $1.minutes Minutes to add to time string
  * @returns {string} HH:mm:ss
  */
-export function addTime(timeString, { minutes = 0, hours = 0 }) {
+export function addTime(timeString, { minutes = 0, hours = 0 } = {}) {
   let [hour, minute, second = 0] = timeString.split(":").map(Number)
   hour = mod(hour + hours, 24)
   minute += minutes
@@ -109,3 +109,21 @@ export function addDays(dateString, days = 0) {
   date.setUTCDate(date.getUTCDate() + days)
   return date.toISOString().slice(0, 10)
 }
+
+/**
+ * Get all dates between two dates, with limit.
+ * @param {string} start
+ * @param {string} end
+ * @returns {Array}
+ */
+export function getDateRange(start, end, { limit = 1000 } = {}) {
+  const dates = []
+  while (start <= end) {
+    dates.push(start)
+    start = addDays(start, 1)
+    if (dates.length >= limit) {
+      break
+    }
+  }
+  return dates
+}

package/src/time.test.js

@@ -1,5 +1,13 @@
 import { describe, expect, test } from "@jest/globals"
-import { addDays, addTime, getEasternTime, isDate, isTime, isUnixTimestamp } from "./time.js"
+import {
+  addDays,
+  addTime,
+  getDateRange,
+  getEasternTime,
+  isDate,
+  isTime,
+  isUnixTimestamp,
+} from "./time.js"
 
 // getEasternTime changed: removed "days" param, added "timestamp" param
 describe("getEasternTime", () => {
@@ -212,6 +220,12 @@ describe("addTime", () => {
   test("handles midnight", () => {
     expect(addTime("00:00:00", { hours: 0, minutes: 0 })).toBe("00:00:00")
   })
+
+  // New: test default parameters (no options argument)
+  test("handles missing options argument (all defaults)", () => {
+    expect(addTime("12:34:56")).toBe("12:34:56")
+    expect(addTime("05:10")).toBe("05:10:00")
+  })
 })
 
 describe("addDays", () => {
@@ -264,3 +278,48 @@ describe("addDays", () => {
     expect(addDays("2024-11-03", -1)).toBe("2024-11-02")
   })
 })
+
+// New tests for getDateRange (newly exported function)
+describe("getDateRange", () => {
+  test("returns all dates between start and end inclusive", () => {
+    expect(getDateRange("2024-06-01", "2024-06-03")).toEqual([
+      "2024-06-01",
+      "2024-06-02",
+      "2024-06-03",
+    ])
+  })
+
+  test("returns just the start date if start equals end", () => {
+    expect(getDateRange("2024-06-01", "2024-06-01")).toEqual(["2024-06-01"])
+  })
+
+  test("returns empty array if start > end", () => {
+    expect(getDateRange("2024-06-03", "2024-06-01")).toEqual([])
+  })
+
+  test("respects limit option", () => {
+    expect(getDateRange("2024-06-01", "2024-06-10", { limit: 3 })).toEqual([
+      "2024-06-01",
+      "2024-06-02",
+      "2024-06-03",
+    ])
+  })
+
+  test("returns at most 1000 dates by default", () => {
+    const dates = getDateRange("2020-01-01", "2025-01-01")
+    expect(dates.length).toBeLessThanOrEqual(1000)
+    expect(dates[0]).toBe("2020-01-01")
+  })
+
+  test("can return more than 1000 dates if limit is raised", () => {
+    const dates = getDateRange("2020-01-01", "2025-01-01", { limit: 2000 })
+    expect(dates.length).toBeGreaterThan(1000)
+    expect(dates[0]).toBe("2020-01-01")
+    expect(dates[dates.length - 1]).toBe("2025-01-01")
+  })
+
+  // ISSUE: getDateRange does not validate that start/end are valid dates, so invalid input may yield unexpected results.
+  test("handles invalid date input (returns empty array if start > end lexically)", () => {
+    expect(getDateRange("not-a-date", "2024-01-01")).toEqual([])
+  })
+})