Tempo

Appearance

Constructors ​

Constructor ​

ts
new Tempo(options?): Tempo;

Instantiates a new Tempo object with configuration only.

Parameters ​

ParameterTypeDescription
options?OptionsConfiguration options for this specific instance.

Returns ​

Tempo

Constructor ​

ts
new Tempo(tempo, options?): Tempo;

Instantiates a new Tempo object with a value.

Parameters ​

ParameterTypeDescription
tempoDateTimeThe date-time value to parse.
options?OptionsConfiguration options for this specific instance.

Returns ​

Tempo

Properties ​

[$Identity] ​

ts
static [$Identity]: boolean = true;

allow instanceof to work across module boundaries via the local brand symbol

[$IsBase] ​

ts
static [$IsBase]: boolean = true;

Accessors ​

[toStringTag] ​

Get Signature ​

ts
get toStringTag: string;
Returns ​

string

cal ​

Get Signature ​

ts
get cal(): string;

Temporal Calendar ID (e.g., 'iso8601' | 'gregory')

Returns ​

string

config ​

Get Signature ​

ts
get config(): Config;

current Tempo configuration

Returns ​

Config

day ​

Get Signature ​

ts
get day(): number;

Day of the month (alias for dd)

Returns ​

number

dd ​

Get Signature ​

ts
get dd(): number;

Day of the month (1-31)

Returns ​

number

dow ​

Get Signature ​

ts
get dow(): 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;

iso weekday number: Mon=1, Sun=7

Returns ​

0 | 1 | 2 | 3 | 4 | 5 | 6 | 7

epoch ​

Get Signature ​

ts
get epoch(): {
  ms: number;
  ns: bigint;
  ss: number;
  us: number;
};

units since epoch

Returns ​
ms ​
ts
readonly ms: number;

milliseconds since epoch

ns ​
ts
readonly ns: bigint;

nanoseconds since epoch

ss ​
ts
readonly ss: number;

seconds since epoch

us ​
ts
readonly us: number;

microseconds since epoch

ff ​

Get Signature ​

ts
get ff(): number;

Fractional seconds (e.g., 0.123456789)

Returns ​

number

fmt ​

Get Signature ​

ts
get fmt(): any;

Formatted results for all pre-defined format codes

Returns ​

any

hh ​

Get Signature ​

ts
get hh(): hh;

Hour of the day (0-23)

Returns ​

hh

iso ​

Get Signature ​

ts
get iso(): string;

Standard ISO 8601 string in UTC

Returns ​

string

isValid ​

Get Signature ​

ts
get isValid(): boolean | ZonedDateTime;

true if the underlying date-time is valid.

Returns ​

boolean | ZonedDateTime

mi ​

Get Signature ​

ts
get mi(): mi;

Minutes of the hour (0-59)

Returns ​

mi

mm ​

Get Signature ​

ts
get mm(): mm;

Month number: Jan=1, Dec=12

Returns ​

mm

mmm ​

Get Signature ​

ts
get mmm(): 
  | "All"
  | "Jan"
  | "Feb"
  | "Mar"
  | "Apr"
  | "May"
  | "Jun"
  | "Jul"
  | "Aug"
  | "Sep"
  | "Oct"
  | "Nov"
  | "Dec";

Short month name (e.g., 'Jan')

Returns ​

| "All" | "Jan" | "Feb" | "Mar" | "Apr" | "May" | "Jun" | "Jul" | "Aug" | "Sep" | "Oct" | "Nov" | "Dec"

mon ​

Get Signature ​

ts
get mon(): 
  | "May"
  | "Every"
  | "January"
  | "February"
  | "March"
  | "April"
  | "June"
  | "July"
  | "August"
  | "September"
  | "October"
  | "November"
  | "December";

Full month name (e.g., 'January')

Returns ​

| "May" | "Every" | "January" | "February" | "March" | "April" | "June" | "July" | "August" | "September" | "October" | "November" | "December"

ms ​

Get Signature ​

ts
get ms(): ms;

Milliseconds of the second (0-999)

Returns ​

ms

nano ​

Get Signature ​

ts
get nano(): bigint;

Nanoseconds since Unix epoch (BigInt)

Returns ​

bigint

ns ​

Get Signature ​

ts
get ns(): ns;

Nanoseconds of the microsecond (0-999)

Returns ​

ns

parse ​

Get Signature ​

ts
get parse(): Parse;

Instance-specific parse rules (merged with global)

Returns ​

Parse

ranges ​

Get Signature ​

ts
get ranges(): Record<string, string>;

current range key for every registered term

Returns ​

Record<string, string>

ss ​

Get Signature ​

ts
get ss(): ss;

Seconds of the minute (0-59)

Returns ​

ss

term ​

Get Signature ​

ts
get term(): TempoTermRegistry;

Keyed results for all resolved terms

Returns ​

TempoTermRegistry

terms ​

Get Signature ​

ts
get terms(): Record<string, string[]>;

list of registered terms and their available range keys

Returns ​

Record<string, string[]>

ts ​

Get Signature ​

ts
get ts(): number | bigint;

Unix timestamp (defaults to milliseconds)

Returns ​

number | bigint

tz ​

Get Signature ​

ts
get tz(): string;

IANA Time Zone ID (e.g., 'Australia/Sydney')

Returns ​

string

us ​

Get Signature ​

ts
get us(): us;

Microseconds of the millisecond (0-999)

Returns ​

us

wkd ​

Get Signature ​

ts
get wkd(): 
  | "Everyday"
  | "Monday"
  | "Tuesday"
  | "Wednesday"
  | "Thursday"
  | "Friday"
  | "Saturday"
  | "Sunday";

