@naturalcycles/js-lib 14.97.0 → 14.98.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,9 +1,8 @@
-import { Sequence } from '../seq/seq';
 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
  */
@@ -33,11 +32,7 @@ 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): IsoDateString[];
-    static rangeIncl(minIncl: LocalDateConfig, maxIncl: LocalDateConfig, step?: number, stepUnit?: LocalDateUnit): LocalDate[];
-    static rangeInclString(minIncl: LocalDateConfig, maxIncl: LocalDateConfig, step?: number, stepUnit?: LocalDateUnit): IsoDateString[];
+    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;
@@ -47,9 +42,9 @@ export declare class 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;
     /**

package/dist/datetime/localDate.js

@@ -2,10 +2,9 @@
 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
@@ -51,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 ||
@@ -64,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;
     }
@@ -91,32 +99,23 @@ 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;
-    }
-    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;
-        });
-    }
-    static rangeString(minIncl, maxExcl, step = 1, stepUnit = 'day') {
-        return LocalDate.range(minIncl, maxExcl, step, stepUnit).map(ld => ld.toString());
-    }
-    static rangeIncl(minIncl, maxIncl, step = 1, stepUnit = 'day') {
-        return LocalDate.range(minIncl, LocalDate.of(maxIncl).add(1, stepUnit), step, stepUnit);
-    }
-    static rangeInclString(minIncl, maxIncl, step = 1, stepUnit = 'day') {
-        return LocalDate.range(minIncl, LocalDate.of(maxIncl).add(1, stepUnit), step, stepUnit).map(ld => ld.toString());
+        }
+        return dates;
     }
     get(unit) {
         return unit === 'year' ? this.$year : unit === 'month' ? this.$month : this.$day;
@@ -147,14 +146,16 @@ class LocalDate {
         d = LocalDate.of(d);
         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;
@@ -244,24 +245,29 @@ class LocalDate {
             $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) {
@@ -305,14 +311,10 @@ 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);

package/dist/datetime/localTime.d.ts

@@ -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: {
@@ -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;
     /**

package/dist/datetime/localTime.js

@@ -48,7 +48,7 @@ class LocalTime {
             date = new Date(d * 1000);
         }
         else {
-            date = new Date(d);
+            date = new Date(d.slice(0, 19));
         }
         // validation
         if (isNaN(date.getDate())) {
@@ -60,6 +60,28 @@ class LocalTime {
         // }
         return new LocalTime(date, false);
     }
+    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);
+        if (isNaN(date.getDate())) {
+            throw new TypeError(`Cannot parse "${d}" to Date`);
+        }
+        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);
+        if (isNaN(date.getDate())) {
+            throw new TypeError(`Cannot parse "${d}" to UnixTimestamp`);
+        }
+        return date.valueOf() / 1000;
+    }
     static isValid(d) {
         return this.parseOrNull(d) !== null;
     }
@@ -164,7 +186,7 @@ class LocalTime {
         return Math.abs(this.diff(other, unit));
     }
     diff(other, unit) {
-        const date2 = LocalTime.of(other).$date;
+        const date2 = LocalTime.parseToDate(other);
         if (unit === 'year') {
             return this.$date.getFullYear() - date2.getFullYear();
         }
@@ -241,14 +263,16 @@ class LocalTime {
     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;
@@ -269,7 +293,7 @@ class LocalTime {
      */
     cmp(d) {
         const t1 = this.$date.valueOf();
-        const t2 = LocalTime.of(d).$date.valueOf();
+        const t2 = LocalTime.parseToDate(d).valueOf();
         if (t1 === t2)
             return 0;
         return t1 < t2 ? -1 : 1;
@@ -295,8 +319,8 @@ class LocalTime {
             second: this.$date.getSeconds(),
         };
     }
