@naturalcycles/js-lib 15.84.0 → 15.84.1

package/dist/datetime/localTime.js

@@ -1,5 +1,6 @@
 import { comparators } from '../array/sort.js';
 import { _assert } from '../error/assert.js';
+import { Intl2 } from '../intl/intl.js';
 import { localDate } from './localDate.js';
 import { _ms } from './time.util.js';
 // oxlint-disable-next-line import/no-cycle -- intentional cycle
@@ -69,15 +70,7 @@ export class LocalTime {
      * @experimental
      */
     inTimezone(tz) {
-        const d = new Date(this.$date.toLocaleString('en-US', { timeZone: tz }));
-        return new WallTime({
-            year: d.getFullYear(),
-            month: d.getMonth() + 1,
-            day: d.getDate(),
-            hour: d.getHours(),
-            minute: d.getMinutes(),
-            second: d.getSeconds(),
-        });
+        return new WallTime(getWallComponentsInTimezone(this.$date, tz));
     }
     /**
      * UTC offset is the opposite of "timezone offset" - it's the number of minutes to add
@@ -96,8 +89,13 @@ export class LocalTime {
     getUTCOffsetMinutes(tz) {
         if (tz) {
             // based on: https://stackoverflow.com/a/53652131/4919972
+            // The wall clock in `tz` is interpreted as UTC (not as host-local time, like the
+            // stackoverflow answer does): `wall = utc + offset`, so `offset = Date.UTC(wall) - now`.
+            // This makes the result independent of the host timezone (the host-local interpretation
+            // returned offsets relative to the host, and was distorted by the host's DST gaps).
             const nowTime = this.$date.getTime();
-            const tzTime = new Date(this.$date.toLocaleString('en-US', { timeZone: tz })).getTime();
+            const { year, month, day, hour, minute, second } = getWallComponentsInTimezone(this.$date, tz);
+            const tzTime = Date.UTC(year, month - 1, day, hour, minute, second);
             return Math.round((tzTime - nowTime) / 60000) || 0;
         }
         return -this.$date.getTimezoneOffset() || 0;
@@ -120,10 +118,12 @@ export class LocalTime {
      */
     getUTCOffsetString(tz) {
         const minutes = this.getUTCOffsetMinutes(tz);
-        const hours = Math.trunc(minutes / 60);
-        const sign = hours < 0 ? '-' : '+';
-        const h = String(Math.abs(hours)).padStart(2, '0');
-        const m = String(minutes % 60).padStart(2, '0');
+        // Sign is taken from minutes (not truncated hours), and minutes are abs-ed,
+        // so negative fractional offsets like Newfoundland -03:30 don't render as `-03:-30`
+        const sign = minutes < 0 ? '-' : '+';
+        const absMinutes = Math.abs(minutes);
+        const h = String(Math.trunc(absMinutes / 60)).padStart(2, '0');
+        const m = String(absMinutes % 60).padStart(2, '0');
         return `${sign}${h}:${m}`;
     }
     get(unit) {
@@ -995,6 +995,36 @@ function differenceInMonths(a, b) {
     const anchor2 = addMonths(a, wholeMonthDiff + sign).getTime();
     return -(wholeMonthDiff + ((b.getTime() - anchor) / (anchor2 - anchor)) * sign);
 }
+const dateTimeObjectKeys = new Set([
+    'year',
+    'month',
+    'day',
+    'hour',
+    'minute',
+    'second',
+]);
+// Intl.DateTimeFormat construction is expensive (~30µs), while a cached formatter
+// (via Intl2) converts in ~3µs. Unlike `date.toLocaleString(...)` + `new Date(string)`
+// round-trip, formatToParts is also immune to the host timezone's DST gaps.
+function getWallComponentsInTimezone(date, tz) {
+    const fmt = Intl2.DateTimeFormat('en-US', {
+        timeZone: tz,
+        year: 'numeric',
+        month: 'numeric',
+        day: 'numeric',
+        hour: 'numeric',
+        minute: 'numeric',
+        second: 'numeric',
+        hourCycle: 'h23',
+    });
+    const dto = {};
+    for (const { type, value } of fmt.formatToParts(date)) {
+        if (dateTimeObjectKeys.has(type)) {
+            dto[type] = Number(value);
+        }
+    }
+    return dto;
+}
 const localTimeFactory = new LocalTimeFactory();
 export const localTime = localTimeFactory.fromInput.bind(localTimeFactory);
 // The line below is the blackest of black magic I have ever written in 2024.

package/dist/promise/pGradualQueue.js

@@ -110,6 +110,7 @@ function runSafe(fn) {
     }
     catch (err) {
         // Handle synchronous throws
+        // oxlint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
         return Promise.reject(err);
     }
 }

package/dist/promise/pQueue.js

@@ -107,6 +107,7 @@ function runSafe(fn) {
     }
     catch (err) {
         // Handle synchronous throws - ensure inFlight is decremented
+        // oxlint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
         return Promise.reject(err);
     }
 }

