@naturalcycles/js-lib 14.88.0 → 14.89.0

package/dist-esm/datetime/localDate.js

@@ -0,0 +1,285 @@
+import { _assert } from '../error/assert';
+import { Sequence } from '../seq/seq';
+import { END } from '../types';
+const m31 = new Set([1, 3, 5, 7, 8, 10, 12]);
+/**
+ * @experimental
+ */
+export class LocalDate {
+    constructor(year, month, day) {
+        this.year = year;
+        this.month = month;
+        this.day = day;
+    }
+    static create(year, month, day) {
+        return new LocalDate(year, month, day);
+    }
+    /**
+     * Parses input String into LocalDate.
+     * Input can already be a LocalDate - it is returned as-is in that case.
+     */
+    static of(d) {
+        if (d instanceof LocalDate)
+            return d;
+        const [year, month, day] = d.slice(0, 10).split('-').map(Number);
+        if (!day || !month || (!year && year !== 0)) {
+            throw new Error(`Cannot parse "${d}" into LocalDate`);
+        }
+        return new LocalDate(year, month, day);
+    }
+    static parseCompact(d) {
+        const [year, month, day] = [d.slice(0, 4), d.slice(4, 2), d.slice(6, 2)].map(Number);
+        if (!day || !month || (!year && year !== 0)) {
+            throw new Error(`Cannot parse "${d}" into LocalDate`);
+        }
+        return new LocalDate(year, month, day);
+    }
+    static fromDate(d) {
+        return new LocalDate(d.getFullYear(), d.getMonth() + 1, d.getDate());
+    }
+    static today() {
+        return this.fromDate(new Date());
+    }
+    static sort(items, mutate = false, descending = false) {
+        const mod = descending ? -1 : 1;
+        return (mutate ? items : [...items]).sort((a, b) => a.cmp(b) * mod);
+    }
+    static earliestOrUndefined(items) {
+        return items.length ? LocalDate.earliest(items) : undefined;
+    }
+    static earliest(items) {
+        _assert(items.length, 'LocalDate.earliest called on empty array');
+        return items.reduce((min, item) => (min.isSameOrBefore(item) ? min : item));
+    }
+    static latestOrUndefined(items) {
+        return items.length ? LocalDate.latest(items) : undefined;
+    }
+    static latest(items) {
+        _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);
+            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 Sequence.create(min, d => {
+            const next = d.add(step, stepUnit);
+            return next.isAfter(max) ? 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());
+    }
+    isSame(d) {
+        d = LocalDate.of(d);
+        return this.day === d.day && this.month === d.month && this.year === d.year;
+    }
+    isBefore(d) {
+        return this.cmp(d) === -1;
+    }
+    isSameOrBefore(d) {
+        return this.cmp(d) <= 0;
+    }
+    isAfter(d) {
+        return this.cmp(d) === 1;
+    }
+    isSameOrAfter(d) {
+        return this.cmp(d) >= 0;
+    }
+    /**
+     * Returns 1 if this > d
+     * returns 0 if they are equal
+     * returns -1 if this < d
+     */
+    cmp(d) {
+        d = LocalDate.of(d);
+        if (this.year < d.year)
+            return -1;
+        if (this.year > d.year)
+            return 1;
+        if (this.month < d.month)
+            return -1;
+        if (this.month > d.month)
+            return 1;
+        if (this.day < d.day)
+            return -1;
+        if (this.day > d.day)
+            return 1;
+        return 0;
+    }
+    /**
+     * Same as Math.abs( diff )
+     */
+    absDiff(d, unit) {
+        return Math.abs(this.diff(d, unit));
+    }
+    /**
+     * Returns the number of **full** units difference (aka `Math.ceil`).
+     *
+     * a.diff(b) means "a minus b"
+     */
+    diff(d, unit) {
+        d = LocalDate.of(d);
+        if (unit === 'year') {
+            return this.year - d.year;
+        }
+        if (unit === '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++) {
+                days += this.getYearDays(year);
+            }
+        }
+        else if (this.year < d.year) {
+            for (let year = this.year; year < d.year; year++) {
+                days -= this.getYearDays(year);
+            }
+        }
+        if (d.month < this.month) {
+            for (let month = d.month; month < this.month; month++) {
+                days += this.getMonthLen(this.year, month);
+            }
+        }
+        else if (this.month < d.month) {
+            for (let month = this.month; month < d.month; month++) {
+                days -= this.getMonthLen(d.year, month);
+            }
+        }
+        return days;
+    }
+    add(num, unit, mutate = false) {
+        let { day, month, year } = this;
+        if (unit === 'day') {
+            day += num;
+        }
+        else if (unit === 'month') {
+            month += num;
+        }
+        else if (unit === 'year') {
+            year += num;
+        }
+        // check day overflow
+        let monLen = this.getMonthLen(year, month);
+        while (day > monLen) {
+            day -= monLen;
+            month += 1;
+            if (month > 12) {
+                year += 1;
+                month -= 12;
+            }
+            monLen = this.getMonthLen(year, month);
+        }
+        while (day < 1) {
+            day += monLen;
+            month -= 1;
+            if (month < 1) {
+                year -= 1;
+                month += 12;
+            }
+            monLen = this.getMonthLen(year, month);
+        }
+        // check month overflow
+        while (month > 12) {
+            year += 1;
+            month -= 12;
+        }
+        while (month < 1) {
+            year -= 1;
+            month += 12;
+        }
+        if (mutate) {
+            this.year = year;
+            this.month = month;
+            this.day = day;
+            return this;
+        }
+        return new LocalDate(year, month, day);
+    }
+    subtract(num, unit, mutate = false) {
+        return this.add(-num, unit, mutate);
+    }
+    startOf(unit) {
+        if (unit === 'day')
+            return this;
+        if (unit === 'month')
+            return LocalDate.create(this.year, this.month, 1);
+        // year
+        return LocalDate.create(this.year, 1, 1);
+    }
+    endOf(unit) {
+        if (unit === 'day')
+            return this;
+        if (unit === 'month')
+            return LocalDate.create(this.year, this.month, this.getMonthLen(this.year, this.month));
+        // year
+        return LocalDate.create(this.year, 12, 31);
+    }
+    getYearDays(year) {
+        return this.isLeapYear(year) ? 366 : 365;
+    }
+    getMonthLen(year, month) {
+        if (month === 2)
+            return this.isLeapYear(year) ? 29 : 28;
+        return m31.has(month) ? 31 : 30;
+    }
+    isLeapYear(year) {
+        if (year % 4 !== 0)
+            return false;
+        if (year % 100 !== 0)
+            return true;
+        return year % 400 === 0;
+    }
+    clone() {
+        return new LocalDate(this.year, this.month, this.day);
+    }
+    /**
+     * Converts LocalDate into instance of Date.
+     * Year, month and day will match.
+     * Hour, minute, second, ms will be 0.
+     * Timezone will match local timezone.
+     */
+    toDate() {
+        return new Date(this.year, this.month - 1, this.day);
+    }
+    toString() {
+        return [
+            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'),
+        ].join('');
+    }
+    toJSON() {
+        return this.toString();
+    }
+}
+/**
+ * Shortcut wrapper around `LocalDate.parse` / `LocalDate.today`
+ */
+export function localDate(d) {
+    return d ? LocalDate.of(d) : LocalDate.today();
+}