Full weekday name (e.g., 'Monday')

Returns ​

| "Everyday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday"

ww ​

Get Signature ​

ts
get ww(): wy;
Deprecated ​

use wy

Returns ​

wy

www ​

Get Signature ​

ts
get www(): "All" | "Mon" | "Tue" | "Wed" | "Thu" | "Fri" | "Sat" | "Sun";

Short weekday name (e.g., 'Mon')

Returns ​

"All" | "Mon" | "Tue" | "Wed" | "Thu" | "Fri" | "Sat" | "Sun"

wy ​

Get Signature ​

ts
get wy(): wy;

iso week number of the year

Returns ​

wy

yw ​

Get Signature ​

ts
get yw(): number;

4-digit iso week-numbering year

Returns ​

number

yy ​

Get Signature ​

ts
get yy(): number;

4-digit year (e.g., 2024)

Returns ​

number

[$guard] ​

Get Signature ​

ts
get static $guard: any;

Master Guard predicate (implements RegExp-like interface)

Returns ​

any

$ImmutableSkip ​

Get Signature ​

ts
get static $ImmutableSkip(): string[];
Returns ​

string[]

config ​

Get Signature ​

ts
get static config(): any;

global Tempo configuration

Returns ​

any

default ​

Get Signature ​

ts
get static default(): Readonly<{
  calendar?: CalendarLike;
  catch?: boolean;
  debug?: DebugLevel;
  discovery?: string | symbol | Discovery;
  intl?: IntlOptions;
  license?: string;
  locale?: string | string[];
  mode?: "auto" | "strict" | "defer";
  monthDay?: boolean | MonthDay;
  pivot?: number;
  planner?: PlannerOptions;
  plugins?: TempoPlugin | TermPlugin | (TempoPlugin | TermPlugin)[];
  registry?: {
     events?:   | Extend<{
        christmas: "25 Dec";
        christmas ?eve: "24 Dec";
        fortnight: (this) => AliasContext;
        new.?years? ?eve: "31 Dec";
        new.?years?(?: ?day)?: "01 Jan";
        now: (this) => AliasContext;
        ny: "01 Jan";
        nye: "31 Dec";
        today: (this) => ZonedDateTime;
        tomorrow: (this) => AliasContext;
        xmas: "25 Dec";
        xmas ?eve: "24 Dec";
        yesterday: (this) => AliasContext;
      }, string, string | Function>
        | RegistryOption<Logic>;
     formats?: Property<any>;
     ignores?: Ignore;
     layouts?:   | Extend<{
      [key: symbol]: string;
      }, symbol, string>
        | RegistryOption<Pattern>;
     locales?: Record<string, Record<string, string | Function>>;
     modifiers?: Record<string, string | string[]>;
     periods?:   | Extend<{
        after[ -]?noon: "3:00pm";
        evening: "18:00";
        half[ -]?hour: (this) => string;
        mid[ -]?day: "12:00";
        mid[ -]?morning: "10:00";
        mid[ -]?night: "24:00";
        morning: "8:00";
        night: "20:00";
        noon: "12:00";
      }, string, string | Function>
        | RegistryOption<Logic>;
     snippets?:   | Extend<{
      [key: symbol]: RegExp;
      }, symbol, RegExp>
        | RegistryOption<Pattern>;
     tokens?: Record<string, TokenEvaluator>;
  };
  scope: "default";
  silent?: boolean;
  sphere?: string;
  store?: string;
  timeStamp?: TimeStamp;
  timeZone: TimeZoneLike;
  value?: DateTime;
}>;

Tempo initial default settings

Returns ​

Readonly<{ calendar?: CalendarLike; catch?: boolean; debug?: DebugLevel; discovery?: string | symbol | Discovery; intl?: IntlOptions; license?: string; locale?: string | string[]; mode?: "auto" | "strict" | "defer"; monthDay?: boolean | MonthDay; pivot?: number; planner?: PlannerOptions; plugins?: TempoPlugin | TermPlugin | (TempoPlugin | TermPlugin)[]; registry?: { events?: | Extend<{ christmas: "25 Dec"; christmas ?eve: "24 Dec"; fortnight: (this) => AliasContext; new.?years? ?eve: "31 Dec"; new.?years?(?: ?day)?: "01 Jan"; now: (this) => AliasContext; ny: "01 Jan"; nye: "31 Dec"; today: (this) => ZonedDateTime; tomorrow: (this) => AliasContext; xmas: "25 Dec"; xmas ?eve: "24 Dec"; yesterday: (this) => AliasContext; }, string, string | Function> | RegistryOption<Logic>; formats?: Property<any>; ignores?: Ignore; layouts?: | Extend<{ [key: symbol]: string; }, symbol, string> | RegistryOption<Pattern>; locales?: Record<string, Record<string, string | Function>>; modifiers?: Record<string, string | string[]>; periods?: | Extend<{ after[ -]?noon: "3:00pm"; evening: "18:00"; half[ -]?hour: (this) => string; mid[ -]?day: "12:00"; mid[ -]?morning: "10:00"; mid[ -]?night: "24:00"; morning: "8:00"; night: "20:00"; noon: "12:00"; }, string, string | Function> | RegistryOption<Logic>; snippets?: | Extend<{ [key: symbol]: RegExp; }, symbol, RegExp> | RegistryOption<Pattern>; tokens?: Record<string, TokenEvaluator>; }; scope: "default"; silent?: boolean; sphere?: string; store?: string; timeStamp?: TimeStamp; timeZone: TimeZoneLike; value?: DateTime; }>

discovery ​

