tempor

Experimental variation/extensions to the ECMAScript "temporal" proposal

Installation

npm i tempor

API

export class CivilDate {
  constructor(year: number, month: number, day: number);
  readonly year: number;
  readonly month: number;
  readonly day: number;
  readonly dayOfYear: number;
  readonly dayOfWeek: number;
  readonly weekOfYear: number;
  plus(deltas: { years?: number, months?: number, days?: number }): CivilDate;
  minus(deltas: { years?: number, months?: number, days?: number }): CivilDate;
  with(components: { year?: number, month?: number, day?: number }): CivilDate;
  withTime(time: CivilTime): CivilDateTime;
  until(other: CivilDate): Duration;
  since(other: CivilDate): Duration;
  toCalendarDateString(): string;
  toWeekDateString(): string;
  toOrdinalDateString(): string;
  toString(): string;
  toJSON(): string;
  equals(other: CivilDate): boolean;
  compareTo(other: CivilDate): number;
  static fromDayOfEpoch(day: number): CivilDate;
  static fromCalendarDate(year: number, month: number, day: number): CivilDate;
  static fromWeekDate(year: number, weekOfYear: number, dayOfWeek: number): CivilDate;
  static fromOrdinalDate(year: number, dayOfYear: number): CivilDate;
  static fromString(text: string): CivilDate;
  static now(clock: Clock): CivilDate;
}

export class CivilTime {
  constructor(hour: number, minute: number, second?: number, millisecond?: number, nanosecond?: number);
  readonly hour: number;
  readonly minute: number;
  readonly second: number;
  readonly millisecond: number;
  readonly nanosecond: number;
  plus(deltas: { hours?: number, minutes?: number, seconds?: number, milliseconds?: number, nanoseconds?: number }): CivilTime;
  minus(deltas: { hours?: number, minutes?: number, seconds?: number, milliseconds?: number, nanoseconds?: number }): CivilTime;
  with(components: { hour?: number, minute?: number, second?: number, millisecond?: number, nanosecond?: number }): CivilTime;
  withDate(date: CivilDate): CivilDateTime;
  withOffset(offset: ZoneOffset): OffsetTime;
  until(other: CivilTime): Duration;
  since(other: CivilTime): Duration;
  toString(): string;
  toJSON(): string;
  equals(other: CivilTime): boolean;
  compareTo(other: CivilTime): number;
  static fromTime(hour: number, minute: number, second?: number, millisecond?: number): CivilTime;
  static fromMilliseconds(milliseconds: number, nanoseconds?: number): CivilTime;
  static fromString(text: string): CivilTime;
  static now(clock: Clock): CivilTime;
}

export class CivilDateTime {
  constructor(year: number, month: number, day: number, hour: number, minute: number, second?: number, millisecond?: number, nanosecond?: number);
  readonly year: number;
  readonly month: number;
  readonly day: number;
  readonly dayOfYear: number;
  readonly dayOfWeek: number;
  readonly weekOfYear: number;
  readonly hour: number;
  readonly minute: number;
  readonly second: number;
  readonly millisecond: number;
  readonly nanosecond: number;
  plus(deltas: { years?: number, months?: number, days?: number, hours?: number, minutes?: number, seconds?: number, milliseconds?: number, nanoseconds?: number }): CivilDateTime;
  minus(deltas: { years?: number, months?: number, days?: number, hours?: number, minutes?: number, seconds?: number, milliseconds?: number, nanoseconds?: number }): CivilDateTime;
  with(components: { year?: number, month?: number, day?: number, hour?: number, minute?: number, second?: number, millisecond?: number, nanosecond?: number }): CivilDateTime;
  withOffset(offset: ZoneOffset): OffsetDateTime;
  withZone(zone: Zone | string): ZonedDateTime;
  until(other: CivilDateTime): Duration;
  since(other: CivilDateTime): Duration;
  toCivilDate(): CivilDate;
  toCivilTime(): CivilTime;
  toCalendarDateTimeString(): string;
  toWeekDateTimeString(): string;
  toOrdinalDateTimeString(): string;
  toString(): string;
  toJSON(): string;
  equals(other: CivilDateTime): boolean;
  compareTo(other: CivilDateTime): number;
  static from(date: CivilDate, time: CivilTime): CivilDateTime;
  static fromDayOfEpoch(day: number, nanoseconds?: bigint): CivilDateTime;
  static fromCalendarDateTime(year: number, month: number, day: number, hour: number, minute: number, second?: number, millisecond?: number, nanosecond?: number): CivilDateTime;
  static fromWeekDateTime(year: number, weekOfYear: number, dayOfWeek: number, hour: number, minute: number, second?: number, millisecond?: number, nanosecond?: numberr): CivilDateTime;
  static fromOrdinalDateTime(year: number, dayOfYear: number, hour: number, minute: number, second?: number, millisecond?: number, nanosecond?: number): CivilDateTime;
  static fromString(text: string): CivilDateTime;
  static now(clock: Clock): CivilDateTime;
}

