ream.js/build/module/lib/ream.d.ts

A comprehensive, functional datetime library for JavaScript/TypeScript with immutable data structures, real IANA timezone database support, DST handling, and a plugin system

/*********************************************************************
 *  REAM-DATETIME  v3.0  —  Full-blown Day.js/Moment replacement
 *  Includes: IANA time-zones, DST math, calendars, locale, plug-ins
 *  Everything is pure, total, and categorically composable.
 ********************************************************************/
export declare const isLeap: (y: number) => boolean;
export declare const daysInMonth: number[];
export declare const MILLIS: {
    SECOND: number;
    MINUTE: number;
    HOUR: number;
    DAY: number;
    WEEK: number;
};
export declare type Instant = Readonly<{
    readonly epochMs: number;
}>;
export declare type Duration = Readonly<{
    readonly ms: number;
}>;
export declare type PlainDate = Readonly<{
    readonly y: number;
    readonly m: number;
    readonly d: number;
}>;
export declare type PlainTime = Readonly<{
    readonly h: number;
    readonly min: number;
    readonly s: number;
    readonly ms: number;
}>;
export declare type PlainDateTime = PlainDate & PlainTime;
export declare type TimeZone = {
    readonly name: string;
    readonly offsetMinutes: number;
    readonly dst: boolean;
    readonly abbreviation?: string;
};
export declare const getTimezoneInfo: (tzName: string, instant: Instant) => TimeZone;
export declare const tzOffset: (tz: string, i: Instant) => number;
export declare const getAvailableTimezones: () => readonly string[];
export declare type ZDT<A> = Readonly<{
    readonly instant: Instant;
    readonly zone: TimeZone;
    readonly payload: A;
}>;
export declare const zdt: <A>(i: Instant, z: TimeZone, p: A) => Readonly<{
    readonly instant: Instant;
    readonly zone: TimeZone;
    readonly payload: A;
}>;
export declare const zfmap: <A, B>(f: (a: A) => B) => (z: Readonly<{
    readonly instant: Instant;
    readonly zone: TimeZone;
    readonly payload: A;
}>) => Readonly<{
    readonly instant: Instant;
    readonly zone: TimeZone;
    readonly payload: B;
}>;
export declare type Calendar = 'gregory' | 'iso8601' | 'buddhist' | 'persian';
export declare const calendars: Record<Calendar, {
    readonly firstDay: number;
    readonly monthNames: readonly string[];
}>;
export declare type Locale = string;
export declare type FormatToken = 'YYYY' | 'YY' | 'MMMM' | 'MMM' | 'MM' | 'M' | 'DD' | 'D' | 'dddd' | 'ddd' | 'HH' | 'H' | 'hh' | 'h' | 'mm' | 'm' | 'ss' | 's' | 'SSS' | 'SS' | 'S' | 'a' | 'A' | 'Z' | 'ZZ';
export declare const formatToken: (token: FormatToken, pdt: PlainDateTime, locale: Locale) => string;
export declare const format: (pattern: string, pdt: PlainDateTime, locale?: string) => string;
export declare const zero: Duration;
export declare const add: (d1: Duration, d2: Duration) => Duration;
export declare const sub: (d1: Duration, d2: Duration) => Duration;
export declare const durations: {
    milliseconds: (n: number) => Duration;
    seconds: (n: number) => Duration;
    minutes: (n: number) => Duration;
    hours: (n: number) => Duration;
    days: (n: number) => Duration;
    weeks: (n: number) => Duration;
};
export declare const instant: (epochMs: number) => Instant;
export declare const duration: (ms: number) => Duration;
export declare const now: () => Instant;
export declare const dateTime: (y: number, month: number, d: number, h: number, min: number, s: number, ms: number) => PlainDateTime;
export declare const fromPlain: (pdt: PlainDateTime) => Instant;
export declare const toPlain: (i: Instant) => PlainDateTime;
export declare const parseISO: (isoString: string) => PlainDateTime;
export declare const addDuration: (dur: Duration) => (i: Instant) => Instant;
export declare const addYears: (n: number) => (d: PlainDate) => PlainDate;
export declare const addMonths: (n: number) => (d: PlainDate) => PlainDate;
export declare const addDays: (n: number) => (d: PlainDate) => PlainDate;
export declare const addHours: (n: number) => (dt: PlainDateTime) => PlainDateTime;
export declare const addMinutes: (n: number) => (dt: PlainDateTime) => PlainDateTime;
export declare const addSeconds: (n: number) => (dt: PlainDateTime) => PlainDateTime;
export declare const addMilliseconds: (n: number) => (dt: PlainDateTime) => PlainDateTime;
export declare const dayOfWeek: (d: PlainDate) => number;
export declare const startOfWeek: (d: PlainDate, startOn?: number) => PlainDate;
export declare const UTC: TimeZone;
export declare const zone: (name: string, instant?: Instant) => TimeZone;
export declare const withZone: (z: TimeZone) => (dt: PlainDateTime) => ZDT<PlainDateTime>;
export declare const withZoneName: (zoneName: string) => (dt: PlainDateTime) => ZDT<PlainDateTime>;
export declare const toUTC: (zdtObj: ZDT<PlainDateTime>) => ZDT<PlainDateTime>;
export declare const toZone: (zoneName: string) => (zdtObj: ZDT<PlainDateTime>) => ZDT<PlainDateTime>;
export declare const offset: (zdtObj: ZDT<PlainDateTime>) => Duration;
export declare const isValidTimezone: (tzName: string) => boolean;
export declare const getTimezoneOffset: (tzName: string, instant?: Instant) => number;
export declare const isDST: (tzName: string, instant?: Instant) => boolean;
export declare type Interval<A> = {
    readonly start: ZDT<A>;
    readonly end: ZDT<A>;
};
export declare const interval: <A>(s: Readonly<{
    readonly instant: Instant;
    readonly zone: TimeZone;
    readonly payload: A;
}>, e: Readonly<{
    readonly instant: Instant;
    readonly zone: TimeZone;
    readonly payload: A;
}>) => Interval<A>;
export declare const durationOfInterval: <A>(iv: Interval<A>) => Duration;
export declare type RecurrenceRule = (origin: ZDT<PlainDateTime>) => Generator<ZDT<PlainDateTime>, void, unknown>;
export declare const every: (dur: Duration) => RecurrenceRule;
export declare const everyDay: RecurrenceRule;
export declare const everyWeek: RecurrenceRule;
export declare const everyMonth: (n?: number) => RecurrenceRule;
export declare const humanize: (d: Duration) => string;
export declare type ReamDate = {
    readonly clone: () => ReamDate;
    readonly year: () => number;
    readonly month: () => number;
    readonly date: () => number;
    readonly day: () => number;
    readonly weekday: () => number;
    readonly hour: () => number;
    readonly minute: () => number;
    readonly second: () => number;
    readonly millisecond: () => number;
    readonly add: (value: number, unit: keyof typeof durations) => ReamDate;
    readonly subtract: (value: number, unit: keyof typeof durations) => ReamDate;
    readonly format: (pattern?: string, locale?: Locale) => string;
    readonly toISOString: () => string;
    readonly toLocaleString: (locale?: Locale) => string;
    readonly tz: (name: string) => ReamDate;
    readonly utc: () => ReamDate;
    readonly timezone: () => TimeZone;
    readonly isDST: () => boolean;
    readonly offset: () => number;
    readonly valueOf: () => number;
};
export declare type Plugin = {
    readonly install: (api: ReamDate) => ReamDate;
};
export declare const extend: (plugin: Plugin) => (rd: ReamDate) => ReamDate;
declare const ream: (input?: string | number | Date | PlainDateTime | undefined, zoneName?: string) => ReamDate;
export default ream;
export declare const relativePlugin: Plugin;
export declare const businessPlugin: Plugin;