Get Signature ​

ts
get static discovery(): any;

global discovery configuration

Returns ​

any

FORMAT ​

Get Signature ​

ts
get static FORMAT(): Extend<EnumifyType<{
  date: "{yyyy}-{mm}-{dd}";
  dayDate: "{dd}-{mmm}-{yyyy}";
  dayMonth: "{dd}-{mmm}";
  dayTime: "{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}";
  display: "{www}, {dd} {mmm} {yyyy}";
  logStamp: "{ymd}T{hms}.{ff}";
  sortTime: "{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}";
  time: "{hh}:{mi}:{ss}";
  weekDate: "{www}, {yyyy}-{mmm}-{dd}";
  weekStamp: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}";
  weekTime: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}";
  yearMonth: "{yyyy}{mm}";
  yearMonthDay: "{ymd}";
  yearWeek: "{yw}{wy}";
}>, string, string | number>;

Pre-configured format {name -> string} pairs

Returns ​

Extend<EnumifyType<{ date: "{yyyy}-{mm}-{dd}"; dayDate: "{dd}-{mmm}-{yyyy}"; dayMonth: "{dd}-{mmm}"; dayTime: "{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}"; display: "{www}, {dd} {mmm} {yyyy}"; logStamp: "{ymd}T{hms}.{ff}"; sortTime: "{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}"; time: "{hh}:{mi}:{ss}"; weekDate: "{www}, {yyyy}-{mmm}-{dd}"; weekStamp: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}"; weekTime: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}"; yearMonth: "{yyyy}{mm}"; yearMonthDay: "{ymd}"; yearWeek: "{yw}{wy}"; }>, string, string | number>

formats ​

Get Signature ​

ts
get static formats(): 
  | Extend<EnumifyType<{
  date: "{yyyy}-{mm}-{dd}";
  dayDate: "{dd}-{mmm}-{yyyy}";
  dayMonth: "{dd}-{mmm}";
  dayTime: "{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}";
  display: "{www}, {dd} {mmm} {yyyy}";
  logStamp: "{ymd}T{hms}.{ff}";
  sortTime: "{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}";
  time: "{hh}:{mi}:{ss}";
  weekDate: "{www}, {yyyy}-{mmm}-{dd}";
  weekStamp: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}";
  weekTime: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}";
  yearMonth: "{yyyy}{mm}";
  yearMonthDay: "{ymd}";
  yearWeek: "{yw}{wy}";
}>, string, string | number>
| EnumifyType<any>;
Deprecated ​

Use Tempo.registry.formats instead

Returns ​

| Extend<EnumifyType<{ date: "{yyyy}-{mm}-{dd}"; dayDate: "{dd}-{mmm}-{yyyy}"; dayMonth: "{dd}-{mmm}"; dayTime: "{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}"; display: "{www}, {dd} {mmm} {yyyy}"; logStamp: "{ymd}T{hms}.{ff}"; sortTime: "{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}"; time: "{hh}:{mi}:{ss}"; weekDate: "{www}, {yyyy}-{mmm}-{dd}"; weekStamp: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}"; weekTime: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}"; yearMonth: "{yyyy}{mm}"; yearMonthDay: "{ymd}"; yearWeek: "{yw}{wy}"; }>, string, string | number> | EnumifyType<any>

ignores ​

Get Signature ​

ts
get static ignores(): Secure<Ignore>;

static Tempo.ignores (registry)

Returns ​

Secure<Ignore>

instant ​

Get Signature ​

ts
get static instant(): Instant;

get the current system Instant

Returns ​

Instant

license ​

Get Signature ​

ts
get static license(): {
  audience?: string;
  error?: string;
  expires?: any;
  issuedAt?: any;
  issuer?: string;
  jti?: string;
  scopes: {
   [k: string]: any;
  };
  status: string;
  subject?: string;
};

human-readable formatted license state

Returns ​
ts
{
  audience?: string;
  error?: string;
  expires?: any;
  issuedAt?: any;
  issuer?: string;
  jti?: string;
  scopes: {
   [k: string]: any;
  };
  status: string;
  subject?: string;
}
audience? ​
ts
readonly optional audience?: string;
error? ​
ts
readonly optional error?: string;
expires? ​
ts
readonly optional expires?: any;
issuedAt? ​
ts
optional issuedAt?: any;
issuer? ​
ts
readonly optional issuer?: string;
jti? ​
ts
readonly optional jti?: string;
scopes ​
ts
scopes: {
[k: string]: any;
};
Index Signature ​
ts
[k: string]: any
status ​
ts
readonly status: string;
subject? ​
ts
readonly optional subject?: string;

LIMIT ​

Get Signature ​

ts
get static LIMIT(): {
  get maxTempo(): bigint;
  get minTempo(): bigint;
};

some useful Dates

Returns ​
maxTempo ​
Get Signature ​
ts
get maxTempo(): bigint;

Tempo(31-Dec-9999.23:59:59).ns

Returns ​

bigint

minTempo ​
Get Signature ​
ts
get minTempo(): bigint;

Tempo(01-Jan-1000.00:00:00).ns

Returns ​

bigint

MODE ​

Get Signature ​

ts
get static MODE(): EnumifyType<{
  Auto: "auto";
  Defer: "defer";
  Strict: "strict";
}>;

initialization strategies

Returns ​

EnumifyType<{ Auto: "auto"; Defer: "defer"; Strict: "strict"; }>

MONTH_DAY ​

Get Signature ​