export class OffsetTime {
  constructor(offset: ZoneOffset, hour: number, minute: number, second?: number, millisecond?: number, nanosecond?: number);
  readonly offset: ZoneOffset;
  readonly offsetSeconds: number;
  readonly offsetString: string;
  readonly hour: number;
  readonly minute: number;
  readonly second: number;
  readonly millisecond: number;
  readonly nanosecond: number;
  plus(deltas: { hours?: number, minutes?: number, seconds?: number, milliseconds?: number, nanoseconds?: number }): OffsetTime;
  minus(deltas: { hours?: number, minutes?: number, seconds?: number, milliseconds?: number, nanoseconds?: number }): OffsetTime;
  with(components: { hour?: number, minute?: number, second?: number, millisecond?: number, nanosecond?: number }): OffsetTime;
  withOffsetSameInstant(offset: ZoneOffset): OffsetTime;
  withOffsetSameLocal(offset: ZoneOffset): OffsetTime;
  withDate(date: CivilDate): OffsetDateTime;
  until(other: OffsetTime): Duration;
  since(other: OffsetTime): Duration;
  toCivilTime(): CivilTime;
  toString(): string;
  toJSON(): string;
  equals(other: CivilTime): boolean;
  compareTo(other: CivilTime): number;
  static from(offset: ZoneOffset, time: CivilTime): OffsetTime;
  static fromNanoseconds(offset: ZoneOffset, nanoseconds: bigint): OffsetTime;
  static fromInstant(offset: ZoneOffset, instant: Instant): OffsetTime;
  static fromString(text: string): OffsetTime;
  static now(clock: Clock): OffsetTime;
}

