@naturalcycles/js-lib 14.96.0 → 14.97.1

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;
     }
@@ -118,7 +140,7 @@ class LocalTime {
     month(v) {
         return v === undefined ? this.get('month') : this.set('month', v);
     }
-    date(v) {
+    day(v) {
         return v === undefined ? this.get('day') : this.set('day', v);
     }
     hour(v) {
@@ -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/error/try.d.ts

@@ -10,20 +10,26 @@ import { AppError } from './app.error';
  * For convenience, second argument type is non-optional,
  * so you can use it without `!`. But you SHOULD always check `if (err)` first!
  *
+ * ERR is typed as Error, not `unknown`. While unknown would be more correct,
+ * according to recent TypeScript, Error gives more developer convenience.
+ * In our code we NEVER throw non-errors.
+ * Only possibility of non-error is in the 3rd-party library code, in these cases it
+ * can be manually cast to `unknown` for extra safety.
+ *
  * @example
  *
  * const [err, v] = _try(() => someFunction())
  * if (err) ...do something...
  * v // go ahead and use v
  */
-export declare function _try<ERR = unknown, RETURN = void>(fn: () => RETURN): [err: ERR | null, value: RETURN];
+export declare function _try<ERR = Error, RETURN = void>(fn: () => RETURN): [err: ERR | null, value: RETURN];
 /**
  * Like _try, but for Promises.
  *
  * Also, intentionally types second return item as non-optional,
  * but you should check for `err` presense first!
  */
-export declare function pTry<ERR = unknown, RETURN = void>(promise: Promise<RETURN>): Promise<[err: ERR | null, value: Awaited<RETURN>]>;
+export declare function pTry<ERR = Error, RETURN = void>(promise: Promise<RETURN>): Promise<[err: ERR | null, value: Awaited<RETURN>]>;
 /**
  * It is thrown when Error was expected, but didn't happen
  * ("pass" happened instead).

package/dist/error/try.js

@@ -12,6 +12,12 @@ const app_error_1 = require("./app.error");
  * For convenience, second argument type is non-optional,
  * so you can use it without `!`. But you SHOULD always check `if (err)` first!
  *
+ * ERR is typed as Error, not `unknown`. While unknown would be more correct,
+ * according to recent TypeScript, Error gives more developer convenience.
+ * In our code we NEVER throw non-errors.
+ * Only possibility of non-error is in the 3rd-party library code, in these cases it
+ * can be manually cast to `unknown` for extra safety.
+ *
  * @example
  *
  * const [err, v] = _try(() => someFunction())
@@ -49,7 +55,7 @@ exports.pTry = pTry;
  */
 class UnexpectedPassError extends app_error_1.AppError {
     constructor() {
-        super('_expectedError passed unexpectedly');
+        super('expected error was not thrown');
     }
 }
 exports.UnexpectedPassError = UnexpectedPassError;

package/dist/error/tryCatch.d.ts

@@ -5,7 +5,7 @@ export interface TryCatchOptions {
      * The value returned from the function will be returned from the wrapped method (!).
      * onError function may be asynchronous.
      */
-    onError?: (err: unknown) => any;
+    onError?: (err: Error) => any;
     /**
      * @default false
      */

package/dist/error/tryCatch.js

@@ -30,7 +30,7 @@ function _tryCatch(fn, opt = {}) {
             }
             if (onError) {
                 try {
-                    return await onError(err); // eslint-disable-line @typescript-eslint/return-await
+                    return await onError((0, index_1._anyToError)(err)); // eslint-disable-line @typescript-eslint/return-await
                 }
                 catch { }
             }

package/dist/index.d.ts

@@ -51,7 +51,7 @@ export * from './string/string.util';
 import { JsonStringifyFunction, StringifyAnyOptions, _stringifyAny } from './string/stringifyAny';
 export * from './time/time.util';
 import { Class, ConditionalExcept, ConditionalPick, Merge, Promisable, ReadonlyDeep, Simplify } from './typeFest';
-import { AsyncMapper, AsyncPredicate, BaseDBEntity, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, Saved, Unsaved, BatchResult, InstanceId, IsoDate, IsoDateTime, KeyValueTuple, Mapper, ObjectMapper, ObjectPredicate, Predicate, PromiseMap, AnyObject, AnyFunction, Reviver, SavedDBEntity, StringMap, UnixTimestamp, Integer, ValueOf, ValuesOf, AbortableMapper, AbortableAsyncPredicate, AbortableAsyncMapper, AbortablePredicate, END, SKIP, _noop, _objectKeys, _passNothingPredicate, _passthroughMapper, _passthroughPredicate, _passUndefinedMapper, _stringMapEntries, _stringMapValues } from './types';
+import { AsyncMapper, AsyncPredicate, BaseDBEntity, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, Saved, Unsaved, BatchResult, InstanceId, IsoDate, IsoDateString, IsoDateTimeString, KeyValueTuple, Mapper, ObjectMapper, ObjectPredicate, Predicate, PromiseMap, AnyObject, AnyFunction, Reviver, SavedDBEntity, StringMap, UnixTimestampNumber, UnixTimestamp, Integer, ValueOf, ValuesOf, AbortableMapper, AbortableAsyncPredicate, AbortableAsyncMapper, AbortablePredicate, END, SKIP, _noop, _objectKeys, _passNothingPredicate, _passthroughMapper, _passthroughPredicate, _passUndefinedMapper, _stringMapEntries, _stringMapValues } from './types';
 export * from './unit/size.util';
 import { is } from './vendor/is';
 import { CommonLogLevel, CommonLogFunction, CommonLogger, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, CommonLogWithLevelFunction, commonLoggerCreate } from './log/commonLogger';
@@ -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, IsoDateTime, Reviver, PMapOptions, Mapper, AsyncMapper, Predicate, AsyncPredicate, BatchResult, DeferredPromise, PRetryOptions, PTimeoutOptions, TryCatchOptions, StringifyAnyOptions, JsonStringifyFunction, Merge, ReadonlyDeep, Promisable, Simplify, ConditionalPick, ConditionalExcept, Class, 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/types.d.ts

@@ -111,18 +111,26 @@ export interface InstanceId {
  *
  * @example '2019-06-21'
  */
+export declare type IsoDateString = string;
+/**
+ * @deprecated use IsoDateString
+ */
 export declare type IsoDate = string;
 /**
  * Interface explicitly states that the value is an ISO DateTime string (with time).
  *
  * @example '2019-06-21T05:21:73Z'
  */
-export declare type IsoDateTime = string;
+export declare type IsoDateTimeString = string;
 /**
  * Interface explicitly states that the value is a Unix timestamp (in seconds).
  *
  * @example 1628945450
  */
+export declare type UnixTimestampNumber = number;
+/**
+ * @deprecated use UnixTimestampNumber
+ */
 export declare type UnixTimestamp = number;
 /**
  * Same as `number`, but with semantic meaning that it's an Integer.
@@ -136,11 +144,11 @@ export interface SavedDBEntity<ID = string> {
     /**
      * unixTimestamp of when the entity was first created (in the DB).
      */
-    created: UnixTimestamp;
+    created: UnixTimestampNumber;
     /**
      * unixTimestamp of when the entity was last updated (in the DB).
      */
-    updated: UnixTimestamp;
+    updated: UnixTimestampNumber;
 }
 /**
  * Base interface for any Entity that can be saved to DB.

package/dist-esm/datetime/dateInterval.js

@@ -27,14 +27,16 @@ export 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;
@@ -42,9 +44,14 @@ export class DateInterval {
     /**
      * Ranges of DateInterval (start, end) are INCLUSIVE.
      */
-    includes(d) {
+    includes(d, incl = '[]') {
         d = 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.
@@ -54,18 +61,14 @@ export class DateInterval {
         d = DateInterval.parse(d);
         return this.start.cmp(d.start) || this.end.cmp(d.end);
     }
+    getDays(incl = '[]') {
+        return 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.range(this.start, this.end, incl, step, stepUnit);
     }
     toString() {
         return [this.start, this.end].join('/');