package/dist/promise/pTimeout.js

@@ -59,6 +59,7 @@ export async function pTimeout(fn, opt) {
             resolve(await fn(signal));
         }
         catch (err) {
+            // oxlint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
             reject(err);
         }
         finally {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/js-lib",
   "type": "module",
-  "version": "15.84.0",
+  "version": "15.84.1",
   "dependencies": {
     "tslib": "^2"
   },
@@ -14,11 +14,9 @@
     }
   },
   "devDependencies": {
-    "@types/crypto-js": "^4",
     "@types/node": "^26",
     "@types/semver": "^7",
     "typescript": "^7",
-    "crypto-js": "^4",
     "dayjs": "^1",
     "@naturalcycles/dev-lib": "0.0.0"
   },

package/src/datetime/localTime.ts

@@ -1,5 +1,6 @@
 import { comparators } from '../array/sort.js'
 import { _assert } from '../error/assert.js'
+import { Intl2 } from '../intl/intl.js'
 import type {
   IANATimezone,
   Inclusiveness,
@@ -108,15 +109,7 @@ export class LocalTime {
    * @experimental
    */
   inTimezone(tz: IANATimezone): WallTime {
-    const d = new Date(this.$date.toLocaleString('en-US', { timeZone: tz }))
-    return new WallTime({
-      year: d.getFullYear(),
-      month: d.getMonth() + 1,
-      day: d.getDate(),
-      hour: d.getHours(),
-      minute: d.getMinutes(),
-      second: d.getSeconds(),
-    })
+    return new WallTime(getWallComponentsInTimezone(this.$date, tz))
   }
 
   /**
@@ -136,8 +129,13 @@ export class LocalTime {
   getUTCOffsetMinutes(tz?: IANATimezone): NumberOfMinutes {
     if (tz) {
       // based on: https://stackoverflow.com/a/53652131/4919972
+      // The wall clock in `tz` is interpreted as UTC (not as host-local time, like the
+      // stackoverflow answer does): `wall = utc + offset`, so `offset = Date.UTC(wall) - now`.
+      // This makes the result independent of the host timezone (the host-local interpretation
+      // returned offsets relative to the host, and was distorted by the host's DST gaps).
       const nowTime = this.$date.getTime()
-      const tzTime = new Date(this.$date.toLocaleString('en-US', { timeZone: tz })).getTime()
+      const { year, month, day, hour, minute, second } = getWallComponentsInTimezone(this.$date, tz)
+      const tzTime = Date.UTC(year, month - 1, day, hour, minute, second)
       return Math.round((tzTime - nowTime) / 60000) || 0
     }
 
@@ -163,10 +161,12 @@ export class LocalTime {
    */
   getUTCOffsetString(tz: IANATimezone): string {
     const minutes = this.getUTCOffsetMinutes(tz)
-    const hours = Math.trunc(minutes / 60)
-    const sign = hours < 0 ? '-' : '+'
-    const h = String(Math.abs(hours)).padStart(2, '0')
-    const m = String(minutes % 60).padStart(2, '0')
+    // Sign is taken from minutes (not truncated hours), and minutes are abs-ed,
+    // so negative fractional offsets like Newfoundland -03:30 don't render as `-03:-30`
+    const sign = minutes < 0 ? '-' : '+'
+    const absMinutes = Math.abs(minutes)
+    const h = String(Math.trunc(absMinutes / 60)).padStart(2, '0')
+    const m = String(absMinutes % 60).padStart(2, '0')
     return `${sign}${h}:${m}`
   }
 
@@ -1165,6 +1165,41 @@ function differenceInMonths(a: Date, b: Date): number {
   return -(wholeMonthDiff + ((b.getTime() - anchor) / (anchor2 - anchor)) * sign)
 }
 
+const dateTimeObjectKeys = new Set<keyof DateTimeObject>([
+  'year',
+  'month',
+  'day',
+  'hour',
+  'minute',
+  'second',
+])
+
+// Intl.DateTimeFormat construction is expensive (~30µs), while a cached formatter
+// (via Intl2) converts in ~3µs. Unlike `date.toLocaleString(...)` + `new Date(string)`
+// round-trip, formatToParts is also immune to the host timezone's DST gaps.
+function getWallComponentsInTimezone(date: Date, tz: IANATimezone): DateTimeObject {
+  const fmt = Intl2.DateTimeFormat('en-US', {
+    timeZone: tz,
+    year: 'numeric',
+    month: 'numeric',
+    day: 'numeric',
+    hour: 'numeric',
+    minute: 'numeric',
+    second: 'numeric',
+    hourCycle: 'h23',
+  })
+
+  const dto = {} as DateTimeObject
+
+  for (const { type, value } of fmt.formatToParts(date)) {
+    if (dateTimeObjectKeys.has(type as keyof DateTimeObject)) {
+      dto[type as keyof DateTimeObject] = Number(value)
+    }
+  }
+
+  return dto
+}
+
 interface LocalTimeFn extends LocalTimeFactory {
   (d: LocalTimeInput): LocalTime
 }

package/src/promise/pGradualQueue.ts

@@ -159,7 +159,8 @@ function runSafe<R>(fn: AsyncFunction<R>): Promise<R> {
     return fn()
   } catch (err) {
     // Handle synchronous throws
-    return Promise.reject(err as Error)
+    // oxlint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+    return Promise.reject(err)
   }
 }
 

package/src/promise/pQueue.ts

@@ -150,7 +150,8 @@ function runSafe<R>(fn: AsyncFunction<R>): Promise<R> {
     return fn()
   } catch (err) {
     // Handle synchronous throws - ensure inFlight is decremented
-    return Promise.reject(err as Error)
+    // oxlint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+    return Promise.reject(err)
   }
 }
 

