@naturalcycles/js-lib 14.96.1 → 14.98.0

package/src/datetime/localDate.ts

@@ -1,20 +1,22 @@
 import { _assert } from '../error/assert'
-import { Sequence } from '../seq/seq'
-import { END, IsoDate, UnixTimestamp } from '../types'
+import { IsoDateString, UnixTimestampNumber } from '../types'
 import { LocalTime } from './localTime'
 
 export type LocalDateUnit = 'year' | 'month' | 'day'
 export type Inclusiveness = '()' | '[]' | '[)' | '(]'
 
-const m31 = new Set<number>([1, 3, 5, 7, 8, 10, 12])
+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 | string
+export type LocalDateConfig = LocalDate | IsoDateString
+
+/* eslint-disable no-dupe-class-members */
 
 /**
  * @experimental
  */
 export class LocalDate {
-  private constructor(public year: number, public month: number, public day: number) {}
+  private constructor(private $year: number, private $month: number, private $day: number) {}
 
   static create(year: number, month: number, day: number): LocalDate {
     return new LocalDate(year, month, day)
@@ -59,8 +61,13 @@ export class LocalDate {
     if (!d) return null
     if (d instanceof LocalDate) return d
 
-    // todo: explore more performant options
-    const [year, month, day] = d.slice(0, 10).split('-').map(Number)
+    // const [year, month, day] = d.slice(0, 10).split('-').map(Number)
+    const matches = DATE_REGEX.exec(d.slice(0, 10))
+    if (!matches) return null
+
+    const year = Number(matches[1])
+    const month = Number(matches[2])
+    const day = Number(matches[3])
 
     if (
       !year ||
@@ -77,6 +84,11 @@ export class LocalDate {
     return new LocalDate(year, month, day)
   }
 
+  // Can use just .toString()
+  // static parseToString(d: LocalDateConfig): IsoDateString {
+  //   return typeof d === 'string' ? d : d.toString()
+  // }
+
   static isValid(iso: string | undefined | null): boolean {
     return this.parseOrNull(iso) !== null
   }
@@ -115,81 +127,83 @@ export class LocalDate {
   }
 
   static range(
-    minIncl: LocalDateConfig,
-    maxExcl: LocalDateConfig,
+    min: LocalDateConfig,
+    max: LocalDateConfig,
+    incl: Inclusiveness = '[)',
     step = 1,
     stepUnit: LocalDateUnit = 'day',
   ): LocalDate[] {
-    const days: LocalDate[] = []
-    let current = LocalDate.of(minIncl).startOf(stepUnit)
-    const max = LocalDate.of(maxExcl).startOf(stepUnit)
+    const dates: LocalDate[] = []
+    const $min = LocalDate.of(min)
+    const $max = LocalDate.of(max).startOf(stepUnit)
+
+    let current = $min.startOf(stepUnit)
+    if (current.isAfter($min, incl[0] === '[')) {
+      // ok
+    } else {
+      current.add(1, stepUnit, true)
+    }
 
-    do {
-      days.push(current)
+    const incl2 = incl[1] === ']'
+    while (current.isBefore($max, incl2)) {
+      dates.push(current)
       current = current.add(step, stepUnit)
-    } while (current.isBefore(max))
+    }
 
-    return days
+    return dates
   }
 
-  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())
+  get(unit: LocalDateUnit): number {
+    return unit === 'year' ? this.$year : unit === 'month' ? this.$month : this.$day
   }
 
-  static rangeIncl(
-    minIncl: LocalDateConfig,
-    maxIncl: LocalDateConfig,
-    step = 1,
-    stepUnit: LocalDateUnit = 'day',
-  ): LocalDate[] {
-    return LocalDate.range(minIncl, LocalDate.of(maxIncl).add(1, stepUnit), step, stepUnit)
+  set(unit: LocalDateUnit, v: number, mutate = false): LocalDate {
+    const t = mutate ? this : this.clone()
+
+    if (unit === 'year') {
+      t.$year = v
+    } else if (unit === 'month') {
+      t.$month = v
+    } else {
+      t.$day = v
+    }
+
+    return t
   }
 
-  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(),
-    )
+  year(): number
+  year(v: number): LocalDate
+  year(v?: number): number | LocalDate {
+    return v === undefined ? this.$year : this.set('year', v)
+  }
+  month(): number
+  month(v: number): LocalDate
+  month(v?: number): number | LocalDate {
+    return v === undefined ? this.$month : this.set('month', v)
+  }
+  day(): number
+  day(v: number): LocalDate
+  day(v?: number): number | LocalDate {
+    return v === undefined ? this.$day : this.set('day', v)
   }
 
   isSame(d: LocalDateConfig): boolean {
     d = LocalDate.of(d)
-    return this.day === d.day && this.month === d.month && this.year === d.year
+    return this.$day === d.$day && this.$month === d.$month && this.$year === d.$year
   }
 
-  isBefore(d: LocalDateConfig): boolean {
-    return this.cmp(d) === -1
+  isBefore(d: LocalDateConfig, inclusive = false): boolean {
+    const r = this.cmp(d)
+    return r === -1 || (r === 0 && inclusive)
   }
 
   isSameOrBefore(d: LocalDateConfig): boolean {
     return this.cmp(d) <= 0
   }
 
-  isAfter(d: LocalDateConfig): boolean {
-    return this.cmp(d) === 1
+  isAfter(d: LocalDateConfig, inclusive = false): boolean {
+    const r = this.cmp(d)
+    return r === 1 || (r === 0 && inclusive)
   }
 
   isSameOrAfter(d: LocalDateConfig): boolean {
@@ -211,12 +225,12 @@ export class LocalDate {
    */
   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
+    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
   }
 
@@ -236,33 +250,33 @@ export class LocalDate {
     d = LocalDate.of(d)
 
     if (unit === 'year') {
-      return this.year - d.year
+      return this.$year - d.$year
     }
 
     if (unit === 'month') {
-      return (this.year - d.year) * 12 + (this.month - d.month)
+      return (this.$year - d.$year) * 12 + (this.$month - d.$month)
     }
 
     // unit is 'day'
-    let days = this.day - d.day
+    let days = this.$day - d.$day
 
-    if (d.year < this.year) {
-      for (let year = d.year; year < this.year; year++) {
+    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++) {
+    } else if (this.$year < d.$year) {
+      for (let year = this.$year; year < d.$year; year++) {
         days -= LocalDate.getYearLength(year)
       }
     }
 
-    if (d.month < this.month) {
-      for (let month = d.month; month < this.month; month++) {
-        days += LocalDate.getMonthLength(this.year, month)
+    if (d.$month < this.$month) {
+      for (let month = d.$month; month < this.$month; month++) {
+        days += LocalDate.getMonthLength(this.$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 (this.$month < d.$month) {
+      for (let month = this.$month; month < d.$month; month++) {
+        days -= LocalDate.getMonthLength(d.$year, month)
       }
     }
 
@@ -270,57 +284,62 @@ export class LocalDate {
   }
 
   add(num: number, unit: LocalDateUnit, mutate = false): LocalDate {
-    let { day, month, year } = this
+    let { $day, $month, $year } = this
 
     if (unit === 'day') {
-      day += num
+      $day += num
     } else if (unit === 'month') {
-      month += num
+      $month += num
     } else if (unit === 'year') {
-      year += num
+      $year += num
     }
 
     // check day overflow
-    let monLen = LocalDate.getMonthLength(year, month)
-    while (day > monLen) {
-      day -= monLen
-      month += 1
-      if (month > 12) {
-        year += 1
-        month -= 12
-      }
-
-      monLen = LocalDate.getMonthLength(year, month)
-    }
-    while (day < 1) {
-      day += monLen
-      month -= 1
-      if (month < 1) {
-        year -= 1
-        month += 12
+    if (unit === 'day') {
+      if ($day < 1) {
+        while ($day < 1) {
+          $month -= 1
+          if ($month < 1) {
+            $year -= 1
+            $month += 12
+          }
+
+          $day += LocalDate.getMonthLength($year, $month)
+        }
+      } else {
+        let monLen = LocalDate.getMonthLength($year, $month)
+
+        while ($day > monLen) {
+          $day -= monLen
+          $month += 1
+          if ($month > 12) {
+            $year += 1
+            $month -= 12
+          }
+
+          monLen = LocalDate.getMonthLength($year, $month)
+        }
       }
-
-      monLen = LocalDate.getMonthLength(year, month)
     }
 
     // check month overflow
-    while (month > 12) {
-      year += 1
-      month -= 12
+    while ($month > 12) {
+      $year += 1
+      $month -= 12
     }
-    while (month < 1) {
-      year -= 1
-      month += 12
+    while ($month < 1) {
+      $year -= 1
+      $month += 12
     }
 
     if (mutate) {
-      this.year = year
-      this.month = month
-      this.day = day
+      this.$year = $year
+      this.$month = $month
+      this.$day = $day
       return this
     }
 
-    return new LocalDate(year, month, day)
+    return new LocalDate($year, $month, $day)
   }
 
   subtract(num: number, unit: LocalDateUnit, mutate = false): LocalDate {
@@ -329,21 +348,21 @@ export class LocalDate {
 
   startOf(unit: LocalDateUnit): LocalDate {
     if (unit === 'day') return this
-    if (unit === 'month') return LocalDate.create(this.year, this.month, 1)
+    if (unit === 'month') return LocalDate.create(this.$year, this.$month, 1)
     // year
-    return LocalDate.create(this.year, 1, 1)
+    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,
-        LocalDate.getMonthLength(this.year, this.month),
+        this.$year,
+        this.$month,
+        LocalDate.getMonthLength(this.$year, this.$month),
       )
     // year
-    return LocalDate.create(this.year, 12, 31)
+    return LocalDate.create(this.$year, 12, 31)
   }
 
   static getYearLength(year: number): number {
@@ -352,17 +371,15 @@ export class LocalDate {
 
   static getMonthLength(year: number, month: number): number {
     if (month === 2) return this.isLeapYear(year) ? 29 : 28
-    return m31.has(month) ? 31 : 30
+    return MDAYS[month]!
   }
 
   static isLeapYear(year: number): boolean {
-    if (year % 4 !== 0) return false
-    if (year % 100 !== 0) return true
-    return year % 400 === 0
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)
   }
 
   clone(): LocalDate {
-    return new LocalDate(this.year, this.month, this.day)
+    return new LocalDate(this.$year, this.$month, this.$day)
   }
 
   /**
@@ -372,35 +389,35 @@ export class LocalDate {
    * Timezone will match local timezone.
    */
   toDate(): Date {
-    return new Date(this.year, this.month - 1, this.day)
+    return new Date(this.$year, this.$month - 1, this.$day)
   }
 
   toLocalTime(): LocalTime {
     return LocalTime.of(this.toDate())
   }
 
-  toISODate(): IsoDate {
+  toISODate(): IsoDateString {
     return this.toString()
   }
 
-  toString(): IsoDate {
+  toString(): IsoDateString {
     return [
-      String(this.year).padStart(4, '0'),
-      String(this.month).padStart(2, '0'),
-      String(this.day).padStart(2, '0'),
+      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'),
+      String(this.$year).padStart(4, '0'),
+      String(this.$month).padStart(2, '0'),
+      String(this.$day).padStart(2, '0'),
     ].join('')
   }
 
   // May be not optimal, as LocalTime better suits it
-  unix(): UnixTimestamp {
+  unix(): UnixTimestampNumber {
     return Math.floor(this.toDate().valueOf() / 1000)
   }
 
@@ -408,7 +425,7 @@ export class LocalDate {
     return this.toDate().valueOf()
   }
 
-  toJSON(): IsoDate {
+  toJSON(): IsoDateString {
     return this.toString()
   }
 }

package/src/datetime/localTime.ts

@@ -1,11 +1,11 @@
 import { _assert } from '../error/assert'
 import { _ms } from '../time/time.util'
-import { IsoDate, IsoDateTime, UnixTimestamp } from '../types'
+import { IsoDateString, IsoDateTimeString, UnixTimestampNumber } from '../types'
 import { Inclusiveness, LocalDate } from './localDate'
 
 export type LocalTimeUnit = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second'
 
-export type LocalTimeConfig = LocalTime | Date | IsoDateTime | UnixTimestamp
+export type LocalTimeConfig = LocalTime | Date | IsoDateTimeString | UnixTimestampNumber
 
 export interface LocalTimeComponents {
   year: number
@@ -62,7 +62,7 @@ export class LocalTime {
     } else if (typeof d === 'number') {
       date = new Date(d * 1000)
     } else {
-      date = new Date(d)
+      date = new Date(d.slice(0, 19))
     }
 
     // validation
@@ -78,6 +78,32 @@ export class LocalTime {
     return new LocalTime(date, false)
   }
 
+  static parseToDate(d: LocalTimeConfig): Date {
+    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: LocalTimeConfig): UnixTimestampNumber {
+    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: LocalTimeConfig | undefined | null): boolean {
     return this.parseOrNull(d) !== null
   }
@@ -144,9 +170,9 @@ export class LocalTime {
   month(v?: number): number | LocalTime {
     return v === undefined ? this.get('month') : this.set('month', v)
   }
-  date(): number
-  date(v: number): LocalTime
-  date(v?: number): number | LocalTime {
+  day(): number
+  day(v: number): LocalTime
+  day(v?: number): number | LocalTime {
     return v === undefined ? this.get('day') : this.set('day', v)
   }
   hour(): number
@@ -205,7 +231,7 @@ export class LocalTime {
   }
 
   diff(other: LocalTimeConfig, unit: LocalTimeUnit): number {
-    const date2 = LocalTime.of(other).$date
+    const date2 = LocalTime.parseToDate(other)
 
     if (unit === 'year') {
       return this.$date.getFullYear() - date2.getFullYear()
@@ -295,16 +321,18 @@ export class LocalTime {
     return this.cmp(d) === 0
   }
 
-  isBefore(d: LocalTimeConfig): boolean {
-    return this.cmp(d) === -1
+  isBefore(d: LocalTimeConfig, inclusive = false): boolean {
+    const r = this.cmp(d)
+    return r === -1 || (r === 0 && inclusive)
   }
 
   isSameOrBefore(d: LocalTimeConfig): boolean {
     return this.cmp(d) <= 0
   }
 
-  isAfter(d: LocalTimeConfig): boolean {
-    return this.cmp(d) === 1
+  isAfter(d: LocalTimeConfig, inclusive = false): boolean {
+    const r = this.cmp(d)
+    return r === 1 || (r === 0 && inclusive)
   }
 
   isSameOrAfter(d: LocalTimeConfig): boolean {
@@ -326,7 +354,7 @@ export class LocalTime {
    */
   cmp(d: LocalTimeConfig): -1 | 0 | 1 {
     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
   }
@@ -355,8 +383,8 @@ export class LocalTime {
     }
   }
 
-  fromNow(now: LocalTimeConfig = LocalTime.now()): string {
-    const msDiff = LocalTime.of(now).unixMillis() - this.unixMillis()
+  fromNow(now: LocalTimeConfig = new Date()): string {
+    const msDiff = LocalTime.parseToDate(now).valueOf() - this.$date.valueOf()
 
     if (msDiff === 0) return 'now'
 
@@ -375,7 +403,7 @@ export class LocalTime {
     return new LocalTime(new Date(this.$date), this.utcMode)
   }
 
-  unix(): UnixTimestamp {
+  unix(): UnixTimestampNumber {
     return Math.floor(this.$date.valueOf() / 1000)
   }
 
@@ -383,7 +411,7 @@ export class LocalTime {
     return this.$date.valueOf()
   }
 
-  valueOf(): UnixTimestamp {
+  valueOf(): UnixTimestampNumber {
     return Math.floor(this.$date.valueOf() / 1000)
   }
 
@@ -403,7 +431,7 @@ export class LocalTime {
     )
   }
 
-  toPretty(seconds = true): IsoDateTime {
+  toPretty(seconds = true): IsoDateTimeString {
     const { year, month, day, hour, minute, second } = this.components()
 
     return (
@@ -432,14 +460,14 @@ export class LocalTime {
   /**
    * Returns e.g: `1984-06-21T17:56:21`, only the date part of DateTime
    */
-  toISODateTime(): IsoDateTime {
+  toISODateTime(): IsoDateTimeString {
     return this.$date.toISOString().slice(0, 19)
   }
 
   /**
    * Returns e.g: `1984-06-21`, only the date part of DateTime
    */
-  toISODate(): IsoDate {
+  toISODate(): IsoDateString {
     const { year, month, day } = this.components()
 
     return [
@@ -488,7 +516,7 @@ export class LocalTime {
     return String(this.unix())
   }
 
-  toJSON(): UnixTimestamp {
+  toJSON(): UnixTimestampNumber {
     return this.unix()
   }
 }
@@ -499,5 +527,3 @@ export class LocalTime {
 export function localTime(d?: LocalTimeConfig): LocalTime {
   return d ? LocalTime.of(d) : LocalTime.now()
 }
-
-// todo: range