@naturalcycles/js-lib 14.86.0 → 14.89.0

package/dist-esm/string/leven.js

@@ -0,0 +1,71 @@
+const array = [];
+const characterCodeCache = [];
+/* eslint-disable unicorn/prefer-code-point, no-bitwise */
+/**
+ * Modified version of: https://github.com/sindresorhus/leven/
+ *
+ * Returns a Levenshtein distance between first and second word.
+ */
+export function _leven(first, second) {
+    if (first === second) {
+        return 0;
+    }
+    const swap = first;
+    // Swapping the strings if `a` is longer than `b` so we know which one is the
+    // shortest & which one is the longest
+    if (first.length > second.length) {
+        first = second;
+        second = swap;
+    }
+    let firstLength = first.length;
+    let secondLength = second.length;
+    // Performing suffix trimming:
+    // We can linearly drop suffix common to both strings since they
+    // don't increase distance at all
+    // Note: `~-` is the bitwise way to perform a `- 1` operation
+    while (firstLength > 0 && first.charCodeAt(~-firstLength) === second.charCodeAt(~-secondLength)) {
+        firstLength--;
+        secondLength--;
+    }
+    // Performing prefix trimming
+    // We can linearly drop prefix common to both strings since they
+    // don't increase distance at all
+    let start = 0;
+    while (start < firstLength && first.charCodeAt(start) === second.charCodeAt(start)) {
+        start++;
+    }
+    firstLength -= start;
+    secondLength -= start;
+    if (firstLength === 0) {
+        return secondLength;
+    }
+    let bCharacterCode;
+    let result;
+    let temporary;
+    let temporary2;
+    let index = 0;
+    let index2 = 0;
+    while (index < firstLength) {
+        characterCodeCache[index] = first.charCodeAt(start + index);
+        array[index] = ++index;
+    }
+    while (index2 < secondLength) {
+        bCharacterCode = second.charCodeAt(start + index2);
+        temporary = index2++;
+        result = index2;
+        for (index = 0; index < firstLength; index++) {
+            temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1;
+            temporary = array[index];
+            // eslint-disable-next-line no-multi-assign
+            result = array[index] =
+                temporary > result
+                    ? temporary2 > result
+                        ? result + 1
+                        : temporary2
+                    : temporary2 > temporary
+                        ? temporary + 1
+                        : temporary2;
+        }
+    }
+    return result;
+}

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.86.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
+  }
+}

package/src/datetime/localDate.ts

