@internationalized/date 3.0.0-alpha.0 → 3.0.0-alpha.1

package/src/manipulation.ts

@@ -0,0 +1,445 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import {AnyCalendarDate, AnyTime, CycleOptions, CycleTimeOptions, DateField, DateFields, Disambiguation, Duration, TimeField, TimeFields} from './types';
+import {CalendarDate, CalendarDateTime, Time, ZonedDateTime} from './CalendarDate';
+import {epochFromDate, fromAbsolute, toAbsolute, toCalendar, toCalendarDateTime} from './conversion';
+import {GregorianCalendar} from './calendars/GregorianCalendar';
+import {Mutable} from './utils';
+
+const ONE_HOUR = 3600000;
+
+export function add(date: CalendarDateTime, duration: Duration): CalendarDateTime;
+export function add(date: CalendarDate, duration: Duration): CalendarDate;
+export function add(date: CalendarDate | CalendarDateTime, duration: Duration): CalendarDate | CalendarDateTime;
+export function add(date: CalendarDate | CalendarDateTime, duration: Duration) {
+  let mutableDate: Mutable<AnyCalendarDate> = date.copy();
+  let days = 'hour' in date ? addTimeFields(date, duration) : 0;
+
+  addYears(mutableDate, duration.years || 0);
+  if (mutableDate.calendar.balanceYearMonth) {
+    mutableDate.calendar.balanceYearMonth(mutableDate, date);
+  }
+
+  mutableDate.month += duration.months || 0;
+
+  balanceYearMonth(mutableDate);
+  constrainMonthDay(mutableDate);
+
+  mutableDate.day += (duration.weeks || 0) * 7;
+  mutableDate.day += duration.days || 0;
+  mutableDate.day += days;
+
+  balanceDay(mutableDate);
+
+  if (mutableDate.calendar.balanceDate) {
+    mutableDate.calendar.balanceDate(mutableDate);
+  }
+
+  return mutableDate;
+}
+
+function addYears(date: Mutable<AnyCalendarDate>, years: number) {
+  if (date.calendar.getYearsToAdd) {
+    years = date.calendar.getYearsToAdd(date, years);
+  }
+
+  date.year += years;
+}
+
+function balanceYearMonth(date: Mutable<AnyCalendarDate>) {
+  while (date.month < 1) {
+    addYears(date, -1);
+    date.month += date.calendar.getMonthsInYear(date);
+  }
+
+  let monthsInYear = 0;
+  while (date.month > (monthsInYear = date.calendar.getMonthsInYear(date))) {
+    date.month -= monthsInYear;
+    addYears(date, 1);
+  }
+}
+
+function balanceDay(date: Mutable<AnyCalendarDate>) {
+  while (date.day < 1) {
+    date.month--;
+    balanceYearMonth(date);
+    date.day += date.calendar.getDaysInMonth(date);
+  }
+
+  while (date.day > date.calendar.getDaysInMonth(date)) {
+    date.day -= date.calendar.getDaysInMonth(date);
+    date.month++;
+    balanceYearMonth(date);
+  }
+}
+
+function constrainMonthDay(date: Mutable<AnyCalendarDate>) {
+  date.month = Math.max(1, Math.min(date.calendar.getMonthsInYear(date), date.month));
+  date.day = Math.max(1, Math.min(date.calendar.getDaysInMonth(date), date.day));
+}
+
+export function constrain(date: Mutable<AnyCalendarDate>) {
+  if (date.calendar.constrainDate) {
+    date.calendar.constrainDate(date);
+  }
+
+  date.year = Math.max(1, Math.min(date.calendar.getYearsInEra(date), date.year));
+  constrainMonthDay(date);
+}
+
+export function invertDuration(duration: Duration): Duration {
+  let inverseDuration = {};
+  for (let key in duration) {
+    if (typeof duration[key] === 'number') {
+      inverseDuration[key] = -duration[key];
+    }
+  }
+
+  return inverseDuration;
+}
+
+export function subtract(date: CalendarDateTime, duration: Duration): CalendarDateTime;
+export function subtract(date: CalendarDate, duration: Duration): CalendarDate;
+export function subtract(date: CalendarDate | CalendarDateTime, duration: Duration): CalendarDate | CalendarDateTime {
+  return add(date, invertDuration(duration));
+}
+
+export function set(date: CalendarDateTime, fields: DateFields): CalendarDateTime;
+export function set(date: CalendarDate, fields: DateFields): CalendarDate;
+export function set(date: CalendarDate | CalendarDateTime, fields: DateFields) {
+  let mutableDate: Mutable<AnyCalendarDate> = date.copy();
+
+  if (fields.era != null) {
+    mutableDate.era = fields.era;
+  }
+
+  if (fields.year != null) {
+    mutableDate.year = fields.year;
+  }
+
+  if (fields.month != null) {
+    mutableDate.month = fields.month;
+  }
+
+  if (fields.day != null) {
+    mutableDate.day = fields.day;
+  }
+
+  constrain(mutableDate);
+  return mutableDate;
+}
+
+export function setTime(value: CalendarDateTime, fields: TimeFields): CalendarDateTime;
+export function setTime(value: Time, fields: TimeFields): Time;
+export function setTime(value: Time | CalendarDateTime, fields: TimeFields) {
+  let mutableValue: Mutable<Time | CalendarDateTime> = value.copy();
+
+  if (fields.hour != null) {
+    mutableValue.hour = fields.hour;
+  }
+
+  if (fields.minute != null) {
+    mutableValue.minute = fields.minute;
+  }
+
+  if (fields.second != null) {
+    mutableValue.second = fields.second;
+  }
+
+  if (fields.millisecond != null) {
+    mutableValue.millisecond = fields.millisecond;
+  }
+
+  constrainTime(mutableValue);
+  return mutableValue;
+}
+
+function balanceTime(time: Mutable<AnyTime>): number {
+  time.second += Math.floor(time.millisecond / 1000);
+  time.millisecond = nonNegativeMod(time.millisecond, 1000);
+
+  time.minute += Math.floor(time.second / 60);
+  time.second = nonNegativeMod(time.second, 60);
+
+  time.hour += Math.floor(time.minute / 60);
+  time.minute = nonNegativeMod(time.minute, 60);
+
+  let days = Math.floor(time.hour / 24);
+  time.hour = nonNegativeMod(time.hour, 24);
+
+  return days;
+}
+
+export function constrainTime(time: Mutable<AnyTime>) {
+  time.millisecond = Math.max(0, Math.min(time.millisecond, 1000));
+  time.second = Math.max(0, Math.min(time.second, 59));
+  time.minute = Math.max(0, Math.min(time.minute, 59));
+  time.hour = Math.max(0, Math.min(time.hour, 23));
+}
+
+function nonNegativeMod(a: number, b: number) {
+  let result = a % b;
+  if (result < 0) {
+    result += b;
+  }
+  return result;
+}
+
+function addTimeFields(time: Mutable<AnyTime>, duration: Duration): number {
+  time.hour += duration.hours || 0;
+  time.minute += duration.minutes || 0;
+  time.second += duration.seconds || 0;
+  time.millisecond += duration.milliseconds || 0;
+  return balanceTime(time);
+}
+
+export function addTime(time: Time, duration: Duration): Time {
+  let res = time.copy();
+  addTimeFields(res, duration);
+  return res;
+}
+
+export function subtractTime(time: Time, duration: Duration): Time {
+  return addTime(time, invertDuration(duration));
+}
+
+export function cycleDate(value: CalendarDateTime, field: DateField, amount: number, options?: CycleOptions): CalendarDateTime;
+export function cycleDate(value: CalendarDate, field: DateField, amount: number, options?: CycleOptions): CalendarDate;
+export function cycleDate(value: CalendarDate | CalendarDateTime, field: DateField, amount: number, options?: CycleOptions) {
+  let mutable: Mutable<CalendarDate | CalendarDateTime> = value.copy();
+
+  switch (field) {
+    case 'era': {
+      let eras = value.calendar.getEras();
+      let eraIndex = eras.indexOf(value.era);
+      if (eraIndex < 0) {
+        throw new Error('Invalid era: ' + value.era);
+      }
+      eraIndex = cycleValue(eraIndex, amount, 0, eras.length - 1, options?.round);
+      mutable.era = eras[eraIndex];
+
+      // Constrain the year and other fields within the era, so the era doesn't change when we balance below.
+      constrain(mutable);
+      break;
+    }
+    case 'year': {
+      if (mutable.calendar.getYearsToAdd) {
+        amount = mutable.calendar.getYearsToAdd(mutable, amount);
+      }
+
+      // The year field should not cycle within the era as that can cause weird behavior affecting other fields.
+      // We need to also allow values < 1 so that decrementing goes to the previous era. If we get -Infinity back
+      // we know we wrapped around after reaching 9999 (the maximum), so set the year back to 1.
+      mutable.year = cycleValue(value.year, amount, -Infinity, 9999, options?.round);
+      if (mutable.year === -Infinity) {
+        mutable.year = 1;
+      }
+
+      if (mutable.calendar.balanceYearMonth) {
+        mutable.calendar.balanceYearMonth(mutable, value);
+      }
+      break;
+    }
+    case 'month':
+      mutable.month = cycleValue(value.month, amount, 1, value.calendar.getMonthsInYear(value), options?.round);
+      break;
+    case 'day':
+      mutable.day = cycleValue(value.day, amount, 1, value.calendar.getDaysInMonth(value), options?.round);
+      break;
+    default:
+      throw new Error('Unsupported field ' + field);
+  }
+
+  if (value.calendar.balanceDate) {
+    value.calendar.balanceDate(mutable);
+  }
+
+  constrain(mutable);
+  return mutable;
+}
+
+export function cycleTime(value: CalendarDateTime, field: TimeField, amount: number, options?: CycleTimeOptions): CalendarDateTime;
+export function cycleTime(value: Time, field: TimeField, amount: number, options?: CycleTimeOptions): Time;
+export function cycleTime(value: Time | CalendarDateTime, field: TimeField, amount: number, options?: CycleTimeOptions) {
+  let mutable: Mutable<Time | CalendarDateTime> = value.copy();
+
+  switch (field) {
+    case 'hour': {
+      let hours = value.hour;
+      let min = 0;
+      let max = 23;
+      if (options?.hourCycle === 12) {
+        let isPM = hours >= 12;
+        min = isPM ? 12 : 0;
+        max = isPM ? 23 : 11;
+      }
+      mutable.hour = cycleValue(hours, amount, min, max, options?.round);
+      break;
+    }
+    case 'minute':
+      mutable.minute = cycleValue(value.minute, amount, 0, 59, options?.round);
+      break;
+    case 'second':
+      mutable.second = cycleValue(value.second, amount, 0, 59, options?.round);
+      break;
+    case 'millisecond':
+      mutable.millisecond = cycleValue(value.millisecond, amount, 0, 999, options?.round);
+      break;
+    default:
+      throw new Error('Unsupported field ' + field);
+  }
+
+  return mutable;
+}
+
+function cycleValue(value: number, amount: number, min: number, max: number, round = false) {
+  if (round) {
+    value += Math.sign(amount);
+
+    if (value < min) {
+      value = max;
+    }
+
+    let div = Math.abs(amount);
+    if (amount > 0) {
+      value = Math.ceil(value / div) * div;
+    } else {
+      value = Math.floor(value / div) * div;
+    }
+
+    if (value > max) {
+      value = min;
+    }
+  } else {
+    value += amount;
+    if (value < min) {
+      value = max - (min - value - 1);
+    } else if (value > max) {
+      value = min + (value - max - 1);
+    }
+  }
+
+  return value;
+}
+
+export function addZoned(dateTime: ZonedDateTime, duration: Duration): ZonedDateTime {
+  let ms: number;
+  if ((duration.years != null && duration.years !== 0) || (duration.months != null && duration.months !== 0) || (duration.days != null && duration.days !== 0)) {
+    let res = add(toCalendarDateTime(dateTime), {
+      years: duration.years,
+      months: duration.months,
+      days: duration.days
+    });
+
+    // Changing the date may change the timezone offset, so we need to recompute
+    // using the 'compatible' disambiguation.
+    ms = toAbsolute(res, dateTime.timeZone);
+  } else {
+    // Otherwise, preserve the offset of the original date.
+    ms = epochFromDate(dateTime) - dateTime.offset;
+  }
+
+  // Perform time manipulation in milliseconds rather than on the original time fields to account for DST.
+  // For example, adding one hour during a DST transition may result in the hour field staying the same or
+  // skipping an hour. This results in the offset field changing value instead of the specified field.
+  ms += duration.milliseconds || 0;
+  ms += (duration.seconds || 0) * 1000;
+  ms += (duration.minutes || 0) * 60 * 1000;
+  ms += (duration.hours || 0) * 60 * 60 * 1000;
+
+  let res = fromAbsolute(ms, dateTime.timeZone);
+  return toCalendar(res, dateTime.calendar);
+}
+
+export function subtractZoned(dateTime: ZonedDateTime, duration: Duration): ZonedDateTime {
+  return addZoned(dateTime, invertDuration(duration));
+}
+
+export function cycleZoned(dateTime: ZonedDateTime, field: DateField | TimeField, amount: number, options?: CycleTimeOptions): ZonedDateTime {
+  // For date fields, we want the time to remain consistent and the UTC offset to potentially change to account for DST changes.
+  // For time fields, we want the time to change by the amount given. This may result in the hour field staying the same, but the UTC
+  // offset changing in the case of a backward DST transition, or skipping an hour in the case of a forward DST transition.
+  switch (field) {
+    case 'hour': {
+      let min = 0;
+      let max = 23;
+      if (options?.hourCycle === 12) {
+        let isPM = dateTime.hour >= 12;
+        min = isPM ? 12 : 0;
+        max = isPM ? 23 : 11;
+      }
+
+      // The minimum and maximum hour may be affected by daylight saving time.
+      // For example, it might jump forward at midnight, and skip 1am.
+      // Or it might end at midnight and repeat the 11pm hour. To handle this, we get
+      // the possible absolute times for the min and max, and find the maximum range
+      // that is within the current day.
+      let plainDateTime = toCalendarDateTime(dateTime);
+      let minDate = toCalendar(setTime(plainDateTime, {hour: min}), new GregorianCalendar());
+      let minAbsolute = [toAbsolute(minDate, dateTime.timeZone, 'earlier'), toAbsolute(minDate, dateTime.timeZone, 'later')]
+        .filter(ms => fromAbsolute(ms, dateTime.timeZone).day === minDate.day)[0];
+
+      let maxDate = toCalendar(setTime(plainDateTime, {hour: max}), new GregorianCalendar());
+      let maxAbsolute = [toAbsolute(maxDate, dateTime.timeZone, 'earlier'), toAbsolute(maxDate, dateTime.timeZone, 'later')]
+        .filter(ms => fromAbsolute(ms, dateTime.timeZone).day === maxDate.day).pop();
+
+      // Since hours may repeat, we need to operate on the absolute time in milliseconds.
+      // This is done in hours from the Unix epoch so that cycleValue works correctly,
+      // and then converted back to milliseconds.
+      let ms = epochFromDate(dateTime) - dateTime.offset;
+      let hours = Math.floor(ms / ONE_HOUR);
+      let remainder = ms % ONE_HOUR;
+      ms = cycleValue(
+        hours,
+        amount,
+        Math.floor(minAbsolute / ONE_HOUR),
+        Math.floor(maxAbsolute / ONE_HOUR),
+        options?.round
+      ) * ONE_HOUR + remainder;
+
+      // Now compute the new timezone offset, and convert the absolute time back to local time.
+      return toCalendar(fromAbsolute(ms, dateTime.timeZone), dateTime.calendar);
+    }
+    case 'minute':
+    case 'second':
+    case 'millisecond':
+      // @ts-ignore
+      return cycleTime(dateTime, field, amount, options);
+    case 'era':
+    case 'year':
+    case 'month':
+    case 'day': {
+      let res = cycleDate(toCalendarDateTime(dateTime), field, amount, options);
+      let ms = toAbsolute(res, dateTime.timeZone);
+      return toCalendar(fromAbsolute(ms, dateTime.timeZone), dateTime.calendar);
+    }
+    default:
+      throw new Error('Unsupported field ' + field);
+  }
+}
+
+export function setZoned(dateTime: ZonedDateTime, fields: DateFields & TimeFields, disambiguation?: Disambiguation): ZonedDateTime {
+  // Set the date/time fields, and recompute the UTC offset to account for DST changes.
+  // We also need to validate by converting back to a local time in case hours are skipped during forward DST transitions.
+  let plainDateTime = toCalendarDateTime(dateTime);
+  let res = setTime(set(plainDateTime, fields), fields);
+
+  // If the resulting plain date time values are equal, return the original time.
+  // We don't want to change the offset when setting the time to the same value.
+  if (res.compare(plainDateTime) === 0) {
+    return dateTime;
+  }
+
+  let ms = toAbsolute(res, dateTime.timeZone, disambiguation);
+  return toCalendar(fromAbsolute(ms, dateTime.timeZone), dateTime.calendar);
+}