-    fromNow(now = LocalTime.now()) {
-        const msDiff = LocalTime.of(now).unixMillis() - this.unixMillis();
+    fromNow(now = new Date()) {
+        const msDiff = LocalTime.parseToDate(now).valueOf() - this.$date.valueOf();
         if (msDiff === 0)
             return 'now';
         if (msDiff >= 0) {
@@ -408,4 +432,3 @@ function localTime(d) {
     return d ? LocalTime.of(d) : LocalTime.now();
 }
 exports.localTime = localTime;
-// todo: range

package/dist/datetime/timeInterval.d.ts

@@ -0,0 +1,38 @@
+import { UnixTimestampNumber } from '../types';
+import { Inclusiveness } from './localDate';
+import { LocalTime, LocalTimeConfig } from './localTime';
+export declare type TimeIntervalConfig = TimeInterval | TimeIntervalString;
+export declare type TimeIntervalString = string;
+/**
+ * Class that supports an "interval of time" between 2 timestamps - start and end.
+ * Example: `1649267185/1649267187`.
+ *
+ * @experimental
+ */
+export declare class TimeInterval {
+    private $start;
+    private $end;
+    private constructor();
+    static of(start: LocalTimeConfig, end: LocalTimeConfig): TimeInterval;
+    get start(): UnixTimestampNumber;
+    get end(): UnixTimestampNumber;
+    get startTime(): LocalTime;
+    get endTime(): LocalTime;
+    /**
+     * Parses string like `1649267185/1649267187` into a TimeInterval.
+     */
+    static parse(d: TimeIntervalConfig): TimeInterval;
+    isSame(d: TimeIntervalConfig): boolean;
+    isBefore(d: TimeIntervalConfig, inclusive?: boolean): boolean;
+    isSameOrBefore(d: TimeIntervalConfig): boolean;
+    isAfter(d: TimeIntervalConfig, inclusive?: boolean): boolean;
+    isSameOrAfter(d: TimeIntervalConfig): boolean;
+    includes(d: LocalTimeConfig, incl?: Inclusiveness): boolean;
+    /**
+     * TimeIntervals compare by start date.
+     * If it's the same - then by end date.
+     */
+    cmp(d: TimeIntervalConfig): -1 | 0 | 1;
+    toString(): TimeIntervalString;
+    toJSON(): TimeIntervalString;
+}

package/dist/datetime/timeInterval.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeInterval = void 0;
+const localTime_1 = require("./localTime");
+/**
+ * Class that supports an "interval of time" between 2 timestamps - start and end.
+ * Example: `1649267185/1649267187`.
+ *
+ * @experimental
+ */
+class TimeInterval {
+    constructor($start, $end) {
+        this.$start = $start;
+        this.$end = $end;
+    }
+    static of(start, end) {
+        return new TimeInterval(localTime_1.LocalTime.parseToUnixTimestamp(start), localTime_1.LocalTime.parseToUnixTimestamp(end));
+    }
+    get start() {
+        return this.$start;
+    }
+    get end() {
+        return this.$end;
+    }
+    get startTime() {
+        return localTime_1.LocalTime.of(this.$start);
+    }
+    get endTime() {
+        return localTime_1.LocalTime.of(this.$end);
+    }
+    /**
+     * Parses string like `1649267185/1649267187` into a TimeInterval.
+     */
+    static parse(d) {
+        if (d instanceof TimeInterval)
+            return d;
+        const [start, end] = d.split('/').map(Number);
+        if (!end || !start) {
+            throw new Error(`Cannot parse "${d}" into TimeInterval`);
+        }
+        return new TimeInterval(start, end);
+    }
+    isSame(d) {
+        return this.cmp(d) === 0;
+    }
+    isBefore(d, inclusive = false) {
+        const r = this.cmp(d);
+        return r === -1 || (r === 0 && inclusive);
+    }
+    isSameOrBefore(d) {
+        return this.cmp(d) <= 0;
+    }
+    isAfter(d, inclusive = false) {
+        const r = this.cmp(d);
+        return r === 1 || (r === 0 && inclusive);
+    }
+    isSameOrAfter(d) {
+        return this.cmp(d) >= 0;
+    }
+    includes(d, incl = '[)') {
+        d = localTime_1.LocalTime.parseToUnixTimestamp(d);
+        if (d < this.$start || (d === this.$start && incl[0] === '('))
+            return false;
+        if (d > this.$end || (d === this.$end && incl[1] === ')'))
+            return false;
+        return true;
+    }
+    /**
+     * TimeIntervals compare by start date.
+     * If it's the same - then by end date.
+     */
+    cmp(d) {
+        d = TimeInterval.parse(d);
+        if (this.$start > d.$start)
+            return 1;
+        if (this.$start < d.$start)
+            return -1;
+        if (this.$end > d.$end)
+            return 1;
+        if (this.$end < d.$end)
+            return -1;
+        return 0;
+    }
+    toString() {
+        return [this.$start, this.$end].join('/');
+    }
+    toJSON() {
+        return this.toString();
+    }
+}
+exports.TimeInterval = TimeInterval;

package/dist/index.d.ts

@@ -63,8 +63,10 @@ export * from './string/leven';
 export * from './datetime/localDate';
 export * from './datetime/localTime';
 export * from './datetime/dateInterval';
+export * from './datetime/timeInterval';
 import { LocalDateConfig, LocalDateUnit, Inclusiveness } from './datetime/localDate';
 import { LocalTimeConfig, LocalTimeUnit, LocalTimeComponents } from './datetime/localTime';
 import { DateIntervalConfig, DateIntervalString } from './datetime/dateInterval';
-export type { DateIntervalConfig, DateIntervalString, LocalDateConfig, LocalDateUnit, Inclusiveness, LocalTimeConfig, LocalTimeUnit, LocalTimeComponents, AbortableMapper, AbortablePredicate, AbortableAsyncPredicate, AbortableAsyncMapper, PQueueCfg, MemoCache, AsyncMemoCache, PromiseDecoratorCfg, PromiseDecoratorResp, ErrorData, ErrorObject, HttpErrorData, HttpErrorResponse, Admin401ErrorData, Admin403ErrorData, StringMap, PromiseMap, AnyObject, AnyFunction, ValuesOf, ValueOf, KeyValueTuple, ObjectMapper, ObjectPredicate, InstanceId, IsoDate, IsoDateString, IsoDateTimeString, Reviver, PMapOptions, Mapper, AsyncMapper, Predicate, AsyncPredicate, BatchResult, DeferredPromise, PRetryOptions, PTimeoutOptions, TryCatchOptions, StringifyAnyOptions, JsonStringifyFunction, Merge, ReadonlyDeep, Promisable, Simplify, ConditionalPick, ConditionalExcept, Class, UnixTimestampNumber, UnixTimestamp, Integer, BaseDBEntity, SavedDBEntity, Saved, Unsaved, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, JsonSchema, JsonSchemaAny, JsonSchemaOneOf, JsonSchemaAllOf, JsonSchemaAnyOf, JsonSchemaNot, JsonSchemaRef, JsonSchemaConst, JsonSchemaEnum, JsonSchemaString, JsonSchemaNumber, JsonSchemaBoolean, JsonSchemaNull, JsonSchemaRootObject, JsonSchemaObject, JsonSchemaArray, JsonSchemaTuple, JsonSchemaBuilder, CommonLogLevel, CommonLogWithLevelFunction, CommonLogFunction, CommonLogger, };
+import { TimeIntervalConfig, TimeIntervalString } from './datetime/timeInterval';
+export type { DateIntervalConfig, DateIntervalString, TimeIntervalConfig, TimeIntervalString, LocalDateConfig, LocalDateUnit, Inclusiveness, LocalTimeConfig, LocalTimeUnit, LocalTimeComponents, AbortableMapper, AbortablePredicate, AbortableAsyncPredicate, AbortableAsyncMapper, PQueueCfg, MemoCache, AsyncMemoCache, PromiseDecoratorCfg, PromiseDecoratorResp, ErrorData, ErrorObject, HttpErrorData, HttpErrorResponse, Admin401ErrorData, Admin403ErrorData, StringMap, PromiseMap, AnyObject, AnyFunction, ValuesOf, ValueOf, KeyValueTuple, ObjectMapper, ObjectPredicate, InstanceId, IsoDate, IsoDateString, IsoDateTimeString, Reviver, PMapOptions, Mapper, AsyncMapper, Predicate, AsyncPredicate, BatchResult, DeferredPromise, PRetryOptions, PTimeoutOptions, TryCatchOptions, StringifyAnyOptions, JsonStringifyFunction, Merge, ReadonlyDeep, Promisable, Simplify, ConditionalPick, ConditionalExcept, Class, UnixTimestampNumber, UnixTimestamp, Integer, BaseDBEntity, SavedDBEntity, Saved, Unsaved, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, JsonSchema, JsonSchemaAny, JsonSchemaOneOf, JsonSchemaAllOf, JsonSchemaAnyOf, JsonSchemaNot, JsonSchemaRef, JsonSchemaConst, JsonSchemaEnum, JsonSchemaString, JsonSchemaNumber, JsonSchemaBoolean, JsonSchemaNull, JsonSchemaRootObject, JsonSchemaObject, JsonSchemaArray, JsonSchemaTuple, JsonSchemaBuilder, CommonLogLevel, CommonLogWithLevelFunction, CommonLogFunction, CommonLogger, };
 export { is, _createPromiseDecorator, _stringMapValues, _stringMapEntries, _objectKeys, pMap, _passthroughMapper, _passUndefinedMapper, _passthroughPredicate, _passNothingPredicate, _noop, ErrorMode, pDefer, AggregatedError, pRetry, pRetryFn, pTimeout, pTimeoutFn, _tryCatch, _TryCatch, _stringifyAny, jsonSchema, JsonSchemaAnyBuilder, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, commonLoggerCreate, PQueue, END, SKIP, };

package/dist/index.js

@@ -95,3 +95,4 @@ tslib_1.__exportStar(require("./string/leven"), exports);
 tslib_1.__exportStar(require("./datetime/localDate"), exports);
 tslib_1.__exportStar(require("./datetime/localTime"), exports);
 tslib_1.__exportStar(require("./datetime/dateInterval"), exports);
+tslib_1.__exportStar(require("./datetime/timeInterval"), exports);

package/dist/json-schema/jsonSchemaBuilder.d.ts

@@ -113,8 +113,8 @@ export declare class JsonSchemaObjectBuilder<T extends AnyObject> extends JsonSc
     minProps(minProperties: number): this;
     maxProps(maxProperties: number): this;
     additionalProps(additionalProperties: boolean): this;
-    baseDBEntity<ID = string>(idType?: string): JsonSchemaObjectBuilder<T & BaseDBEntity<ID>>;
-    savedDBEntity<ID = string>(idType?: string): JsonSchemaObjectBuilder<T & SavedDBEntity<ID>>;
+    baseDBEntity<ID extends string | number = string>(idType?: string): JsonSchemaObjectBuilder<T & BaseDBEntity<ID>>;
+    savedDBEntity<ID extends string | number = string>(idType?: string): JsonSchemaObjectBuilder<T & SavedDBEntity<ID>>;
     extend<T2 extends AnyObject>(s2: JsonSchemaObjectBuilder<T2>): JsonSchemaObjectBuilder<T & T2>;
 }
 export declare class JsonSchemaArrayBuilder<ITEM> extends JsonSchemaAnyBuilder<ITEM[], JsonSchemaArray<ITEM>> {

package/dist/math/math.util.d.ts

@@ -7,6 +7,10 @@
  * // 2.5
  */
 export declare function _average(values: number[]): number;
+/**
+ * Same as _average, but safely returns null if input array is empty or nullish.
+ */
+export declare function _averageOrNull(values: number[] | undefined | null): number | null;
 /**
  * valuesArray and weightsArray length is expected to be the same.
  */

package/dist/math/math.util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._median = exports._percentiles = exports._percentile = exports._averageWeighted = exports._average = void 0;
+exports._median = exports._percentiles = exports._percentile = exports._averageWeighted = exports._averageOrNull = exports._average = void 0;
 const number_util_1 = require("../number/number.util");
 /**
  * @returns Average of the array of numbers
@@ -14,6 +14,13 @@ function _average(values) {
     return values.reduce((a, b) => a + b) / values.length;
 }
 exports._average = _average;
+/**
+ * Same as _average, but safely returns null if input array is empty or nullish.
+ */
+function _averageOrNull(values) {
+    return values?.length ? values.reduce((a, b) => a + b) / values.length : null;
+}
+exports._averageOrNull = _averageOrNull;
 /**
  * valuesArray and weightsArray length is expected to be the same.
  */

package/dist/math/sma.d.ts

@@ -14,6 +14,10 @@ export declare class SimpleMovingAverage {
      * Returns 0 (not undefined) for empty data.
      */
     avg: number;
+    /**
+     * Push new value.
+     * Returns newly calculated average (using newly pushed value).
+     */
     push(n: number): number;
     private calculateAvg;
 }

package/dist/math/sma.js

@@ -18,6 +18,10 @@ class SimpleMovingAverage {
          */
         this.avg = 0;
     }
+    /**
+     * Push new value.
+     * Returns newly calculated average (using newly pushed value).
+     */
     push(n) {
         this.data[this.nextIndex] = n;
         this.nextIndex =