@naturalcycles/js-lib 14.97.0 → 14.97.1

package/src/datetime/localTime.ts

@@ -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
   }
@@ -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'
 
@@ -499,5 +527,3 @@ export class LocalTime {
 export function localTime(d?: LocalTimeConfig): LocalTime {
   return d ? LocalTime.of(d) : LocalTime.now()
 }
-
-// todo: range

package/src/datetime/timeInterval.ts

@@ -0,0 +1,104 @@
+import { UnixTimestampNumber } from '../types'
+import { Inclusiveness } from './localDate'
+import { LocalTime, LocalTimeConfig } from './localTime'
+
+export type TimeIntervalConfig = TimeInterval | TimeIntervalString
+export type TimeIntervalString = string
+
+/**
+ * Class that supports an "interval of time" between 2 timestamps - start and end.
+ * Example: `1649267185/1649267187`.
+ *
+ * @experimental
+ */
+export class TimeInterval {
+  private constructor(private $start: UnixTimestampNumber, private $end: UnixTimestampNumber) {}
+
+  static of(start: LocalTimeConfig, end: LocalTimeConfig): TimeInterval {
+    return new TimeInterval(
+      LocalTime.parseToUnixTimestamp(start),
+      LocalTime.parseToUnixTimestamp(end),
+    )
+  }
+
+  get start(): UnixTimestampNumber {
+    return this.$start
+  }
+
+  get end(): UnixTimestampNumber {
+    return this.$end
+  }
+
+  get startTime(): LocalTime {
+    return LocalTime.of(this.$start)
+  }
+
+  get endTime(): LocalTime {
+    return LocalTime.of(this.$end)
+  }
+
+  /**
+   * Parses string like `1649267185/1649267187` into a TimeInterval.
+   */
+  static parse(d: TimeIntervalConfig): TimeInterval {
+    if (d instanceof TimeInterval) return d
+
+    const [start, end] = d.split('/').map(Number)
+
+    if (!end || !start) {
+      throw new Error(`Cannot parse "${d}" into TimeInterval`)
+    }
+
+    return new TimeInterval(start, end)
+  }
+
+  isSame(d: TimeIntervalConfig): boolean {
+    return this.cmp(d) === 0
+  }
+
+  isBefore(d: TimeIntervalConfig, inclusive = false): boolean {
+    const r = this.cmp(d)
+    return r === -1 || (r === 0 && inclusive)
+  }
+
+  isSameOrBefore(d: TimeIntervalConfig): boolean {
+    return this.cmp(d) <= 0
+  }
+
+  isAfter(d: TimeIntervalConfig, inclusive = false): boolean {
+    const r = this.cmp(d)
+    return r === 1 || (r === 0 && inclusive)
+  }
+
+  isSameOrAfter(d: TimeIntervalConfig): boolean {
+    return this.cmp(d) >= 0
+  }
+
+  includes(d: LocalTimeConfig, incl: Inclusiveness = '[)'): boolean {
+    d = LocalTime.parseToUnixTimestamp(d)
+    if (d < this.$start || (d === this.$start && incl[0] === '(')) return false
+    if (d > this.$end || (d === this.$end && incl[1] === ')')) return false
+    return true
+  }
+
+  /**
+   * TimeIntervals compare by start date.
+   * If it's the same - then by end date.
+   */
+  cmp(d: TimeIntervalConfig): -1 | 0 | 1 {
+    d = TimeInterval.parse(d)
+    if (this.$start > d.$start) return 1
+    if (this.$start < d.$start) return -1
+    if (this.$end > d.$end) return 1
+    if (this.$end < d.$end) return -1
+    return 0
+  }
+
+  toString(): TimeIntervalString {
+    return [this.$start, this.$end].join('/')
+  }
+
+  toJSON(): TimeIntervalString {
+    return this.toString()
+  }
+}

package/src/index.ts

@@ -160,13 +160,17 @@ export * from './string/leven'
 export * from './datetime/localDate'
 export * from './datetime/localTime'
 export * from './datetime/dateInterval'
+export * from './datetime/timeInterval'
 import { LocalDateConfig, LocalDateUnit, Inclusiveness } from './datetime/localDate'
 import { LocalTimeConfig, LocalTimeUnit, LocalTimeComponents } from './datetime/localTime'
 import { DateIntervalConfig, DateIntervalString } from './datetime/dateInterval'
+import { TimeIntervalConfig, TimeIntervalString } from './datetime/timeInterval'
 
 export type {
   DateIntervalConfig,
   DateIntervalString,
+  TimeIntervalConfig,
+  TimeIntervalString,
   LocalDateConfig,
   LocalDateUnit,
   Inclusiveness,