@@ -0,0 +1,355 @@
+import { _assert } from '../error/assert'
+import { Sequence } from '../seq/seq'
+import { END, IsoDate } from '../types'
+
+export type LocalDateUnit = 'year' | 'month' | 'day'
+
+const m31 = new Set<number>([1, 3, 5, 7, 8, 10, 12])
+
+export type LocalDateConfig = LocalDate | string
+
+/**
+ * @experimental
+ */
+export class LocalDate {
+  private constructor(public year: number, public month: number, public day: number) {}
+
+  static create(year: number, month: number, day: number): LocalDate {
+    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: LocalDateConfig): LocalDate {
+    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: string): LocalDate {
+    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: Date): LocalDate {
+    return new LocalDate(d.getFullYear(), d.getMonth() + 1, d.getDate())
+  }
+
+  static today(): LocalDate {
+    return this.fromDate(new Date())
+  }
+
+  static sort(items: LocalDate[], mutate = false, descending = false): LocalDate[] {
+    const mod = descending ? -1 : 1
+    return (mutate ? items : [...items]).sort((a, b) => a.cmp(b) * mod)
+  }
+
+  static earliestOrUndefined(items: LocalDate[]): LocalDate | undefined {
+    return items.length ? LocalDate.earliest(items) : undefined
+  }
+
+  static earliest(items: LocalDate[]): LocalDate {
+    _assert(items.length, 'LocalDate.earliest called on empty array')
+
+    return items.reduce((min, item) => (min.isSameOrBefore(item) ? min : item))
+  }
+
+  static latestOrUndefined(items: LocalDate[]): LocalDate | undefined {
+    return items.length ? LocalDate.latest(items) : undefined
+  }
+
+  static latest(items: LocalDate[]): LocalDate {
+    _assert(items.length, 'LocalDate.latest called on empty array')
+
+    return items.reduce((max, item) => (max.isSameOrAfter(item) ? max : item))
+  }
+
+  static range(
+    minIncl: LocalDateConfig,
+    maxExcl: LocalDateConfig,
+    step = 1,
+    stepUnit: LocalDateUnit = 'day',
+  ): LocalDate[] {
+    const days: LocalDate[] = []
+    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: LocalDateConfig,
+    maxExcl: LocalDateConfig,
+    step = 1,
+    stepUnit: LocalDateUnit = 'day',
+  ): Sequence<LocalDate> {
+    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: LocalDateConfig,
+    maxExcl: LocalDateConfig,
+    step = 1,
+    stepUnit: LocalDateUnit = 'day',
+  ): IsoDate[] {
+    return LocalDate.range(minIncl, maxExcl, step, stepUnit).map(ld => ld.toString())
+  }
+
+  static rangeIncl(
+    minIncl: LocalDateConfig,
+    maxIncl: LocalDateConfig,
+    step = 1,
+    stepUnit: LocalDateUnit = 'day',
+  ): LocalDate[] {
+    return LocalDate.range(minIncl, LocalDate.of(maxIncl).add(1, stepUnit), step, stepUnit)
+  }
+
+  static rangeInclString(
+    minIncl: LocalDateConfig,
+    maxIncl: LocalDateConfig,
+    step = 1,
+    stepUnit: LocalDateUnit = 'day',
+  ): IsoDate[] {
+    return LocalDate.range(minIncl, LocalDate.of(maxIncl).add(1, stepUnit), step, stepUnit).map(
+      ld => ld.toString(),
+    )
+  }
+
+  isSame(d: LocalDateConfig): boolean {
+    d = LocalDate.of(d)
+    return this.day === d.day && this.month === d.month && this.year === d.year
+  }
+
+  isBefore(d: LocalDateConfig): boolean {
+    return this.cmp(d) === -1
+  }
+
+  isSameOrBefore(d: LocalDateConfig): boolean {
+    return this.cmp(d) <= 0
+  }
+
+  isAfter(d: LocalDateConfig): boolean {
+    return this.cmp(d) === 1
+  }
+
+  isSameOrAfter(d: LocalDateConfig): boolean {
+    return this.cmp(d) >= 0
+  }
+
+  /**
+   * Returns 1 if this > d
+   * returns 0 if they are equal
+   * returns -1 if this < d
+   */
+  cmp(d: LocalDateConfig): -1 | 0 | 1 {
+    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: LocalDateConfig, unit: LocalDateUnit): number {
+    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: LocalDateConfig, unit: LocalDateUnit): number {
+    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: number, unit: LocalDateUnit, mutate = false): LocalDate {
+    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: number, unit: LocalDateUnit, mutate = false): LocalDate {
+    return this.add(-num, unit, mutate)
+  }
+
+  startOf(unit: LocalDateUnit): LocalDate {
+    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: LocalDateUnit): LocalDate {
+    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)
+  }
+
+  private getYearDays(year: number): number {
+    return this.isLeapYear(year) ? 366 : 365
+  }
+
+  private getMonthLen(year: number, month: number): number {
+    if (month === 2) return this.isLeapYear(year) ? 29 : 28
+    return m31.has(month) ? 31 : 30
+  }
+
+  private isLeapYear(year: number): boolean {
+    if (year % 4 !== 0) return false
+    if (year % 100 !== 0) return true
+    return year % 400 === 0
+  }
+
+  clone(): LocalDate {
+    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(): Date {
+    return new Date(this.year, this.month - 1, this.day)
+  }
+
+  toString(): IsoDate {
+    return [
+      String(this.year).padStart(4, '0'),
+      String(this.month).padStart(2, '0'),
+      String(this.day).padStart(2, '0'),
+    ].join('-')
+  }
+
+  toStringCompact(): string {
+    return [
+      String(this.year).padStart(4, '0'),
+      String(this.month).padStart(2, '0'),
+      String(this.day).padStart(2, '0'),
+    ].join('')
+  }
+
+  toJSON(): IsoDate {
+    return this.toString()
+  }
+}
+
+/**
+ * Shortcut wrapper around `LocalDate.parse` / `LocalDate.today`
+ */
+export function localDate(d?: LocalDateConfig): LocalDate {
+  return d ? LocalDate.of(d) : LocalDate.today()
+}