package/dist-esm/datetime/localTime.js

@@ -0,0 +1,299 @@
+import { _assert } from '../error/assert';
+/* eslint-disable no-dupe-class-members */
+// Design choices:
+// No milliseconds
+// No timezone support, ISO8601 is parsed as LocalDateTime, discarding Timezone information
+// Formats as unix timestamp, ISO8601 or "pretty string"
+// toString and .toJSON formats as unix timestamp
+// No "unixMillis", just pure unixtimestamp
+// .valueOf returns unix timestamp (no millis)
+// Prevents dayjs(undefined) being dayjs.now()
+// Validates on parse, throws if invalid. Doesn't allow invalid objects
+/**
+ * @experimental
+ */
+export class LocalTime {
+    constructor($date) {
+        this.$date = $date;
+    }
+    /**
+     * Parses input String into LocalDate.
+     * Input can already be a LocalDate - it is returned as-is in that case.
+     */
+    static of(d) {
+        if (d instanceof LocalTime)
+            return d;
+        if (d instanceof Date)
+            return new LocalTime(d);
+        if (typeof d === 'number') {
+            // unix timestamp
+            return new LocalTime(new Date(d * 1000));
+        }
+        const date = new Date(d);
+        // validation
+        if (isNaN(date.getDate())) {
+            throw new TypeError(`Cannot parse "${d}" into LocalTime`);
+        }
+        return new LocalTime(date);
+    }
+    static unix(ts) {
+        return new LocalTime(new Date(ts * 1000));
+    }
+    static now() {
+        return this.of(new Date());
+    }
+    static fromComponents(c) {
+        return new LocalTime(new Date(c.year, c.month - 1, c.day, c.hour, c.minute, c.second));
+    }
+    get(unit) {
+        if (unit === 'year') {
+            return this.$date.getFullYear();
+        }
+        if (unit === 'month') {
+            return this.$date.getMonth() + 1;
+        }
+        if (unit === 'day') {
+            return this.$date.getDate();
+        }
+        if (unit === 'hour') {
+            return this.$date.getHours();
+        }
+        if (unit === 'minute') {
+            return this.$date.getMinutes();
+        }
+        // second
+        return this.$date.getSeconds();
+    }
+    set(unit, v, mutate = false) {
+        const t = mutate ? this : this.clone();
+        if (unit === 'year') {
+            t.$date.setFullYear(v);
+        }
+        else if (unit === 'month') {
+            t.$date.setMonth(v - 1);
+        }
+        else if (unit === 'day') {
+            t.$date.setDate(v);
+        }
+        else if (unit === 'hour') {
+            t.$date.setHours(v);
+        }
+        else if (unit === 'minute') {
+            t.$date.setMinutes(v);
+        }
+        else if (unit === 'second') {
+            t.$date.setSeconds(v);
+        }
+        return t;
+    }
+    year(v) {
+        return v === undefined ? this.$date.getFullYear() : this.set('year', v);
+    }
+    month(v) {
+        return v === undefined ? this.$date.getMonth() + 1 : this.set('month', v);
+    }
+    date(v) {
+        return v === undefined ? this.$date.getDate() : this.set('day', v);
+    }
+    hour(v) {
+        return v === undefined ? this.$date.getHours() : this.set('hour', v);
+    }
+    minute(v) {
+        return v === undefined ? this.$date.getMinutes() : this.set('minute', v);
+    }
+    second(v) {
+        return v === undefined ? this.$date.getSeconds() : this.set('second', v);
+    }
+    setComponents(c, mutate = false) {
+        const d = mutate ? this.$date : new Date(this.$date);
+        if (c.year) {
+            d.setFullYear(c.year);
+        }
+        if (c.month) {
+            d.setMonth(c.month - 1);
+        }
+        if (c.day) {
+            d.setDate(c.day);
+        }
+        if (c.hour !== undefined) {
+            d.setHours(c.hour);
+        }
+        if (c.minute !== undefined) {
+            d.setMinutes(c.minute);
+        }
+        if (c.second !== undefined) {
+            d.setSeconds(c.second);
+        }
+        return mutate ? this : new LocalTime(d);
+    }
+    add(num, unit, mutate = false) {
+        return this.set(unit, this.get(unit) + num, mutate);
+    }
+    subtract(num, unit, mutate = false) {
+        return this.add(-num, unit, mutate);
+    }
+    absDiff(other, unit) {
+        return Math.abs(this.diff(other, unit));
+    }
+    diff(other, unit) {
+        const date2 = LocalTime.of(other).$date;
+        if (unit === 'year') {
+            return this.$date.getFullYear() - date2.getFullYear();
+        }
+        if (unit === 'month') {
+            return ((this.$date.getFullYear() - date2.getFullYear()) * 12 +
+                this.$date.getMonth() -
+                date2.getMonth());
+        }
+        const secDiff = (this.$date.valueOf() - date2.valueOf()) / 1000;
+        let r;
+        if (unit === 'day') {
+            r = secDiff / (24 * 60 * 60);
+        }
+        else if (unit === 'hour') {
+            r = secDiff / (60 * 60);
+        }
+        else if (unit === 'minute') {
+            r = secDiff / 60;
+        }
+        else {
+            // unit === 'second'
+            r = secDiff;
+        }
+        r = r < 0 ? -Math.floor(-r) : Math.floor(r);
+        if (Object.is(r, -0))
+            return 0;
+        return r;
+    }
+    startOf(unit, mutate = false) {
+        if (unit === 'second')
+            return this;
+        if (mutate) {
+            const d = this.$date;
+            d.setSeconds(0);
+            if (unit === 'minute')
+                return this;
+            d.setMinutes(0);
+            if (unit === 'hour')
+                return this;
+            d.setHours(0);
+            if (unit === 'day')
+                return this;
+            d.setDate(0);
+            if (unit === 'month')
+                return this;
+            d.setMonth(0);
+            return this;
+        }
+        const c = this.components();
+        c.second = 0;
+        if (unit === 'year') {
+            c.month = c.day = 1;
+            c.hour = c.minute = 0;
+        }
+        else if (unit === 'month') {
+            c.day = 1;
+            c.hour = c.minute = 0;
+        }
+        else if (unit === 'day') {
+            c.hour = c.minute = 0;
+        }
+        else if (unit === 'hour') {
+            c.minute = 0;
+        }
+        return LocalTime.fromComponents(c);
+    }
+    static sort(items, mutate = false, descending = false) {
+        const mod = descending ? -1 : 1;
+        return (mutate ? items : [...items]).sort((a, b) => {
+            const v1 = a.$date.valueOf();
+            const v2 = b.$date.valueOf();
+            if (v1 === v2)
+                return 0;
+            return (v1 < v2 ? -1 : 1) * mod;
+        });
+    }
+    static earliestOrUndefined(items) {
+        return items.length ? LocalTime.earliest(items) : undefined;
+    }
+    static earliest(items) {
+        _assert(items.length, 'LocalTime.earliest called on empty array');
+        return items.reduce((min, item) => (min.isSameOrBefore(item) ? min : item));
+    }
+    static latestOrUndefined(items) {
+        return items.length ? LocalTime.latest(items) : undefined;
+    }
+    static latest(items) {
+        _assert(items.length, 'LocalTime.latest called on empty array');
+        return items.reduce((max, item) => (max.isSameOrAfter(item) ? max : item));
+    }
+    isSame(d) {
+        return this.cmp(d) === 0;
+    }
+    isBefore(d) {
+        return this.cmp(d) === -1;
+    }
+    isSameOrBefore(d) {
+        return this.cmp(d) <= 0;
+    }
+    isAfter(d) {
+        return this.cmp(d) === 1;
+    }
+    isSameOrAfter(d) {
+        return this.cmp(d) >= 0;
+    }
+    /**
+     * Returns 1 if this > d
+     * returns 0 if they are equal
+     * returns -1 if this < d
+     */
+    cmp(d) {
+        const t1 = this.$date.valueOf();
+        const t2 = LocalTime.of(d).$date.valueOf();
+        if (t1 === t2)
+            return 0;
+        return t1 < t2 ? -1 : 1;
+    }
+    // todo: endOf
+    components() {
+        return {
+            year: this.$date.getFullYear(),
+            month: this.$date.getMonth() + 1,
+            day: this.$date.getDate(),
+            hour: this.$date.getHours(),
+            minute: this.$date.getMinutes(),
+            second: this.$date.getSeconds(),
+        };
+    }
+    getDate() {
+        return this.$date;
+    }
+    clone() {
+        return new LocalTime(new Date(this.$date));
+    }
+    unix() {
+        return Math.floor(this.$date.valueOf() / 1000);
+    }
+    valueOf() {
+        return Math.floor(this.$date.valueOf() / 1000);
+    }
+    toISO8601() {
+        return this.$date.toISOString().slice(0, 19);
+    }
+    toPretty() {
+        return this.$date.toISOString().slice(0, 19).split('T').join(' ');
+    }
+    toString() {
+        return String(this.unix());
+    }
+    toJSON() {
+        return this.unix();
+    }
+}
+/**
+ * Shortcut wrapper around `LocalDate.parse` / `LocalDate.today`
+ */
+export function localTime(d) {
+    return d ? LocalTime.of(d) : LocalTime.now();
+}
+// todo: range

