@naturalcycles/js-lib 14.96.0 → 14.97.1

package/dist/datetime/dateInterval.d.ts

@@ -1,5 +1,5 @@
-import { LocalDate, LocalDateConfig } from './localDate';
-export declare type DateIntervalConfig = DateInterval | string;
+import { Inclusiveness, LocalDate, LocalDateConfig, LocalDateUnit } from './localDate';
+export declare type DateIntervalConfig = DateInterval | DateIntervalString;
 export declare type DateIntervalString = string;
 /**
  * Class that supports ISO8601 "Time interval" standard that looks like `2022-02-24/2022-03-30`.
@@ -16,24 +16,25 @@ export declare class DateInterval {
      */
     static parse(d: DateIntervalConfig): DateInterval;
     isSame(d: DateIntervalConfig): boolean;
-    isBefore(d: DateIntervalConfig): boolean;
+    isBefore(d: DateIntervalConfig, inclusive?: boolean): boolean;
     isSameOrBefore(d: DateIntervalConfig): boolean;
-    isAfter(d: DateIntervalConfig): boolean;
+    isAfter(d: DateIntervalConfig, inclusive?: boolean): boolean;
     isSameOrAfter(d: DateIntervalConfig): boolean;
     /**
      * Ranges of DateInterval (start, end) are INCLUSIVE.
      */
-    includes(d: LocalDateConfig): boolean;
+    includes(d: LocalDateConfig, incl?: Inclusiveness): boolean;
+    intersects(int: DateIntervalConfig, inclusive?: boolean): boolean;
     /**
      * DateIntervals compare by start date.
      * If it's the same - then by end date.
      */
     cmp(d: DateIntervalConfig): -1 | 0 | 1;
+    getDays(incl?: Inclusiveness): LocalDate[];
     /**
      * Returns an array of LocalDates that are included in the interval.
-     * Ranges are INCLUSIVE.
      */
-    getDays(): LocalDate[];
+    range(incl?: Inclusiveness, step?: number, stepUnit?: LocalDateUnit): LocalDate[];
     toString(): DateIntervalString;
     toJSON(): DateIntervalString;
 }

package/dist/datetime/dateInterval.js