export class OffsetDateTime {
  constructor(offset: ZoneOffset, year: number, month: number, day: number, hour: number, minute: number, second?: number, millisecond?: number, nanosecond?: number);
  readonly offset: ZoneOffset;
  readonly offsetSeconds: number;
  readonly offsetString: string;
  readonly year: number;
  readonly month: number;
  readonly day: number;
  readonly dayOfYear: number;
  readonly dayOfWeek: number;
  readonly weekOfYear: number;
  readonly hour: number;
  readonly minute: number;
  readonly second: number;
  readonly millisecond: number;
  readonly nanosecond: number;
  plus(deltas: { years?: number, months?: number, days?: number, hours?: number, minutes?: number, seconds?: number, milliseconds?: number, nanoseconds?: number }): OffsetDateTime;
  minus(deltas: { years?: number, months?: number, days?: number, hours?: number, minutes?: number, seconds?: number, milliseconds?: number, nanoseconds?: number }): OffsetDateTime;
  with(components: { year?: number, month?: number, day?: number, hour?: number, minute?: number, second?: number, millisecond?: number, nanosecond?: number }): OffsetDateTime;
  withOffsetSameInstant(offset: ZoneOffset): OffsetDateTime;
  withOffsetSameInstant(offset: ZoneOffset): OffsetDateTime;
  withOffsetSameLocal(offset: ZoneOffset): OffsetDateTime;
  withOffsetSameLocal(offset: ZoneOffset): OffsetDateTime;
  withZoneSameInstant(offset: Zone): ZonedDateTime;
  withZoneSameInstant(offset: Zone): ZonedDateTime;
  withZoneSameLocal(offset: Zone): ZonedDateTime;
  withZoneSameLocal(offset: Zone): ZonedDateTime;
  until(other: OffsetDateTime): Duration;
  since(other: OffsetDateTime): Duration;
  toCivilDate(): CivilDate;
  toCivilTime(): CivilTime;
  toCivilDateTime(): CivilDateTime;
  toZonedDateTime(): ZonedDateTime;
  toString(): string;
  toJSON(): string;
  equals(other: OffsetDateTime): boolean;
  compareTo(other: OffsetDateTime): number;
  static from(offset: ZoneOffset, datetime: CivilDateTime): OffsetDateTime;
  static fromEpochDays(offset: ZoneOffset, day: number, nanoseconds?: bigint): OffsetDateTime;
  static fromCalendarDateTime(offset: ZoneOffset, year: number, month: number, day: number, hour: number, minute: number, second?: number, millisecond?: number, nanosecond?: number): OffsetDateTime;
  static fromWeekDateTime(offset: ZoneOffset, year: number, weekOfYear: number, dayOfWeek: number, hour: number, minute: number, second?: number, millisecond?: number, nanosecond?: numberr): OffsetDateTime;
  static fromOrdinalDateTime(offset: ZoneOffset, year: number, dayOfYear: number, hour: number, minute: number, second?: number, millisecond?: number, nanosecond?: number): OffsetDateTime;
  static fromInstant(offset: ZoneOffset, instant: Instant): OffsetDateTime;
  static fromString(text: string): OffsetDateTime;
  static now(clock: Clock): OffsetDateTime;
}

export class ZonedDateTime {
  constructor(instant: Instant, zone: Zone | string);
  readonly instant: Instant;
  readonly zone: Zone;
  readonly ianaZone: string;
  readonly timeZone: string;
  readonly offset: ZoneOffset;
  readonly offsetSeconds: number;
  readonly offsetString: string;
  readonly year: number;
  readonly month: number;
  readonly day: number;
  readonly dayOfYear: number;
  readonly dayOfWeek: number;
  readonly weekOfYear: number;
  readonly hour: number;
  readonly minute: number;
  readonly second: number;
  readonly millisecond: number;
  readonly nanosecond: number;
  plus(deltas: { years?: number, months?: number, days?: number, hours?: number, minutes?: number, seconds?: number, milliseconds?: number, nanoseconds?: number }): ZonedDateTime;
  minus(deltas: { years?: number, months?: number, days?: number, hours?: number, minutes?: number, seconds?: number, milliseconds?: number, nanoseconds?: number }): ZonedDateTime;
  with(components: { year?: number, month?: number, day?: number, hour?: number, minute?: number, second?: number, millisecond?: number, nanosecond?: number }): ZonedDateTime;
  withZoneSameInstant(offset: Zone): ZonedDateTime;
  withZoneSameInstant(offset: Zone): ZonedDateTime;
  withZoneSameLocal(offset: Zone): ZonedDateTime;
  withZoneSameLocal(offset: Zone): ZonedDateTime;
  until(other: ZonedDateTime): Duration;
  since(other: ZonedDateTime): Duration;
  toCivilDate(): CivilDate;
  toCivilTime(): CivilTime;
  toCivilDateTime(): CivilDateTime;
  toOffsetTime(): OffsetTime;
  toOffsetDateTime(): OffsetDateTime;
  toZonedCalendarDateTimeString(): string;
  toZonedWeekDateTimeString(): string;
  toZonedOrdinalDateTimeString(): string;
  toString(): string;
  toJSON(): string;
  equals(other: ZonedDateTime): boolean;
  compareTo(other: ZonedDateTime): number;
  static fromCalendarDateTime(zone: Zone | string, year: number, month: number, day: number, hour: number, minute: number, second?: number, millisecond?: number, nanosecond?: number): ZonedDateTime;
  static fromWeekDateTime(zone: Zone | string, year: number, weekOfYear: number, dayOfWeek: number, hour: number, minute: number, second?: number, millisecond?: number, nanosecond?: numberr): ZonedDateTime;
  static fromOrdinalDateTime(zone: Zone | string, year: number, dayOfYear: number, hour: number, minute: number, second?: number, millisecond?: number, nanosecond?: number): ZonedDateTime;
  static fromString(text: string): ZonedDateTime;
  static now(clock: Clock): ZonedDateTime;
}

