@internationalized/date 3.12.0 → 3.12.2

package/src/CalendarDate.ts

@@ -10,17 +10,46 @@
  * governing permissions and limitations under the License.
  */
 
-import {add, addTime, addZoned, constrain, constrainTime, cycleDate, cycleTime, cycleZoned, set, setTime, setZoned, subtract, subtractTime, subtractZoned} from './manipulation';
-import {AnyCalendarDate, AnyTime, Calendar, CycleOptions, CycleTimeOptions, DateDuration, DateField, DateFields, DateTimeDuration, Disambiguation, TimeDuration, TimeField, TimeFields} from './types';
+import {
+  add,
+  addTime,
+  addZoned,
+  constrain,
+  constrainTime,
+  cycleDate,
+  cycleTime,
+  cycleZoned,
+  set,
+  setTime,
+  setZoned,
+  subtract,
+  subtractTime,
+  subtractZoned
+} from './manipulation';
+import {
+  AnyCalendarDate,
+  AnyTime,
+  Calendar,
+  CycleOptions,
+  CycleTimeOptions,
+  DateDuration,
+  DateField,
+  DateFields,
+  DateTimeDuration,
+  Disambiguation,
+  TimeDuration,
+  TimeField,
+  TimeFields
+} from './types';
 import {compareDate, compareTime} from './queries';
 import {dateTimeToString, dateToString, timeToString, zonedDateTimeToString} from './string';
 import {GregorianCalendar} from './calendars/GregorianCalendar';
 import {toCalendarDateTime, toDate, toZoned, zonedToDate} from './conversion';
 