@@ -30,14 +30,16 @@ class DateInterval {
     isSame(d) {
         return this.cmp(d) === 0;
     }
-    isBefore(d) {
-        return this.cmp(d) === -1;
+    isBefore(d, inclusive = false) {
+        const r = this.cmp(d);
+        return r === -1 || (r === 0 && inclusive);
     }
     isSameOrBefore(d) {
         return this.cmp(d) <= 0;
     }
-    isAfter(d) {
-        return this.cmp(d) === 1;
+    isAfter(d, inclusive = false) {
+        const r = this.cmp(d);
+        return r === 1 || (r === 0 && inclusive);
     }
     isSameOrAfter(d) {
         return this.cmp(d) >= 0;
@@ -45,9 +47,14 @@ class DateInterval {
     /**
      * Ranges of DateInterval (start, end) are INCLUSIVE.
      */
-    includes(d) {
+    includes(d, incl = '[]') {
         d = localDate_1.LocalDate.of(d);
-        return d.isSameOrAfter(this.start) && d.isSameOrBefore(this.end);
+        return d.isAfter(this.start, incl[0] === '[') && d.isBefore(this.end, incl[1] === ']');
+    }
+    intersects(int, inclusive = true) {
+        const $int = DateInterval.parse(int);
+        const incl = inclusive ? '[]' : '()';
+        return this.includes($int.start, incl) || this.includes($int.end, incl);
     }
     /**
      * DateIntervals compare by start date.
@@ -57,18 +64,14 @@ class DateInterval {
         d = DateInterval.parse(d);
         return this.start.cmp(d.start) || this.end.cmp(d.end);
     }
+    getDays(incl = '[]') {
+        return localDate_1.LocalDate.range(this.start, this.end, incl, 1, 'day');
+    }
     /**
      * Returns an array of LocalDates that are included in the interval.
-     * Ranges are INCLUSIVE.
      */
-    getDays() {
-        const days = [];
-        let current = this.start;
-        do {
-            days.push(current);
-            current = current.add(1, 'day');
-        } while (current.isSameOrBefore(this.end));
-        return days;
+    range(incl = '[]', step = 1, stepUnit = 'day') {
+        return localDate_1.LocalDate.range(this.start, this.end, incl, step, stepUnit);
     }
     toString() {
         return [this.start, this.end].join('/');

package/dist/datetime/localDate.d.ts

@@ -1,16 +1,15 @@
-import { Sequence } from '../seq/seq';
-import { IsoDate, UnixTimestamp } from '../types';
+import { IsoDateString, UnixTimestampNumber } from '../types';
 import { LocalTime } from './localTime';
 export declare type LocalDateUnit = 'year' | 'month' | 'day';
 export declare type Inclusiveness = '()' | '[]' | '[)' | '(]';
-export declare type LocalDateConfig = LocalDate | string;
+export declare type LocalDateConfig = LocalDate | IsoDateString;
 /**
  * @experimental
  */
 export declare class LocalDate {
-    year: number;
-    month: number;
-    day: number;
+    private $year;
+    private $month;
+    private $day;
     private constructor();
     static create(year: number, month: number, day: number): LocalDate;
     /**
@@ -33,15 +32,19 @@ export declare class LocalDate {
     static earliest(items: LocalDate[]): LocalDate;
     static latestOrUndefined(items: LocalDate[]): LocalDate | undefined;
     static latest(items: LocalDate[]): LocalDate;
-    static range(minIncl: LocalDateConfig, maxExcl: LocalDateConfig, step?: number, stepUnit?: LocalDateUnit): LocalDate[];
-    static rangeSeq(minIncl: LocalDateConfig, maxExcl: LocalDateConfig, step?: number, stepUnit?: LocalDateUnit): Sequence<LocalDate>;
-    static rangeString(minIncl: LocalDateConfig, maxExcl: LocalDateConfig, step?: number, stepUnit?: LocalDateUnit): IsoDate[];
-    static rangeIncl(minIncl: LocalDateConfig, maxIncl: LocalDateConfig, step?: number, stepUnit?: LocalDateUnit): LocalDate[];
-    static rangeInclString(minIncl: LocalDateConfig, maxIncl: LocalDateConfig, step?: number, stepUnit?: LocalDateUnit): IsoDate[];
+    static range(min: LocalDateConfig, max: LocalDateConfig, incl?: Inclusiveness, step?: number, stepUnit?: LocalDateUnit): LocalDate[];
+    get(unit: LocalDateUnit): number;
+    set(unit: LocalDateUnit, v: number, mutate?: boolean): LocalDate;
+    year(): number;
+    year(v: number): LocalDate;
+    month(): number;
+    month(v: number): LocalDate;
+    day(): number;
+    day(v: number): LocalDate;
     isSame(d: LocalDateConfig): boolean;
-    isBefore(d: LocalDateConfig): boolean;
+    isBefore(d: LocalDateConfig, inclusive?: boolean): boolean;
     isSameOrBefore(d: LocalDateConfig): boolean;
-    isAfter(d: LocalDateConfig): boolean;
+    isAfter(d: LocalDateConfig, inclusive?: boolean): boolean;
     isSameOrAfter(d: LocalDateConfig): boolean;
     isBetween(min: LocalDateConfig, max: LocalDateConfig, incl?: Inclusiveness): boolean;
     /**
@@ -76,12 +79,12 @@ export declare class LocalDate {
      */
     toDate(): Date;
     toLocalTime(): LocalTime;
-    toISODate(): IsoDate;
-    toString(): IsoDate;
+    toISODate(): IsoDateString;
+    toString(): IsoDateString;
     toStringCompact(): string;
-    unix(): UnixTimestamp;
+    unix(): UnixTimestampNumber;
     unixMillis(): number;
-    toJSON(): IsoDate;
+    toJSON(): IsoDateString;
 }
 /**
  * Shortcut wrapper around `LocalDate.parse` / `LocalDate.today`

package/dist/datetime/localDate.js

@@ -2,18 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.localDate = exports.LocalDate = void 0;
 const assert_1 = require("../error/assert");
-const seq_1 = require("../seq/seq");
-const types_1 = require("../types");
 const localTime_1 = require("./localTime");
-const m31 = new Set([1, 3, 5, 7, 8, 10, 12]);
+const MDAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const DATE_REGEX = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+/* eslint-disable no-dupe-class-members */
 /**
  * @experimental
  */
 class LocalDate {
-    constructor(year, month, day) {
-        this.year = year;
-        this.month = month;
-        this.day = day;
+    constructor($year, $month, $day) {
+        this.$year = $year;
+        this.$month = $month;
+        this.$day = $day;
     }
     static create(year, month, day) {
         return new LocalDate(year, month, day);
@@ -50,8 +50,13 @@ class LocalDate {
             return null;
         if (d instanceof LocalDate)
             return d;
-        // todo: explore more performant options
-        const [year, month, day] = d.slice(0, 10).split('-').map(Number);
+        // const [year, month, day] = d.slice(0, 10).split('-').map(Number)
+        const matches = DATE_REGEX.exec(d.slice(0, 10));
+        if (!matches)
+            return null;
+        const year = Number(matches[1]);
+        const month = Number(matches[2]);
+        const day = Number(matches[3]);
         if (!year ||
             !month ||
             month < 1 ||
@@ -63,6 +68,10 @@ class LocalDate {
         }
         return new LocalDate(year, month, day);
     }
+    // Can use just .toString()
+    // static parseToString(d: LocalDateConfig): IsoDateString {
+    //   return typeof d === 'string' ? d : d.toString()
+    // }
     static isValid(iso) {
         return this.parseOrNull(iso) !== null;
     }
@@ -90,45 +99,63 @@ class LocalDate {
         (0, assert_1._assert)(items.length, 'LocalDate.latest called on empty array');
         return items.reduce((max, item) => (max.isSameOrAfter(item) ? max : item));
     }
-    static range(minIncl, maxExcl, step = 1, stepUnit = 'day') {
-        const days = [];
-        let current = LocalDate.of(minIncl).startOf(stepUnit);
-        const max = LocalDate.of(maxExcl).startOf(stepUnit);
-        do {
-            days.push(current);
+    static range(min, max, incl = '[)', step = 1, stepUnit = 'day') {
+        const dates = [];
+        const $min = LocalDate.of(min);
+        const $max = LocalDate.of(max).startOf(stepUnit);
+        let current = $min.startOf(stepUnit);
+        if (current.isAfter($min, incl[0] === '[')) {
+            // ok
+        }
+        else {
+            current.add(1, stepUnit, true);
+        }
+        const incl2 = incl[1] === ']';
+        while (current.isBefore($max, incl2)) {
+            dates.push(current);
             current = current.add(step, stepUnit);
-        } while (current.isBefore(max));
-        return days;
+        }
+        return dates;
+    }
+    get(unit) {
+        return unit === 'year' ? this.$year : unit === 'month' ? this.$month : this.$day;
     }
-    static rangeSeq(minIncl, maxExcl, step = 1, stepUnit = 'day') {
-        const min = LocalDate.of(minIncl).startOf(stepUnit);
-        const max = LocalDate.of(maxExcl).startOf(stepUnit);
-        return seq_1.Sequence.create(min, d => {
-            const next = d.add(step, stepUnit);
-            return next.isAfter(max) ? types_1.END : next;
-        });
+    set(unit, v, mutate = false) {
+        const t = mutate ? this : this.clone();
+        if (unit === 'year') {
+            t.$year = v;
+        }
+        else if (unit === 'month') {
+            t.$month = v;
+        }
+        else {
+            t.$day = v;
+        }
+        return t;
     }
-    static rangeString(minIncl, maxExcl, step = 1, stepUnit = 'day') {
-        return LocalDate.range(minIncl, maxExcl, step, stepUnit).map(ld => ld.toString());
+    year(v) {
+        return v === undefined ? this.$year : this.set('year', v);
     }
-    static rangeIncl(minIncl, maxIncl, step = 1, stepUnit = 'day') {
-        return LocalDate.range(minIncl, LocalDate.of(maxIncl).add(1, stepUnit), step, stepUnit);
+    month(v) {
+        return v === undefined ? this.$month : this.set('month', v);
     }
-    static rangeInclString(minIncl, maxIncl, step = 1, stepUnit = 'day') {
-        return LocalDate.range(minIncl, LocalDate.of(maxIncl).add(1, stepUnit), step, stepUnit).map(ld => ld.toString());
+    day(v) {
+        return v === undefined ? this.$day : this.set('day', v);
     }
     isSame(d) {
         d = LocalDate.of(d);
-        return this.day === d.day && this.month === d.month && this.year === d.year;
+        return this.$day === d.$day && this.$month === d.$month && this.$year === d.$year;
     }
-    isBefore(d) {
-        return this.cmp(d) === -1;
+    isBefore(d, inclusive = false) {
+        const r = this.cmp(d);
+        return r === -1 || (r === 0 && inclusive);
     }
     isSameOrBefore(d) {
         return this.cmp(d) <= 0;
     }
-    isAfter(d) {
-        return this.cmp(d) === 1;
+    isAfter(d, inclusive = false) {
+        const r = this.cmp(d);
+        return r === 1 || (r === 0 && inclusive);
     }
     isSameOrAfter(d) {
         return this.cmp(d) >= 0;
@@ -149,17 +176,17 @@ class LocalDate {
      */
     cmp(d) {
         d = LocalDate.of(d);
-        if (this.year < d.year)
+        if (this.$year < d.$year)
             return -1;
-        if (this.year > d.year)
+        if (this.$year > d.$year)
             return 1;
-        if (this.month < d.month)
+        if (this.$month < d.$month)
             return -1;
-        if (this.month > d.month)
+        if (this.$month > d.$month)
             return 1;
-        if (this.day < d.day)
+        if (this.$day < d.$day)
             return -1;
-        if (this.day > d.day)
+        if (this.$day > d.$day)
             return 1;
         return 0;
     }
@@ -177,82 +204,87 @@ class LocalDate {
     diff(d, unit) {
         d = LocalDate.of(d);
         if (unit === 'year') {
-            return this.year - d.year;
+            return this.$year - d.$year;
         }
         if (unit === 'month') {
-            return (this.year - d.year) * 12 + (this.month - d.month);
+            return (this.$year - d.$year) * 12 + (this.$month - d.$month);
         }
         // unit is 'day'
-        let days = this.day - d.day;
-        if (d.year < this.year) {
-            for (let year = d.year; year < this.year; year++) {
+        let days = this.$day - d.$day;
+        if (d.$year < this.$year) {
+            for (let year = d.$year; year < this.$year; year++) {
                 days += LocalDate.getYearLength(year);
             }
         }
-        else if (this.year < d.year) {
-            for (let year = this.year; year < d.year; year++) {
+        else if (this.$year < d.$year) {
+            for (let year = this.$year; year < d.$year; year++) {
                 days -= LocalDate.getYearLength(year);
             }
         }
-        if (d.month < this.month) {
-            for (let month = d.month; month < this.month; month++) {
-                days += LocalDate.getMonthLength(this.year, month);
+        if (d.$month < this.$month) {
+            for (let month = d.$month; month < this.$month; month++) {
+                days += LocalDate.getMonthLength(this.$year, month);
             }
         }
-        else if (this.month < d.month) {
-            for (let month = this.month; month < d.month; month++) {
-                days -= LocalDate.getMonthLength(d.year, month);
+        else if (this.$month < d.$month) {
+            for (let month = this.$month; month < d.$month; month++) {
+                days -= LocalDate.getMonthLength(d.$year, month);
             }
         }
         return days;
     }
     add(num, unit, mutate = false) {
-        let { day, month, year } = this;
+        let { $day, $month, $year } = this;
         if (unit === 'day') {
-            day += num;
+            $day += num;
         }
         else if (unit === 'month') {
-            month += num;
+            $month += num;
         }
         else if (unit === 'year') {
-            year += num;
+            $year += num;
         }
         // check day overflow
-        let monLen = LocalDate.getMonthLength(year, month);
-        while (day > monLen) {
-            day -= monLen;
-            month += 1;
-            if (month > 12) {
-                year += 1;
-                month -= 12;
+        if (unit === 'day') {
+            if ($day < 1) {
+                while ($day < 1) {
+                    $month -= 1;
+                    if ($month < 1) {
+                        $year -= 1;
+                        $month += 12;
+                    }
+                    $day += LocalDate.getMonthLength($year, $month);
+                }
             }
-            monLen = LocalDate.getMonthLength(year, month);
-        }
-        while (day < 1) {
-            day += monLen;
-            month -= 1;
-            if (month < 1) {
-                year -= 1;
-                month += 12;
+            else {
+                let monLen = LocalDate.getMonthLength($year, $month);
+                while ($day > monLen) {
+                    $day -= monLen;
+                    $month += 1;
+                    if ($month > 12) {
+                        $year += 1;
+                        $month -= 12;
+                    }
+                    monLen = LocalDate.getMonthLength($year, $month);
+                }
             }
-            monLen = LocalDate.getMonthLength(year, month);
         }
         // check month overflow
-        while (month > 12) {
-            year += 1;
-            month -= 12;
+        while ($month > 12) {
+            $year += 1;
+            $month -= 12;
         }
-        while (month < 1) {
-            year -= 1;
-            month += 12;
+        while ($month < 1) {
+            $year -= 1;
+            $month += 12;
         }
         if (mutate) {
-            this.year = year;
-            this.month = month;
-            this.day = day;
+            this.$year = $year;
+            this.$month = $month;
+            this.$day = $day;
             return this;
         }
-        return new LocalDate(year, month, day);
+        return new LocalDate($year, $month, $day);
     }
     subtract(num, unit, mutate = false) {
         return this.add(-num, unit, mutate);
@@ -261,17 +293,17 @@ class LocalDate {
         if (unit === 'day')
             return this;
         if (unit === 'month')
-            return LocalDate.create(this.year, this.month, 1);
+            return LocalDate.create(this.$year, this.$month, 1);
         // year
-        return LocalDate.create(this.year, 1, 1);
+        return LocalDate.create(this.$year, 1, 1);
     }
     endOf(unit) {
         if (unit === 'day')
             return this;
         if (unit === 'month')
-            return LocalDate.create(this.year, this.month, LocalDate.getMonthLength(this.year, this.month));
+            return LocalDate.create(this.$year, this.$month, LocalDate.getMonthLength(this.$year, this.$month));
         // year
-        return LocalDate.create(this.year, 12, 31);
+        return LocalDate.create(this.$year, 12, 31);
     }
     static getYearLength(year) {
         return this.isLeapYear(year) ? 366 : 365;
@@ -279,17 +311,13 @@ class LocalDate {
     static getMonthLength(year, month) {
         if (month === 2)
             return this.isLeapYear(year) ? 29 : 28;
-        return m31.has(month) ? 31 : 30;
+        return MDAYS[month];
     }
     static isLeapYear(year) {
-        if (year % 4 !== 0)
-            return false;
-        if (year % 100 !== 0)
-            return true;
-        return year % 400 === 0;
+        return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
     }
     clone() {
-        return new LocalDate(this.year, this.month, this.day);
+        return new LocalDate(this.$year, this.$month, this.$day);
     }
     /**
      * Converts LocalDate into instance of Date.
@@ -298,7 +326,7 @@ class LocalDate {
      * Timezone will match local timezone.
      */
     toDate() {
-        return new Date(this.year, this.month - 1, this.day);
+        return new Date(this.$year, this.$month - 1, this.$day);
     }
     toLocalTime() {
         return localTime_1.LocalTime.of(this.toDate());
@@ -308,16 +336,16 @@ class LocalDate {
     }
     toString() {
         return [
-            String(this.year).padStart(4, '0'),
-            String(this.month).padStart(2, '0'),
-            String(this.day).padStart(2, '0'),
+            String(this.$year).padStart(4, '0'),
+            String(this.$month).padStart(2, '0'),
+            String(this.$day).padStart(2, '0'),
         ].join('-');
     }
     toStringCompact() {
         return [
-            String(this.year).padStart(4, '0'),
-            String(this.month).padStart(2, '0'),
-            String(this.day).padStart(2, '0'),
+            String(this.$year).padStart(4, '0'),
+            String(this.$month).padStart(2, '0'),
+            String(this.$day).padStart(2, '0'),
         ].join('');
     }
     // May be not optimal, as LocalTime better suits it

package/dist/datetime/localTime.d.ts

@@ -1,7 +1,7 @@
-import { IsoDate, IsoDateTime, UnixTimestamp } from '../types';
+import { IsoDateString, IsoDateTimeString, UnixTimestampNumber } from '../types';
 import { Inclusiveness, LocalDate } from './localDate';
 export declare type LocalTimeUnit = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second';
-export declare type LocalTimeConfig = LocalTime | Date | IsoDateTime | UnixTimestamp;
+export declare type LocalTimeConfig = LocalTime | Date | IsoDateTimeString | UnixTimestampNumber;
 export interface LocalTimeComponents {
     year: number;
     month: number;
@@ -28,6 +28,8 @@ export declare class LocalTime {
      * Returns null if invalid
      */
     static parseOrNull(d: LocalTimeConfig | undefined | null): LocalTime | null;
+    static parseToDate(d: LocalTimeConfig): Date;
+    static parseToUnixTimestamp(d: LocalTimeConfig): UnixTimestampNumber;
     static isValid(d: LocalTimeConfig | undefined | null): boolean;
     static now(): LocalTime;
     static fromComponents(c: {
@@ -40,8 +42,8 @@ export declare class LocalTime {
     year(v: number): LocalTime;
     month(): number;
     month(v: number): LocalTime;
-    date(): number;
-    date(v: number): LocalTime;
+    day(): number;
+    day(v: number): LocalTime;
     hour(): number;
     hour(v: number): LocalTime;
     minute(): number;
@@ -60,9 +62,9 @@ export declare class LocalTime {
     static latestOrUndefined(items: LocalTime[]): LocalTime | undefined;
     static latest(items: LocalTime[]): LocalTime;
     isSame(d: LocalTimeConfig): boolean;
-    isBefore(d: LocalTimeConfig): boolean;
+    isBefore(d: LocalTimeConfig, inclusive?: boolean): boolean;
     isSameOrBefore(d: LocalTimeConfig): boolean;
-    isAfter(d: LocalTimeConfig): boolean;
+    isAfter(d: LocalTimeConfig, inclusive?: boolean): boolean;
     isSameOrAfter(d: LocalTimeConfig): boolean;
     isBetween(min: LocalTimeConfig, max: LocalTimeConfig, incl?: Inclusiveness): boolean;
     /**
@@ -75,19 +77,19 @@ export declare class LocalTime {
     fromNow(now?: LocalTimeConfig): string;
     getDate(): Date;
     clone(): LocalTime;
-    unix(): UnixTimestamp;
+    unix(): UnixTimestampNumber;
     unixMillis(): number;
-    valueOf(): UnixTimestamp;
+    valueOf(): UnixTimestampNumber;
     toLocalDate(): LocalDate;
-    toPretty(seconds?: boolean): IsoDateTime;
+    toPretty(seconds?: boolean): IsoDateTimeString;
     /**
      * Returns e.g: `1984-06-21T17:56:21`, only the date part of DateTime
      */
-    toISODateTime(): IsoDateTime;
+    toISODateTime(): IsoDateTimeString;
     /**
      * Returns e.g: `1984-06-21`, only the date part of DateTime
      */
-    toISODate(): IsoDate;
+    toISODate(): IsoDateString;
     /**
      * Returns e.g: `17:03:15` (or `17:03` with seconds=false)
      */
@@ -97,7 +99,7 @@ export declare class LocalTime {
      */
     toStringCompact(seconds?: boolean): string;
     toString(): string;
-    toJSON(): UnixTimestamp;
+    toJSON(): UnixTimestampNumber;
 }
 /**
  * Shortcut wrapper around `LocalDate.parse` / `LocalDate.today`