@naturalcycles/js-lib 14.98.3 → 14.99.2

package/src/datetime/localDate.ts

@@ -2,13 +2,15 @@ import { _assert } from '../error/assert'
 import { IsoDateString, IsoDateTimeString, UnixTimestampNumber } from '../types'
 import { LocalTime } from './localTime'
 
-export type LocalDateUnit = 'year' | 'month' | 'day'
+export type LocalDateUnit = LocalDateUnitStrict | 'week'
+export type LocalDateUnitStrict = 'year' | 'month' | 'day'
 export type Inclusiveness = '()' | '[]' | '[)' | '(]'
 
 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)$/
 
 export type LocalDateConfig = LocalDate | IsoDateString
+export type LocalDateFormatter = (ld: LocalDate) => string
 
 /* eslint-disable no-dupe-class-members */
 
@@ -106,24 +108,28 @@ export class LocalDate {
     return (mutate ? items : [...items]).sort((a, b) => a.cmp(b) * mod)
   }
 
-  static earliestOrUndefined(items: LocalDate[]): LocalDate | undefined {
+  static earliestOrUndefined(items: LocalDateConfig[]): LocalDate | undefined {
     return items.length ? LocalDate.earliest(items) : undefined
   }
 
-  static earliest(items: LocalDate[]): LocalDate {
+  static earliest(items: LocalDateConfig[]): LocalDate {
     _assert(items.length, 'LocalDate.earliest called on empty array')
 
-    return items.reduce((min, item) => (min.isSameOrBefore(item) ? min : item))
+    return items
+      .map(i => LocalDate.of(i))
+      .reduce((min, item) => (min.isSameOrBefore(item) ? min : item))
   }
 
-  static latestOrUndefined(items: LocalDate[]): LocalDate | undefined {
+  static latestOrUndefined(items: LocalDateConfig[]): LocalDate | undefined {
     return items.length ? LocalDate.latest(items) : undefined
   }
 
-  static latest(items: LocalDate[]): LocalDate {
+  static latest(items: LocalDateConfig[]): LocalDate {
     _assert(items.length, 'LocalDate.latest called on empty array')
 
-    return items.reduce((max, item) => (max.isSameOrAfter(item) ? max : item))
+    return items
+      .map(i => LocalDate.of(i))
+      .reduce((max, item) => (max.isSameOrAfter(item) ? max : item))
   }
 
   static range(
@@ -133,6 +139,11 @@ export class LocalDate {
     step = 1,
     stepUnit: LocalDateUnit = 'day',
   ): LocalDate[] {
+    if (stepUnit === 'week') {
+      step *= 7
+      stepUnit = 'day'
+    }
+
     const dates: LocalDate[] = []
     const $min = LocalDate.of(min)
     const $max = LocalDate.of(max).startOf(stepUnit)
@@ -153,11 +164,11 @@ export class LocalDate {
     return dates
   }
 
-  get(unit: LocalDateUnit): number {
+  get(unit: LocalDateUnitStrict): number {
     return unit === 'year' ? this.$year : unit === 'month' ? this.$month : this.$day
   }
 
-  set(unit: LocalDateUnit, v: number, mutate = false): LocalDate {
+  set(unit: LocalDateUnitStrict, v: number, mutate = false): LocalDate {
     const t = mutate ? this : this.clone()
 
     if (unit === 'year') {
@@ -242,50 +253,69 @@ export class LocalDate {
   }
 
   /**
-   * Returns the number of **full** units difference (aka `Math.ceil`).
+   * Returns the number of **full** units difference (aka `Math.floor`).
    *
    * a.diff(b) means "a minus b"
    */
   diff(d: LocalDateConfig, unit: LocalDateUnit): number {
     d = LocalDate.of(d)
 
+    const sign = this.cmp(d)
+    if (!sign) return 0
+
+    // Put items in descending order: "big minus small"
+    const [big, small] = sign === 1 ? [this, d] : [d, this]
+
     if (unit === 'year') {
-      return this.$year - d.$year
+      let years = big.$year - small.$year
+
+      if (big.$month < small.$month || (big.$month === small.$month && big.$day < small.$day)) {
+        years--
+      }
+
+      return years * sign || 0
     }
 
     if (unit === 'month') {
-      return (this.$year - d.$year) * 12 + (this.$month - d.$month)
+      let months = (big.$year - small.$year) * 12 + (big.$month - small.$month)
+      if (big.$day < small.$day) months--
+      return months * sign || 0
     }
 
-    // unit is 'day'
-    let days = this.$day - d.$day
+    // unit is 'day' or 'week'
+    let days = big.$day - small.$day
 
-    if (d.$year < this.$year) {
-      for (let year = d.$year; year < this.$year; year++) {
-        days += LocalDate.getYearLength(year)
-      }
-    } else if (this.$year < d.$year) {
-      for (let year = this.$year; year < d.$year; year++) {
-        days -= LocalDate.getYearLength(year)
-      }
+    // If small date is after 1st of March - next year's "leapness" should be used
+    const offsetYear = small.$month >= 3 ? 1 : 0
+    for (let year = small.$year; year < big.$year; year++) {
+      days += LocalDate.getYearLength(year + offsetYear)
     }
 
-    if (d.$month < this.$month) {
-      for (let month = d.$month; month < this.$month; month++) {
-        days += LocalDate.getMonthLength(this.$year, month)
+    if (small.$month < big.$month) {
+      for (let month = small.$month; month < big.$month; month++) {
+        days += LocalDate.getMonthLength(big.$year, month)
       }
-    } else if (this.$month < d.$month) {
-      for (let month = this.$month; month < d.$month; month++) {
-        days -= LocalDate.getMonthLength(d.$year, month)
+    } else if (big.$month < small.$month) {
+      for (let month = big.$month; month < small.$month; month++) {
+        days -= LocalDate.getMonthLength(big.$year, month)
       }
     }
 
-    return days
+    if (unit === 'week') {
+      return Math.trunc(days / 7) * sign || 0
+    }
+
+    return days * sign || 0
   }
 
   add(num: number, unit: LocalDateUnit, mutate = false): LocalDate {
     let { $day, $month, $year } = this
 
+    if (unit === 'week') {
+      num *= 7
+      unit = 'day'
+    }
+
     if (unit === 'day') {
       $day += num
     } else if (unit === 'month') {
@@ -346,14 +376,14 @@ export class LocalDate {
     return this.add(-num, unit, mutate)
   }
 
-  startOf(unit: LocalDateUnit): LocalDate {
+  startOf(unit: LocalDateUnitStrict): 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 {
+  endOf(unit: LocalDateUnitStrict): LocalDate {
     if (unit === 'day') return this
     if (unit === 'month')
       return LocalDate.create(
@@ -435,6 +465,10 @@ export class LocalDate {
   toJSON(): IsoDateString {
     return this.toString()
   }
+
+  format(fmt: LocalDateFormatter): string {
+    return fmt(this)
+  }
 }
 
 /**