@naturalcycles/js-lib 14.244.0 → 14.245.1

package/dist-esm/datetime/localTime.js

@@ -19,10 +19,22 @@ 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]);
-// It supports 2 forms:
-// 1. 2023-03-03
-// 2. 2023-03-03T05:10:02
-const DATE_TIME_REGEX = /^(\d{4})-(\d{2})-(\d{2})([T\s](\d{2}):(\d{2}):(\d{2}))?/;
+/**
+ * It supports 2 forms:
+ * 1. 2023-03-03
+ * 2. 2023-03-03T05:10:02
+ * // todo: make it even looser, like Day.js
+ */
+const DATE_TIME_REGEX_LOOSE = /^(\d{4})-(\d{2})-(\d{2})([Tt\s](\d{2}):?(\d{2})?:?(\d{2})?)?/;
+/**
+ * Supports 2 forms:
+ * 1. 2023-03-03
+ * 2. 2023-03-03T05:10:02
+ * Ok, now it allows arbitrary stuff after `:ss`, to allow millis/timezone info,
+ * but it will not take it into account.
+ */
+const DATE_TIME_REGEX_STRICT = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})/;
+const DATE_REGEX_STRICT = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
 export class LocalTime {
     constructor($date) {
         this.$date = $date;
@@ -279,7 +291,7 @@ export class LocalTime {
         }
         if (unit === 'year' || unit === 'month') {
             const d = addMonths(this.$date, unit === 'month' ? num : num * 12, mutate);
-            return mutate ? this : localTime.from(d);
+            return mutate ? this : localTime.fromInput(d);
         }
         return this.set(unit, this.get(unit) + num, mutate);
     }
@@ -290,7 +302,7 @@ export class LocalTime {
         return Math.abs(this.diff(other, unit));
     }
     diff(other, unit) {
-        const date2 = localTime.from(other).$date;
+        const date2 = localTime.fromInput(other).$date;
         const secDiff = (this.$date.valueOf() - date2.valueOf()) / 1000;
         if (!secDiff)
             return 0;
@@ -418,13 +430,13 @@ export class LocalTime {
      * Third argument allows to override "now".
      */
     isOlderThan(n, unit, now) {
-        return this.isBefore(localTime.from(now ?? new Date()).plus(-n, unit));
+        return this.isBefore(localTime.fromInput(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.from(now ?? new Date()).plus(-n, unit));
+        return this.isSameOrBefore(localTime.fromInput(now ?? new Date()).plus(-n, unit));
     }
     /**
      * Checks if this localTime is younger (>) than "now" by X units.
@@ -436,13 +448,13 @@ export class LocalTime {
      * Third argument allows to override "now".
      */
     isYoungerThan(n, unit, now) {
-        return this.isAfter(localTime.from(now ?? new Date()).plus(-n, unit));
+        return this.isAfter(localTime.fromInput(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.from(now ?? new Date()).plus(-n, unit));
+        return this.isSameOrAfter(localTime.fromInput(now ?? new Date()).plus(-n, unit));
     }
     getAgeInYears(now) {
         return this.getAgeIn('year', now);
@@ -463,7 +475,7 @@ export class LocalTime {
         return this.getAgeIn('second', now);
     }
     getAgeIn(unit, now) {
-        return localTime.from(now ?? new Date()).diff(this, unit);
+        return localTime.fromInput(now ?? new Date()).diff(this, unit);
     }
     /**
      * Returns 1 if this > d
@@ -472,7 +484,7 @@ export class LocalTime {
      */
     compare(d) {
         const t1 = this.$date.valueOf();
-        const t2 = localTime.from(d).$date.valueOf();
+        const t2 = localTime.fromInput(d).$date.valueOf();
         if (t1 === t2)
             return 0;
         return t1 < t2 ? -1 : 1;
@@ -498,7 +510,7 @@ export class LocalTime {
         };
     }
     toFromNowString(now = new Date()) {
-        const msDiff = localTime.from(now).$date.valueOf() - this.$date.valueOf();
+        const msDiff = localTime.fromInput(now).$date.valueOf() - this.$date.valueOf();
         if (msDiff === 0)
             return 'now';
         if (msDiff >= 0) {
@@ -604,118 +616,198 @@ export class LocalTime {
 }
 class LocalTimeFactory {
     /**
-     * Parses input String into LocalTime.
-     * Input can already be a LocalTime - it is returned as-is in that case.
+     * Creates a LocalTime from the input, unless it's falsy - then returns undefined.
+     *
+     * `localTime` function will instead return LocalTime of `now` for falsy input.
      */
-    from(input) {
-        const lt = this.fromOrNull(input);
-        this.assertNotNull(lt, input);
-        return lt;
+    orUndefined(input) {
+        return input || input === 0 ? this.fromInput(input) : undefined;
     }
-    fromDate(date) {
-        return new LocalTime(date);
+    /**
+     * Creates a LocalTime from the input, unless it's falsy - then returns LocalTime.now
+     */
+    orNow(input) {
+        return input || input === 0 ? this.fromInput(input) : this.now();
     }
-    fromUnix(ts) {
-        return new LocalTime(new Date(ts * 1000));
+    now() {
+        return new LocalTime(new Date());
     }
     /**
-     * Create LocalTime from unixTimestamp in milliseconds (not in seconds).
+     Convenience function to return current Unix timestamp in seconds.
+     Like Date.now(), but in seconds.
      */
-    fromMillis(millis) {
-        return new LocalTime(new Date(millis));
+    nowUnix() {
+        return Math.floor(Date.now() / 1000);
     }
     /**
-     * Returns null if invalid
+     * Create LocalTime from LocalTimeInput.
+     * Input can already be a LocalTime - it is returned as-is in that case.
+     * Date - will be used as-is.
+     * String - will be parsed as strict `yyyy-mm-ddThh:mm:ss`.
+     * Number - will be treated as unix timestamp in seconds.
      */
-    fromOrNull(d) {
-        if (d instanceof LocalTime)
-            return d;
-        if (d instanceof Date) {
-            return new LocalTime(d);
-        }
-        if (typeof d === 'number') {
-            return new LocalTime(new Date(d * 1000));
-        }
-        if (typeof d === 'string') {
-            return this.fromStringOrNull(d);
-        }
-        // This check is after checking the number, to support `0`
-        // unexpected type, e.g Function or something
-        return null;
-    }
-    fromStringOrNull(s) {
-        const date = this.parseStringToDateOrNull(s);
-        return date ? new LocalTime(date) : null;
-    }
-    fromDateTimeObject(input) {
-        const { year, month, day = 1, hour = 0, minute = 0, second = 0 } = input;
-        return new LocalTime(new Date(year, month - 1, day, hour, minute, second));
-    }
-    parseStringToDateOrNull(s) {
-        if (!s)
-            return null;
-        // 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))
-        // Parsing is inspired by how Day.js does it
-        // Specifically, it ensures that `localTime('2023-03-03')` returns the expected Date, and not a day before
-        // Because `new Date('2023-03-03')` in NewYork gives you '2023-03-02 19:00:00 GMT-0500'
-        const m = s.match(DATE_TIME_REGEX);
-        // Validate in 3 ways:
-        // 1. Should match Regex.
-        // In some ways it's stricter than Date constructor, e.g it doesn't allow 2023/05/05
-        // In other ways it's looser, e.g it allows `2023-05-05T`, while Date constructor doesn't.
-        // 2. Date constructor (of Node/v8 implementation, which we know is different from e.g WebKit/Safari)
-        // should not return `Invalid Date`.
-        // 3. Year, month and day should be valid, e.g 2023-01-32 should not be allowed.
-        // UPD: Actually, 3 can be skipped, because 2 is catching it already
-        // UPD: 2 is skipped, 1 and 3 are kept
-        // if (!m || isNaN(new Date(s).getDate())) return null
-        if (!m)
-            return null;
-        const year = Number(m[1]);
-        const month = Number(m[2]);
-        const day = Number(m[3]);
-        const hour = Number(m[5]);
-        const minute = Number(m[6]);
-        const second = Number(m[7]);
-        // Validation for just the Date part
-        if (!year ||
-            !month ||
-            month < 1 ||
-            month > 12 ||
-            !day ||
-            day < 1 ||
-            day > localDate.getMonthLength(year, month)) {
-            return null;
-        }
-        // Validation for Date+Time string, since the string is longer than YYYY-MM-DD
-        if (s.length > 10 &&
-            (isNaN(hour) ||
-                isNaN(minute) ||
-                isNaN(second) ||
-                hour < 0 ||
-                hour > 23 ||
-                minute < 0 ||
-                minute > 59 ||
-                second < 0 ||
-                second > 59)) {
-            return null;
-        }
-        return new Date(year, month - 1, day, hour || 0, minute || 0, second || 0, 0);
+    fromInput(input) {
+        if (input instanceof LocalTime)
+            return input;
+        if (input instanceof Date) {
+            return this.fromDate(input);
+        }
+        if (typeof input === 'number') {
+            return this.fromUnix(input);
+        }
+        // It means it's a string
+        // Will parse it STRICTLY
+        return this.fromIsoDateTimeString(input);
     }
+    /**
+     * Returns true if input is valid to create LocalTime.
+     */
     isValid(input) {
-        return this.fromOrNull(input) !== null;
+        if (!input)
+            return false;
+        if (input instanceof LocalTime)
+            return true;
+        if (input instanceof Date)
+            return !isNaN(input.getDate());
+        // We currently don't validate Unixtimestamp input, treat it as always valid
+        if (typeof input === 'number')
+            return true;
+        return this.isValidString(input);
     }
+    /**
+     * Returns true if isoString is a valid iso8601 string like `yyyy-mm-ddThh:mm:dd`.
+     */
     isValidString(isoString) {
-        return this.fromStringOrNull(isoString) !== null;
+        return !!this.parseStrictlyOrUndefined(isoString);
     }
-    assertNotNull(lt, input) {
-        _assert(lt !== null, `Cannot parse "${input}" into LocalTime`, {
-            input,
-        });
+    /**
+     * Tries to convert/parse the input into LocalTime.
+     * Uses LOOSE parsing.
+     * If invalid - doesn't throw, but returns undefined instead.
+     */
+    try(input) {
+        if (input instanceof LocalTime)
+            return input;
+        if (input instanceof Date) {
+            if (isNaN(input.getDate()))
+                return;
+            return new LocalTime(input);
+        }
+        if (typeof input === 'number') {
+            return this.fromUnix(input);
+        }
+        if (!input)
+            return;
+        const date = this.parseLooselyOrUndefined(input);
+        return date ? new LocalTime(date) : undefined;
+    }
+    /**
+     * Performs STRICT parsing.
+     * Only allows IsoDateTimeString or IsoDateString input, nothing else.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-duplicate-type-constituents
+    fromIsoDateTimeString(s) {
+        const d = this.parseStrictlyOrUndefined(s);
+        _assert(d, `Cannot parse "${s}" into LocalTime`);
+        return new LocalTime(d);
+    }
+    /**
+     * Performs LOOSE parsing.
+     * Tries to coerce imprefect/incorrect string input into IsoDateTimeString.
+     * Use with caution.
+     * Allows to input IsoDateString, will set h:m:s to zeros.
+     */
+    parse(s) {
+        const d = this.parseLooselyOrUndefined(String(s));
+        _assert(d, `Cannot parse "${s}" into LocalTime`);
+        return new LocalTime(d);
+    }
+    parseStrictlyOrUndefined(s) {
+        if (!s || typeof s !== 'string')
+            return;
+        let m = DATE_TIME_REGEX_STRICT.exec(s);
+        if (!m) {
+            // DateTime regex didn't match, try just-Date regex
+            m = DATE_REGEX_STRICT.exec(s);
+            if (!m)
+                return;
+        }
+        const o = {
+            year: Number(m[1]),
+            month: Number(m[2]),
+            day: Number(m[3]),
+            hour: Number(m[4]) || 0,
+            minute: Number(m[5]) || 0,
+            second: Number(m[6]) || 0,
+        };
+        if (!this.isDateTimeObjectValid(o))
+            return;
+        return this.createDateFromDateTimeObject(o);
+    }
+    parseLooselyOrUndefined(s) {
+        if (!s || typeof s !== 'string')
+            return;
+        const m = DATE_TIME_REGEX_LOOSE.exec(s);
+        if (!m) {
+            if (s.length < 8)
+                return;
+            // Attempt to parse with Date constructor
+            const d = new Date(s);
+            return isNaN(d.getDate()) ? undefined : d;
+        }
+        const o = {
+            year: Number(m[1]),
+            month: Number(m[2]),
+            day: Number(m[3]) || 1,
+            // [4] is skipped due to extra regex parentheses group
+            hour: Number(m[5]) || 0,
+            minute: Number(m[6]) || 0,
+            second: Number(m[7]) || 0,
+        };
+        if (!this.isDateTimeObjectValid(o))
+            return;
+        return this.createDateFromDateTimeObject(o);
+    }
+    /**
+     * Throws on invalid value.
+     */
+    validateDateTimeObject(o) {
+        _assert(this.isDateTimeObjectValid(o), `Cannot construct LocalTime from: ${o.year}-${o.month}-${o.day} ${o.hour}:${o.minute}:${o.second}`);
+    }
+    isDateTimeObjectValid(o) {
+        return localDate.isDateObjectValid(o) && this.isTimeObjectValid(o);
+    }
+    isTimeObjectValid({ hour, minute, second }) {
+        return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59;
+    }
+    fromDate(date) {
+        _assert(!isNaN(date.getDate()), `localTime.fromDate is called on Date object that is invalid`);
+        return new LocalTime(date);
+    }
+    fromUnix(ts) {
+        return new LocalTime(new Date(ts * 1000));
+    }
+    /**
+     * Create LocalTime from unixTimestamp in milliseconds (not in seconds).
+     */
+    fromMillis(millis) {
+        return new LocalTime(new Date(millis));
     }
+    fromDateTimeObject(o) {
+        // todo: validate?
+        return new LocalTime(this.createDateFromDateTimeObject(o));
+    }
+    createDateFromDateTimeObject(o) {
+        return new Date(o.year, o.month - 1, o.day || 1, o.hour || 0, o.minute || 0, o.second || 0);
+    }
+    // private assertNotNull(
+    //   lt: LocalTime | null,
+    //   input: LocalTimeInputNullable,
+    // ): asserts lt is LocalTime {
+    //   _assert(lt !== null, `Cannot parse "${input}" into LocalTime`, {
+    //     input,
+    //   })
+    // }
     /**
      * Returns the IANA timezone e.g `Europe/Stockholm`.
      * https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
@@ -733,23 +825,6 @@ class LocalTimeFactory {
     isTimezoneValid(tz) {
         return Intl.supportedValuesOf('timeZone').includes(tz);
     }
-    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(input) {
-        return input || input === 0 ? this.from(input) : undefined;
-    }
-    /**
-     * Creates a LocalTime from the input, unless it's falsy - then returns LocalTime.now
-     */
-    orNow(input) {
-        return input || input === 0 ? this.from(input) : this.now();
-    }
     sort(items, dir = 'asc', mutate = false) {
         const mod = dir === 'desc' ? -1 : 1;
         return (mutate ? items : [...items]).sort((a, b) => {
@@ -767,7 +842,7 @@ class LocalTimeFactory {
         const items2 = items.filter(_isTruthy);
         _assert(items2.length, 'localTime.min called on empty array');
         return items2
-            .map(i => this.from(i))
+            .map(i => this.fromInput(i))
             .reduce((min, item) => (min.$date.valueOf() <= item.$date.valueOf() ? min : item));
     }
     maxOrUndefined(items) {
@@ -777,7 +852,7 @@ class LocalTimeFactory {
         const items2 = items.filter(_isTruthy);
         _assert(items2.length, 'localTime.max called on empty array');
         return items2
-            .map(i => this.from(i))
+            .map(i => this.fromInput(i))
             .reduce((max, item) => (max.$date.valueOf() >= item.$date.valueOf() ? max : item));
     }
 }
@@ -870,14 +945,7 @@ function differenceInMonths(a, b) {
     return -(wholeMonthDiff + ((b.getTime() - anchor) / (anchor2 - anchor)) * sign);
 }
 const localTimeFactory = new LocalTimeFactory();
-export const localTime = localTimeFactory.from.bind(localTimeFactory);
+export const localTime = localTimeFactory.fromInput.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);
-}

package/dist-esm/datetime/timeInterval.js

@@ -11,7 +11,7 @@ export class TimeInterval {
         this.$end = $end;
     }
     static of(start, end) {
-        return new TimeInterval(localTime.from(start).unix, localTime.from(end).unix);
+        return new TimeInterval(localTime.fromInput(start).unix, localTime.fromInput(end).unix);
     }
     get start() {
         return this.$start;
@@ -55,7 +55,7 @@ export class TimeInterval {
         return this.cmp(d) >= 0;
     }
     includes(d, incl = '[)') {
-        d = localTime.from(d).unix;
+        d = localTime.fromInput(d).unix;
         // 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/decorators/logMethod.decorator.js

@@ -1,4 +1,4 @@
-import { SimpleMovingAverage, _stringify, _assert } from '..';
+import { _assert, _stringify, SimpleMovingAverage } from '..';
 import { _ms } from '../time/time.util';
 import { _getArgsSignature, _getMethodSignature } from './decorator.util';
 /**

package/dist-esm/index.js

@@ -1,88 +1,88 @@
+export * from './abort';
 export * from './array/array.util';
-export * from './define';
-export * from './string/url.util';
 export * from './array/range';
+export * from './datetime/dateInterval';
+export * from './datetime/localDate';
+export * from './datetime/localTime';
+export * from './datetime/timeInterval';
+export * from './datetime/wallTime';
+export * from './decorators/asyncMemo.decorator';
 export * from './decorators/createPromiseDecorator';
 export * from './decorators/debounce';
 export * from './decorators/debounce.decorator';
 export * from './decorators/decorator.util';
 export * from './decorators/logMethod.decorator';
 export * from './decorators/memo.decorator';
-export * from './decorators/asyncMemo.decorator';
 export * from './decorators/memo.util';
 export * from './decorators/memoFn';
 export * from './decorators/memoFnAsync';
 export * from './decorators/retry.decorator';
 export * from './decorators/timeout.decorator';
-export * from './error/assert';
+export * from './define';
 export * from './enum.util';
+export * from './env';
+export * from './env/buildInfo';
+export * from './error/assert';
 export * from './error/error.model';
 export * from './error/error.util';
 export * from './error/errorMode';
 export * from './error/try';
 export * from './error/tryCatch';
+export * from './form.util';
+export * from './http/fetcher';
+export * from './http/fetcher.model';
+export * from './http/http.model';
+export * from './is.util';
+export * from './iter/asyncIterable2';
+export * from './iter/iterable2';
 export * from './json-schema/from-data/generateJsonSchemaFromData';
 export * from './json-schema/jsonSchema.cnst';
 export * from './json-schema/jsonSchema.model';
 export * from './json-schema/jsonSchema.util';
 export * from './json-schema/jsonSchemaBuilder';
+export * from './log/commonLogger';
 export * from './math/math.util';
 export * from './math/sma';
+export * from './math/stack.util';
 export * from './number/createDeterministicRandom';
 export * from './number/number.util';
 export * from './object/deepEquals';
+export * from './object/map2';
 export * from './object/object.util';
+export * from './object/set2';
 export * from './object/sortObject';
 export * from './object/sortObjectDeep';
-export * from './object/map2';
-export * from './object/set2';
+export * from './polyfill';
+export * from './promise/abortable';
 export * from './promise/pDefer';
 export * from './promise/pDelay';
 export * from './promise/pFilter';
 export * from './promise/pHang';
 export * from './promise/pMap';
 export * from './promise/pProps';
+export * from './promise/pQueue';
 export * from './promise/pRetry';
 export * from './promise/pState';
 export * from './promise/pTimeout';
+export * from './semver';
 export * from './string/case';
-export * from './string/json.util';
-export * from './string/string.util';
-export * from './string/readingTime';
 export * from './string/escape';
+export * from './string/hash.util';
+export * from './string/json.util';
+export * from './string/leven';
 export * from './string/pupa';
+export * from './string/readingTime';
+export * from './string/regex';
+export * from './string/safeJsonStringify';
+export * from './string/string.util';
 export * from './string/stringify';
+export * from './string/url.util';
 export * from './time/time.util';
-export * from './is.util';
 export * from './typeFest';
 export * from './types';
 export * from './unit/size.util';
-export * from './log/commonLogger';
-export * from './string/safeJsonStringify';
-export * from './promise/pQueue';
-export * from './promise/abortable';
-export * from './iter/iterable2';
-export * from './iter/asyncIterable2';
-export * from './math/stack.util';
-export * from './string/leven';
-export * from './datetime/localDate';
-export * from './datetime/localTime';
-export * from './datetime/wallTime';
-export * from './datetime/dateInterval';
-export * from './datetime/timeInterval';
-export * from './env';
-export * from './http/http.model';
-export * from './http/fetcher';
-export * from './http/fetcher.model';
-export * from './string/hash.util';
-export * from './env/buildInfo';
-export * from './form.util';
-export * from './semver';
 export * from './web';
-export * from './abort';
-export * from './polyfill';
-export * from './string/regex';
-export * from './zod/zod.util';
 export * from './zod/zod.shared.schemas';
-import { z, ZodSchema, ZodError } from 'zod';
-export { z, ZodSchema, ZodError };
+export * from './zod/zod.util';
+import { z, ZodError, ZodSchema } from 'zod';
+export { z, ZodError, ZodSchema };

package/dist-esm/json-schema/jsonSchemaBuilder.js

@@ -1,5 +1,5 @@
 import { _uniq } from '../array/array.util';
-import { mergeJsonSchemaObjects, _deepCopy, _sortObject } from '../index';
+import { _deepCopy, _sortObject, mergeJsonSchemaObjects } from '../index';
 import { JSON_SCHEMA_ORDER } from './jsonSchema.cnst';
 /**
  * Fluent (chainable) API to manually create Json Schemas.

package/dist-esm/log/commonLogger.js

@@ -1,4 +1,5 @@
-import { _noop } from '../index';
+// copy-pasted to avoid weird circular dependency
+const _noop = (..._args) => undefined;
 export const commonLogLevelNumber = {
     log: 10,
     warn: 20,

package/dist-esm/time/time.util.js

@@ -35,8 +35,10 @@ export function _ms(millis) {
     if (millis < 1000)
         return `${Math.round(millis)} ms`;
     // < 5 sec
-    if (millis < 5000)
-        return `${(millis / 1000).toFixed(3)} sec`;
+    if (millis < 5000) {
+        const s = millis / 1000;
+        return `${Math.trunc(s) === s ? s : s.toFixed(3)} sec`;
+    }
     const sec = Math.floor(millis / 1000) % 60;
     const min = Math.floor(millis / (60 * 1000)) % 60;
     const hrs = Math.floor(millis / (3600 * 1000));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.244.0",
+  "version": "14.245.1",
   "scripts": {
     "prepare": "husky",
     "build-prod": "build-prod-esm-cjs",

package/src/datetime/dateInterval.ts

@@ -1,5 +1,5 @@
 import { Inclusiveness } from '../types'
-import { localDate, LocalDateInput, LocalDateUnit, LocalDate } from './localDate'
+import { LocalDate, localDate, LocalDateInput, LocalDateUnit } from './localDate'
 
 export type DateIntervalConfig = DateInterval | DateIntervalString
 export type DateIntervalString = string