ts
get static MONTH_DAY(): {
  layouts: readonly [readonly ["dayMonthYearShort", "monthDayYearShort"], readonly ["dayMonthYear", "monthDayYear"]];
  locales: readonly ["en-US", "en-AS"];
  timezones: {
     en-AS: readonly ["Pacific/Pago_Pago"];
     en-US: readonly ["America/Adak", "America/Anchorage", "America/Boise", "America/Chicago", "America/Denver", "America/Detroit", "America/Indiana/Indianapolis", "America/Indiana/Knox", "America/Indiana/Marengo", "America/Indiana/Petersburg", "America/Indiana/Tell_City", "America/Indiana/Vevay", "America/Indiana/Vincennes", "America/Indiana/Winamac", "America/Indianapolis", "America/Juneau", "America/Kentucky/Louisville", "America/Kentucky/Monticello", "America/Los_Angeles", "America/Louisville", "America/Menominee", "America/Metlakatla", "America/New_York", "America/Nome", "America/North_Dakota/Beulah", "America/North_Dakota/Center", "America/North_Dakota/New_Salem", "America/Phoenix", "America/Sitka", "America/Yakutat", "Pacific/Honolulu", "US/Aleutian", "US/Alaska", "US/Arizona", "US/Central", "US/Eastern", "US/Mountain", "US/Pacific"];
  };
};

regional date-parsing configuration

Returns ​
ts
{
  layouts: readonly [readonly ["dayMonthYearShort", "monthDayYearShort"], readonly ["dayMonthYear", "monthDayYear"]];
  locales: readonly ["en-US", "en-AS"];
  timezones: {
     en-AS: readonly ["Pacific/Pago_Pago"];
     en-US: readonly ["America/Adak", "America/Anchorage", "America/Boise", "America/Chicago", "America/Denver", "America/Detroit", "America/Indiana/Indianapolis", "America/Indiana/Knox", "America/Indiana/Marengo", "America/Indiana/Petersburg", "America/Indiana/Tell_City", "America/Indiana/Vevay", "America/Indiana/Vincennes", "America/Indiana/Winamac", "America/Indianapolis", "America/Juneau", "America/Kentucky/Louisville", "America/Kentucky/Monticello", "America/Los_Angeles", "America/Louisville", "America/Menominee", "America/Metlakatla", "America/New_York", "America/Nome", "America/North_Dakota/Beulah", "America/North_Dakota/Center", "America/North_Dakota/New_Salem", "America/Phoenix", "America/Sitka", "America/Yakutat", "Pacific/Honolulu", "US/Aleutian", "US/Alaska", "US/Arizona", "US/Central", "US/Eastern", "US/Mountain", "US/Pacific"];
  };
}
layouts ​
ts
readonly layouts: readonly [readonly ["dayMonthYearShort", "monthDayYearShort"], readonly ["dayMonthYear", "monthDayYear"]];
locales ​
ts
readonly locales: readonly ["en-US", "en-AS"];
timezones ​
ts
readonly timezones: {
  en-AS: readonly ["Pacific/Pago_Pago"];
  en-US: readonly ["America/Adak", "America/Anchorage", "America/Boise", "America/Chicago", "America/Denver", "America/Detroit", "America/Indiana/Indianapolis", "America/Indiana/Knox", "America/Indiana/Marengo", "America/Indiana/Petersburg", "America/Indiana/Tell_City", "America/Indiana/Vevay", "America/Indiana/Vincennes", "America/Indiana/Winamac", "America/Indianapolis", "America/Juneau", "America/Kentucky/Louisville", "America/Kentucky/Monticello", "America/Los_Angeles", "America/Louisville", "America/Menominee", "America/Metlakatla", "America/New_York", "America/Nome", "America/North_Dakota/Beulah", "America/North_Dakota/Center", "America/North_Dakota/New_Salem", "America/Phoenix", "America/Sitka", "America/Yakutat", "Pacific/Honolulu", "US/Aleutian", "US/Alaska", "US/Arizona", "US/Central", "US/Eastern", "US/Mountain", "US/Pacific"];
};
timezones.en-AS ​
ts
readonly en-AS: readonly ["Pacific/Pago_Pago"];
timezones.en-US ​
ts
readonly en-US: readonly ["America/Adak", "America/Anchorage", "America/Boise", "America/Chicago", "America/Denver", "America/Detroit", "America/Indiana/Indianapolis", "America/Indiana/Knox", "America/Indiana/Marengo", "America/Indiana/Petersburg", "America/Indiana/Tell_City", "America/Indiana/Vevay", "America/Indiana/Vincennes", "America/Indiana/Winamac", "America/Indianapolis", "America/Juneau", "America/Kentucky/Louisville", "America/Kentucky/Monticello", "America/Los_Angeles", "America/Louisville", "America/Menominee", "America/Metlakatla", "America/New_York", "America/Nome", "America/North_Dakota/Beulah", "America/North_Dakota/Center", "America/North_Dakota/New_Salem", "America/Phoenix", "America/Sitka", "America/Yakutat", "Pacific/Honolulu", "US/Aleutian", "US/Alaska", "US/Arizona", "US/Central", "US/Eastern", "US/Mountain", "US/Pacific"];

NUMBER ​

Get Signature ​

ts
get static NUMBER(): Extend<EnumifyType<{
  eight: 8;
  five: 5;
  four: 4;
  nine: 9;
  one: 1;
  seven: 7;
  six: 6;
  ten: 10;
  three: 3;
  two: 2;
  zero: 0;
}>, string, number>;

Number names (0-10)

Returns ​

Extend<EnumifyType<{ eight: 8; five: 5; four: 4; nine: 9; one: 1; seven: 7; six: 6; ten: 10; three: 3; two: 2; zero: 0; }>, string, number>