package/src/promise/pTimeout.ts

@@ -108,7 +108,8 @@ export async function pTimeout<T>(
     try {
       resolve(await fn(signal))
     } catch (err) {
-      reject(err as Error)
+      // oxlint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+      reject(err)
     } finally {
       clearTimeout(timer)
     }

package/src/typeFest.ts

@@ -57,9 +57,9 @@ export type Except<ObjectType, KeysType extends keyof ObjectType> = {
  * When you use a type that will iterate through an object that has indexed keys and explicitly defined keys you end up with a type where only the indexed keys are kept. This is because `keyof` of an indexed type always returns `string | number | symbol`, because every key is possible in that object. With this type, you can save the indexed keys and reinject them later, like in the second example below.
  */
 export type PickIndexSignature<ObjectType> = {
-  [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
-    ? KeyType
-    : never]: ObjectType[KeyType]
+  [
+    KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never
+  ]: ObjectType[KeyType]
 }
 
 /**
@@ -73,9 +73,9 @@ export type PickIndexSignature<ObjectType> = {
  * (The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
  */
 export type OmitIndexSignature<ObjectType> = {
-  [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
-    ? never
-    : KeyType]: ObjectType[KeyType]
+  [
+    KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType
+  ]: ObjectType[KeyType]
 }
 
 /**