package/dist-esm/index.js

@@ -57,4 +57,6 @@ import { PQueue } from './promise/pQueue';
 export * from './seq/seq';
 export * from './math/stack.util';
 export * from './string/leven';
+export * from './datetime/localDate';
+export * from './datetime/localTime';
 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-esm/vendor/is.js

@@ -138,15 +138,15 @@ is.array = (value, assertion) => {
     }
     return value.every(assertion);
 };
-is.buffer = (value) => { var _a, _b, _c, _d; return (_d = (_c = (_b = (_a = value) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.isBuffer) === null || _c === void 0 ? void 0 : _c.call(_b, value)) !== null && _d !== void 0 ? _d : false; };
+is.buffer = (value) => { var _a, _b, _c; return (_c = (_b = (_a = value === null || value === void 0 ? void 0 : value.constructor) === null || _a === void 0 ? void 0 : _a.isBuffer) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : false; };
 is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value);
 is.object = (value) => !is.null_(value) && (typeof value === 'object' || is.function_(value));
-is.iterable = (value) => { var _a; return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a[Symbol.iterator]); };
-is.asyncIterable = (value) => { var _a; return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a[Symbol.asyncIterator]); };
+is.iterable = (value) => is.function_(value === null || value === void 0 ? void 0 : value[Symbol.iterator]);
+is.asyncIterable = (value) => is.function_(value === null || value === void 0 ? void 0 : value[Symbol.asyncIterator]);
 is.generator = (value) => is.iterable(value) && is.function_(value.next) && is.function_(value.throw);
 is.asyncGenerator = (value) => is.asyncIterable(value) && is.function_(value.next) && is.function_(value.throw);
 is.nativePromise = (value) => isObjectOfType('Promise')(value);