options ​

Get Signature ​

ts
get static options(): any;
Returns ​

any

parse ​

Get Signature ​

ts
get static parse(): {
  anchor?: ZonedDateTime;
  event: {
   [key: string]: string | Function;
     christmas: "25 Dec";
     christmas ?eve: "24 Dec";
     fortnight: (this) => AliasContext;
     new.?years? ?eve: "31 Dec";
     new.?years?(?: ?day)?: "01 Jan";
     now: (this) => AliasContext;
     ny: "01 Jan";
     nye: "31 Dec";
     today: (this) => ZonedDateTime;
     tomorrow: (this) => AliasContext;
     xmas: "25 Dec";
     xmas ?eve: "24 Dec";
     yesterday: (this) => AliasContext;
  };
  ignore: {
   [key: string]: string;
  };
  isAnchored?: boolean;
  layout: {
   [key: symbol]: string;
  };
  mode: "auto" | "strict" | "defer";
  monthDay: MonthDay;
  pattern: Registry;
  period: {
   [key: string]: string | Function;
     after[ -]?noon: "3:00pm";
     evening: "18:00";
     half[ -]?hour: (this) => string;
     mid[ -]?day: "12:00";
     mid[ -]?morning: "10:00";
     mid[ -]?night: "24:00";
     morning: "8:00";
     night: "20:00";
     noon: "12:00";
  };
  pivot: number;
  planner: {
     layoutOrder: (string | symbol)[];
     preFilter: boolean;
  };
  result: Match[];
  snippet: {
   [key: symbol]: RegExp;
  };
  token: Extend;
};

configuration governing the static 'rules' used when parsing t.DateTime argument

Returns ​
anchor? ​
ts
readonly optional anchor?: ZonedDateTime;

anchor value used for this parse operation

event ​
ts
readonly event: {
[key: string]: string | Function;
  christmas: "25 Dec";
  christmas ?eve: "24 Dec";
  fortnight: (this) => AliasContext;
  new.?years? ?eve: "31 Dec";
  new.?years?(?: ?day)?: "01 Jan";
  now: (this) => AliasContext;
  ny: "01 Jan";
  nye: "31 Dec";
  today: (this) => ZonedDateTime;
  tomorrow: (this) => AliasContext;
  xmas: "25 Dec";
  xmas ?eve: "24 Dec";
  yesterday: (this) => AliasContext;
};
Index Signature ​
ts
[key: string]: string | Function
event.christmas ​
ts
readonly christmas: "25 Dec" = '25 Dec';
event.christmas ?eve ​
ts
readonly christmas ?eve: "24 Dec" = '24 Dec';
event.fortnight ​
ts
readonly fortnight: (this) => AliasContext;
Parameters ​
ParameterType
thisAliasContext
Returns ​

AliasContext

event.new.?years? ?eve ​
ts
readonly new.?years? ?eve: "31 Dec" = '31 Dec';
event.new.?years?(?: ?day)? ​
ts
readonly new.?years?(?: ?day)?: "01 Jan" = '01 Jan';
event.now ​
ts
readonly now: (this) => AliasContext;
Parameters ​
ParameterType
thisAliasContext
Returns ​

AliasContext

event.ny ​
ts
readonly ny: "01 Jan" = '01 Jan';
event.nye ​
ts
readonly nye: "31 Dec" = '31 Dec';
event.today ​
ts
readonly today: (this) => ZonedDateTime;
Parameters ​
ParameterType
thisAliasContext
Returns ​

ZonedDateTime

event.tomorrow ​
ts
readonly tomorrow: (this) => AliasContext;
Parameters ​
ParameterType
thisAliasContext
Returns ​

AliasContext

event.xmas ​
ts
readonly xmas: "25 Dec" = '25 Dec';
event.xmas ?eve ​
ts
readonly xmas ?eve: "24 Dec" = '24 Dec';
event.yesterday ​
ts
readonly yesterday: (this) => AliasContext;
Parameters ​
ParameterType
thisAliasContext
Returns ​

AliasContext

ignore ​
ts
readonly ignore: {
[key: string]: string;
};
Index Signature ​
ts
[key: string]: string
isAnchored? ​
ts
readonly optional isAnchored?: boolean;

was this a nested/anchored parse?

layout ​
ts
readonly layout: {
[key: symbol]: string;
};
Index Signature ​
ts
[key: symbol]: string
mode ​
ts
readonly mode: "auto" | "strict" | "defer";

initialization strategy ('auto'|'strict'|'defer')

monthDay ​
ts
readonly monthDay: MonthDay;
pattern ​
ts
readonly pattern: Registry;

Map of regex-patterns to match input-string

period ​
ts
readonly period: {
[key: string]: string | Function;
  after[ -]?noon: "3:00pm";
  evening: "18:00";
  half[ -]?hour: (this) => string;
  mid[ -]?day: "12:00";
  mid[ -]?morning: "10:00";
  mid[ -]?night: "24:00";
  morning: "8:00";
  night: "20:00";
  noon: "12:00";
};
Index Signature ​
ts
[key: string]: string | Function
period.after[ -]?noon ​
ts
readonly after[ -]?noon: "3:00pm" = '3:00pm';
period.evening ​
ts
readonly evening: "18:00" = '18:00';
period.half[ -]?hour ​
ts
readonly half[ -]?hour: (this) => string;
Parameters ​
ParameterType
thisAliasContext
Returns ​

string