package/src/queries.ts

@@ -0,0 +1,217 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import {AnyCalendarDate, AnyTime} from './types';
+import {CalendarDate, CalendarDateTime, ZonedDateTime} from './CalendarDate';
+import {fromAbsolute, toAbsolute, toCalendar, toCalendarDate} from './conversion';
+import {weekStartData} from './weekStartData';
+
+type DateValue = CalendarDate | CalendarDateTime | ZonedDateTime;
+
+export function isSameDay(a: DateValue, b: DateValue): boolean {
+  b = toCalendar(b, a.calendar);
+  return a.era === b.era && a.year === b.year && a.month === b.month && a.day === b.day;
+}
+
+export function isSameMonth(a: DateValue, b: DateValue): boolean {
+  b = toCalendar(b, a.calendar);
+  // In the Japanese calendar, months can span multiple eras/years, so only compare the first of the month.
+  a = startOfMonth(a);
+  b = startOfMonth(b);
+  return a.era === b.era && a.year === b.year && a.month === b.month;
+}
+
+export function isSameYear(a: DateValue, b: DateValue): boolean {
+  b = toCalendar(b, a.calendar);
+  a = startOfYear(a);
+  b = startOfYear(b);
+  return a.era === b.era && a.year === b.year;
+}
+
+export function isEqualDay(a: DateValue, b: DateValue): boolean {
+  return a.calendar.identifier === b.calendar.identifier && a.era === b.era && a.year === b.year && a.month === b.month && a.day === b.day;
+}
+
+export function isEqualMonth(a: DateValue, b: DateValue): boolean {
+  a = startOfMonth(a);
+  b = startOfMonth(b);
+  return a.calendar.identifier === b.calendar.identifier && a.era === b.era && a.year === b.year && a.month === b.month;
+}
+
+export function isEqualYear(a: DateValue, b: DateValue): boolean {
+  a = startOfYear(a);
+  b = startOfYear(b);
+  return a.calendar.identifier === b.calendar.identifier && a.era === b.era && a.year === b.year;
+}
+
+export function isToday(date: DateValue, timeZone: string): boolean {
+  return isSameDay(date, today(timeZone));
+}
+
+export function getDayOfWeek(date: DateValue, locale: string) {
+  let julian = date.calendar.toJulianDay(date);
+
+  // If julian is negative, then julian % 7 will be negative, so we adjust
+  // accordingly.  Julian day 0 is Monday.
+  let dayOfWeek = Math.ceil(julian + 1 - getWeekStart(locale)) % 7;
+  if (dayOfWeek < 0) {
+    dayOfWeek += 7;
+  }
+
+  return dayOfWeek;
+}
+
+export function now(timeZone: string): ZonedDateTime {
+  return fromAbsolute(Date.now(), timeZone);
+}
+
+export function today(timeZone: string): CalendarDate {
+  return toCalendarDate(now(timeZone));
+}
+
+export function compareDate(a: AnyCalendarDate, b: AnyCalendarDate): number {
+  return a.calendar.toJulianDay(a) - b.calendar.toJulianDay(b);
+}
+
+export function compareTime(a: AnyTime, b: AnyTime): number {
+  return timeToMs(a) - timeToMs(b);
+}
+
+function timeToMs(a: AnyTime): number {
+  return a.hour * 60 * 60 * 1000 + a.minute * 60 * 1000 + a.second * 1000 + a.millisecond;
+}
+
+export function getHoursInDay(a: CalendarDate, timeZone: string): number {
+  let ms = toAbsolute(a, timeZone);
+  let tomorrow = a.add({days: 1});
+  let tomorrowMs = toAbsolute(tomorrow, timeZone);
+  return (tomorrowMs - ms) / 3600000;
+}
+
+let localTimeZone = null;
+export function getLocalTimeZone(): string {
+  // TODO: invalidate this somehow?
+  if (localTimeZone == null) {
+    localTimeZone = new Intl.DateTimeFormat().resolvedOptions().timeZone;
+  }
+
+  return localTimeZone;
+}
+
+export function startOfMonth(date: ZonedDateTime): ZonedDateTime;
+export function startOfMonth(date: CalendarDateTime): CalendarDateTime;
+export function startOfMonth(date: CalendarDate): CalendarDate;
+export function startOfMonth(date: DateValue): DateValue;
+export function startOfMonth(date: DateValue) {
+  // Use `subtract` instead of `set` so we don't get constrained in an era.
+  return date.subtract({days: date.day - 1});
+}
+
+export function endOfMonth(date: ZonedDateTime): ZonedDateTime;
+export function endOfMonth(date: CalendarDateTime): CalendarDateTime;
+export function endOfMonth(date: CalendarDate): CalendarDate;
+export function endOfMonth(date: DateValue): DateValue;
+export function endOfMonth(date: DateValue) {
+  return date.add({days: date.calendar.getDaysInMonth(date) - date.day});
+}
+
+export function startOfYear(date: ZonedDateTime): ZonedDateTime;
+export function startOfYear(date: CalendarDateTime): CalendarDateTime;
+export function startOfYear(date: CalendarDate): CalendarDate;
+export function startOfYear(date: DateValue): DateValue;
+export function startOfYear(date: DateValue) {
+  return startOfMonth(date.subtract({months: date.month - 1}));
+}
+
+export function endOfYear(date: ZonedDateTime): ZonedDateTime;
+export function endOfYear(date: CalendarDateTime): CalendarDateTime;
+export function endOfYear(date: CalendarDate): CalendarDate;
+export function endOfYear(date: DateValue): DateValue;
+export function endOfYear(date: DateValue) {
+  return endOfMonth(date.add({months: date.calendar.getMonthsInYear(date) - date.month}));
+}
+
+export function getMinimumMonthInYear(date: AnyCalendarDate) {
+  if (date.calendar.getMinimumMonthInYear) {
+    return date.calendar.getMinimumMonthInYear(date);
+  }
+
+  return 1;
+}
+
+export function getMinimumDayInMonth(date: AnyCalendarDate) {
+  if (date.calendar.getMinimumDayInMonth) {
+    return date.calendar.getMinimumDayInMonth(date);
+  }
+
+  return 1;
+}
+
+export function startOfWeek(date: ZonedDateTime, locale: string): ZonedDateTime;
+export function startOfWeek(date: CalendarDateTime, locale: string): CalendarDateTime;
+export function startOfWeek(date: CalendarDate, locale: string): CalendarDate;
+export function startOfWeek(date: DateValue, locale: string): DateValue;
+export function startOfWeek(date: DateValue, locale: string) {
+  let dayOfWeek = getDayOfWeek(date, locale);
+  return date.subtract({days: dayOfWeek});
+}
+
+export function endOfWeek(date: ZonedDateTime, locale: string): ZonedDateTime;
+export function endOfWeek(date: CalendarDateTime, locale: string): CalendarDateTime;
+export function endOfWeek(date: CalendarDate, locale: string): CalendarDate;
+export function endOfWeek(date: DateValue, locale: string) {
+  return startOfWeek(date, locale).add({days: 6});
+}
+
+const cachedRegions = new Map<string, string>();
+
+function getRegion(locale: string) {
+  // If the Intl.Locale API is available, use it to get the region for the locale.
+  // @ts-ignore
+  if (Intl.Locale) {
+    // Constructing an Intl.Locale is expensive, so cache the result.
+    let region = cachedRegions.get(locale);
+    if (!region) {
+      // @ts-ignore
+      region = new Intl.Locale(locale).maximize().region;
+      cachedRegions.set(locale, region);
+    }
+    return region;
+  }
+
+  // If not, just try splitting the string.
+  // If the second part of the locale string is 'u',
+  // then this is a unicode extension, so ignore it.
+  // Otherwise, it should be the region.
+  let part = locale.split('-')[1];
+  return part === 'u' ? null : part;
+}
+
+function getWeekStart(locale: string) {
+  // TODO: use Intl.Locale for this once browsers support the weekInfo property
+  // https://github.com/tc39/proposal-intl-locale-info
+  let region = getRegion(locale);
+  return weekStartData[region] || 0;
+}
+
+export function getWeeksInMonth(date: DateValue, locale: string) {
+  let days = date.calendar.getDaysInMonth(date);
+  return Math.ceil((getDayOfWeek(startOfMonth(date), locale) + days) / 7);
+}
+
+export function minDate<A extends DateValue, B extends DateValue>(a: A, b: B): A | B {
+  return a.compare(b) <= 0 ? a : b;
+}
+
+export function maxDate<A extends DateValue, B extends DateValue>(a: A, b: B): A | B {
+  return a.compare(b) >= 0 ? a : b;
+}