-const hasPromiseAPI = (value) => { var _a, _b; return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a.then) && is.function_((_b = value) === null || _b === void 0 ? void 0 : _b.catch); };
+const hasPromiseAPI = (value) => is.function_(value === null || value === void 0 ? void 0 : value.then) && is.function_(value === null || value === void 0 ? void 0 : value.catch);
 is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value);
 is.generatorFunction = isObjectOfType('GeneratorFunction');
 is.asyncGeneratorFunction = (value) => getObjectType(value) === 'AsyncGeneratorFunction';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.88.0",
+  "version": "14.89.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",
@@ -14,6 +14,7 @@
     "@naturalcycles/bench-lib": "^1.5.0",
     "@naturalcycles/dev-lib": "^12.0.0",
     "@naturalcycles/nodejs-lib": "^12.33.4",
+    "@naturalcycles/time-lib": "^3.5.1",
     "@types/node": "^17.0.4",
     "jest": "^27.0.1",
     "patch-package": "^6.2.1",

package/src/__exclude/lazyLocalDate.ts

@@ -0,0 +1,73 @@
+import { LocalDateUnit, LocalDate, LocalDateConfig } from '../datetime/localDate'
+
+export class LazyLocalDate {
+  constructor(private str: string) {}
+
+  private ld?: LocalDate
+
+  eq(d: LocalDateConfig): boolean {
+    if (typeof d === 'string') return d === this.str
+    this.ld ||= LocalDate.of(this.str)
+    return this.ld.isSame(d)
+  }
+
+  lt(d: LocalDateConfig): boolean {
+    return this.cmp(d) === -1
+  }
+
+  lte(d: LocalDateConfig): boolean {
+    return this.cmp(d) <= 0
+  }
+
+  gt(d: LocalDateConfig): boolean {
+    return this.cmp(d) === 1
+  }
+
+  gte(d: LocalDateConfig): boolean {
+    return this.cmp(d) >= 0
+  }
+
+  cmp(d: LocalDateConfig): -1 | 0 | 1 {
+    if (typeof d === 'string') {
+      return this.str < d ? -1 : this.str > d ? 1 : 0
+    }
+
+    this.ld ||= LocalDate.of(this.str)
+    return this.ld.cmp(d)
+  }
+
+  absDiff(d: LocalDateConfig, unit: LocalDateUnit): number {
+    return Math.abs(this.diff(d, unit))
+  }
+
+  diff(d: LocalDateConfig, unit: LocalDateUnit): number {
+    this.ld ||= LocalDate.of(this.str)
+    return this.ld.diff(d, unit)
+  }
+
+  add(num: number, unit: LocalDateUnit): LocalDate {
+    this.ld ||= LocalDate.of(this.str)
+    return this.ld.add(num, unit)
+  }
+
+  subtract(num: number, unit: LocalDateUnit): LocalDate {
+    return this.add(-num, unit)
+  }
+
+  clone(): LazyLocalDate {
+    return new LazyLocalDate(this.str)
+  }
+
+  toDate(): Date {
+    this.ld ||= LocalDate.of(this.str)
+    return this.ld.toDate()
+  }
+
+  toString(): string {
+    return this.str
+  }
+
+  toJSON(): string {
+    return this.str
+  }
+}