0.0.9 • Published 5 years ago
tempor v0.0.9
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;
}