period.mid[ -]?day ​
ts
readonly mid[ -]?day: "12:00" = '12:00';
period.mid[ -]?morning ​
ts
readonly mid[ -]?morning: "10:00" = '10:00';
period.mid[ -]?night ​
ts
readonly mid[ -]?night: "24:00" = '24:00';
period.morning ​
ts
readonly morning: "8:00" = '8:00';
period.night ​
ts
readonly night: "20:00" = '20:00';
period.noon ​
ts
readonly noon: "12:00" = '12:00';
pivot ​
ts
readonly pivot: number;

pivot year for two-digit years

planner ​
ts
planner: {
  layoutOrder: (string | symbol)[];
  preFilter: boolean;
};
planner.layoutOrder ​
ts
layoutOrder: (string | symbol)[];
planner.preFilter ​
ts
preFilter: boolean;
result ​
ts
readonly result: Match[];

parsing match result

snippet ​
ts
readonly snippet: {
[key: symbol]: RegExp;
};
Index Signature ​
ts
[key: symbol]: RegExp
token ​
ts
readonly token: Extend;

Symbol registry

properties ​

Get Signature ​

ts
get static properties(): SecureArray<string>;

static Tempo properties getter

Returns ​

SecureArray<string>

registry ​

Get Signature ​

ts
get static registry(): any;

static Tempo.registry

Returns ​

any

terms ​

Get Signature ​

ts
get static terms(): SecureArray<PremiumPlugin> & Record<string, PremiumPlugin>;

static Tempo.terms (registry)

Returns ​

SecureArray<PremiumPlugin> & Record<string, PremiumPlugin>

TIMEZONE ​

Get Signature ​

ts
get static TIMEZONE(): Extend<{
  acst: "Australia/Adelaide";
  aest: "Australia/Sydney";
  awst: "Australia/Perth";
  cet: "Europe/Paris";
  cst: "America/Chicago";
  eet: "Europe/Helsinki";
  est: "America/New_York";
  gmt: "Europe/London";
  ist: "Asia/Kolkata";
  jst: "Asia/Tokyo";
  mst: "America/Denver";
  npt: "Asia/Kathmandu";
  nzt: "Pacific/Auckland";
  pst: "America/Los_Angeles";
  utc: "UTC";
}, string, string>;

TimeZone aliases

Returns ​

Extend<{ acst: "Australia/Adelaide"; aest: "Australia/Sydney"; awst: "Australia/Perth"; cet: "Europe/Paris"; cst: "America/Chicago"; eet: "Europe/Helsinki"; est: "America/New_York"; gmt: "Europe/London"; ist: "Asia/Kolkata"; jst: "Asia/Tokyo"; mst: "America/Denver"; npt: "Asia/Kathmandu"; nzt: "Pacific/Auckland"; pst: "America/Los_Angeles"; utc: "UTC"; }, string, string>

version ​

Get Signature ​

ts
get static version(): string;

the version of this Tempo build (stamped at build-time from package.json)

Returns ​

string

Methods ​

[iterator]() ​

ts
iterator: ArrayIterator<EntryOf<any>>;

iterate over instance formats

Returns ​

ArrayIterator<EntryOf<any>>

[toPrimitive]() ​

ts
toPrimitive: string | number | bigint;

allow for auto-convert of Tempo to BigInt, Number or String

Parameters ​

ParameterType
hint?"string" | "number" | "default"

Returns ​

string | number | bigint

add() ​

ts
add(tempo?, options?): Tempo;

returns a new Tempo with specific duration added.

Parameters ​

ParameterType
tempo?MutateAdd
options?Options

Returns ​

Tempo

clone() ​

ts
clone(): Tempo;

returns a clone of the current Tempo instance.

Returns ​

Tempo

format() ​

Call Signature ​

ts
format<K>(fmt, options?): any;

apply a custom format.

Type Parameters ​
Type Parameter
K extends Format
Parameters ​
ParameterType
fmtK
options?any
Returns ​

any

Call Signature ​

ts
format(options): string;

applies a format to the instance.

Parameters ​
ParameterType
optionsDateTimeFormatOptions & { calendar?: string; timeZone?: string; }
Returns ​

string

Call Signature ​

ts
format(fmt, options?): bigint;

applies a format to the instance.

Parameters ​
ParameterType
fmt"{nano}"
options?any
Returns ​

bigint

Call Signature ​

ts
format(fmt, options?): number;

applies a format to the instance.

Parameters ​
ParameterType
fmt| "{yw}{wy}" | "{yyyy}{mm}" | "{ymd}" | "{yyyy}{wy}" | "{yyyy}{mm}{dd}" | "{yywy}" | "{yw}" | "{ymd6}" | "{hms}" | "{ff}" | "{dmy}" | "{dmy6}" | "{mdy}" | "{mdy6}"
options?any
Returns ​

number

Call Signature ​

ts
format(fmt?, options?): any;

applies a format to the instance.

Parameters ​
ParameterType
fmt?any
options?any
Returns ​

any

set() ​

ts
set(tempo?, options?): Tempo;

returns a new Tempo with specific offsets.

Parameters ​

ParameterType
tempo?MutateSet
options?Options

Returns ​

Tempo

setCatchMode() ​

ts
setCatchMode(catchMode): this;

explicitly enable/disable "catch" mode for this instance

Parameters ​

ParameterType
catchModeboolean

Returns ​

this

since() ​

Call Signature ​

ts
since(arg0?, arg1?): any;

time elapsed since another date-time

Parameters ​
ParameterType
arg0?any
arg1?any
Returns ​

any

Call Signature ​

ts
since(until, opts?): string;

time elapsed since (with unit)

Parameters ​
ParameterType
untilUntil
opts?Options
Returns ​

string

Call Signature ​

ts
since(dateTimeOrOpts, until): string;