+export type DateValue = CalendarDate | CalendarDateTime | ZonedDateTime;
+
 function shiftArgs(args: any[]) {
-  let calendar: Calendar = typeof args[0] === 'object'
-    ? args.shift()
-    : new GregorianCalendar();
+  let calendar: Calendar = typeof args[0] === 'object' ? args.shift() : new GregorianCalendar();
 
   let era: string;
   if (typeof args[0] === 'string') {
@@ -93,7 +122,10 @@ export class CalendarDate {
     return subtract(this, duration);
   }
 
-  /** Returns a new `CalendarDate` with the given fields set to the provided values. Other fields will be constrained accordingly. */
+  /**
+   * Returns a new `CalendarDate` with the given fields set to the provided values. Other fields
+   * will be constrained accordingly.
+   */
   set(fields: DateFields): CalendarDate {
     return set(this, fields);
   }
@@ -106,7 +138,10 @@ export class CalendarDate {
     return cycleDate(this, field, amount, options);
   }
 
-  /** Converts the date to a native JavaScript Date object, with the time set to midnight in the given time zone. */
+  /**
+   * Converts the date to a native JavaScript Date object, with the time set to midnight in the
+   * given time zone.
+   */
   toDate(timeZone: string): Date {
     return toDate(this, timeZone);
   }
@@ -116,7 +151,10 @@ export class CalendarDate {
     return dateToString(this);
   }
 
-  /** Compares this date with another. A negative result indicates that this date is before the given one, and a positive date indicates that it is after. */
+  /**
+   * Compares this date with another. A negative result indicates that this date is before the given
+   * one, and a positive date indicates that it is after.
+   */
   compare(b: AnyCalendarDate): number {
     return compareDate(this, b);
   }
@@ -136,12 +174,7 @@ export class Time {
   /** The millisecond in the second. */
   public readonly millisecond: number;
 
-  constructor(
-    hour: number = 0,
-    minute: number = 0,
-    second: number = 0,
-    millisecond: number = 0
-  ) {
+  constructor(hour: number = 0, minute: number = 0, second: number = 0, millisecond: number = 0) {
     this.hour = hour;
     this.minute = minute;
     this.second = second;
@@ -164,7 +197,10 @@ export class Time {
     return subtractTime(this, duration);
   }
 
-  /** Returns a new `Time` with the given fields set to the provided values. Other fields will be constrained accordingly. */
+  /**
+   * Returns a new `Time` with the given fields set to the provided values. Other fields will be
+   * constrained accordingly.
+   */
   set(fields: TimeFields): Time {
     return setTime(this, fields);
   }
@@ -182,7 +218,10 @@ export class Time {
     return timeToString(this);
   }
 
-  /** Compares this time with another. A negative result indicates that this time is before the given one, and a positive time indicates that it is after. */
+  /**
+   * Compares this time with another. A negative result indicates that this time is before the given
+   * one, and a positive time indicates that it is after.
+   */
   compare(b: AnyTime): number {
     return compareTime(this, b);
   }
@@ -216,10 +255,46 @@ export class CalendarDateTime {
   /** The millisecond in the second. */
   public readonly millisecond: number;
 
-  constructor(year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number);
-  constructor(era: string, year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number);
-  constructor(calendar: Calendar, year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number);
-  constructor(calendar: Calendar, era: string, year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number);
+  constructor(
+    year: number,
+    month: number,
+    day: number,
+    hour?: number,
+    minute?: number,
+    second?: number,
+    millisecond?: number
+  );
+  constructor(
+    era: string,
+    year: number,
+    month: number,
+    day: number,
+    hour?: number,
+    minute?: number,
+    second?: number,
+    millisecond?: number
+  );
+  constructor(
+    calendar: Calendar,
+    year: number,
+    month: number,
+    day: number,
+    hour?: number,
+    minute?: number,
+    second?: number,
+    millisecond?: number
+  );
+  constructor(
+    calendar: Calendar,
+    era: string,
+    year: number,
+    month: number,
+    day: number,
+    hour?: number,
+    minute?: number,
+    second?: number,
+    millisecond?: number
+  );
   constructor(...args: any[]) {
     let [calendar, era, year, month, day] = shiftArgs(args);
     this.calendar = calendar;
@@ -238,9 +313,28 @@ export class CalendarDateTime {
   /** Returns a copy of this date. */
   copy(): CalendarDateTime {
     if (this.era) {
-      return new CalendarDateTime(this.calendar, this.era, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+      return new CalendarDateTime(
+        this.calendar,
+        this.era,
+        this.year,
+        this.month,
+        this.day,
+        this.hour,
+        this.minute,
+        this.second,
+        this.millisecond
+      );
     } else {
-      return new CalendarDateTime(this.calendar, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+      return new CalendarDateTime(
+        this.calendar,
+        this.year,
+        this.month,
+        this.day,
+        this.hour,
+        this.minute,
+        this.second,
+        this.millisecond
+      );
     }
   }
 
@@ -254,7 +348,10 @@ export class CalendarDateTime {
     return subtract(this, duration);
   }
 
-  /** Returns a new `CalendarDateTime` with the given fields set to the provided values. Other fields will be constrained accordingly. */
+  /**
+   * Returns a new `CalendarDateTime` with the given fields set to the provided values. Other fields
+   * will be constrained accordingly.
+   */
   set(fields: DateFields & TimeFields): CalendarDateTime {
     return set(setTime(this, fields), fields);
   }
@@ -263,7 +360,11 @@ export class CalendarDateTime {
    * Returns a new `CalendarDateTime` with the given field adjusted by a specified amount.
    * When the resulting value reaches the limits of the field, it wraps around.
    */
-  cycle(field: DateField | TimeField, amount: number, options?: CycleTimeOptions): CalendarDateTime {
+  cycle(
+    field: DateField | TimeField,
+    amount: number,
+    options?: CycleTimeOptions
+  ): CalendarDateTime {
     switch (field) {
       case 'era':
       case 'year':
@@ -285,7 +386,10 @@ export class CalendarDateTime {
     return dateTimeToString(this);
   }
 
-  /** Compares this date with another. A negative result indicates that this date is before the given one, and a positive date indicates that it is after. */
+  /**
+   * Compares this date with another. A negative result indicates that this date is before the given
+   * one, and a positive date indicates that it is after.
+   */
   compare(b: CalendarDate | CalendarDateTime | ZonedDateTime): number {
     let res = compareDate(this, b);
     if (res === 0) {
@@ -328,10 +432,54 @@ export class ZonedDateTime {
   /** The UTC offset for this time, in milliseconds. */
   public readonly offset: number;
 
-  constructor(year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
-  constructor(era: string, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
-  constructor(calendar: Calendar, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
-  constructor(calendar: Calendar, era: string, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
+  constructor(
+    year: number,
+    month: number,
+    day: number,
+    timeZone: string,
+    offset: number,
+    hour?: number,
+    minute?: number,
+    second?: number,
+    millisecond?: number
+  );
+  constructor(
+    era: string,
+    year: number,
+    month: number,
+    day: number,
+    timeZone: string,
+    offset: number,
+    hour?: number,
+    minute?: number,
+    second?: number,
+    millisecond?: number
+  );
+  constructor(
+    calendar: Calendar,
+    year: number,
+    month: number,
+    day: number,
+    timeZone: string,
+    offset: number,
+    hour?: number,
+    minute?: number,
+    second?: number,
+    millisecond?: number
+  );
+  constructor(
+    calendar: Calendar,
+    era: string,
+    year: number,
+    month: number,
+    day: number,
+    timeZone: string,
+    offset: number,
+    hour?: number,
+    minute?: number,
+    second?: number,
+    millisecond?: number
+  );
   constructor(...args: any[]) {
     let [calendar, era, year, month, day] = shiftArgs(args);
     let timeZone = args.shift();
@@ -354,9 +502,32 @@ export class ZonedDateTime {
   /** Returns a copy of this date. */
   copy(): ZonedDateTime {
     if (this.era) {
-      return new ZonedDateTime(this.calendar, this.era, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond);
+      return new ZonedDateTime(
+        this.calendar,
+        this.era,
+        this.year,
+        this.month,
+        this.day,
+        this.timeZone,
+        this.offset,
+        this.hour,
+        this.minute,
+        this.second,
+        this.millisecond
+      );
     } else {
-      return new ZonedDateTime(this.calendar, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond);
+      return new ZonedDateTime(
+        this.calendar,
+        this.year,
+        this.month,
+        this.day,
+        this.timeZone,
+        this.offset,
+        this.hour,
+        this.minute,
+        this.second,
+        this.millisecond
+      );
     }
   }
 
@@ -370,7 +541,10 @@ export class ZonedDateTime {
     return subtractZoned(this, duration);
   }
 
-  /** Returns a new `ZonedDateTime` with the given fields set to the provided values. Other fields will be constrained accordingly. */
+  /**
+   * Returns a new `ZonedDateTime` with the given fields set to the provided values. Other fields
+   * will be constrained accordingly.
+   */
   set(fields: DateFields & TimeFields, disambiguation?: Disambiguation): ZonedDateTime {
     return setZoned(this, fields, disambiguation);
   }
@@ -388,17 +562,23 @@ export class ZonedDateTime {
     return zonedToDate(this);
   }
 
-   /** Converts the date to an ISO 8601 formatted string, including the UTC offset and time zone identifier. */
+  /**
+   * Converts the date to an ISO 8601 formatted string, including the UTC offset and time zone
+   * identifier.
+   */
   toString(): string {
     return zonedDateTimeToString(this);
   }
 
-   /** Converts the date to an ISO 8601 formatted string in UTC. */
+  /** Converts the date to an ISO 8601 formatted string in UTC. */
   toAbsoluteString(): string {
     return this.toDate().toISOString();
   }
 
-  /** Compares this date with another. A negative result indicates that this date is before the given one, and a positive date indicates that it is after. */
+  /**
+   * Compares this date with another. A negative result indicates that this date is before the given
+   * one, and a positive date indicates that it is after.
+   */
   compare(b: CalendarDate | CalendarDateTime | ZonedDateTime): number {
     // TODO: Is this a bad idea??
     return this.toDate().getTime() - toZoned(b, this.timeZone).toDate().getTime();

package/src/DateFormatter.ts

@@ -13,7 +13,7 @@
 let formatterCache = new Map<string, Intl.DateTimeFormat>();
 
 interface DateRangeFormatPart extends Intl.DateTimeFormatPart {
-  source: 'startRange' | 'endRange' | 'shared'
+  source: 'startRange' | 'endRange' | 'shared';
 }
 
 /** A wrapper around Intl.DateTimeFormat that fixes various browser bugs, and polyfills new features. */
@@ -27,7 +27,10 @@ export class DateFormatter implements Intl.DateTimeFormat {
     this.options = options;
   }
 
-  /** Formats a date as a string according to the locale and format options passed to the constructor. */
+  /**
+   * Formats a date as a string according to the locale and format options passed to the
+   * constructor.
+   */
   format(value: Date): string {
     return this.formatter.format(value);
   }
@@ -68,9 +71,9 @@ export class DateFormatter implements Intl.DateTimeFormat {
     let startParts = this.formatter.formatToParts(start);
     let endParts = this.formatter.formatToParts(end);
     return [
-      ...startParts.map(p => ({...p, source: 'startRange'} as DateRangeFormatPart)),
+      ...startParts.map(p => ({...p, source: 'startRange'}) as DateRangeFormatPart),
       {type: 'literal', value: ' – ', source: 'shared'},
-      ...endParts.map(p => ({...p, source: 'endRange'} as DateRangeFormatPart))
+      ...endParts.map(p => ({...p, source: 'endRange'}) as DateRangeFormatPart)
     ];
   }
 
@@ -116,7 +119,10 @@ const hour12Preferences = {
   }
 };
 
-function getCachedDateFormatter(locale: string, options: Intl.DateTimeFormatOptions = {}): Intl.DateTimeFormat {
+function getCachedDateFormatter(
+  locale: string,
+  options: Intl.DateTimeFormatOptions = {}
+): Intl.DateTimeFormat {
   // Work around buggy hour12 behavior in Chrome / ECMA 402 spec by using hourCycle instead.
   // Only apply the workaround if the issue is detected, because the hourCycle option is buggy in Safari.
   if (typeof options.hour12 === 'boolean' && hasBuggyHour12Behavior()) {
@@ -127,7 +133,13 @@ function getCachedDateFormatter(locale: string, options: Intl.DateTimeFormatOpti
     delete options.hour12;
   }
 
-  let cacheKey = locale + (options ? Object.entries(options).sort((a, b) => a[0] < b[0] ? -1 : 1).join() : '');
+  let cacheKey =
+    locale +
+    (options
+      ? Object.entries(options)
+          .sort((a, b) => (a[0] < b[0] ? -1 : 1))
+          .join()
+      : '');
   if (formatterCache.has(cacheKey)) {
     return formatterCache.get(cacheKey)!;
   }
@@ -140,10 +152,11 @@ function getCachedDateFormatter(locale: string, options: Intl.DateTimeFormatOpti
 let _hasBuggyHour12Behavior: boolean | null = null;
 function hasBuggyHour12Behavior() {
   if (_hasBuggyHour12Behavior == null) {
-    _hasBuggyHour12Behavior = new Intl.DateTimeFormat('en-US', {
-      hour: 'numeric',
-      hour12: false
-    }).format(new Date(2020, 2, 3, 0)) === '24';
+    _hasBuggyHour12Behavior =
+      new Intl.DateTimeFormat('en-US', {
+        hour: 'numeric',
+        hour12: false
+      }).format(new Date(2020, 2, 3, 0)) === '24';
   }
 
   return _hasBuggyHour12Behavior;
@@ -152,10 +165,11 @@ function hasBuggyHour12Behavior() {
 let _hasBuggyResolvedHourCycle: boolean | null = null;
 function hasBuggyResolvedHourCycle() {
   if (_hasBuggyResolvedHourCycle == null) {
-    _hasBuggyResolvedHourCycle = new Intl.DateTimeFormat('fr', {
-      hour: 'numeric',
-      hour12: false
-    }).resolvedOptions().hourCycle === 'h12';
+    _hasBuggyResolvedHourCycle =
+      new Intl.DateTimeFormat('fr', {
+        hour: 'numeric',
+        hour12: false
+      }).resolvedOptions().hourCycle === 'h12';
   }
 
   return _hasBuggyResolvedHourCycle;
@@ -175,8 +189,14 @@ function getResolvedHourCycle(locale: string, options: Intl.DateTimeFormatOption
     timeZone: undefined // use local timezone
   });
 
-  let min = parseInt(formatter.formatToParts(new Date(2020, 2, 3, 0)).find(p => p.type === 'hour')!.value, 10);
-  let max = parseInt(formatter.formatToParts(new Date(2020, 2, 3, 23)).find(p => p.type === 'hour')!.value, 10);
+  let min = parseInt(
+    formatter.formatToParts(new Date(2020, 2, 3, 0)).find(p => p.type === 'hour')!.value,
+    10
+  );
+  let max = parseInt(
+    formatter.formatToParts(new Date(2020, 2, 3, 23)).find(p => p.type === 'hour')!.value,
+    10
+  );
 
   if (min === 0 && max === 23) {
     return 'h23';

package/src/calendars/BuddhistCalendar.ts

@@ -55,10 +55,5 @@ export class BuddhistCalendar extends GregorianCalendar {
 
 function toGregorian(date: AnyCalendarDate) {
   let [era, year] = fromExtendedYear(date.year + BUDDHIST_ERA_START);
-  return new CalendarDate(
-    era,
-    year,
-    date.month,
-    date.day
-  );
+  return new CalendarDate(era, year, date.month, date.day);
 }

package/src/calendars/EthiopicCalendar.ts

@@ -26,11 +26,12 @@ const AMETE_MIHRET_DELTA = 5500;
 
 function ceToJulianDay(epoch: number, year: number, month: number, day: number): number {
   return (
-    epoch                   // difference from Julian epoch to 1,1,1
-    + 365 * year            // number of days from years
-    + Math.floor(year / 4)  // extra day of leap year
-    + 30 * (month - 1)      // number of days from months (1 based)
-    + day - 1               // number of days for present month (1 based)
+    epoch + // difference from Julian epoch to 1,1,1
+    365 * year + // number of days from years
+    Math.floor(year / 4) + // extra day of leap year
+    30 * (month - 1) + // number of days from months (1 based)
+    day -
+    1 // number of days for present month (1 based)
   );
 }
 

package/src/calendars/GregorianCalendar.ts

@@ -18,7 +18,12 @@ import {CalendarDate} from '../CalendarDate';
 import {mod, Mutable} from '../utils';
 
 const EPOCH = 1721426; // 001/01/03 Julian C.E.
-export function gregorianToJulianDay(era: string, year: number, month: number, day: number): number {
+export function gregorianToJulianDay(
+  era: string,
+  year: number,
+  month: number,
+  day: number
+): number {
   year = getExtendedYear(era, year);
 
   let y1 = year - 1;
@@ -64,8 +69,9 @@ const daysInMonth = {
 };
 
 /**
- * The Gregorian calendar is the most commonly used calendar system in the world. It supports two eras: BC, and AD.
- * Years always contain 12 months, and 365 or 366 days depending on whether it is a leap year.
+ * The Gregorian calendar is the most commonly used calendar system in the world. It supports two
+ * eras: BC, and AD. Years always contain 12 months, and 365 or 366 days depending on whether it is
+ * a leap year.
  */
 export class GregorianCalendar implements Calendar {
   identifier: CalendarIdentifier = 'gregory';
@@ -81,7 +87,8 @@ export class GregorianCalendar implements Calendar {
     let dquad = mod(dcent, 1461);
     let yindex = Math.floor(dquad / 365);
 
-    let extendedYear = quadricent * 400 + cent * 100 + quad * 4 + yindex + (cent !== 4 && yindex !== 4 ? 1 : 0);
+    let extendedYear =
+      quadricent * 400 + cent * 100 + quad * 4 + yindex + (cent !== 4 && yindex !== 4 ? 1 : 0);
     let [era, year] = fromExtendedYear(extendedYear);
     let yearDay = jd0 - gregorianToJulianDay(era, year, 1, 1);
     let leapAdj = 2;

package/src/calendars/HebrewCalendar.ts

@@ -22,7 +22,7 @@ const HEBREW_EPOCH = 347997;
 // Hebrew date calculations are performed in terms of days, hours, and
 // "parts" (or halakim), which are 1/1080 of an hour, or 3 1/3 seconds.
 const HOUR_PARTS = 1080;
-const DAY_PARTS  = 24 * HOUR_PARTS;
+const DAY_PARTS = 24 * HOUR_PARTS;
 
 // An approximate value for the length of a lunar month.
 // It is used to calculate the approximate year and month of a given
@@ -132,9 +132,9 @@ export class HebrewCalendar implements Calendar {
 
   fromJulianDay(jd: number): CalendarDate {
     let d = jd - HEBREW_EPOCH;
-    let m = (d * DAY_PARTS) / MONTH_PARTS;           // Months (approx)
+    let m = (d * DAY_PARTS) / MONTH_PARTS; // Months (approx)
     let year = Math.floor((19 * m + 234) / 235) + 1; // Years (approx)
-    let ys = startOfYear(year);                      // 1st day of year
+    let ys = startOfYear(year); // 1st day of year
     let dayOfYear = Math.floor(d - ys);
 
     // Because of the postponement rules, it's possible to guess wrong.  Fix it.
@@ -202,7 +202,11 @@ export class HebrewCalendar implements Calendar {
     if (previousDate.year !== date.year) {
       if (isLeapYear(previousDate.year) && !isLeapYear(date.year) && previousDate.month > 6) {
         date.month--;
-      } else if (!isLeapYear(previousDate.year) && isLeapYear(date.year) && previousDate.month > 6) {
+      } else if (
+        !isLeapYear(previousDate.year) &&
+        isLeapYear(date.year) &&
+        previousDate.month > 6
+      ) {
         date.month++;
       }
     }

package/src/calendars/IndianCalendar.ts

@@ -15,7 +15,12 @@
 
 import {AnyCalendarDate, CalendarIdentifier} from '../types';
 import {CalendarDate} from '../CalendarDate';
-import {fromExtendedYear, GregorianCalendar, gregorianToJulianDay, isLeapYear} from './GregorianCalendar';
+import {
+  fromExtendedYear,
+  GregorianCalendar,
+  gregorianToJulianDay,
+  isLeapYear
+} from './GregorianCalendar';
 
 // Starts in 78 AD,
 const INDIAN_ERA_START = 78;
@@ -48,7 +53,7 @@ export class IndianCalendar extends GregorianCalendar {
 
       // Days in leapMonth this year, previous Gregorian year
       leapMonth = isLeapYear(date.year - 1) ? 31 : 30;
-      yDay += leapMonth + (31 * 5) + (30 * 3) + 10;
+      yDay += leapMonth + 31 * 5 + 30 * 3 + 10;
     } else {
       // Days in leapMonth this year
       leapMonth = isLeapYear(date.year) ? 31 : 30;
@@ -62,7 +67,7 @@ export class IndianCalendar extends GregorianCalendar {
       indianDay = yDay + 1;
     } else {
       let mDay = yDay - leapMonth;
-      if (mDay < (31 * 5)) {
+      if (mDay < 31 * 5) {
         indianMonth = Math.floor(mDay / 31) + 2;
         indianDay = (mDay % 31) + 1;
       } else {