ivt
Version:
Ivt Components Library
1,616 lines (1,585 loc) • 113 kB
JavaScript
import { g as getDefaultOptions$1, t as toDate, c as constructFrom, m as millisecondsInHour, a as millisecondsInMinute, b as millisecondsInSecond, d as getWeekYear, s as startOfWeek, e as startOfISOWeek, h as getWeek, i as getISOWeek, j as addDays, k as getTimezoneOffsetInMilliseconds, l as enUS, n as longFormatters, o as isProtectedWeekYearToken, w as warnOrThrowProtectedError, p as isProtectedDayOfYearToken, q as buildFormatLongFn, r as buildLocalizeFn, u as buildMatchFn, v as buildMatchPatternFn, x as isValid, f as format } from './format-Cn5wls3k.mjs';
/**
* @name getDefaultOptions
* @category Common Helpers
* @summary Get default options.
* @pure false
*
* @description
* Returns an object that contains defaults for
* `options.locale`, `options.weekStartsOn` and `options.firstWeekContainsDate`
* arguments for all functions.
*
* You can change these with [setDefaultOptions](https://date-fns.org/docs/setDefaultOptions).
*
* @returns The default options
*
* @example
* const result = getDefaultOptions()
* //=> {}
*
* @example
* setDefaultOptions({ weekStarsOn: 1, firstWeekContainsDate: 4 })
* const result = getDefaultOptions()
* //=> { weekStarsOn: 1, firstWeekContainsDate: 4 }
*/ function getDefaultOptions() {
return Object.assign({}, getDefaultOptions$1());
}
/**
* The {@link getISODay} function options.
*/ /**
* @name getISODay
* @category Weekday Helpers
* @summary Get the day of the ISO week of the given date.
*
* @description
* Get the day of the ISO week of the given date,
* which is 7 for Sunday, 1 for Monday etc.
*
* ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
*
* @param date - The given date
* @param options - An object with options
*
* @returns The day of ISO week
*
* @example
* // Which day of the ISO week is 26 February 2012?
* const result = getISODay(new Date(2012, 1, 26))
* //=> 7
*/ function getISODay(date, options) {
const day = toDate(date, options?.in).getDay();
return day === 0 ? 7 : day;
}
/**
* @name transpose
* @category Generic Helpers
* @summary Transpose the date to the given constructor.
*
* @description
* The function transposes the date to the given constructor. It helps you
* to transpose the date in the system time zone to say `UTCDate` or any other
* date extension.
*
* @typeParam InputDate - The input `Date` type derived from the passed argument.
* @typeParam ResultDate - The result `Date` type derived from the passed constructor.
*
* @param date - The date to use values from
* @param constructor - The date constructor to use
*
* @returns Date transposed to the given constructor
*
* @example
* // Create July 10, 2022 00:00 in locale time zone
* const date = new Date(2022, 6, 10)
* //=> 'Sun Jul 10 2022 00:00:00 GMT+0800 (Singapore Standard Time)'
*
* @example
* // Transpose the date to July 10, 2022 00:00 in UTC
* transpose(date, UTCDate)
* //=> 'Sun Jul 10 2022 00:00:00 GMT+0000 (Coordinated Universal Time)'
*/ function transpose(date, constructor) {
const date_ = isConstructor(constructor) ? new constructor(0) : constructFrom(constructor, 0);
date_.setFullYear(date.getFullYear(), date.getMonth(), date.getDate());
date_.setHours(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
return date_;
}
function isConstructor(constructor) {
return typeof constructor === "function" && constructor.prototype?.constructor === constructor;
}
const TIMEZONE_UNIT_PRIORITY = 10;
class Setter {
validate(_utcDate, _options) {
return true;
}
constructor(){
this.subPriority = 0;
}
}
class ValueSetter extends Setter {
validate(date, options) {
return this.validateValue(date, this.value, options);
}
set(date, flags, options) {
return this.setValue(date, flags, this.value, options);
}
constructor(value, validateValue, setValue, priority, subPriority){
super();
this.value = value;
this.validateValue = validateValue;
this.setValue = setValue;
this.priority = priority;
if (subPriority) {
this.subPriority = subPriority;
}
}
}
class DateTimezoneSetter extends Setter {
set(date, flags) {
if (flags.timestampIsSet) return date;
return constructFrom(date, transpose(date, this.context));
}
constructor(context, reference){
super(), this.priority = TIMEZONE_UNIT_PRIORITY, this.subPriority = -1;
this.context = context || ((date)=>constructFrom(reference, date));
}
}
class Parser {
run(dateString, token, match, options) {
const result = this.parse(dateString, token, match, options);
if (!result) {
return null;
}
return {
setter: new ValueSetter(result.value, this.validate, this.set, this.priority, this.subPriority),
rest: result.rest
};
}
validate(_utcDate, _value, _options) {
return true;
}
}
class EraParser extends Parser {
parse(dateString, token, match) {
switch(token){
// AD, BC
case "G":
case "GG":
case "GGG":
return match.era(dateString, {
width: "abbreviated"
}) || match.era(dateString, {
width: "narrow"
});
// A, B
case "GGGGG":
return match.era(dateString, {
width: "narrow"
});
// Anno Domini, Before Christ
case "GGGG":
default:
return match.era(dateString, {
width: "wide"
}) || match.era(dateString, {
width: "abbreviated"
}) || match.era(dateString, {
width: "narrow"
});
}
}
set(date, flags, value) {
flags.era = value;
date.setFullYear(value, 0, 1);
date.setHours(0, 0, 0, 0);
return date;
}
constructor(...args){
super(...args), this.priority = 140, this.incompatibleTokens = [
"R",
"u",
"t",
"T"
];
}
}
const numericPatterns = {
month: /^(1[0-2]|0?\d)/,
date: /^(3[0-1]|[0-2]?\d)/,
dayOfYear: /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/,
week: /^(5[0-3]|[0-4]?\d)/,
hour23h: /^(2[0-3]|[0-1]?\d)/,
hour24h: /^(2[0-4]|[0-1]?\d)/,
hour11h: /^(1[0-1]|0?\d)/,
hour12h: /^(1[0-2]|0?\d)/,
minute: /^[0-5]?\d/,
second: /^[0-5]?\d/,
singleDigit: /^\d/,
twoDigits: /^\d{1,2}/,
threeDigits: /^\d{1,3}/,
fourDigits: /^\d{1,4}/,
anyDigitsSigned: /^-?\d+/,
singleDigitSigned: /^-?\d/,
twoDigitsSigned: /^-?\d{1,2}/,
threeDigitsSigned: /^-?\d{1,3}/,
fourDigitsSigned: /^-?\d{1,4}/
};
const timezonePatterns = {
basicOptionalMinutes: /^([+-])(\d{2})(\d{2})?|Z/,
basic: /^([+-])(\d{2})(\d{2})|Z/,
basicOptionalSeconds: /^([+-])(\d{2})(\d{2})((\d{2}))?|Z/,
extended: /^([+-])(\d{2}):(\d{2})|Z/,
extendedOptionalSeconds: /^([+-])(\d{2}):(\d{2})(:(\d{2}))?|Z/
};
function mapValue(parseFnResult, mapFn) {
if (!parseFnResult) {
return parseFnResult;
}
return {
value: mapFn(parseFnResult.value),
rest: parseFnResult.rest
};
}
function parseNumericPattern(pattern, dateString) {
const matchResult = dateString.match(pattern);
if (!matchResult) {
return null;
}
return {
value: parseInt(matchResult[0], 10),
rest: dateString.slice(matchResult[0].length)
};
}
function parseTimezonePattern(pattern, dateString) {
const matchResult = dateString.match(pattern);
if (!matchResult) {
return null;
}
// Input is 'Z'
if (matchResult[0] === "Z") {
return {
value: 0,
rest: dateString.slice(1)
};
}
const sign = matchResult[1] === "+" ? 1 : -1;
const hours = matchResult[2] ? parseInt(matchResult[2], 10) : 0;
const minutes = matchResult[3] ? parseInt(matchResult[3], 10) : 0;
const seconds = matchResult[5] ? parseInt(matchResult[5], 10) : 0;
return {
value: sign * (hours * millisecondsInHour + minutes * millisecondsInMinute + seconds * millisecondsInSecond),
rest: dateString.slice(matchResult[0].length)
};
}
function parseAnyDigitsSigned(dateString) {
return parseNumericPattern(numericPatterns.anyDigitsSigned, dateString);
}
function parseNDigits(n, dateString) {
switch(n){
case 1:
return parseNumericPattern(numericPatterns.singleDigit, dateString);
case 2:
return parseNumericPattern(numericPatterns.twoDigits, dateString);
case 3:
return parseNumericPattern(numericPatterns.threeDigits, dateString);
case 4:
return parseNumericPattern(numericPatterns.fourDigits, dateString);
default:
return parseNumericPattern(new RegExp("^\\d{1," + n + "}"), dateString);
}
}
function parseNDigitsSigned(n, dateString) {
switch(n){
case 1:
return parseNumericPattern(numericPatterns.singleDigitSigned, dateString);
case 2:
return parseNumericPattern(numericPatterns.twoDigitsSigned, dateString);
case 3:
return parseNumericPattern(numericPatterns.threeDigitsSigned, dateString);
case 4:
return parseNumericPattern(numericPatterns.fourDigitsSigned, dateString);
default:
return parseNumericPattern(new RegExp("^-?\\d{1," + n + "}"), dateString);
}
}
function dayPeriodEnumToHours(dayPeriod) {
switch(dayPeriod){
case "morning":
return 4;
case "evening":
return 17;
case "pm":
case "noon":
case "afternoon":
return 12;
case "am":
case "midnight":
case "night":
default:
return 0;
}
}
function normalizeTwoDigitYear(twoDigitYear, currentYear) {
const isCommonEra = currentYear > 0;
// Absolute number of the current year:
// 1 -> 1 AC
// 0 -> 1 BC
// -1 -> 2 BC
const absCurrentYear = isCommonEra ? currentYear : 1 - currentYear;
let result;
if (absCurrentYear <= 50) {
result = twoDigitYear || 100;
} else {
const rangeEnd = absCurrentYear + 50;
const rangeEndCentury = Math.trunc(rangeEnd / 100) * 100;
const isPreviousCentury = twoDigitYear >= rangeEnd % 100;
result = twoDigitYear + rangeEndCentury - (isPreviousCentury ? 100 : 0);
}
return isCommonEra ? result : 1 - result;
}
function isLeapYearIndex$1(year) {
return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
}
// From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_Patterns
// | Year | y | yy | yyy | yyyy | yyyyy |
// |----------|-------|----|-------|-------|-------|
// | AD 1 | 1 | 01 | 001 | 0001 | 00001 |
// | AD 12 | 12 | 12 | 012 | 0012 | 00012 |
// | AD 123 | 123 | 23 | 123 | 0123 | 00123 |
// | AD 1234 | 1234 | 34 | 1234 | 1234 | 01234 |
// | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 |
class YearParser extends Parser {
parse(dateString, token, match) {
const valueCallback = (year)=>({
year,
isTwoDigitYear: token === "yy"
});
switch(token){
case "y":
return mapValue(parseNDigits(4, dateString), valueCallback);
case "yo":
return mapValue(match.ordinalNumber(dateString, {
unit: "year"
}), valueCallback);
default:
return mapValue(parseNDigits(token.length, dateString), valueCallback);
}
}
validate(_date, value) {
return value.isTwoDigitYear || value.year > 0;
}
set(date, flags, value) {
const currentYear = date.getFullYear();
if (value.isTwoDigitYear) {
const normalizedTwoDigitYear = normalizeTwoDigitYear(value.year, currentYear);
date.setFullYear(normalizedTwoDigitYear, 0, 1);
date.setHours(0, 0, 0, 0);
return date;
}
const year = !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
date.setFullYear(year, 0, 1);
date.setHours(0, 0, 0, 0);
return date;
}
constructor(...args){
super(...args), this.priority = 130, this.incompatibleTokens = [
"Y",
"R",
"u",
"w",
"I",
"i",
"e",
"c",
"t",
"T"
];
}
}
// Local week-numbering year
class LocalWeekYearParser extends Parser {
parse(dateString, token, match) {
const valueCallback = (year)=>({
year,
isTwoDigitYear: token === "YY"
});
switch(token){
case "Y":
return mapValue(parseNDigits(4, dateString), valueCallback);
case "Yo":
return mapValue(match.ordinalNumber(dateString, {
unit: "year"
}), valueCallback);
default:
return mapValue(parseNDigits(token.length, dateString), valueCallback);
}
}
validate(_date, value) {
return value.isTwoDigitYear || value.year > 0;
}
set(date, flags, value, options) {
const currentYear = getWeekYear(date, options);
if (value.isTwoDigitYear) {
const normalizedTwoDigitYear = normalizeTwoDigitYear(value.year, currentYear);
date.setFullYear(normalizedTwoDigitYear, 0, options.firstWeekContainsDate);
date.setHours(0, 0, 0, 0);
return startOfWeek(date, options);
}
const year = !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
date.setFullYear(year, 0, options.firstWeekContainsDate);
date.setHours(0, 0, 0, 0);
return startOfWeek(date, options);
}
constructor(...args){
super(...args), this.priority = 130, this.incompatibleTokens = [
"y",
"R",
"u",
"Q",
"q",
"M",
"L",
"I",
"d",
"D",
"i",
"t",
"T"
];
}
}
// ISO week-numbering year
class ISOWeekYearParser extends Parser {
parse(dateString, token) {
if (token === "R") {
return parseNDigitsSigned(4, dateString);
}
return parseNDigitsSigned(token.length, dateString);
}
set(date, _flags, value) {
const firstWeekOfYear = constructFrom(date, 0);
firstWeekOfYear.setFullYear(value, 0, 4);
firstWeekOfYear.setHours(0, 0, 0, 0);
return startOfISOWeek(firstWeekOfYear);
}
constructor(...args){
super(...args), this.priority = 130, this.incompatibleTokens = [
"G",
"y",
"Y",
"u",
"Q",
"q",
"M",
"L",
"w",
"d",
"D",
"e",
"c",
"t",
"T"
];
}
}
class ExtendedYearParser extends Parser {
parse(dateString, token) {
if (token === "u") {
return parseNDigitsSigned(4, dateString);
}
return parseNDigitsSigned(token.length, dateString);
}
set(date, _flags, value) {
date.setFullYear(value, 0, 1);
date.setHours(0, 0, 0, 0);
return date;
}
constructor(...args){
super(...args), this.priority = 130, this.incompatibleTokens = [
"G",
"y",
"Y",
"R",
"w",
"I",
"i",
"e",
"c",
"t",
"T"
];
}
}
class QuarterParser extends Parser {
parse(dateString, token, match) {
switch(token){
// 1, 2, 3, 4
case "Q":
case "QQ":
return parseNDigits(token.length, dateString);
// 1st, 2nd, 3rd, 4th
case "Qo":
return match.ordinalNumber(dateString, {
unit: "quarter"
});
// Q1, Q2, Q3, Q4
case "QQQ":
return match.quarter(dateString, {
width: "abbreviated",
context: "formatting"
}) || match.quarter(dateString, {
width: "narrow",
context: "formatting"
});
// 1, 2, 3, 4 (narrow quarter; could be not numerical)
case "QQQQQ":
return match.quarter(dateString, {
width: "narrow",
context: "formatting"
});
// 1st quarter, 2nd quarter, ...
case "QQQQ":
default:
return match.quarter(dateString, {
width: "wide",
context: "formatting"
}) || match.quarter(dateString, {
width: "abbreviated",
context: "formatting"
}) || match.quarter(dateString, {
width: "narrow",
context: "formatting"
});
}
}
validate(_date, value) {
return value >= 1 && value <= 4;
}
set(date, _flags, value) {
date.setMonth((value - 1) * 3, 1);
date.setHours(0, 0, 0, 0);
return date;
}
constructor(...args){
super(...args), this.priority = 120, this.incompatibleTokens = [
"Y",
"R",
"q",
"M",
"L",
"w",
"I",
"d",
"D",
"i",
"e",
"c",
"t",
"T"
];
}
}
class StandAloneQuarterParser extends Parser {
parse(dateString, token, match) {
switch(token){
// 1, 2, 3, 4
case "q":
case "qq":
return parseNDigits(token.length, dateString);
// 1st, 2nd, 3rd, 4th
case "qo":
return match.ordinalNumber(dateString, {
unit: "quarter"
});
// Q1, Q2, Q3, Q4
case "qqq":
return match.quarter(dateString, {
width: "abbreviated",
context: "standalone"
}) || match.quarter(dateString, {
width: "narrow",
context: "standalone"
});
// 1, 2, 3, 4 (narrow quarter; could be not numerical)
case "qqqqq":
return match.quarter(dateString, {
width: "narrow",
context: "standalone"
});
// 1st quarter, 2nd quarter, ...
case "qqqq":
default:
return match.quarter(dateString, {
width: "wide",
context: "standalone"
}) || match.quarter(dateString, {
width: "abbreviated",
context: "standalone"
}) || match.quarter(dateString, {
width: "narrow",
context: "standalone"
});
}
}
validate(_date, value) {
return value >= 1 && value <= 4;
}
set(date, _flags, value) {
date.setMonth((value - 1) * 3, 1);
date.setHours(0, 0, 0, 0);
return date;
}
constructor(...args){
super(...args), this.priority = 120, this.incompatibleTokens = [
"Y",
"R",
"Q",
"M",
"L",
"w",
"I",
"d",
"D",
"i",
"e",
"c",
"t",
"T"
];
}
}
class MonthParser extends Parser {
parse(dateString, token, match) {
const valueCallback = (value)=>value - 1;
switch(token){
// 1, 2, ..., 12
case "M":
return mapValue(parseNumericPattern(numericPatterns.month, dateString), valueCallback);
// 01, 02, ..., 12
case "MM":
return mapValue(parseNDigits(2, dateString), valueCallback);
// 1st, 2nd, ..., 12th
case "Mo":
return mapValue(match.ordinalNumber(dateString, {
unit: "month"
}), valueCallback);
// Jan, Feb, ..., Dec
case "MMM":
return match.month(dateString, {
width: "abbreviated",
context: "formatting"
}) || match.month(dateString, {
width: "narrow",
context: "formatting"
});
// J, F, ..., D
case "MMMMM":
return match.month(dateString, {
width: "narrow",
context: "formatting"
});
// January, February, ..., December
case "MMMM":
default:
return match.month(dateString, {
width: "wide",
context: "formatting"
}) || match.month(dateString, {
width: "abbreviated",
context: "formatting"
}) || match.month(dateString, {
width: "narrow",
context: "formatting"
});
}
}
validate(_date, value) {
return value >= 0 && value <= 11;
}
set(date, _flags, value) {
date.setMonth(value, 1);
date.setHours(0, 0, 0, 0);
return date;
}
constructor(...args){
super(...args), this.incompatibleTokens = [
"Y",
"R",
"q",
"Q",
"L",
"w",
"I",
"D",
"i",
"e",
"c",
"t",
"T"
], this.priority = 110;
}
}
class StandAloneMonthParser extends Parser {
parse(dateString, token, match) {
const valueCallback = (value)=>value - 1;
switch(token){
// 1, 2, ..., 12
case "L":
return mapValue(parseNumericPattern(numericPatterns.month, dateString), valueCallback);
// 01, 02, ..., 12
case "LL":
return mapValue(parseNDigits(2, dateString), valueCallback);
// 1st, 2nd, ..., 12th
case "Lo":
return mapValue(match.ordinalNumber(dateString, {
unit: "month"
}), valueCallback);
// Jan, Feb, ..., Dec
case "LLL":
return match.month(dateString, {
width: "abbreviated",
context: "standalone"
}) || match.month(dateString, {
width: "narrow",
context: "standalone"
});
// J, F, ..., D
case "LLLLL":
return match.month(dateString, {
width: "narrow",
context: "standalone"
});
// January, February, ..., December
case "LLLL":
default:
return match.month(dateString, {
width: "wide",
context: "standalone"
}) || match.month(dateString, {
width: "abbreviated",
context: "standalone"
}) || match.month(dateString, {
width: "narrow",
context: "standalone"
});
}
}
validate(_date, value) {
return value >= 0 && value <= 11;
}
set(date, _flags, value) {
date.setMonth(value, 1);
date.setHours(0, 0, 0, 0);
return date;
}
constructor(...args){
super(...args), this.priority = 110, this.incompatibleTokens = [
"Y",
"R",
"q",
"Q",
"M",
"w",
"I",
"D",
"i",
"e",
"c",
"t",
"T"
];
}
}
/**
* The {@link setWeek} function options.
*/ /**
* @name setWeek
* @category Week Helpers
* @summary Set the local week to the given date.
*
* @description
* Set the local week to the given date, saving the weekday number.
* The exact calculation depends on the values of
* `options.weekStartsOn` (which is the index of the first day of the week)
* and `options.firstWeekContainsDate` (which is the day of January, which is always in
* the first week of the week-numbering year)
*
* Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The date to be changed
* @param week - The week of the new date
* @param options - An object with options
*
* @returns The new date with the local week set
*
* @example
* // Set the 1st week to 2 January 2005 with default options:
* const result = setWeek(new Date(2005, 0, 2), 1)
* //=> Sun Dec 26 2004 00:00:00
*
* @example
* // Set the 1st week to 2 January 2005,
* // if Monday is the first day of the week,
* // and the first week of the year always contains 4 January:
* const result = setWeek(new Date(2005, 0, 2), 1, {
* weekStartsOn: 1,
* firstWeekContainsDate: 4
* })
* //=> Sun Jan 4 2004 00:00:00
*/ function setWeek(date, week, options) {
const date_ = toDate(date, options?.in);
const diff = getWeek(date_, options) - week;
date_.setDate(date_.getDate() - diff * 7);
return toDate(date_, options?.in);
}
// Local week of year
class LocalWeekParser extends Parser {
parse(dateString, token, match) {
switch(token){
case "w":
return parseNumericPattern(numericPatterns.week, dateString);
case "wo":
return match.ordinalNumber(dateString, {
unit: "week"
});
default:
return parseNDigits(token.length, dateString);
}
}
validate(_date, value) {
return value >= 1 && value <= 53;
}
set(date, _flags, value, options) {
return startOfWeek(setWeek(date, value, options), options);
}
constructor(...args){
super(...args), this.priority = 100, this.incompatibleTokens = [
"y",
"R",
"u",
"q",
"Q",
"M",
"L",
"I",
"d",
"D",
"i",
"t",
"T"
];
}
}
/**
* The {@link setISOWeek} function options.
*/ /**
* @name setISOWeek
* @category ISO Week Helpers
* @summary Set the ISO week to the given date.
*
* @description
* Set the ISO week to the given date, saving the weekday number.
*
* ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The `Date` type of the context function.
*
* @param date - The date to be changed
* @param week - The ISO week of the new date
* @param options - An object with options
*
* @returns The new date with the ISO week set
*
* @example
* // Set the 53rd ISO week to 7 August 2004:
* const result = setISOWeek(new Date(2004, 7, 7), 53)
* //=> Sat Jan 01 2005 00:00:00
*/ function setISOWeek(date, week, options) {
const _date = toDate(date, options?.in);
const diff = getISOWeek(_date, options) - week;
_date.setDate(_date.getDate() - diff * 7);
return _date;
}
// ISO week of year
class ISOWeekParser extends Parser {
parse(dateString, token, match) {
switch(token){
case "I":
return parseNumericPattern(numericPatterns.week, dateString);
case "Io":
return match.ordinalNumber(dateString, {
unit: "week"
});
default:
return parseNDigits(token.length, dateString);
}
}
validate(_date, value) {
return value >= 1 && value <= 53;
}
set(date, _flags, value) {
return startOfISOWeek(setISOWeek(date, value));
}
constructor(...args){
super(...args), this.priority = 100, this.incompatibleTokens = [
"y",
"Y",
"u",
"q",
"Q",
"M",
"L",
"w",
"d",
"D",
"e",
"c",
"t",
"T"
];
}
}
const DAYS_IN_MONTH = [
31,
28,
31,
30,
31,
30,
31,
31,
30,
31,
30,
31
];
const DAYS_IN_MONTH_LEAP_YEAR = [
31,
29,
31,
30,
31,
30,
31,
31,
30,
31,
30,
31
];
// Day of the month
class DateParser extends Parser {
parse(dateString, token, match) {
switch(token){
case "d":
return parseNumericPattern(numericPatterns.date, dateString);
case "do":
return match.ordinalNumber(dateString, {
unit: "date"
});
default:
return parseNDigits(token.length, dateString);
}
}
validate(date, value) {
const year = date.getFullYear();
const isLeapYear = isLeapYearIndex$1(year);
const month = date.getMonth();
if (isLeapYear) {
return value >= 1 && value <= DAYS_IN_MONTH_LEAP_YEAR[month];
} else {
return value >= 1 && value <= DAYS_IN_MONTH[month];
}
}
set(date, _flags, value) {
date.setDate(value);
date.setHours(0, 0, 0, 0);
return date;
}
constructor(...args){
super(...args), this.priority = 90, this.subPriority = 1, this.incompatibleTokens = [
"Y",
"R",
"q",
"Q",
"w",
"I",
"D",
"i",
"e",
"c",
"t",
"T"
];
}
}
class DayOfYearParser extends Parser {
parse(dateString, token, match) {
switch(token){
case "D":
case "DD":
return parseNumericPattern(numericPatterns.dayOfYear, dateString);
case "Do":
return match.ordinalNumber(dateString, {
unit: "date"
});
default:
return parseNDigits(token.length, dateString);
}
}
validate(date, value) {
const year = date.getFullYear();
const isLeapYear = isLeapYearIndex$1(year);
if (isLeapYear) {
return value >= 1 && value <= 366;
} else {
return value >= 1 && value <= 365;
}
}
set(date, _flags, value) {
date.setMonth(0, value);
date.setHours(0, 0, 0, 0);
return date;
}
constructor(...args){
super(...args), this.priority = 90, this.subpriority = 1, this.incompatibleTokens = [
"Y",
"R",
"q",
"Q",
"M",
"L",
"w",
"I",
"d",
"E",
"i",
"e",
"c",
"t",
"T"
];
}
}
/**
* The {@link setDay} function options.
*/ /**
* @name setDay
* @category Weekday Helpers
* @summary Set the day of the week to the given date.
*
* @description
* Set the day of the week to the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The date to be changed
* @param day - The day of the week of the new date
* @param options - An object with options.
*
* @returns The new date with the day of the week set
*
* @example
* // Set week day to Sunday, with the default weekStartsOn of Sunday:
* const result = setDay(new Date(2014, 8, 1), 0)
* //=> Sun Aug 31 2014 00:00:00
*
* @example
* // Set week day to Sunday, with a weekStartsOn of Monday:
* const result = setDay(new Date(2014, 8, 1), 0, { weekStartsOn: 1 })
* //=> Sun Sep 07 2014 00:00:00
*/ function setDay(date, day, options) {
const defaultOptions = getDefaultOptions$1();
const weekStartsOn = options?.weekStartsOn ?? options?.locale?.options?.weekStartsOn ?? defaultOptions.weekStartsOn ?? defaultOptions.locale?.options?.weekStartsOn ?? 0;
const date_ = toDate(date, options?.in);
const currentDay = date_.getDay();
const remainder = day % 7;
const dayIndex = (remainder + 7) % 7;
const delta = 7 - weekStartsOn;
const diff = day < 0 || day > 6 ? day - (currentDay + delta) % 7 : (dayIndex + delta) % 7 - (currentDay + delta) % 7;
return addDays(date_, diff, options);
}
// Day of week
class DayParser extends Parser {
parse(dateString, token, match) {
switch(token){
// Tue
case "E":
case "EE":
case "EEE":
return match.day(dateString, {
width: "abbreviated",
context: "formatting"
}) || match.day(dateString, {
width: "short",
context: "formatting"
}) || match.day(dateString, {
width: "narrow",
context: "formatting"
});
// T
case "EEEEE":
return match.day(dateString, {
width: "narrow",
context: "formatting"
});
// Tu
case "EEEEEE":
return match.day(dateString, {
width: "short",
context: "formatting"
}) || match.day(dateString, {
width: "narrow",
context: "formatting"
});
// Tuesday
case "EEEE":
default:
return match.day(dateString, {
width: "wide",
context: "formatting"
}) || match.day(dateString, {
width: "abbreviated",
context: "formatting"
}) || match.day(dateString, {
width: "short",
context: "formatting"
}) || match.day(dateString, {
width: "narrow",
context: "formatting"
});
}
}
validate(_date, value) {
return value >= 0 && value <= 6;
}
set(date, _flags, value, options) {
date = setDay(date, value, options);
date.setHours(0, 0, 0, 0);
return date;
}
constructor(...args){
super(...args), this.priority = 90, this.incompatibleTokens = [
"D",
"i",
"e",
"c",
"t",
"T"
];
}
}
// Local day of week
class LocalDayParser extends Parser {
parse(dateString, token, match, options) {
const valueCallback = (value)=>{
// We want here floor instead of trunc, so we get -7 for value 0 instead of 0
const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
return (value + options.weekStartsOn + 6) % 7 + wholeWeekDays;
};
switch(token){
// 3
case "e":
case "ee":
return mapValue(parseNDigits(token.length, dateString), valueCallback);
// 3rd
case "eo":
return mapValue(match.ordinalNumber(dateString, {
unit: "day"
}), valueCallback);
// Tue
case "eee":
return match.day(dateString, {
width: "abbreviated",
context: "formatting"
}) || match.day(dateString, {
width: "short",
context: "formatting"
}) || match.day(dateString, {
width: "narrow",
context: "formatting"
});
// T
case "eeeee":
return match.day(dateString, {
width: "narrow",
context: "formatting"
});
// Tu
case "eeeeee":
return match.day(dateString, {
width: "short",
context: "formatting"
}) || match.day(dateString, {
width: "narrow",
context: "formatting"
});
// Tuesday
case "eeee":
default:
return match.day(dateString, {
width: "wide",
context: "formatting"
}) || match.day(dateString, {
width: "abbreviated",
context: "formatting"
}) || match.day(dateString, {
width: "short",
context: "formatting"
}) || match.day(dateString, {
width: "narrow",
context: "formatting"
});
}
}
validate(_date, value) {
return value >= 0 && value <= 6;
}
set(date, _flags, value, options) {
date = setDay(date, value, options);
date.setHours(0, 0, 0, 0);
return date;
}
constructor(...args){
super(...args), this.priority = 90, this.incompatibleTokens = [
"y",
"R",
"u",
"q",
"Q",
"M",
"L",
"I",
"d",
"D",
"E",
"i",
"c",
"t",
"T"
];
}
}
// Stand-alone local day of week
class StandAloneLocalDayParser extends Parser {
parse(dateString, token, match, options) {
const valueCallback = (value)=>{
// We want here floor instead of trunc, so we get -7 for value 0 instead of 0
const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
return (value + options.weekStartsOn + 6) % 7 + wholeWeekDays;
};
switch(token){
// 3
case "c":
case "cc":
return mapValue(parseNDigits(token.length, dateString), valueCallback);
// 3rd
case "co":
return mapValue(match.ordinalNumber(dateString, {
unit: "day"
}), valueCallback);
// Tue
case "ccc":
return match.day(dateString, {
width: "abbreviated",
context: "standalone"
}) || match.day(dateString, {
width: "short",
context: "standalone"
}) || match.day(dateString, {
width: "narrow",
context: "standalone"
});
// T
case "ccccc":
return match.day(dateString, {
width: "narrow",
context: "standalone"
});
// Tu
case "cccccc":
return match.day(dateString, {
width: "short",
context: "standalone"
}) || match.day(dateString, {
width: "narrow",
context: "standalone"
});
// Tuesday
case "cccc":
default:
return match.day(dateString, {
width: "wide",
context: "standalone"
}) || match.day(dateString, {
width: "abbreviated",
context: "standalone"
}) || match.day(dateString, {
width: "short",
context: "standalone"
}) || match.day(dateString, {
width: "narrow",
context: "standalone"
});
}
}
validate(_date, value) {
return value >= 0 && value <= 6;
}
set(date, _flags, value, options) {
date = setDay(date, value, options);
date.setHours(0, 0, 0, 0);
return date;
}
constructor(...args){
super(...args), this.priority = 90, this.incompatibleTokens = [
"y",
"R",
"u",
"q",
"Q",
"M",
"L",
"I",
"d",
"D",
"E",
"i",
"e",
"t",
"T"
];
}
}
/**
* The {@link setISODay} function options.
*/ /**
* @name setISODay
* @category Weekday Helpers
* @summary Set the day of the ISO week to the given date.
*
* @description
* Set the day of the ISO week to the given date.
* ISO week starts with Monday.
* 7 is the index of Sunday, 1 is the index of Monday, etc.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The date to be changed
* @param day - The day of the ISO week of the new date
* @param options - An object with options
*
* @returns The new date with the day of the ISO week set
*
* @example
* // Set Sunday to 1 September 2014:
* const result = setISODay(new Date(2014, 8, 1), 7)
* //=> Sun Sep 07 2014 00:00:00
*/ function setISODay(date, day, options) {
const date_ = toDate(date, options?.in);
const currentDay = getISODay(date_, options);
const diff = day - currentDay;
return addDays(date_, diff, options);
}
// ISO day of week
class ISODayParser extends Parser {
parse(dateString, token, match) {
const valueCallback = (value)=>{
if (value === 0) {
return 7;
}
return value;
};
switch(token){
// 2
case "i":
case "ii":
return parseNDigits(token.length, dateString);
// 2nd
case "io":
return match.ordinalNumber(dateString, {
unit: "day"
});
// Tue
case "iii":
return mapValue(match.day(dateString, {
width: "abbreviated",
context: "formatting"
}) || match.day(dateString, {
width: "short",
context: "formatting"
}) || match.day(dateString, {
width: "narrow",
context: "formatting"
}), valueCallback);
// T
case "iiiii":
return mapValue(match.day(dateString, {
width: "narrow",
context: "formatting"
}), valueCallback);
// Tu
case "iiiiii":
return mapValue(match.day(dateString, {
width: "short",
context: "formatting"
}) || match.day(dateString, {
width: "narrow",
context: "formatting"
}), valueCallback);
// Tuesday
case "iiii":
default:
return mapValue(match.day(dateString, {
width: "wide",
context: "formatting"
}) || match.day(dateString, {
width: "abbreviated",
context: "formatting"
}) || match.day(dateString, {
width: "short",
context: "formatting"
}) || match.day(dateString, {
width: "narrow",
context: "formatting"
}), valueCallback);
}
}
validate(_date, value) {
return value >= 1 && value <= 7;
}
set(date, _flags, value) {
date = setISODay(date, value);
date.setHours(0, 0, 0, 0);
return date;
}
constructor(...args){
super(...args), this.priority = 90, this.incompatibleTokens = [
"y",
"Y",
"u",
"q",
"Q",
"M",
"L",
"w",
"d",
"D",
"E",
"e",
"c",
"t",
"T"
];
}
}
class AMPMParser extends Parser {
parse(dateString, token, match) {
switch(token){
case "a":
case "aa":
case "aaa":
return match.dayPeriod(dateString, {
width: "abbreviated",
context: "formatting"
}) || match.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
case "aaaaa":
return match.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
case "aaaa":
default:
return match.dayPeriod(dateString, {
width: "wide",
context: "formatting"
}) || match.dayPeriod(dateString, {
width: "abbreviated",
context: "formatting"
}) || match.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
}
}
set(date, _flags, value) {
date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
return date;
}
constructor(...args){
super(...args), this.priority = 80, this.incompatibleTokens = [
"b",
"B",
"H",
"k",
"t",
"T"
];
}
}
class AMPMMidnightParser extends Parser {
parse(dateString, token, match) {
switch(token){
case "b":
case "bb":
case "bbb":
return match.dayPeriod(dateString, {
width: "abbreviated",
context: "formatting"
}) || match.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
case "bbbbb":
return match.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
case "bbbb":
default:
return match.dayPeriod(dateString, {
width: "wide",
context: "formatting"
}) || match.dayPeriod(dateString, {
width: "abbreviated",
context: "formatting"
}) || match.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
}
}
set(date, _flags, value) {
date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
return date;
}
constructor(...args){
super(...args), this.priority = 80, this.incompatibleTokens = [
"a",
"B",
"H",
"k",
"t",
"T"
];
}
}
// in the morning, in the afternoon, in the evening, at night
class DayPeriodParser extends Parser {
parse(dateString, token, match) {
switch(token){
case "B":
case "BB":
case "BBB":
return match.dayPeriod(dateString, {
width: "abbreviated",
context: "formatting"
}) || match.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
case "BBBBB":
return match.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
case "BBBB":
default:
return match.dayPeriod(dateString, {
width: "wide",
context: "formatting"
}) || match.dayPeriod(dateString, {
width: "abbreviated",
context: "formatting"
}) || match.dayPeriod(dateString, {
width: "narrow",
context: "formatt