time elapsed since another date-time (with unit)

Parameters ​
ParameterType
dateTimeOrOptsOptions | DateTime
untilUntil
Returns ​

string

Call Signature ​

ts
since(dateTimeOrOpts?, opts?): string;

time elapsed since another date-time (w'out unit)

Parameters ​
ParameterType
dateTimeOrOpts?Options | DateTime
opts?Options
Returns ​

string

Call Signature ​

ts
since(optsOrDate?, optsOrUntil?): string;

time elapsed since another date-time

Parameters ​
ParameterType
optsOrDate?any
optsOrUntil?any
Returns ​

string

toDate() ​

ts
toDate(): Date;

the date-time as a standard Date object.

Returns ​

Date

toDateTime() ​

ts
toDateTime(): ZonedDateTime;

returns the underlying Temporal.ZonedDateTime

Returns ​

ZonedDateTime

toInstant() ​

ts
toInstant(): Instant;

returns the underlying Temporal.Instant

Returns ​

Instant

toJSON() ​

ts
toJSON(): {
  calendar: CalendarLike;
  catch: boolean;
  debug: DebugLevel;
  discovery: string | symbol | Discovery;
  intl: IntlOptions;
  license?: string;
  locale: string | string[];
  mode: "auto" | "strict" | "defer";
  plugins: TempoPlugin | TermPlugin | (TempoPlugin | TermPlugin)[];
  registry: {
     formats: EnumifyType;
     locales: Record<string, Record<string, string | Function>>;
     modifiers?: Record<string, string | string[]>;
     tokens?: Record<string, TokenEvaluator>;
  };
  scope: "global" | "local";
  silent: boolean;
  sphere: string | undefined;
  store: string;
  timeStamp: TimeStamp;
  timeZone: TimeZoneLike;
  value: string;
};

Custom JSON serialization for JSON.stringify.

Returns ​

calendar ​
ts
calendar: CalendarLike;

Temporal calendar

catch ​
ts
catch: boolean;

catch or throw Errors

debug ​
ts
debug: DebugLevel;

additional console.log for tracking

discovery ​
ts
discovery: string | symbol | Discovery;

globalThis Discovery Symbol

intl ​
ts
intl: IntlOptions;

internationalization configuration (relativeTime, etc.)

license? ​
ts
optional license?: string;

license key for premium features

locale ​
ts
locale: string | string[];

locale (e.g. en-AU)

mode ​
ts
mode: "auto" | "strict" | "defer";

initialization strategy ('auto'|'strict'|'defer')

plugins ​
ts
plugins: TempoPlugin | TermPlugin | (TempoPlugin | TermPlugin)[];

plugins to be automatically extended

registry ​
ts
registry: {
  formats: EnumifyType;
  locales: Record<string, Record<string, string | Function>>;
  modifiers?: Record<string, string | string[]>;
  tokens?: Record<string, TokenEvaluator>;
};

custom data augmentation registries

registry.formats ​
ts
formats: EnumifyType;
registry.locales ​
ts
locales: Record<string, Record<string, string | Function>>;
registry.modifiers? ​
ts
optional modifiers?: Record<string, string | string[]>;
registry.tokens? ​
ts
optional tokens?: Record<string, TokenEvaluator>;
scope ​
ts
scope: "global" | "local";

scope for configuration mutations

silent ​
ts
silent: boolean;

suppress console output during catch

sphere ​
ts
sphere: string | undefined;

hemisphere for term.qtr or term.szn

store ​
ts
store: string;

localStorage key

timeStamp ​
ts
timeStamp: TimeStamp;

Precision to measure timestamps (ms | us)

timeZone ​
ts
timeZone: TimeZoneLike;

Temporal timeZone

value ​
ts
value: string;

toNow() ​

ts
toNow(): ZonedDateTime;

the current system time localized to this instance.

Returns ​

ZonedDateTime

toPlainDate() ​

ts
toPlainDate(): PlainDate;

returns a Temporal.PlainDate representation

Returns ​

PlainDate

toPlainDateTime() ​

ts
toPlainDateTime(): PlainDateTime;

returns a Temporal.PlainDateTime representation

Returns ​

PlainDateTime

toPlainTime() ​

ts
toPlainTime(): PlainTime;

returns a Temporal.PlainTime representation

Returns ​

PlainTime

toString() ​

ts
toString(): string;

iso8601 string representation of the date-time.

Returns ​

string

until() ​

Call Signature ​

ts
until(arg0?, arg1?): any;

time duration until another date-time

Parameters ​
ParameterType
arg0?any
arg1?any
Returns ​

any

Call Signature ​

ts
until(dateTimeOrOpts?, opts?): Duration;

time duration until (returns Duration)

Parameters ​
ParameterType
dateTimeOrOpts?Options | DateTime
opts?Options
Returns ​

Duration

Call Signature ​

ts
until(unit, opts?): number;

time duration until (with unit, returns number)

Parameters ​
ParameterType
unitUnit
opts?Options
Returns ​

number

Call Signature ​

ts
until(dateTimeOrOpts, unit): number;

time duration until another date-time (with unit)

Parameters ​
ParameterType
dateTimeOrOptsOptions | DateTime
unitUnit
Returns ​

number

Call Signature ​

ts
until(optsOrDate?, optsOrUntil?): number | Duration;

fallback: union of possible returns

Parameters ​
ParameterType
optsOrDate?| string | number | bigint | TempoBrand | ZonedDateTime | Instant | Options | PlainDate | PlainDateTime | ZonedDateTimeLikeObject | ISOString | Date | Tempo | PlainTime | Duration | Options & { unit?: Unit; } | null
optsOrUntil?Options | Until
Returns ​

number | Duration

[$buildGuard]() ​

ts
static $buildGuard: void;

Parameters ​

ParameterType
targetState?State

Returns ​

void

[$setAliases]() ​

ts
static [$setAliases](
   shape, 
   kind, 
   token, 
   provided?): void;

{dt} is a layout that combines date-related {snippets} (e.g. dd, mm -or- evt) into a pattern against which a string can be tested.
because it will also include a list of events (e.g. 'new_years' | 'xmas'), we need to rebuild {dt} if the user adds a new event

Parameters ​

ParameterType
shapeState
kind"evt" | "per"
tokenany
provided?[string, any][]

Returns ​

void

[$setConfig]() ​

ts
static $setConfig: void;

conform input of Snippet / Layout / Event / Period options
This is needed because we allow the user to flexibly provide detail as {[key]:val} or {[key]:val}[] or [key,val][]

Parameters ​

ParameterType
shapeState
...optionsOptions[]

Returns ​

void

[$setDiscovery]() ​

ts
static $setDiscovery: Options;

support "Global Discovery" of user-options

Parameters ​

ParameterType
shapeState
discovery?Discovery

Returns ​

Options

[$setEvents]() ​

ts
static [$setEvents](
   shape, 
   provided?, 
   rebuild?): void;

Parameters ​

ParameterTypeDefault value
shapeStateundefined
provided?[string, any][]undefined
rebuild?booleantrue

Returns ​

void

[$setPeriods]() ​

ts
static [$setPeriods](
   shape, 
   provided?, 
   rebuild?): void;

Parameters ​

ParameterTypeDefault value
shapeStateundefined
provided?[string, any][]undefined
rebuild?booleantrue

Returns ​

void

[dispose]() ​

ts
static dispose: void;

release global config and reset library to defaults

Returns ​

void

[hasInstance]() ​

ts
static hasInstance: boolean;

Parameters ​

ParameterType
instanceany

Returns ​

boolean

[iterator]() ​

ts
static iterator: ArrayIterator<string>;

iterate over Tempo properties

Returns ​

ArrayIterator<string>

bootstrap() ​

ts
static bootstrap(options?): Promise<typeof Tempo>;

Automatically discovers and loads configuration from tempo.config.* before initializing the engine.

Parameters ​

ParameterType
options?{ configFile?: string; cwd?: string; }
options.configFile?string
options.cwd?string

Returns ​

Promise<typeof Tempo>

compare() ​

ts
static compare(tempo1?, tempo2?): number;

Compares two Tempo instances or date-time values. Returns -1 (earlier), 0 (equal), or 1 (later).

Parameters ​

ParameterType
tempo1?Options | DateTime
tempo2?Options | DateTime

Returns ​

number

create() ​

ts
static create(options?): typeof Tempo;

🏭 Sandbox Factory Mode Create a fresh, isolated Tempo subclass with its own configuration and registries. Returns a new class that inherits from the caller, but maintains independent state.

Parameters ​

ParameterType
optionsOptions

Returns ​

typeof Tempo

extend() ​

Call Signature ​

ts
static extend(plugin, options?): typeof Tempo;

Register a plugin or term extension.

Parameters ​
ParameterTypeDescription
pluginTempoPluginA plugin or term extension to register.
options?OptionsOptional configuration for the plugin.
Returns ​

typeof Tempo

Call Signature ​

ts
static extend(plugins, options?): typeof Tempo;

Register an array of plugins or term extensions.

Parameters ​
ParameterTypeDescription
pluginsany[]An array of plugins, terms, or extensions to register.
options?OptionsOptional configuration for the plugins.
Returns ​

typeof Tempo

Call Signature ​

ts
static extend(...args): typeof Tempo;

Register multiple plugins or term extensions.

Parameters ​
ParameterTypeDescription
...argsany[]A plugin, term, or list of extensions to register.
Returns ​

typeof Tempo

from() ​

Call Signature ​

ts
static from(options?): Tempo;

Creates a new Tempo instance.

Parameters ​
ParameterType
options?Options
Returns ​

Tempo

Call Signature ​

ts
static from(tempo, options?): Tempo;

Creates a new Tempo instance.

Parameters ​
ParameterType
tempoDateTime
options?Options
Returns ​

Tempo

init() ​

ts
static init(options?): typeof Tempo;

Reset Tempo to its default, built-in registration state

Parameters ​

ParameterType
optionsOptions

Returns ​

typeof Tempo

isTempo() ​

ts
static isTempo(instance?): instance is Tempo;

check if a supplied variable is a valid Tempo instance

Parameters ​

ParameterType
instance?any

Returns ​

instance is Tempo

now() ​

ts
static now(): bigint;

Returns ​

bigint

ready() ​

ts
static ready(): Promise<string>;

Wait for the background licensing and validation engine to finish settling. Resolves immediately if no license key or validation is pending.

Returns ​

Promise<string>

The final, human-readable license status ('none', 'active', 'expired', etc.)

regexp() ​

ts
static regexp(layout, snippet?): RegExp;

translates {layout} into an anchored, case-insensitive RegExp.

Parameters ​

ParameterType
layoutstring | RegExp
snippet?Extend<{ [key: symbol]: RegExp; }, symbol, RegExp>

Returns ​

RegExp

setCatchMode() ​

ts
static setCatchMode(catchMode): typeof Tempo;

explicitly enable/disable "catch" mode for internal errors

Parameters ​

ParameterType
catchModeboolean

Returns ​

typeof Tempo

Released under the MIT License.

Copyright © 2026-present Magma Computing