export class Instant {
  constructor(ns: bigint);
  readonly milliseconds: number;
  readonly nanoseconds: number;
  plus(deltas: { hours?: number, minutes?: number, seconds?: number, milliseconds?: number, nanoseconds?: number }): Instant;
  minus(deltas: { hours?: number, minutes?: number, seconds?: number, milliseconds?: number, nanoseconds?: number }): Instant;
  truncate(unit: "hours" | "minutes" | "seconds" | "milliseconds" | "nanoseconds"): Instant;
  with(components: { milliseconds?: number, nanoseconds?: number }): Instant;
  withOffset(offset: ZoneOffset): OffsetDateTime;
  withZone(zone: Zone | string): ZonedDateTime;
  until(other: Instant): Duration;
  since(other: Instant): Duration;
  equals(other: Instant): boolean;
  compareTo(other: Instant): number;
  toCivilDateTime(): CivilDateTime;
  toCivilDate(): CivilDate;
  toCivilTime(): CivilTime;
  toString(): string;
  toJSON(): string;
  static fromString(text: string): Instant;
  static fromMilliseconds(milliseconds: number, nanoseconds?: number): Instant;
  static fromNanoseconds(nanoseconds: bigint): number;
  static now(clock: Clock): Instant;
}

export abstract class Zone {
  static readonly UTC: Zone;
  static readonly SYSTEM: Zone;
  abstract get ianaZone(): string;
  abstract get timeZone(): string;
  abstract getOffset(instant: Instant): ZoneOffset;
  getOffsetSeconds(instant: Instant): number;
  getOffsetString(instant: Instant): string;
  getZoneString(instant: Instant): string;
  withInstant(instant: Instant): ZonedDateTime;
  abstract equals(other: Zone): boolean;
  compareTo(other: Zone): number;
  toString(): string;
  toJSON(): string;
  static fromOffset(offsetSeconds: number): ZoneOffset;
  static fromString(zone: string): Zone;
}

export class ZoneOffset extends Zone {
  constructor(offsetSeconds: number);
  static readonly MIN: ZoneOffset;
  static readonly MAX: ZoneOffset;
  readonly ianaZone: string;
  readonly timeZone: string;
  readonly offsetSeconds: number;
  readonly offsetString: string;
  getOffset(instant: Instant): ZoneOffset;
  getOffsetSeconds(instant: Instant): number;
  getOffsetString(instant: Instant): string;
  equals(other: Zone): boolean;
  compareTo(other: Zone): number;
  toString(): string;
  toJSON(): string;
  static fromString(text: string): ZoneOffset;
}

export abstract class Clock {
  constructor(zone: Zone);
  static readonly default: Clock;
  static readonly UTC: Clock;
  readonly zone: Zone;
  abstract currentInstant(): Instant;
  abstract withZone(zone: Zone | string): Clock;
  withPrecision(precision: "hours" | "minutes" | "seconds" | "milliseconds" | "nanoseconds"): Clock;
  static getSystem(zone: Zone): Clock;
  static getFixed(zone: Zone, instant: Instant): Clock;
}

