@tim-code/my-util 0.7.1 → 0.7.3

package/package.json

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

package/src/promise.js

@@ -109,11 +109,11 @@ export async function allSettled(
     await limiter?.(elements.length)
   }
   if (throws && errors.length) {
-    const string = errors.map((error) => error.message ?? error).join("; ")
+    const string = errors.map((error) => error?.message ?? error).join("; ")
     const resultError = new PromiseAllError(string)
-    const { trace } = errors.find((error) => Array.isArray(error.trace)) ?? {}
-    if (trace) {
-      resultError.stack = trace.join("\n")
+    const { stack } = errors.find((error) => error?.stack) ?? {}
+    if (stack) {
+      resultError.stack = stack
     }
     throw resultError
   }

package/src/promise.test.js

@@ -2,7 +2,7 @@
 import { jest } from "@jest/globals"
 
 // Exported API under test:
-// - class PollError
+// - classes: PollError, PromiseAllError
 // - functions: poll, sleep, allSettled, allPatiently, intervalLimiter, alert, throwFirstReject
 
 import {
@@ -12,6 +12,7 @@ import {
   intervalLimiter,
   poll,
   PollError,
+  PromiseAllError,
   sleep,
   throwFirstReject,
 } from "./promise.js"
@@ -240,13 +241,12 @@ describe("allSettled", () => {
     expect(result.results.every((r) => r.status === "fulfilled")).toBe(true)
   })
 
-  it("throws joined error message when throws=true and adopts trace stack if provided", async () => {
-    const eWithTrace = new Error("e1")
-    eWithTrace.trace = ["trace line 1", "trace line 2"]
+  it("throws joined error message when throws=true and adopts stack from first error", async () => {
+    const e1 = new Error("e1")
     const e2 = new Error("third")
     const arr = [1, 2, 3]
     const cb = (x) => {
-      if (x === 1) return Promise.reject(eWithTrace)
+      if (x === 1) return Promise.reject(e1)
       if (x === 2) return x // fulfilled
       return Promise.reject(e2)
     }
@@ -256,9 +256,9 @@ describe("allSettled", () => {
     } catch (e) {
       thrown = e
     }
-    expect(thrown).toBeInstanceOf(Error)
+    expect(thrown).toBeInstanceOf(PromiseAllError)
     expect(thrown.message).toBe("e1; third")
-    expect(thrown.stack).toBe("trace line 1\ntrace line 2")
+    expect(thrown.stack).toBe(e1.stack)
   })
 })
 

package/src/time.js

@@ -44,6 +44,16 @@ export function getTime({ floorMinute, timestamp, timeZone = false } = {}) {
   return getEasternTime({ floorMinute, timestamp, timeZone })
 }
 
+/**
+ * Get Unix timestamp for a UTC date string.
+ * @param {string} utc UTC date time: "YYYY-MM-DDTHH:mm:ssZ" or with UTC offset
+ * @returns {number} Seconds since epoch
+ */
+export function getUnixTimestamp(utc) {
+  const timestamp = Math.floor(new Date(utc).getTime() / 1000)
+  return timestamp
+}
+
 /**
  * Get today's date in YYYY-MM-DD format using local time.
  * @returns {string}
@@ -96,15 +106,6 @@ export function isDateString(string) {
   )
 }
 
-/**
- * @deprecated Prefer isDateString()
- * @param {string} string
- * @returns {boolean}
- */
-export function isDate(string) {
-  return isDateString(string)
-}
-
 /**
  * Checks if the string represent a valid HH:mm:ss time.
  * @param {string} string
@@ -114,15 +115,6 @@ export function isTimeString(string) {
   return /^([01]\d|2[0-3]):[0-5]\d:[0-5]\d$/u.test(string)
 }
 
-/**
- * @deprecated Prefer isTimeString()
- * @param {string} string
- * @returns {boolean}
- */
-export function isTime(string) {
-  return isTimeString(string)
-}
-
 /**
  * Checks if a number is a Unix timestamp (i.e. in seconds).
  * Would not validate timestamps set very far into the future.

package/src/time.test.js

@@ -9,9 +9,8 @@ import {
   getStartOfWeek,
   getTime,
   getTimeRange,
-  isDate,
+  getUnixTimestamp,
   isDateString,
-  isTime,
   isTimeString,
   isUnixTimestamp,
   today,
@@ -178,6 +177,26 @@ describe("getTime", () => {
   })
 })
 
+describe("getUnixTimestamp", () => {
+  test("parses Zulu (UTC) timestamp", () => {
+    expect(getUnixTimestamp("2024-06-01T12:34:56Z")).toBe(1717245296)
+  })
+
+  test("parses timestamp with positive offset", () => {
+    const expected = Date.UTC(2024, 5, 1, 10, 34, 56) / 1000 // 12:34:56+02:00 == 10:34:56Z
+    expect(getUnixTimestamp("2024-06-01T12:34:56+02:00")).toBe(expected)
+  })
+
+  test("floors fractional seconds", () => {
+    // 999ms floors down to the same second
+    expect(getUnixTimestamp("1970-01-01T00:00:00.999Z")).toBe(0)
+  })
+
+  test("returns NaN for invalid date string", () => {
+    expect(Number.isNaN(getUnixTimestamp("not-a-date"))).toBe(true)
+  })
+})
+
 describe("today", () => {
   test("returns today's date in YYYY-MM-DD format", () => {
     const expected = getTime().date
@@ -247,38 +266,6 @@ describe("isDateString", () => {
   })
 })
 
-describe("isDate (deprecated wrapper)", () => {
-  test("returns true for valid YYYY-MM-DD dates", () => {
-    expect(isDate("2024-06-01")).toBe(true)
-    expect(isDate("1999-12-31")).toBe(true)
-  })
-
-  test("returns false for invalid dates (e.g., 2024-02-31)", () => {
-    expect(isDate("2024-02-31")).toBe(false)
-    expect(isDate("2023-04-31")).toBe(false)
-  })
-
-  test("returns false for invalid formats", () => {
-    expect(isDate("2024/06/01")).toBe(false)
-    expect(isDate("06-01-2024")).toBe(false)
-    expect(isDate("2024-6-1")).toBe(false)
-    expect(isDate("20240601")).toBe(false)
-    expect(isDate("abcd-ef-gh")).toBe(false)
-  })
-
-  test("returns false for impossible months and days", () => {
-    expect(isDate("2024-00-10")).toBe(false)
-    expect(isDate("2024-13-10")).toBe(false)
-    expect(isDate("2024-01-00")).toBe(false)
-    expect(isDate("2024-01-32")).toBe(false)
-  })
-
-  test("returns true for leap day", () => {
-    expect(isDate("2024-02-29")).toBe(true)
-    expect(isDate("2023-02-29")).toBe(false)
-  })
-})
-
 describe("isTimeString", () => {
   test("validates correct times", () => {
     expect(isTimeString("00:00:00")).toBe(true)
@@ -291,26 +278,6 @@ describe("isTimeString", () => {
   })
 })
 
-describe("isTime (deprecated wrapper)", () => {
-  test("returns true for valid HH:mm:ss times", () => {
-    expect(isTime("00:00:00")).toBe(true)
-    expect(isTime("23:59:59")).toBe(true)
-    expect(isTime("12:34:56")).toBe(true)
-  })
-
-  test("returns false for invalid times", () => {
-    expect(isTime("24:00:00")).toBe(false)
-    expect(isTime("12:60:00")).toBe(false)
-    expect(isTime("12:00:60")).toBe(false)
-    expect(isTime("1:00:00")).toBe(false)
-    expect(isTime("12:0:00")).toBe(false)
-    expect(isTime("12:00:0")).toBe(false)
-    expect(isTime("12:00")).toBe(false)
-    expect(isTime("120000")).toBe(false)
-    expect(isTime("ab:cd:ef")).toBe(false)
-  })
-})
-
 describe("isUnixTimestamp", () => {
   test("returns true for valid unix timestamps in seconds", () => {
     expect(isUnixTimestamp(0)).toBe(true)
@@ -428,6 +395,14 @@ describe("getTimeRange", () => {
   test("handles input with no seconds", () => {
     expect(getTimeRange("12:00", "12:02")).toEqual(["12:00:00", "12:01:00", "12:02:00"])
   })
+
+  // ISSUE: getTimeRange allows a zero step, which would otherwise loop forever; it's capped internally at 1440 iterations.
+  test("caps the number of results at MINUTES_IN_DAY when step is zero", () => {
+    const result = getTimeRange("12:00:00", "12:00:00", { hours: 0, minutes: 0 })
+    expect(result.length).toBe(24 * 60)
+    expect(result[0]).toBe("12:00:00")
+    expect(result[result.length - 1]).toBe("12:00:00")
+  })
 })
 
 describe("addDays", () => {