v-calendar-3 1.0.0

package/src/utils/date/helpers.ts

@@ -0,0 +1,1039 @@
+import {
+  pad,
+  isNumber,
+  isString,
+  isDate,
+  isArray,
+  arrayHasItems,
+  isFunction,
+  isObject,
+} from '../helpers';
+import {
+  addDays,
+  addMonths,
+  addYears,
+  getISOWeek,
+  getWeek,
+  getWeeksInMonth,
+} from 'date-fns';
+import { fromZonedTime, toZonedTime } from 'date-fns-tz';
+import { type LocaleConfig, default as Locale } from '../locale';
+
+export { addDays, addMonths, addYears };
+export { DateRepeat } from './repeat';
+
+// #region Types
+
+type DayNameLength = 'narrow' | 'short' | 'long';
+type MonthNameLength = 'short' | 'long';
+
+export type DayInMonth =
+  | 1
+  | 2
+  | 3
+  | 4
+  | 5
+  | 6
+  | 7
+  | 8
+  | 9
+  | 10
+  | 11
+  | 12
+  | 13
+  | 14
+  | 15
+  | 16
+  | 17
+  | 18
+  | 19
+  | 20
+  | 21
+  | 22
+  | 23
+  | 24
+  | 25
+  | 26
+  | 27
+  | 28
+  | 29
+  | 30
+  | 31
+  | -1
+  | -2
+  | -3
+  | -4
+  | -5
+  | -6
+  | -7
+  | -8
+  | -9
+  | -10
+  | -11
+  | -12
+  | -13
+  | -14
+  | -15
+  | -16
+  | -17
+  | -18
+  | -19
+  | -20
+  | -21
+  | -22
+  | -23
+  | -24
+  | -25
+  | -26
+  | -27
+  | -28
+  | -29
+  | -30
+  | -31;
+export type DayOfWeek = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+export type WeekInMonth = 1 | 2 | 3 | 4 | 5 | 6;
+export type WeekInMonthFromEnd = -6 | -5 | -4 | -3 | -2 | -1;
+export type OrdinalWeekInMonth = -5 | -4 | -3 | -2 | -1 | 1 | 2 | 3 | 4 | 5;
+export type MonthInYear = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+export type StartOfWeek = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+
+export type WeekStartsOn = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+export type DateSource = Date | string | number;
+export type TimeNames = Partial<Record<Intl.RelativeTimeFormatUnit, string>>;
+
+// #endregion Types
+
+export function isDayInMonth(dayInMonth: unknown): dayInMonth is DayInMonth {
+  if (!isNumber(dayInMonth)) return false;
+  return dayInMonth >= 1 && dayInMonth <= 31;
+}
+
+export function isDayOfWeek(dayOfWeek: unknown): dayOfWeek is DayOfWeek {
+  if (!isNumber(dayOfWeek)) return false;
+  return dayOfWeek >= 1 && dayOfWeek <= 7;
+}
+
+export function isWeekInMonth(
+  weekInMonth: unknown,
+): weekInMonth is WeekInMonth {
+  if (!isNumber(weekInMonth)) return false;
+  return (
+    (weekInMonth >= -6 && weekInMonth <= -1) ||
+    (weekInMonth >= 1 && weekInMonth <= 6)
+  );
+}
+
+export function isMonthInYear(
+  monthInYear: unknown,
+): monthInYear is MonthInYear {
+  if (!isNumber(monthInYear)) return false;
+  return monthInYear >= 1 && monthInYear <= 12;
+}
+
+export function isOrdinalWeekInMonth(
+  weekInMonth: unknown,
+): weekInMonth is OrdinalWeekInMonth {
+  if (!isNumber(weekInMonth)) return false;
+  if (weekInMonth < -5 || weekInMonth > 5 || weekInMonth === 0) return false;
+  return true;
+}
+
+interface NumberRuleConfig {
+  min?: number;
+  max?: number;
+  interval?: number;
+}
+
+type DatePartsRuleFunction = (part: number, parts: TimeParts) => boolean;
+
+type DatePartsRule =
+  number | Array<number> | NumberRuleConfig | DatePartsRuleFunction;
+
+export interface DatePartsRules {
+  hours?: DatePartsRule;
+  minutes?: DatePartsRule;
+  seconds?: DatePartsRule;
+  milliseconds?: DatePartsRule;
+}
+
+export interface DatePartOption {
+  value: number;
+  label: string;
+  disabled?: boolean;
+}
+
+export interface FormatParseOptions {
+  locale?: Locale | LocaleConfig | string;
+  timezone?: string;
+}
+
+export interface DateOptions {
+  type: string;
+  fillDate: DateSource;
+  mask: string;
+  patch: DatePatch;
+  rules: DatePartsRules;
+}
+
+export interface PageAddress {
+  day?: number;
+  week?: number;
+  month: number;
+  year: number;
+}
+
+export interface TimeParts {
+  hours: number;
+  minutes: number;
+  seconds: number;
+  milliseconds: number;
+}
+
+export interface SimpleDateParts {
+  year: number;
+  month: number;
+  day: number;
+  hours: number;
+  minutes: number;
+  seconds: number;
+  milliseconds: number;
+}
+
+export interface DayParts {
+  dayIndex: number;
+  day: number;
+  dayFromEnd: number;
+  weekday: number;
+  weekdayOrdinal: number;
+  weekdayOrdinalFromEnd: number;
+  week: number;
+  weekFromEnd: number;
+  weeknumber: number;
+  month: number;
+  year: number;
+  date: Date;
+}
+
+export interface DateParts extends DayParts {
+  milliseconds: number;
+  seconds: number;
+  minutes: number;
+  hours: number;
+  time: number;
+  dateTime: number;
+  isValid: boolean;
+  timezoneOffset: number;
+  isPm?: boolean;
+}
+
+export interface MonthParts {
+  firstDayOfWeek: DayOfWeek;
+  firstDayOfMonth: Date;
+  inLeapYear: boolean;
+  firstWeekday: number;
+  numDays: number;
+  numWeeks: number;
+  month: number;
+  year: number;
+  weeknumbers: number[];
+  isoWeeknumbers: number[];
+}
+
+export type DatePatch = 'dateTime' | 'date' | 'time';
+
+export const DatePatchKeys: Record<DatePatch, (keyof SimpleDateParts)[]> = {
+  dateTime: [
+    'year',
+    'month',
+    'day',
+    'hours',
+    'minutes',
+    'seconds',
+    'milliseconds',
+  ],
+  date: ['year', 'month', 'day'],
+  time: ['hours', 'minutes', 'seconds', 'milliseconds'],
+};
+
+export const daysInWeek = 7;
+export const weeksInMonth = 6;
+export const MS_PER_SECOND = 1000;
+export const MS_PER_MINUTE = MS_PER_SECOND * 60;
+export const MS_PER_HOUR = MS_PER_MINUTE * 60;
+export const MS_PER_DAY = MS_PER_HOUR * 24;
+
+const daysInMonths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const maskMacros = ['L', 'iso'];
+
+type DatePartsRange = Readonly<[number, number, number]>;
+type TimePartsKey = 'milliseconds' | 'seconds' | 'minutes' | 'hours';
+const DATE_PART_RANGES: Record<TimePartsKey, DatePartsRange> = {
+  milliseconds: [0, 999, 3],
+  seconds: [0, 59, 2],
+  minutes: [0, 59, 2],
+  hours: [0, 23, 2],
+} as const;
+
+// #region Format constants
+
+const token =
+  /d{1,2}|W{1,4}|M{1,4}|YY(?:YY)?|S{1,3}|Do|Z{1,4}|([HhMsDm])\1?|[aA]|"[^"]*"|'[^']*'/g;
+const literal = /\[([^]*?)\]/gm;
+const formatFlags: any = {
+  D(d: DateParts) {
+    return d.day;
+  },
+  DD(d: DateParts) {
+    return pad(d.day, 2);
+  },
+  // Do(d: DateParts, l: Locale) {
+  //   return l.DoFn(d.day);
+  // },
+  d(d: DateParts) {
+    return d.weekday - 1;
+  },
+  dd(d: DateParts) {
+    return pad(d.weekday - 1, 2);
+  },
+  W(d: DateParts, l: Locale) {
+    return l.dayNamesNarrow[d.weekday - 1];
+  },
+  WW(d: DateParts, l: Locale) {
+    return l.dayNamesShorter[d.weekday - 1];
+  },
+  WWW(d: DateParts, l: Locale) {
+    return l.dayNamesShort[d.weekday - 1];
+  },
+  WWWW(d: DateParts, l: Locale) {
+    return l.dayNames[d.weekday - 1];
+  },
+  M(d: DateParts) {
+    return d.month;
+  },
+  MM(d: DateParts) {
+    return pad(d.month, 2);
+  },
+  MMM(d: DateParts, l: Locale) {
+    return l.monthNamesShort[d.month - 1];
+  },
+  MMMM(d: DateParts, l: Locale) {
+    return l.monthNames[d.month - 1];
+  },
+  YY(d: DateParts) {
+    return String(d.year).substr(2);
+  },
+  YYYY(d: DateParts) {
+    return pad(d.year, 4);
+  },
+  h(d: DateParts) {
+    return d.hours % 12 || 12;
+  },
+  hh(d: DateParts) {
+    return pad(d.hours % 12 || 12, 2);
+  },
+  H(d: DateParts) {
+    return d.hours;
+  },
+  HH(d: DateParts) {
+    return pad(d.hours, 2);
+  },
+  m(d: DateParts) {
+    return d.minutes;
+  },
+  mm(d: DateParts) {
+    return pad(d.minutes, 2);
+  },
+  s(d: DateParts) {
+    return d.seconds;
+  },
+  ss(d: DateParts) {
+    return pad(d.seconds, 2);
+  },
+  S(d: DateParts) {
+    return Math.round(d.milliseconds / 100);
+  },
+  SS(d: DateParts) {
+    return pad(Math.round(d.milliseconds / 10), 2);
+  },
+  SSS(d: DateParts) {
+    return pad(d.milliseconds, 3);
+  },
+  a(d: DateParts, l: Locale) {
+    return d.hours < 12 ? l.amPm[0] : l.amPm[1];
+  },
+  A(d: DateParts, l: Locale) {
+    return d.hours < 12 ? l.amPm[0].toUpperCase() : l.amPm[1].toUpperCase();
+  },
+  Z() {
+    return 'Z';
+  },
+  ZZ(d: DateParts) {
+    const o = d.timezoneOffset;
+    return `${o > 0 ? '-' : '+'}${pad(Math.floor(Math.abs(o) / 60), 2)}`;
+  },
+  ZZZ(d: DateParts) {
+    const o = d.timezoneOffset;
+    return `${o > 0 ? '-' : '+'}${pad(
+      Math.floor(Math.abs(o) / 60) * 100 + (Math.abs(o) % 60),
+      4,
+    )}`;
+  },
+  ZZZZ(d: DateParts) {
+    const o = d.timezoneOffset;
+    return `${o > 0 ? '-' : '+'}${pad(Math.floor(Math.abs(o) / 60), 2)}:${pad(
+      Math.abs(o) % 60,
+      2,
+    )}`;
+  },
+};
+
+// #endregion Format constants
+
+// #region Parse constants
+
+const twoDigits = /\d\d?/;
+const threeDigits = /\d{3}/;
+const fourDigits = /\d{4}/;
+const word =
+  /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
+const noop = () => {};
+const monthUpdate = (arrName: string) => (d: DateParts, v: string, l: any) => {
+  const index = l[arrName].indexOf(
+    v.charAt(0).toUpperCase() + v.substr(1).toLowerCase(),
+  );
+  if (~index) {
+    d.month = index;
+  }
+};
+const parseFlags: any = {
+  D: [
+    twoDigits,
+    (d: DateParts, v: number) => {
+      d.day = v;
+    },
+  ],
+  Do: [
+    new RegExp(twoDigits.source + word.source),
+    (d: DateParts, v: string) => {
+      d.day = parseInt(v, 10);
+    },
+  ],
+  d: [twoDigits, noop],
+  W: [word, noop],
+  M: [
+    twoDigits,
+    (d: DateParts, v: number) => {
+      d.month = v - 1;
+    },
+  ],
+  MMM: [word, monthUpdate('monthNamesShort')],
+  MMMM: [word, monthUpdate('monthNames')],
+  YY: [
+    twoDigits,
+    (d: DateParts, v: number) => {
+      const da = new Date();
+      const cent = +da.getFullYear().toString().substr(0, 2);
+      d.year = +`${v > 68 ? cent - 1 : cent}${v}`;
+    },
+  ],
+  YYYY: [
+    fourDigits,
+    (d: DateParts, v: number) => {
+      d.year = v;
+    },
+  ],
+  S: [
+    /\d/,
+    (d: DateParts, v: number) => {
+      d.milliseconds = v * 100;
+    },
+  ],
+  SS: [
+    /\d{2}/,
+    (d: DateParts, v: number) => {
+      d.milliseconds = v * 10;
+    },
+  ],
+  SSS: [
+    threeDigits,
+    (d: DateParts, v: number) => {
+      d.milliseconds = v;
+    },
+  ],
+  h: [
+    twoDigits,
+    (d: DateParts, v: number) => {
+      d.hours = v;
+    },
+  ],
+  m: [
+    twoDigits,
+    (d: DateParts, v: number) => {
+      d.minutes = v;
+    },
+  ],
+  s: [
+    twoDigits,
+    (d: DateParts, v: number) => {
+      d.seconds = v;
+    },
+  ],
+  a: [
+    word,
+    (d: DateParts, v: string, l: Locale) => {
+      const val = v.toLowerCase();
+      if (val === l.amPm[0]) {
+        d.isPm = false;
+      } else if (val === l.amPm[1]) {
+        d.isPm = true;
+      }
+    },
+  ],
+  Z: [
+    /[^\s]*?[+-]\d\d:?\d\d|[^\s]*?Z?/,
+    (d: DateParts, v: string) => {
+      if (v === 'Z') v = '+00:00';
+      const parts = `${v}`.match(/([+-]|\d\d)/gi);
+      if (parts) {
+        const minutes = +parts[1] * 60 + parseInt(parts[2], 10);
+        d.timezoneOffset = parts[0] === '+' ? minutes : -minutes;
+      }
+    },
+  ],
+};
+parseFlags.DD = parseFlags.D;
+parseFlags.dd = parseFlags.d;
+parseFlags.WWWW = parseFlags.WWW = parseFlags.WW = parseFlags.W;
+parseFlags.MM = parseFlags.M;
+parseFlags.mm = parseFlags.m;
+parseFlags.hh = parseFlags.H = parseFlags.HH = parseFlags.h;
+parseFlags.ss = parseFlags.s;
+parseFlags.A = parseFlags.a;
+parseFlags.ZZZZ = parseFlags.ZZZ = parseFlags.ZZ = parseFlags.Z;
+
+// #endregion Parse constants
+
+function normalizeMasks(masks: string | string[], locale: Locale): string[] {
+  return (
+    ((arrayHasItems(masks) && masks) || [
+      (isString(masks) && masks) || 'YYYY-MM-DD',
+    ]) as string[]
+  ).map(m =>
+    maskMacros.reduce(
+      (prev, curr) => prev.replace(curr, locale.masks[curr] || ''),
+      m,
+    ),
+  );
+}
+
+export function isDateParts(parts: unknown): parts is Partial<DateParts> {
+  return (
+    isObject(parts) && 'year' in parts && 'month' in parts && 'day' in parts
+  );
+}
+
+export function isDateSource(date: unknown): date is DateSource {
+  if (date == null) return false;
+  return isString(date) || isNumber(date) || isDate(date);
+}
+
+export function roundDate(dateMs: number, snapMs = 0) {
+  if (snapMs > 0) return new Date(Math.round(dateMs / snapMs) * snapMs);
+  return new Date(dateMs);
+}
+
+export function startOfWeek(date: Date, firstDayOfWeek: DayOfWeek = 1) {
+  const day = date.getDay() + 1;
+  const daysToAdd =
+    day >= firstDayOfWeek
+      ? firstDayOfWeek - day
+      : -(7 - (firstDayOfWeek - day));
+  return addDays(date, daysToAdd);
+}
+
+export function getStartOfWeek(date: Date, firstDayOfWeek: DayOfWeek = 1) {
+  const day = date.getDay() + 1;
+  const daysToAdd =
+    day >= firstDayOfWeek
+      ? firstDayOfWeek - day
+      : -(7 - (firstDayOfWeek - day));
+  return addDays(date, daysToAdd);
+}
+
+export function getDayIndex(year: number, month: number, day: number) {
+  const utcDate = Date.UTC(year, month - 1, day);
+  return diffInDays(new Date(0), new Date(utcDate));
+}
+
+export function diffInDays(d1: Date, d2: Date) {
+  return Math.round((d2.getTime() - d1.getTime()) / MS_PER_DAY);
+}
+
+export function diffInWeeks(d1: Date, d2: Date) {
+  return Math.ceil(diffInDays(startOfWeek(d1), startOfWeek(d2)) / 7);
+}
+
+export function diffInYears(d1: Date, d2: Date) {
+  return d2.getUTCFullYear() - d1.getUTCFullYear();
+}
+
+export function diffInMonths(d1: Date, d2: Date) {
+  return diffInYears(d1, d2) * 12 + (d2.getMonth() - d1.getMonth());
+}
+
+export function getDateFromParts(
+  parts: Partial<SimpleDateParts>,
+  timezone = '',
+) {
+  const d = new Date();
+  const {
+    year = d.getFullYear(),
+    month = d.getMonth() + 1,
+    day = d.getDate(),
+    hours: hrs = 0,
+    minutes: min = 0,
+    seconds: sec = 0,
+    milliseconds: ms = 0,
+  } = parts;
+
+  if (timezone) {
+    const localDate = new Date(year, month - 1, day, hrs, min, sec, ms);
+    return fromZonedTime(localDate, timezone);
+  }
+  return new Date(year, month - 1, day, hrs, min, sec, ms);
+}
+
+export function getTimezoneOffset(
+  parts: Partial<SimpleDateParts>,
+  timezone = '',
+) {
+  const {
+    year: y = 0,
+    month: m = 0,
+    day: d = 0,
+    hours: hrs = 0,
+    minutes: min = 0,
+    seconds: sec = 0,
+    milliseconds: ms = 0,
+  } = parts;
+  let date;
+  const utcDate = new Date(Date.UTC(y, m - 1, d, hrs, min, sec, ms));
+  if (timezone) {
+    date = fromZonedTime(new Date(y, m - 1, d, hrs, min, sec, ms), timezone);
+  } else {
+    date = new Date(y, m - 1, d, hrs, min, sec, ms);
+  }
+  return (date.getTime() - utcDate.getTime()) / 60000;
+}
+
+export function getDateParts(
+  date: Date,
+  locale: Locale,
+  timezone = locale.timezone,
+): DateParts {
+  const tzDate = timezone
+    ? toZonedTime(date, timezone)
+    : new Date(date.getTime());
+  const milliseconds = tzDate.getMilliseconds();
+  const seconds = tzDate.getSeconds();
+  const minutes = tzDate.getMinutes();
+  const hours = tzDate.getHours();
+  const time =
+    milliseconds +
+    seconds * MS_PER_SECOND +
+    minutes * MS_PER_MINUTE +
+    hours * MS_PER_HOUR;
+  const month = <MonthInYear>(tzDate.getMonth() + 1);
+  const year = tzDate.getFullYear();
+  const monthParts = locale.getMonthParts(month, year);
+  const day = <DayInMonth>tzDate.getDate();
+  const dayFromEnd = monthParts.numDays - day + 1;
+  const weekday = tzDate.getDay() + 1;
+  const weekdayOrdinal = Math.floor((day - 1) / 7 + 1);
+  const weekdayOrdinalFromEnd = Math.floor((monthParts.numDays - day) / 7 + 1);
+  const week = Math.ceil(
+    (day + Math.abs(monthParts.firstWeekday - monthParts.firstDayOfWeek)) / 7,
+  );
+  const weekFromEnd = monthParts.numWeeks - week + 1;
+  const weeknumber = monthParts.weeknumbers[week];
+  const dayIndex = getDayIndex(year, month, day);
+  const parts: DateParts = {
+    milliseconds,
+    seconds,
+    minutes,
+    hours,
+    time,
+    day,
+    dayFromEnd,
+    weekday,
+    weekdayOrdinal,
+    weekdayOrdinalFromEnd,
+    week,
+    weekFromEnd,
+    weeknumber,
+    month,
+    year,
+    date: tzDate,
+    dateTime: tzDate.getTime(),
+    dayIndex,
+    timezoneOffset: 0,
+    isValid: true,
+  };
+  return parts;
+}
+
+export function getMonthPartsKey(
+  month: number,
+  year: number,
+  firstDayOfWeek: DayOfWeek,
+) {
+  return `${year}-${month}-${firstDayOfWeek}`;
+}
+
+export function getMonthParts(
+  month: number,
+  year: number,
+  firstDayOfWeek: DayOfWeek,
+) {
+  const inLeapYear = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+  const firstDayOfMonth = new Date(year, month - 1, 1);
+  const firstWeekday = firstDayOfMonth.getDay() + 1;
+  const numDays = month === 2 && inLeapYear ? 29 : daysInMonths[month - 1];
+  const weekStartsOn: WeekStartsOn = (firstDayOfWeek - 1) as WeekStartsOn;
+  const numWeeks = getWeeksInMonth(firstDayOfMonth, {
+    weekStartsOn,
+  });
+  const weeknumbers = [];
+  const isoWeeknumbers = [];
+  for (let i = 0; i < numWeeks; i++) {
+    const date = addDays(firstDayOfMonth, i * 7);
+    weeknumbers.push(getWeek(date, { weekStartsOn }));
+    isoWeeknumbers.push(getISOWeek(date));
+  }
+  return {
+    firstDayOfWeek,
+    firstDayOfMonth,
+    inLeapYear,
+    firstWeekday,
+    numDays,
+    numWeeks,
+    month,
+    year,
+    weeknumbers,
+    isoWeeknumbers,
+  };
+}
+
+export function getWeekdayDates() {
+  const dates = [];
+  const year = 2020;
+  const month = 1;
+  const day = 5;
+  for (let i = 0; i < daysInWeek; i++) {
+    dates.push(
+      getDateFromParts({
+        year,
+        month,
+        day: day + i,
+        hours: 12,
+      }),
+    );
+  }
+  return dates;
+}
+
+export function getDayNames(
+  length: DayNameLength,
+  localeId: string | undefined = undefined,
+) {
+  const dtf = new Intl.DateTimeFormat(localeId, {
+    weekday: length,
+  });
+  return getWeekdayDates().map(d => dtf.format(d));
+}
+
+export function getHourDates() {
+  const dates = [];
+  for (let i = 0; i <= 24; i++) {
+    dates.push(new Date(2000, 0, 1, i));
+  }
+  return dates;
+}
+
+export function getRelativeTimeNames(localeId = undefined): TimeNames {
+  const units: Intl.RelativeTimeFormatUnit[] = [
+    'second',
+    'minute',
+    'hour',
+    'day',
+    'week',
+    'month',
+    'quarter',
+    'year',
+  ];
+  const rtf = new Intl.RelativeTimeFormat(localeId);
+  return units.reduce<TimeNames>((names, unit) => {
+    const parts = rtf.formatToParts(100, unit);
+    // @ts-ignore
+    names[unit] = parts[1].unit;
+    return names;
+  }, {});
+}
+
+export function getMonthDates() {
+  const dates = [];
+  for (let i = 0; i < 12; i++) {
+    dates.push(new Date(2000, i, 15));
+  }
+  return dates;
+}
+
+export function getMonthNames(length: MonthNameLength, localeId = undefined) {
+  const dtf = new Intl.DateTimeFormat(localeId, {
+    month: length,
+    timeZone: 'UTC',
+  });
+  return getMonthDates().map(d => dtf.format(d));
+}
+
+export function datePartIsValid(
+  part: number,
+  rule: DatePartsRule,
+  parts: DateParts,
+): boolean {
+  if (isNumber(rule)) return rule === part;
+  if (isArray(rule)) return (rule as number[]).includes(part);
+  if (isFunction(rule)) return rule(part, parts);
+  if (rule.min != null && rule.min > part) return false;
+  if (rule.max != null && rule.max < part) return false;
+  if (rule.interval != null && part % rule.interval !== 0) return false;
+  return true;
+}
+
+export function getDatePartOptions(
+  parts: DateParts,
+  range: DatePartsRange,
+  rule: DatePartsRule | undefined,
+) {
+  const options: DatePartOption[] = [];
+  const [min, max, padding] = range;
+  for (let i = min; i <= max; i++) {
+    if (rule == null || datePartIsValid(i, rule, parts)) {
+      options.push({
+        value: i,
+        label: pad(i, padding),
+      });
+    }
+  }
+  return options;
+}
+
+export function getDatePartsOptions(parts: DateParts, rules: DatePartsRules) {
+  return {
+    milliseconds: getDatePartOptions(
+      parts,
+      DATE_PART_RANGES.milliseconds,
+      rules.milliseconds,
+    ),
+    seconds: getDatePartOptions(parts, DATE_PART_RANGES.seconds, rules.seconds),
+    minutes: getDatePartOptions(parts, DATE_PART_RANGES.minutes, rules.minutes),
+    hours: getDatePartOptions(parts, DATE_PART_RANGES.hours, rules.hours),
+  };
+}
+
+export function getNearestDatePart(
+  parts: DateParts,
+  range: DatePartsRange,
+  value: number,
+  rule: DatePartsRule,
+) {
+  const options = getDatePartOptions(parts, range, rule);
+  const result = options.reduce((prev, opt) => {
+    if (opt.disabled) return prev;
+    if (isNaN(prev)) return opt.value;
+    const diffPrev = Math.abs(prev - value);
+    const diffCurr = Math.abs(opt.value - value);
+    return diffCurr < diffPrev ? opt.value : prev;
+  }, NaN);
+  return isNaN(result) ? value : result;
+}
+
+export function applyRulesForDateParts(
+  dateParts: DateParts,
+  rules: DatePartsRules,
+) {
+  const result = <DateParts>{ ...dateParts };
+  Object.entries(rules).forEach(([key, rule]) => {
+    const range = DATE_PART_RANGES[key as TimePartsKey];
+    const value = dateParts[key as TimePartsKey];
+    result[key as TimePartsKey] = getNearestDatePart(
+      dateParts,
+      range,
+      value,
+      rule,
+    );
+  });
+  return result;
+}
+
+export function parseDate(
+  dateString: string,
+  mask: string | string[],
+  locale: Locale,
+) {
+  const masks = normalizeMasks(mask, locale);
+  return (
+    masks
+      .map(m => {
+        if (typeof m !== 'string') {
+          throw new Error('Invalid mask');
+        }
+        // Reset string value
+        let str = dateString;
+        // Avoid regular expression denial of service, fail early for really long strings
+        // https://www.owasp.org/index.php/Regular_expression_Denial_of_Service_-_ReDoS
+        if (str.length > 1000) {
+          return false;
+        }
+
+        let isValid = true;
+        const dp: Partial<DateParts> = {};
+        m.replace(token, $0 => {
+          if (parseFlags[$0]) {
+            const info = parseFlags[$0];
+            const index = str.search(info[0]);
+            if (!~index) {
+              isValid = false;
+            } else {
+              str.replace(info[0], result => {
+                info[1](dp, result, locale);
+                str = str.substr(index + result.length);
+                return result;
+              });
+            }
+          }
+
+          return parseFlags[$0] ? '' : $0.slice(1, $0.length - 1);
+        });
+
+        if (!isValid) {
+          return false;
+        }
+
+        const today = new Date();
+        if (dp.hours != null) {
+          if (dp.isPm === true && +dp.hours !== 12) {
+            dp.hours = +dp.hours + 12;
+          } else if (dp.isPm === false && +dp.hours === 12) {
+            dp.hours = 0;
+          }
+        }
+
+        let date;
+        if (dp.timezoneOffset != null) {
+          dp.minutes = +(dp.minutes || 0) - +dp.timezoneOffset;
+          date = new Date(
+            Date.UTC(
+              dp.year || today.getFullYear(),
+              dp.month || 0,
+              dp.day || 1,
+              dp.hours || 0,
+              dp.minutes || 0,
+              dp.seconds || 0,
+              dp.milliseconds || 0,
+            ),
+          );
+        } else {
+          date = locale.getDateFromParts({
+            year: dp.year || today.getFullYear(),
+            month: (dp.month || 0) + 1,
+            day: dp.day || 1,
+            hours: dp.hours || 0,
+            minutes: dp.minutes || 0,
+            seconds: dp.seconds || 0,
+            milliseconds: dp.milliseconds || 0,
+          });
+        }
+        return date;
+      })
+      .find(d => d) || parseIsoDate(dateString, locale)
+  );
+}
+
+function parseIsoDate(dateString: string, locale: Locale): Date {
+  const match =
+    /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?(Z|[+-]\d{2}:?\d{2})?)?$/.exec(
+      dateString,
+    );
+  if (!match) return new Date(NaN);
+
+  const [, year, month, day, hours, minutes, seconds, fraction, zone] = match;
+  const parts = {
+    year: Number(year),
+    month: Number(month),
+    day: Number(day),
+    hours: Number(hours ?? 0),
+    minutes: Number(minutes ?? 0),
+    seconds: Number(seconds ?? 0),
+    milliseconds: Number((fraction ?? '').padEnd(3, '0')),
+  };
+
+  const validationDate = new Date(
+    Date.UTC(
+      parts.year,
+      parts.month - 1,
+      parts.day,
+      parts.hours,
+      parts.minutes,
+      parts.seconds,
+      parts.milliseconds,
+    ),
+  );
+  if (
+    validationDate.getUTCFullYear() !== parts.year ||
+    validationDate.getUTCMonth() !== parts.month - 1 ||
+    validationDate.getUTCDate() !== parts.day ||
+    validationDate.getUTCHours() !== parts.hours ||
+    validationDate.getUTCMinutes() !== parts.minutes ||
+    validationDate.getUTCSeconds() !== parts.seconds
+  ) {
+    return new Date(NaN);
+  }
+
+  if (!zone) return locale.getDateFromParts(parts);
+
+  let offsetMinutes = 0;
+  if (zone !== 'Z') {
+    const sign = zone.startsWith('-') ? -1 : 1;
+    const normalized = zone.slice(1).replace(':', '');
+    offsetMinutes =
+      sign *
+      (Number(normalized.slice(0, 2)) * 60 + Number(normalized.slice(2)));
+  }
+  return new Date(validationDate.getTime() - offsetMinutes * MS_PER_MINUTE);
+}
+
+export function formatDate(
+  date: Date,
+  masks: string | string[],
+  locale: Locale,
+) {
+  if (date == null) return '';
+  let mask = normalizeMasks(masks, locale)[0];
+  const timezone = /Z$/.test(mask) ? 'UTC' : locale.timezone;
+  const literals: string[] = [];
+  // Make literals inactive by replacing them with ??
+  mask = mask.replace(literal, ($0, $1: string) => {
+    literals.push($1);
+    return '??';
+  });
+  const dateParts = getDateParts(date, locale, timezone);
+  // Apply formatting rules
+  mask = mask.replace(token, $0 =>
+    $0 in formatFlags
+      ? formatFlags[$0](dateParts, locale)
+      : $0.slice(1, $0.length - 1),
+  );
+  // Inline literal values back into the formatted value
+  return mask.replace(/\?\?/g, () => literals.shift()!);
+}