export class Duration {
  constructor(components: { years?: number, months?: number, days?: number, hours?: number, minutes?: number, seconds?: number, milliseconds?: number, nanoseconds?: number });
  static readonly ZERO: Duration;
  readonly years: number;
  readonly months: number;
  readonly days: number;
  readonly hours: number;
  readonly minutes: number;
  readonly seconds: number;
  readonly milliseconds: number;
  readonly nanoseconds: number;
  readonly sign: -1 | 0 | 1;
  plus(deltas: { years?: number, months?: number, days?: number, hours?: number, minutes?: number, seconds?: number, milliseconds?: number, nanoseconds?: number }): Duration;
  minus(deltas: { years?: number, months?: number, days?: number, hours?: number, minutes?: number, seconds?: number, milliseconds?: number, nanoseconds?: number }): Duration;
  scale(amount: number): Duration;
  with(components: { years?: number, months?: number, days?: number, hours?: number, minutes?: number, seconds?: number, milliseconds?: number, nanoseconds?: number }): Duration;
  negate(): Duration;
  abs(): Duration;
  truncate(unit: "years" | "months" | "days" | "hours" | "minutes" | "seconds" | "milliseconds" | "nanoseconds"): Duration;
  toTimeAgoString(): string;
  toString(): string;
  toJSON(): string;
  equals(other: Duration): boolean;
  static fromString(text: string): Duration;
  static fromMilliseconds(milliseconds: number, nanoseconds?: number): Duration;
  static fromNanoseconds(ns: bigint): Duration);
}

export class Interval<T extends Temporal<T>> {
  constructor(start: T, end: T);
  readonly start: T;
  readonly end: T;
  readonly duration: Duration;
  contains(value: T | Interval<T>): boolean;
  overlaps(other: Interval<T>): boolean;
  withStartSameEnd(start: T): Interval<T>;
  withStartSameDuration(start: T): Interval<T>;
  withEndSameStart(end: T): Interval<T>;
  withEndSameDuration(end: T): Interval<T>;
  withDurationSameStart(duration: Duration): Interval<T>;
  withDurationSameEnd(duration: Duration): Interval<T>;
  toStartEndIntervalString(): string;
  toStartDurationIntervalString(): string;
  toDurationEndIntervalString(): string;
  toString(): string;
  static fromStartDuration<T extends Temporal<T>>(start: T, duration: Duration): Interval<T>;
  static fromDurationEnd<T extends Temporal<T>>(duration: Duration, end: T): Interval<T>;
  static fromZonedDateTimeIntervalString(text: string): Interval<ZonedDateTime>;
  static fromOffsetDateTimeIntervalString(text: string): Interval<OffsetDateTime>;
  static fromCivilDateTimeIntervalString(text: string): Interval<CivilDateTime>;
  static fromCivilDateIntervalString(text: string): Interval<CivilDate>;
  static fromCivilTimeIntervalString(text: string): Interval<CivilTime>;
  static fromOffsetTimeIntervalString(text: string): Interval<OffsetTime>;
  static fromString(text: string): Interval<ZonedDateTime> | Interval<OffsetDateTime> | Interval<CivilDateTime> | Interval<CivilDate> | Interval<CivilTime> | Interval<OffsetTime>;
}

export class RecurringInterval<T extends Temporal<T>> {
  constructor(start: T, duration: Duration, repeat?: number);
  constructor(duration: Duration, end: T, repeat?: number);
  readonly repeat: number;
  readonly duration: Duration;
  readonly endpoint: T;
  readonly endpointKind: "start" | "end";
  nextOccurrence(value: T): [number, T] | undefined;
  previousOccurence(value: T): [number, T] | undefined;
  occurences(): IterableIterator<[number, T]>;
  withRepetitions(repeat: number): RecurringInterval<T>;
  withStartSameDuration(start: T): RecurringInterval<T>;
  withEndSameDuration(end: T): RecurringInterval<T>;
  withDurationSameEndpoint(duration: Duration): RecurringInterval<T>;
  toString(): string;
  static fromString(text: string): string;
}