@tim-code/my-util 0.0.7 → 0.0.9

package/package.json

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

package/src/time.js

@@ -5,15 +5,20 @@ import { mod } from "./math.js"
  * @param {Object} $1
  * @param {boolean=} $1.floorMinute If true, floors to the nearest minute. If false, floors to the nearest second.
  * @param {number=} $1.timestamp Unix timestamp to use instead of current time.
- * @returns {Object} { timestamp, date, time, minute, datetime }
+ * @param {string=} $1.timezone Timezone to use instead of Eastern time.
+ * @returns {Object} { timestamp, date, time, datetime }
  */
-export function getEasternTime({ floorMinute = false, timestamp = undefined } = {}) {
+export function getEasternTime({
+  floorMinute = false,
+  timestamp = undefined,
+  timezone = "America/New_York",
+} = {}) {
   if (!timestamp) {
     timestamp = new Date().getTime() / 1000
   }
   timestamp = floorMinute ? Math.floor(timestamp / 60) * 60 : Math.floor(timestamp)
   const string = new Date(timestamp * 1000).toLocaleString("en-US", {
-    timeZone: "America/New_York",
+    ...(timezone ? { timeZone: timezone } : {}),
     hour12: false,
     year: "numeric",
     month: "2-digit",
@@ -25,9 +30,19 @@ export function getEasternTime({ floorMinute = false, timestamp = undefined } =
   const [americanDate, time] = string.split(", ")
   const [month, day, year] = americanDate.split("/")
   const date = [year, month, day].join("-")
-  const minute = parseInt(time.split(":")[1], 10)
-  const datetime = `${date} ${time}`
-  return { timestamp, date, time, minute, datetime }
+  return { timestamp, date, time }
+}
+
+/**
+ * Gets various ways of representing the current time in local timezone. Floors to nearest second by default.
+ * @param {Object} $1
+ * @param {boolean=} $1.floorMinute If true, floors to the nearest minute. If false, floors to the nearest second.
+ * @param {number=} $1.timestamp Unix timestamp to use instead of current time.
+ * @param {string=} $1.timezone Timezone to use instead of local time.
+ * @returns {Object} { timestamp, date, time, minute, datetime }
+ */
+export function getTime({ floorMinute, timestamp, timezone = false }) {
+  return getEasternTime({ floorMinute, timestamp, timezone })
 }
 
 /**
@@ -79,7 +94,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 +124,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,15 +1,25 @@
 import { describe, expect, test } from "@jest/globals"
-import { addDays, addTime, getEasternTime, isDate, isTime, isUnixTimestamp } from "./time.js"
-
-// getEasternTime changed: removed "days" param, added "timestamp" param
+import {
+  addDays,
+  addTime,
+  getDateRange,
+  getEasternTime,
+  getTime,
+  isDate,
+  isTime,
+  isUnixTimestamp,
+} from "./time.js"
+
+// getEasternTime changed: now accepts a "timezone" param and no longer returns "minute" or "datetime"
 describe("getEasternTime", () => {
   test("returns correct structure and types", () => {
     const result = getEasternTime()
     expect(typeof result.timestamp).toBe("number")
     expect(typeof result.date).toBe("string")
     expect(typeof result.time).toBe("string")
-    expect(typeof result.minute).toBe("number")
-    expect(typeof result.datetime).toBe("string")
+    // minute and datetime are no longer returned
+    expect(result).not.toHaveProperty("minute")
+    expect(result).not.toHaveProperty("datetime")
   })
 
   test("floors to minute if floorMinute is true", () => {
@@ -38,7 +48,46 @@ describe("getEasternTime", () => {
     expect(def.date).toEqual(explicit.date)
     expect(def.time).toEqual(explicit.time)
     expect(def.timestamp).toEqual(explicit.timestamp)
-    expect(def.datetime).toEqual(explicit.datetime)
+  })
+
+  // New: test timezone override
+  test("respects timezone parameter", () => {
+    // 2024-06-01T12:34:56Z (UTC)
+    const ts = 1717245296
+    // New York (EDT, UTC-4)
+    const eastern = getEasternTime({ timestamp: ts, timezone: "America/New_York" })
+    // Los Angeles (PDT, UTC-7)
+    const pacific = getEasternTime({ timestamp: ts, timezone: "America/Los_Angeles" })
+    // UTC
+    const utc = getEasternTime({ timestamp: ts, timezone: "UTC" })
+    expect(eastern.time).not.toBe(pacific.time)
+    expect(eastern.time).not.toBe(utc.time)
+    expect(pacific.time).not.toBe(utc.time)
+    // Should match expected hour offset
+    expect(eastern.time.startsWith("08:34")).toBe(true) // EDT
+    expect(pacific.time.startsWith("05:34")).toBe(true) // PDT
+    expect(utc.time.startsWith("12:34")).toBe(true) // UTC
+  })
+
+  test("returns local time if timezone is empty string", () => {
+    // If timezone is falsy (""), should use local time zone
+    // We'll compare to Date.toLocaleString with no timeZone option
+    const ts = 1717245296
+    const local = getEasternTime({ timestamp: ts, timezone: "" })
+    const expected = new Date(ts * 1000).toLocaleString("en-US", {
+      hour12: false,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+    })
+    const [, time] = expected.split(", ")
+    const [month, day, year] = expected.split(", ")[0].split("/")
+    const date = [year, month, day].join("-")
+    expect(local.date).toBe(date)
+    expect(local.time).toBe(time)
   })
 
   // DST boundary tests
@@ -81,6 +130,53 @@ describe("getEasternTime", () => {
   })
 })
 
+// New tests for getTime (newly exported function)
+describe("getTime", () => {
+  test("returns same structure as getEasternTime", () => {
+    const result = getTime({})
+    expect(typeof result.timestamp).toBe("number")
+    expect(typeof result.date).toBe("string")
+    expect(typeof result.time).toBe("string")
+    expect(result).not.toHaveProperty("minute")
+    expect(result).not.toHaveProperty("datetime")
+  })
+
+  test("defaults to local time if timezone is not provided", () => {
+    // getTime({}) should use timezone = false, which disables the timeZone option and uses local
+    const ts = 1717245296
+    const local = getTime({ timestamp: ts })
+    const expected = new Date(ts * 1000).toLocaleString("en-US", {
+      hour12: false,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+    })
+    const [, time] = expected.split(", ")
+    const [month, day, year] = expected.split(", ")[0].split("/")
+    const date = [year, month, day].join("-")
+    expect(local.date).toBe(date)
+    expect(local.time).toBe(time)
+  })
+
+  test("passes timezone through to getEasternTime", () => {
+    // Should match getEasternTime with same timezone
+    const ts = 1717245296
+    const pacific = getTime({ timestamp: ts, timezone: "America/Los_Angeles" })
+    const ref = getEasternTime({ timestamp: ts, timezone: "America/Los_Angeles" })
+    expect(pacific).toEqual(ref)
+  })
+
+  test("floors to minute if floorMinute is true", () => {
+    const ts = 1717245296
+    const floored = getTime({ timestamp: ts, floorMinute: true })
+    expect(floored.timestamp % 60).toBe(0)
+    expect(floored.time.endsWith(":00")).toBe(true)
+  })
+})
+
 describe("isDate", () => {
   test("returns true for valid YYYY-MM-DD dates", () => {
     expect(isDate("2024-06-01")).toBe(true)
@@ -212,6 +308,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 +366,47 @@ describe("addDays", () => {
     expect(addDays("2024-11-03", -1)).toBe("2024-11-02")
   })
 })
+
+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([])
+  })
+})