@naturalcycles/js-lib 14.232.0 → 14.233.0

package/dist-esm/datetime/localTime.js

@@ -1,6 +1,6 @@
 import { _assert } from '../error/assert';
 import { _ms } from '../time/time.util';
-import { LocalDate } from './localDate';
+import { localDate } from './localDate';
 export var ISODayOfWeek;
 (function (ISODayOfWeek) {
     ISODayOfWeek[ISODayOfWeek["MONDAY"] = 1] = "MONDAY";
@@ -17,104 +17,19 @@ const SECONDS_IN_DAY = 86400;
 // const MILLISECONDS_IN_DAY = 86400000
 // const MILLISECONDS_IN_MINUTE = 60000
 const VALID_DAYS_OF_WEEK = new Set([1, 2, 3, 4, 5, 6, 7]);
-/**
- * @experimental
- */
 export class LocalTime {
     constructor($date) {
         this.$date = $date;
     }
     /**
-     * Parses input String into LocalDate.
-     * Input can already be a LocalDate - it is returned as-is in that case.
-     */
-    static of(d) {
-        const t = this.parseOrNull(d);
-        _assert(t !== null, `Cannot parse "${d}" into LocalTime`, {
-            input: d,
-        });
-        return t;
-    }
-    /**
-     * Create LocalTime from unixTimestamp in milliseconds (not in seconds).
-     */
-    static ofMillis(millis) {
-        return LocalTime.of(new Date(millis));
-    }
-    /**
-     * Returns null if invalid
-     */
-    static parseOrNull(d) {
-        if (!d)
-            return null;
-        if (d instanceof LocalTime)
-            return d;
-        let date;
-        if (d instanceof Date) {
-            date = d;
-        }
-        else if (typeof d === 'number') {
-            date = new Date(d * 1000);
-        }
-        else if (typeof d !== 'string') {
-            // unexpected type, e.g Function or something
-            return null;
-        }
-        else {
-            // Slicing removes the "timezone component", and makes the date "local"
-            // e.g 2022-04-06T23:15:00+09:00
-            // becomes 2022-04-06T23:15:00
-            date = new Date(d.slice(0, 19));
-            // We used to slice to remove the timezone information, now we don't
-            // date = new Date(d)
-        }
-        // validation
-        if (isNaN(date.getDate())) {
-            // throw new TypeError(`Cannot parse "${d}" into LocalTime`)
-            return null;
-        }
-        return new LocalTime(date);
-    }
-    static parseToDate(d) {
-        if (d instanceof LocalTime)
-            return d.$date;
-        if (d instanceof Date)
-            return d;
-        const date = typeof d === 'number' ? new Date(d * 1000) : new Date(d);
-        _assert(!isNaN(date.getDate()), `Cannot parse "${d}" to Date`, {
-            input: d,
-        });
-        return date;
-    }
-    static parseToUnixTimestamp(d) {
-        if (typeof d === 'number')
-            return d;
-        if (d instanceof LocalTime)
-            return d.unix();
-        const date = d instanceof Date ? d : new Date(d);
-        _assert(!isNaN(date.getDate()), `Cannot parse "${d}" to UnixTimestamp`, {
-            input: d,
-        });
-        return date.valueOf() / 1000;
-    }
-    static isValid(d) {
-        return this.parseOrNull(d) !== null;
-    }
-    static now() {
-        return new LocalTime(new Date());
-    }
-    static fromComponents(c) {
-        return new LocalTime(new Date(c.year, c.month - 1, c.day || 1, c.hour || 0, c.minute || 0, c.second || 0));
-    }
-    /**
-     * Returns LocalTime that is based on the same unixtimestamp, but in UTC timezone.
+     * Returns [cloned] LocalTime that is based on the same unixtimestamp, but in UTC timezone.
      * Opposite of `.local()` method.
      */
     utc() {
         return new LocalTime(new Date(this.$date.toISOString()));
     }
     /**
-     * Returns LocalTime that is based on the same unixtimestamp, but in local timezone.
+     * Returns [cloned] LocalTime that is based on the same unixtimestamp, but in local timezone.
      * Opposite of `.utc()` method.
      */
     local() {
@@ -221,7 +136,7 @@ export class LocalTime {
         }
         if (unit === 'year' || unit === 'month') {
             const d = addMonths(this.$date, unit === 'month' ? num : num * 12, mutate);
-            return mutate ? this : LocalTime.of(d);
+            return mutate ? this : localTime.of(d);
         }
         return this.set(unit, this.get(unit) + num, mutate);
     }
@@ -232,16 +147,16 @@ export class LocalTime {
         return Math.abs(this.diff(other, unit));
     }
     diff(other, unit) {
-        const date2 = LocalTime.parseToDate(other);
+        const date2 = localTime.parseToDate(other);
         const secDiff = (this.$date.valueOf() - date2.valueOf()) / 1000;
         if (!secDiff)
             return 0;
         let r;
         if (unit === 'year') {
-            r = differenceInMonths(this.getDate(), date2) / 12;
+            r = differenceInMonths(this.$date, date2) / 12;
         }
         else if (unit === 'month') {
-            r = differenceInMonths(this.getDate(), date2);
+            r = differenceInMonths(this.$date, date2);
         }
         else if (unit === 'day') {
             r = secDiff / SECONDS_IN_DAY;
@@ -308,7 +223,7 @@ export class LocalTime {
                     }
                     else {
                         // year or month
-                        const lastDay = LocalDate.getMonthLength(d.getFullYear(), d.getMonth() + 1);
+                        const lastDay = localDate.getMonthLength(d.getFullYear(), d.getMonth() + 1);
                         d.setDate(lastDay);
                     }
                 }
@@ -321,35 +236,7 @@ export class LocalTime {
      * E.g 31 for January.
      */
     daysInMonth() {
-        return LocalDate.getMonthLength(this.$date.getFullYear(), this.$date.getMonth() + 1);
-    }
-    static sort(items, mutate = false, dir = 'asc') {
-        const mod = dir === 'desc' ? -1 : 1;
-        return (mutate ? items : [...items]).sort((a, b) => {
-            const v1 = a.$date.valueOf();
-            const v2 = b.$date.valueOf();
-            if (v1 === v2)
-                return 0;
-            return (v1 < v2 ? -1 : 1) * mod;
-        });
-    }
-    static earliestOrUndefined(items) {
-        return items.length ? LocalTime.earliest(items) : undefined;
-    }
-    static earliest(items) {
-        _assert(items.length, 'LocalTime.earliest called on empty array');
-        return items
-            .map(i => LocalTime.of(i))
-            .reduce((min, item) => (min.isSameOrBefore(item) ? min : item));
-    }
-    static latestOrUndefined(items) {
-        return items.length ? LocalTime.latest(items) : undefined;
-    }
-    static latest(items) {
-        _assert(items.length, 'LocalTime.latest called on empty array');
-        return items
-            .map(i => LocalTime.of(i))
-            .reduce((max, item) => (max.isSameOrAfter(item) ? max : item));
+        return localDate.getMonthLength(this.$date.getFullYear(), this.$date.getMonth() + 1);
     }
     isSame(d) {
         return this.cmp(d) === 0;
@@ -388,13 +275,13 @@ export class LocalTime {
      * Third argument allows to override "now".
      */
     isOlderThan(n, unit, now) {
-        return this.isBefore(LocalTime.of(now !== null && now !== void 0 ? now : new Date()).plus(-n, unit));
+        return this.isBefore(localTime.of(now !== null && now !== void 0 ? now : new Date()).plus(-n, unit));
     }
     /**
      * Checks if this localTime is same or older (<=) than "now" by X units.
      */
     isSameOrOlderThan(n, unit, now) {
-        return this.isSameOrBefore(LocalTime.of(now !== null && now !== void 0 ? now : new Date()).plus(-n, unit));
+        return this.isSameOrBefore(localTime.of(now !== null && now !== void 0 ? now : new Date()).plus(-n, unit));
     }
     /**
      * Checks if this localTime is younger (>) than "now" by X units.
@@ -406,13 +293,13 @@ export class LocalTime {
      * Third argument allows to override "now".
      */
     isYoungerThan(n, unit, now) {
-        return this.isAfter(LocalTime.of(now !== null && now !== void 0 ? now : new Date()).plus(-n, unit));
+        return this.isAfter(localTime.of(now !== null && now !== void 0 ? now : new Date()).plus(-n, unit));
     }
     /**
      * Checks if this localTime is same or younger (>=) than "now" by X units.
      */
     isSameOrYoungerThan(n, unit, now) {
-        return this.isSameOrAfter(LocalTime.of(now !== null && now !== void 0 ? now : new Date()).plus(-n, unit));
+        return this.isSameOrAfter(localTime.of(now !== null && now !== void 0 ? now : new Date()).plus(-n, unit));
     }
     /**
      * Returns 1 if this > d
@@ -421,20 +308,13 @@ export class LocalTime {
      */
     cmp(d) {
         const t1 = this.$date.valueOf();
-        const t2 = LocalTime.parseToDate(d).valueOf();
+        const t2 = localTime.parseToDate(d).valueOf();
         if (t1 === t2)
             return 0;
         return t1 < t2 ? -1 : 1;
     }
     components() {
-        return {
-            year: this.$date.getFullYear(),
-            month: this.$date.getMonth() + 1,
-            day: this.$date.getDate(),
-            hour: this.$date.getHours(),
-            minute: this.$date.getMinutes(),
-            second: this.$date.getSeconds(),
-        };
+        return Object.assign(Object.assign({}, this.dateComponents()), this.timeComponents());
     }
     dateComponents() {
         return {
@@ -451,7 +331,7 @@ export class LocalTime {
         };
     }
     fromNow(now = new Date()) {
-        const msDiff = LocalTime.parseToDate(now).valueOf() - this.$date.valueOf();
+        const msDiff = localTime.parseToDate(now).valueOf() - this.$date.valueOf();
         if (msDiff === 0)
             return 'now';
         if (msDiff >= 0) {
@@ -475,7 +355,7 @@ export class LocalTime {
         return Math.floor(this.$date.valueOf() / 1000);
     }
     toLocalDate() {
-        return LocalDate.fromDate(this.$date);
+        return localDate.fromDate(this.$date);
     }
     /**
      * Returns e.g: `1984-06-21 17:56:21`
@@ -555,60 +435,131 @@ export class LocalTime {
         return fmt(this);
     }
 }
-/**
- * Shortcut wrapper around `LocalTime.of`
- */
-export function localTime(d) {
-    return LocalTime.of(d);
-}
-/**
- * Shortcut wrapper around `LocalTime.now`
- */
-export function localTimeNow() {
-    return LocalTime.now();
-}
-/**
- * Creates a LocalTime from the input, unless it's falsy - then returns undefined.
- *
- * `localTime` function will instead return LocalTime of `now` for falsy input.
- */
-export function localTimeOrUndefined(d) {
-    return d ? LocalTime.of(d) : undefined;
-}
-/**
- * Creates a LocalTime from the input, unless it's falsy - then returns LocalTime.now
- */
-export function localTimeOrNow(d) {
-    return d ? LocalTime.of(d) : LocalTime.now();
-}
-/**
- Convenience function to return current Unix timestamp in seconds.
- Like Date.now(), but in seconds.
- */
-export function nowUnix() {
-    return Math.floor(Date.now() / 1000);
-}
-/**
- * UTC offset is the opposite of "timezone offset" - it's the number of minutes to add
- * to the local time to get UTC time.
- *
- * E.g utcOffset for CEST is -120,
- * which means that you need to add -120 minutes to the local time to get UTC time.
- *
- * Instead of -0 it returns 0, for the peace of mind and less weird test/snapshot differences.
- */
-export function getUTCOffsetMinutes() {
-    return -new Date().getTimezoneOffset() || 0;
-}
-/**
- * Same as getUTCOffsetMinutes, but rounded to hours.
- *
- * E.g for CEST it is -2.
- *
- * Instead of -0 it returns 0, for the peace of mind and less weird test/snapshot differences.
- */
-export function getUTCOffsetHours() {
-    return Math.round(getUTCOffsetMinutes() / 60);
+class LocalTimeFactory {
+    /**
+     * Parses input String into LocalDate.
+     * Input can already be a LocalDate - it is returned as-is in that case.
+     */
+    of(d) {
+        const t = this.parseOrNull(d);
+        _assert(t !== null, `Cannot parse "${d}" into LocalTime`, {
+            input: d,
+        });
+        return t;
+    }
+    /**
+     * Create LocalTime from unixTimestamp in milliseconds (not in seconds).
+     */
+    ofMillis(millis) {
+        return this.of(new Date(millis));
+    }
+    /**
+     * Returns null if invalid
+     */
+    parseOrNull(d) {
+        if (!d)
+            return null;
+        if (d instanceof LocalTime)
+            return d;
+        let date;
+        if (d instanceof Date) {
+            date = d;
+        }
+        else if (typeof d === 'number') {
+            date = new Date(d * 1000);
+        }
+        else if (typeof d !== 'string') {
+            // unexpected type, e.g Function or something
+            return null;
+        }
+        else {
+            // Slicing removes the "timezone component", and makes the date "local"
+            // e.g 2022-04-06T23:15:00+09:00
+            // becomes 2022-04-06T23:15:00
+            date = new Date(d.slice(0, 19));
+            // We used to slice to remove the timezone information, now we don't
+            // date = new Date(d)
+        }
+        // validation
+        if (isNaN(date.getDate())) {
+            // throw new TypeError(`Cannot parse "${d}" into LocalTime`)
+            return null;
+        }
+        return new LocalTime(date);
+    }
+    parseToDate(d) {
+        if (d instanceof LocalTime)
+            return d.$date;
+        if (d instanceof Date)
+            return d;
+        const date = typeof d === 'number' ? new Date(d * 1000) : new Date(d);
+        _assert(!isNaN(date.getDate()), `Cannot parse "${d}" to Date`, {
+            input: d,
+        });
+        return date;
+    }
+    parseToUnixTimestamp(d) {
+        if (typeof d === 'number')
+            return d;
+        if (d instanceof LocalTime)
+            return d.unix();
+        const date = d instanceof Date ? d : new Date(d);
+        _assert(!isNaN(date.getDate()), `Cannot parse "${d}" to UnixTimestamp`, {
+            input: d,
+        });
+        return date.valueOf() / 1000;
+    }
+    isValid(d) {
+        return this.parseOrNull(d) !== null;
+    }
+    now() {
+        return new LocalTime(new Date());
+    }
+    /**
+     * Creates a LocalTime from the input, unless it's falsy - then returns undefined.
+     *
+     * `localTime` function will instead return LocalTime of `now` for falsy input.
+     */
+    orUndefined(d) {
+        return d ? this.of(d) : undefined;
+    }
+    /**
+     * Creates a LocalTime from the input, unless it's falsy - then returns LocalTime.now
+     */
+    orNow(d) {
+        return d ? this.of(d) : this.now();
+    }
+    fromComponents(c) {
+        return new LocalTime(new Date(c.year, c.month - 1, c.day || 1, c.hour || 0, c.minute || 0, c.second || 0));
+    }
+    sort(items, dir = 'asc', mutate = false) {
+        const mod = dir === 'desc' ? -1 : 1;
+        return (mutate ? items : [...items]).sort((a, b) => {
+            const v1 = a.$date.valueOf();
+            const v2 = b.$date.valueOf();
+            if (v1 === v2)
+                return 0;
+            return (v1 < v2 ? -1 : 1) * mod;
+        });
+    }
+    minOrUndefined(items) {
+        return items.length ? this.min(items) : undefined;
+    }
+    min(items) {
+        _assert(items.length, 'localTime.min called on empty array');
+        return items
+            .map(i => this.of(i))
+            .reduce((min, item) => (min.$date.valueOf() <= item.$date.valueOf() ? min : item));
+    }
+    maxOrUndefined(items) {
+        return items.length ? this.max(items) : undefined;
+    }
+    max(items) {
+        _assert(items.length, 'localTime.max called on empty array');
+        return items
+            .map(i => this.of(i))
+            .reduce((max, item) => (max.$date.valueOf() >= item.$date.valueOf() ? max : item));
+    }
 }
 // based on: https://github.com/date-fns/date-fns/blob/master/src/getISOWeek/index.ts
 function getWeek(date) {
@@ -683,7 +634,7 @@ function addMonths(d, num, mutate = false) {
         year--;
         month += 12;
     }
-    const monthLen = LocalDate.getMonthLength(year, month);
+    const monthLen = localDate.getMonthLength(year, month);
     if (day > monthLen)
         day = monthLen;
     d.setFullYear(year, month - 1, day);
@@ -698,3 +649,37 @@ function differenceInMonths(a, b) {
     const anchor2 = addMonths(a, wholeMonthDiff + sign).getTime();
     return -(wholeMonthDiff + ((b.getTime() - anchor) / (anchor2 - anchor)) * sign);
 }
+const localTimeFactory = new LocalTimeFactory();
+export const localTime = localTimeFactory.of.bind(localTimeFactory);
+// The line below is the blackest of black magic I have ever written in 2024.
+// And probably 2023 as well.
+Object.setPrototypeOf(localTime, localTimeFactory);
+/**
+ Convenience function to return current Unix timestamp in seconds.
+ Like Date.now(), but in seconds.
+ */
+export function nowUnix() {
+    return Math.floor(Date.now() / 1000);
+}
+/**
+ * UTC offset is the opposite of "timezone offset" - it's the number of minutes to add
+ * to the local time to get UTC time.
+ *
+ * E.g utcOffset for CEST is -120,
+ * which means that you need to add -120 minutes to the local time to get UTC time.
+ *
+ * Instead of -0 it returns 0, for the peace of mind and less weird test/snapshot differences.
+ */
+export function getUTCOffsetMinutes() {
+    return -new Date().getTimezoneOffset() || 0;
+}
+/**
+ * Same as getUTCOffsetMinutes, but rounded to hours.
+ *
+ * E.g for CEST it is -2.
+ *
+ * Instead of -0 it returns 0, for the peace of mind and less weird test/snapshot differences.
+ */
+export function getUTCOffsetHours() {
+    return Math.round(getUTCOffsetMinutes() / 60);
+}

package/dist-esm/datetime/timeInterval.js

@@ -1,4 +1,4 @@
-import { LocalTime } from './localTime';
+import { localTime } from './localTime';
 /**
  * Class that supports an "interval of time" between 2 timestamps - start and end.
  * Example: `1649267185/1649267187`.
@@ -11,7 +11,7 @@ export class TimeInterval {
         this.$end = $end;
     }
     static of(start, end) {
-        return new TimeInterval(LocalTime.parseToUnixTimestamp(start), LocalTime.parseToUnixTimestamp(end));
+        return new TimeInterval(localTime.parseToUnixTimestamp(start), localTime.parseToUnixTimestamp(end));
     }
     get start() {
         return this.$start;
@@ -20,10 +20,10 @@ export class TimeInterval {
         return this.$end;
     }
     get startTime() {
-        return LocalTime.of(this.$start);
+        return localTime(this.$start);
     }
     get endTime() {
-        return LocalTime.of(this.$end);
+        return localTime(this.$end);
     }
     /**
      * Parses string like `1649267185/1649267187` into a TimeInterval.
@@ -55,7 +55,7 @@ export class TimeInterval {
         return this.cmp(d) >= 0;
     }
     includes(d, incl = '[)') {
-        d = LocalTime.parseToUnixTimestamp(d);
+        d = localTime.parseToUnixTimestamp(d);
         // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
         if (d < this.$start || (d === this.$start && incl[0] === '('))
             return false;

package/dist-esm/env/buildInfo.js

@@ -1,6 +1,6 @@
-import { localTimeNow } from '../datetime/localTime';
+import { localTime } from '../datetime/localTime';
 export function generateBuildInfoDev() {
-    const now = localTimeNow();
+    const now = localTime.now();
     const ts = now.unix();
     const rev = 'devRev';
     const branchName = 'devBranch';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.232.0",
+  "version": "14.233.0",
   "scripts": {
     "prepare": "husky",
     "build-prod": "build-prod-esm-cjs",
@@ -15,7 +15,7 @@
     "zod": "^3.20.2"
   },
   "devDependencies": {
-    "@naturalcycles/bench-lib": "^2.0.0",
+    "@naturalcycles/bench-lib": "^3.0.0",
     "@naturalcycles/dev-lib": "^13.0.1",
     "@naturalcycles/nodejs-lib": "^13.0.1",
     "@naturalcycles/time-lib": "^3.5.1",

package/src/datetime/dateInterval.ts

@@ -1,6 +1,5 @@
 import { Inclusiveness } from '../types'
-import type { LocalDateInput, LocalDateUnit } from './localDate'
-import { LocalDate, localDateRange } from './localDate'
+import { localDate, LocalDateInput, LocalDateUnit, LocalDate } from './localDate'
 
 export type DateIntervalConfig = DateInterval | DateIntervalString
 export type DateIntervalString = string
@@ -17,7 +16,7 @@ export class DateInterval {
   ) {}
 
   static of(start: LocalDateInput, end: LocalDateInput): DateInterval {
-    return new DateInterval(LocalDate.of(start), LocalDate.of(end))
+    return new DateInterval(localDate(start), localDate(end))
   }
 
   /**
@@ -32,7 +31,7 @@ export class DateInterval {
       throw new Error(`Cannot parse "${d}" into DateInterval`)
     }
 
-    return new DateInterval(LocalDate.of(start), LocalDate.of(end))
+    return new DateInterval(localDate(start), localDate(end))
   }
 
   isSame(d: DateIntervalConfig): boolean {
@@ -61,7 +60,7 @@ export class DateInterval {
    * Ranges of DateInterval (start, end) are INCLUSIVE.
    */
   includes(d: LocalDateInput, incl: Inclusiveness = '[]'): boolean {
-    d = LocalDate.of(d)
+    d = localDate(d)
     // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
     return d.isAfter(this.start, incl[0] === '[') && d.isBefore(this.end, incl[1] === ']')
   }
@@ -82,14 +81,14 @@ export class DateInterval {
   }
 
   getDays(incl: Inclusiveness = '[]'): LocalDate[] {
-    return localDateRange(this.start, this.end, incl, 1, 'day')
+    return localDate.range(this.start, this.end, incl, 1, 'day')
   }
 
   /**
    * Returns an array of LocalDates that are included in the interval.
    */
   range(incl: Inclusiveness = '[]', step = 1, stepUnit: LocalDateUnit = 'day'): LocalDate[] {
-    return localDateRange(this.start, this.end, incl, step, stepUnit)
+    return localDate.range(this.start, this.end, incl, step, stepUnit)
   }
 
   toString(): DateIntervalString {