@nextcloud/vue
Version:
Nextcloud vue components
2,983 lines • 91.9 kB
JavaScript
import '../assets/NcDateTimePicker.css';
import { ref, defineComponent, useModel, watchEffect, warn, useTemplateRef, computed, watch, openBlock, createElementBlock, createVNode, unref, mergeProps, createSlots, withCtx, createTextVNode, toDisplayString, createBlock, Teleport, createElementVNode, mergeModels } from "vue";
import { E as mdiChevronUp, F as mdiChevronDown, c as mdiChevronRight, B as mdiChevronLeft, G as mdiClock, H as mdiCalendarBlank, b as mdiClose } from "./mdi.mjs";
import { getCanonicalLocale, getFirstDay, getDayNamesMin, getDayNames } from "@nextcloud/l10n";
import VueDatePicker from "@vuepic/vue-datepicker";
import { N as NcIconSvgWrapper } from "./NcIconSvgWrapper.mjs";
import { _ as _sfc_main$1 } from "./NcTimezonePicker.vue_vue_type_script_setup_true_lang.mjs";
import { r as register, a2 as t14, a as t } from "./_l10n.mjs";
import { N as NcButton } from "./NcButton.mjs";
import { enUS as enUS$1 } from "date-fns/locale/en-US";
import { l as logger } from "./logger.mjs";
import { _ as _export_sfc } from "./_plugin-vue_export-helper.mjs";
const formatDistanceLocale = {
lessThanXSeconds: {
one: "less than a second",
other: "less than {{count}} seconds"
},
xSeconds: {
one: "1 second",
other: "{{count}} seconds"
},
halfAMinute: "half a minute",
lessThanXMinutes: {
one: "less than a minute",
other: "less than {{count}} minutes"
},
xMinutes: {
one: "1 minute",
other: "{{count}} minutes"
},
aboutXHours: {
one: "about 1 hour",
other: "about {{count}} hours"
},
xHours: {
one: "1 hour",
other: "{{count}} hours"
},
xDays: {
one: "1 day",
other: "{{count}} days"
},
aboutXWeeks: {
one: "about 1 week",
other: "about {{count}} weeks"
},
xWeeks: {
one: "1 week",
other: "{{count}} weeks"
},
aboutXMonths: {
one: "about 1 month",
other: "about {{count}} months"
},
xMonths: {
one: "1 month",
other: "{{count}} months"
},
aboutXYears: {
one: "about 1 year",
other: "about {{count}} years"
},
xYears: {
one: "1 year",
other: "{{count}} years"
},
overXYears: {
one: "over 1 year",
other: "over {{count}} years"
},
almostXYears: {
one: "almost 1 year",
other: "almost {{count}} years"
}
};
const formatDistance = (token, count, options) => {
let result;
const tokenValue = formatDistanceLocale[token];
if (typeof tokenValue === "string") {
result = tokenValue;
} else if (count === 1) {
result = tokenValue.one;
} else {
result = tokenValue.other.replace("{{count}}", count.toString());
}
if (options?.addSuffix) {
if (options.comparison && options.comparison > 0) {
return "in " + result;
} else {
return result + " ago";
}
}
return result;
};
function buildFormatLongFn(args) {
return (options = {}) => {
const width = options.width ? String(options.width) : args.defaultWidth;
const format = args.formats[width] || args.formats[args.defaultWidth];
return format;
};
}
const dateFormats = {
full: "EEEE, MMMM do, y",
long: "MMMM do, y",
medium: "MMM d, y",
short: "MM/dd/yyyy"
};
const timeFormats = {
full: "h:mm:ss a zzzz",
long: "h:mm:ss a z",
medium: "h:mm:ss a",
short: "h:mm a"
};
const dateTimeFormats = {
full: "{{date}} 'at' {{time}}",
long: "{{date}} 'at' {{time}}",
medium: "{{date}}, {{time}}",
short: "{{date}}, {{time}}"
};
const formatLong = {
date: buildFormatLongFn({
formats: dateFormats,
defaultWidth: "full"
}),
time: buildFormatLongFn({
formats: timeFormats,
defaultWidth: "full"
}),
dateTime: buildFormatLongFn({
formats: dateTimeFormats,
defaultWidth: "full"
})
};
const formatRelativeLocale = {
lastWeek: "'last' eeee 'at' p",
yesterday: "'yesterday at' p",
today: "'today at' p",
tomorrow: "'tomorrow at' p",
nextWeek: "eeee 'at' p",
other: "P"
};
const formatRelative = (token, _date, _baseDate, _options) => formatRelativeLocale[token];
function buildLocalizeFn(args) {
return (value, options) => {
const context = options?.context ? String(options.context) : "standalone";
let valuesArray;
if (context === "formatting" && args.formattingValues) {
const defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
const width = options?.width ? String(options.width) : defaultWidth;
valuesArray = args.formattingValues[width] || args.formattingValues[defaultWidth];
} else {
const defaultWidth = args.defaultWidth;
const width = options?.width ? String(options.width) : args.defaultWidth;
valuesArray = args.values[width] || args.values[defaultWidth];
}
const index = args.argumentCallback ? args.argumentCallback(value) : value;
return valuesArray[index];
};
}
const eraValues = {
narrow: ["B", "A"],
abbreviated: ["BC", "AD"],
wide: ["Before Christ", "Anno Domini"]
};
const quarterValues = {
narrow: ["1", "2", "3", "4"],
abbreviated: ["Q1", "Q2", "Q3", "Q4"],
wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"]
};
const monthValues = {
narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
abbreviated: [
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec"
],
wide: [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December"
]
};
const dayValues = {
narrow: ["S", "M", "T", "W", "T", "F", "S"],
short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
wide: [
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday"
]
};
const dayPeriodValues = {
narrow: {
am: "a",
pm: "p",
midnight: "mi",
noon: "n",
morning: "morning",
afternoon: "afternoon",
evening: "evening",
night: "night"
},
abbreviated: {
am: "AM",
pm: "PM",
midnight: "midnight",
noon: "noon",
morning: "morning",
afternoon: "afternoon",
evening: "evening",
night: "night"
},
wide: {
am: "a.m.",
pm: "p.m.",
midnight: "midnight",
noon: "noon",
morning: "morning",
afternoon: "afternoon",
evening: "evening",
night: "night"
}
};
const formattingDayPeriodValues = {
narrow: {
am: "a",
pm: "p",
midnight: "mi",
noon: "n",
morning: "in the morning",
afternoon: "in the afternoon",
evening: "in the evening",
night: "at night"
},
abbreviated: {
am: "AM",
pm: "PM",
midnight: "midnight",
noon: "noon",
morning: "in the morning",
afternoon: "in the afternoon",
evening: "in the evening",
night: "at night"
},
wide: {
am: "a.m.",
pm: "p.m.",
midnight: "midnight",
noon: "noon",
morning: "in the morning",
afternoon: "in the afternoon",
evening: "in the evening",
night: "at night"
}
};
const ordinalNumber = (dirtyNumber, _options) => {
const number = Number(dirtyNumber);
const rem100 = number % 100;
if (rem100 > 20 || rem100 < 10) {
switch (rem100 % 10) {
case 1:
return number + "st";
case 2:
return number + "nd";
case 3:
return number + "rd";
}
}
return number + "th";
};
const localize = {
ordinalNumber,
era: buildLocalizeFn({
values: eraValues,
defaultWidth: "wide"
}),
quarter: buildLocalizeFn({
values: quarterValues,
defaultWidth: "wide",
argumentCallback: (quarter) => quarter - 1
}),
month: buildLocalizeFn({
values: monthValues,
defaultWidth: "wide"
}),
day: buildLocalizeFn({
values: dayValues,
defaultWidth: "wide"
}),
dayPeriod: buildLocalizeFn({
values: dayPeriodValues,
defaultWidth: "wide",
formattingValues: formattingDayPeriodValues,
defaultFormattingWidth: "wide"
})
};
function buildMatchFn(args) {
return (string, options = {}) => {
const width = options.width;
const matchPattern = width && args.matchPatterns[width] || args.matchPatterns[args.defaultMatchWidth];
const matchResult = string.match(matchPattern);
if (!matchResult) {
return null;
}
const matchedString = matchResult[0];
const parsePatterns = width && args.parsePatterns[width] || args.parsePatterns[args.defaultParseWidth];
const key = Array.isArray(parsePatterns) ? findIndex(parsePatterns, (pattern) => pattern.test(matchedString)) : (
// [TODO] -- I challenge you to fix the type
findKey(parsePatterns, (pattern) => pattern.test(matchedString))
);
let value;
value = args.valueCallback ? args.valueCallback(key) : key;
value = options.valueCallback ? (
// [TODO] -- I challenge you to fix the type
options.valueCallback(value)
) : value;
const rest = string.slice(matchedString.length);
return { value, rest };
};
}
function findKey(object, predicate) {
for (const key in object) {
if (Object.prototype.hasOwnProperty.call(object, key) && predicate(object[key])) {
return key;
}
}
return void 0;
}
function findIndex(array, predicate) {
for (let key = 0; key < array.length; key++) {
if (predicate(array[key])) {
return key;
}
}
return void 0;
}
function buildMatchPatternFn(args) {
return (string, options = {}) => {
const matchResult = string.match(args.matchPattern);
if (!matchResult) return null;
const matchedString = matchResult[0];
const parseResult = string.match(args.parsePattern);
if (!parseResult) return null;
let value = args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0];
value = options.valueCallback ? options.valueCallback(value) : value;
const rest = string.slice(matchedString.length);
return { value, rest };
};
}
const matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
const parseOrdinalNumberPattern = /\d+/i;
const matchEraPatterns = {
narrow: /^(b|a)/i,
abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
wide: /^(before christ|before common era|anno domini|common era)/i
};
const parseEraPatterns = {
any: [/^b/i, /^(a|c)/i]
};
const matchQuarterPatterns = {
narrow: /^[1234]/i,
abbreviated: /^q[1234]/i,
wide: /^[1234](th|st|nd|rd)? quarter/i
};
const parseQuarterPatterns = {
any: [/1/i, /2/i, /3/i, /4/i]
};
const matchMonthPatterns = {
narrow: /^[jfmasond]/i,
abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
};
const parseMonthPatterns = {
narrow: [
/^j/i,
/^f/i,
/^m/i,
/^a/i,
/^m/i,
/^j/i,
/^j/i,
/^a/i,
/^s/i,
/^o/i,
/^n/i,
/^d/i
],
any: [
/^ja/i,
/^f/i,
/^mar/i,
/^ap/i,
/^may/i,
/^jun/i,
/^jul/i,
/^au/i,
/^s/i,
/^o/i,
/^n/i,
/^d/i
]
};
const matchDayPatterns = {
narrow: /^[smtwf]/i,
short: /^(su|mo|tu|we|th|fr|sa)/i,
abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
};
const parseDayPatterns = {
narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
};
const matchDayPeriodPatterns = {
narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
};
const parseDayPeriodPatterns = {
any: {
am: /^a/i,
pm: /^p/i,
midnight: /^mi/i,
noon: /^no/i,
morning: /morning/i,
afternoon: /afternoon/i,
evening: /evening/i,
night: /night/i
}
};
const match = {
ordinalNumber: buildMatchPatternFn({
matchPattern: matchOrdinalNumberPattern,
parsePattern: parseOrdinalNumberPattern,
valueCallback: (value) => parseInt(value, 10)
}),
era: buildMatchFn({
matchPatterns: matchEraPatterns,
defaultMatchWidth: "wide",
parsePatterns: parseEraPatterns,
defaultParseWidth: "any"
}),
quarter: buildMatchFn({
matchPatterns: matchQuarterPatterns,
defaultMatchWidth: "wide",
parsePatterns: parseQuarterPatterns,
defaultParseWidth: "any",
valueCallback: (index) => index + 1
}),
month: buildMatchFn({
matchPatterns: matchMonthPatterns,
defaultMatchWidth: "wide",
parsePatterns: parseMonthPatterns,
defaultParseWidth: "any"
}),
day: buildMatchFn({
matchPatterns: matchDayPatterns,
defaultMatchWidth: "wide",
parsePatterns: parseDayPatterns,
defaultParseWidth: "any"
}),
dayPeriod: buildMatchFn({
matchPatterns: matchDayPeriodPatterns,
defaultMatchWidth: "any",
parsePatterns: parseDayPeriodPatterns,
defaultParseWidth: "any"
})
};
const enUS = {
code: "en-US",
formatDistance,
formatLong,
formatRelative,
localize,
match,
options: {
weekStartsOn: 0,
firstWeekContainsDate: 1
}
};
const dateLongFormatter = (pattern, formatLong2) => {
switch (pattern) {
case "P":
return formatLong2.date({ width: "short" });
case "PP":
return formatLong2.date({ width: "medium" });
case "PPP":
return formatLong2.date({ width: "long" });
case "PPPP":
default:
return formatLong2.date({ width: "full" });
}
};
const timeLongFormatter = (pattern, formatLong2) => {
switch (pattern) {
case "p":
return formatLong2.time({ width: "short" });
case "pp":
return formatLong2.time({ width: "medium" });
case "ppp":
return formatLong2.time({ width: "long" });
case "pppp":
default:
return formatLong2.time({ width: "full" });
}
};
const dateTimeLongFormatter = (pattern, formatLong2) => {
const matchResult = pattern.match(/(P+)(p+)?/) || [];
const datePattern = matchResult[1];
const timePattern = matchResult[2];
if (!timePattern) {
return dateLongFormatter(pattern, formatLong2);
}
let dateTimeFormat;
switch (datePattern) {
case "P":
dateTimeFormat = formatLong2.dateTime({ width: "short" });
break;
case "PP":
dateTimeFormat = formatLong2.dateTime({ width: "medium" });
break;
case "PPP":
dateTimeFormat = formatLong2.dateTime({ width: "long" });
break;
case "PPPP":
default:
dateTimeFormat = formatLong2.dateTime({ width: "full" });
break;
}
return dateTimeFormat.replace("{{date}}", dateLongFormatter(datePattern, formatLong2)).replace("{{time}}", timeLongFormatter(timePattern, formatLong2));
};
const longFormatters = {
p: timeLongFormatter,
P: dateTimeLongFormatter
};
const dayOfYearTokenRE = /^D+$/;
const weekYearTokenRE = /^Y+$/;
const throwTokens = ["D", "DD", "YY", "YYYY"];
function isProtectedDayOfYearToken(token) {
return dayOfYearTokenRE.test(token);
}
function isProtectedWeekYearToken(token) {
return weekYearTokenRE.test(token);
}
function warnOrThrowProtectedError(token, format, input) {
const _message = message(token, format, input);
console.warn(_message);
if (throwTokens.includes(token)) throw new RangeError(_message);
}
function message(token, format, input) {
const subject = token[0] === "Y" ? "years" : "days of the month";
return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
}
const millisecondsInWeek = 6048e5;
const millisecondsInMinute = 6e4;
const millisecondsInHour = 36e5;
const millisecondsInSecond = 1e3;
const constructFromSymbol = /* @__PURE__ */ Symbol.for("constructDateFrom");
function constructFrom(date, value) {
if (typeof date === "function") return date(value);
if (date && typeof date === "object" && constructFromSymbol in date)
return date[constructFromSymbol](value);
if (date instanceof Date) return new date.constructor(value);
return new Date(value);
}
let defaultOptions = {};
function getDefaultOptions$1() {
return defaultOptions;
}
function getDefaultOptions() {
return Object.assign({}, getDefaultOptions$1());
}
function toDate(argument, context) {
return constructFrom(context || argument, argument);
}
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 {
subPriority = 0;
validate(_utcDate, _options) {
return true;
}
}
class ValueSetter extends Setter {
constructor(value, validateValue, setValue, priority, subPriority) {
super();
this.value = value;
this.validateValue = validateValue;
this.setValue = setValue;
this.priority = priority;
if (subPriority) {
this.subPriority = subPriority;
}
}
validate(date, options) {
return this.validateValue(date, this.value, options);
}
set(date, flags, options) {
return this.setValue(date, flags, this.value, options);
}
}
class DateTimezoneSetter extends Setter {
priority = TIMEZONE_UNIT_PRIORITY;
subPriority = -1;
constructor(context, reference) {
super();
this.context = context || ((date) => constructFrom(reference, date));
}
set(date, flags) {
if (flags.timestampIsSet) return date;
return constructFrom(date, transpose(date, this.context));
}
}
class Parser {
run(dateString, token, match2, options) {
const result = this.parse(dateString, token, match2, 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 {
priority = 140;
parse(dateString, token, match2) {
switch (token) {
// AD, BC
case "G":
case "GG":
case "GGG":
return match2.era(dateString, { width: "abbreviated" }) || match2.era(dateString, { width: "narrow" });
// A, B
case "GGGGG":
return match2.era(dateString, { width: "narrow" });
// Anno Domini, Before Christ
case "GGGG":
default:
return match2.era(dateString, { width: "wide" }) || match2.era(dateString, { width: "abbreviated" }) || match2.era(dateString, { width: "narrow" });
}
}
set(date, flags, value) {
flags.era = value;
date.setFullYear(value, 0, 1);
date.setHours(0, 0, 0, 0);
return date;
}
incompatibleTokens = ["R", "u", "t", "T"];
}
const numericPatterns = {
month: /^(1[0-2]|0?\d)/,
// 0 to 12
date: /^(3[0-1]|[0-2]?\d)/,
// 0 to 31
dayOfYear: /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/,
// 0 to 366
week: /^(5[0-3]|[0-4]?\d)/,
// 0 to 53
hour23h: /^(2[0-3]|[0-1]?\d)/,
// 0 to 23
hour24h: /^(2[0-4]|[0-1]?\d)/,
// 0 to 24
hour11h: /^(1[0-1]|0?\d)/,
// 0 to 11
hour12h: /^(1[0-2]|0?\d)/,
// 0 to 12
minute: /^[0-5]?\d/,
// 0 to 59
second: /^[0-5]?\d/,
// 0 to 59
singleDigit: /^\d/,
// 0 to 9
twoDigits: /^\d{1,2}/,
// 0 to 99
threeDigits: /^\d{1,3}/,
// 0 to 999
fourDigits: /^\d{1,4}/,
// 0 to 9999
anyDigitsSigned: /^-?\d+/,
singleDigitSigned: /^-?\d/,
// 0 to 9, -0 to -9
twoDigitsSigned: /^-?\d{1,2}/,
// 0 to 99, -0 to -99
threeDigitsSigned: /^-?\d{1,3}/,
// 0 to 999, -0 to -999
fourDigitsSigned: /^-?\d{1,4}/
// 0 to 9999, -0 to -9999
};
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;
}
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;
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(year) {
return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
}
class YearParser extends Parser {
priority = 130;
incompatibleTokens = ["Y", "R", "u", "w", "I", "i", "e", "c", "t", "T"];
parse(dateString, token, match2) {
const valueCallback = (year) => ({
year,
isTwoDigitYear: token === "yy"
});
switch (token) {
case "y":
return mapValue(parseNDigits(4, dateString), valueCallback);
case "yo":
return mapValue(
match2.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;
}
}
function startOfWeek(date, options) {
const defaultOptions2 = getDefaultOptions$1();
const weekStartsOn = options?.weekStartsOn ?? options?.locale?.options?.weekStartsOn ?? defaultOptions2.weekStartsOn ?? defaultOptions2.locale?.options?.weekStartsOn ?? 0;
const _date = toDate(date, options?.in);
const day = _date.getDay();
const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
_date.setDate(_date.getDate() - diff);
_date.setHours(0, 0, 0, 0);
return _date;
}
function getWeekYear(date, options) {
const _date = toDate(date, options?.in);
const year = _date.getFullYear();
const defaultOptions2 = getDefaultOptions$1();
const firstWeekContainsDate = options?.firstWeekContainsDate ?? options?.locale?.options?.firstWeekContainsDate ?? defaultOptions2.firstWeekContainsDate ?? defaultOptions2.locale?.options?.firstWeekContainsDate ?? 1;
const firstWeekOfNextYear = constructFrom(options?.in || date, 0);
firstWeekOfNextYear.setFullYear(year + 1, 0, firstWeekContainsDate);
firstWeekOfNextYear.setHours(0, 0, 0, 0);
const startOfNextYear = startOfWeek(firstWeekOfNextYear, options);
const firstWeekOfThisYear = constructFrom(options?.in || date, 0);
firstWeekOfThisYear.setFullYear(year, 0, firstWeekContainsDate);
firstWeekOfThisYear.setHours(0, 0, 0, 0);
const startOfThisYear = startOfWeek(firstWeekOfThisYear, options);
if (+_date >= +startOfNextYear) {
return year + 1;
} else if (+_date >= +startOfThisYear) {
return year;
} else {
return year - 1;
}
}
class LocalWeekYearParser extends Parser {
priority = 130;
parse(dateString, token, match2) {
const valueCallback = (year) => ({
year,
isTwoDigitYear: token === "YY"
});
switch (token) {
case "Y":
return mapValue(parseNDigits(4, dateString), valueCallback);
case "Yo":
return mapValue(
match2.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);
}
incompatibleTokens = [
"y",
"R",
"u",
"Q",
"q",
"M",
"L",
"I",
"d",
"D",
"i",
"t",
"T"
];
}
function startOfISOWeek(date, options) {
return startOfWeek(date, { ...options, weekStartsOn: 1 });
}
class ISOWeekYearParser extends Parser {
priority = 130;
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);
}
incompatibleTokens = [
"G",
"y",
"Y",
"u",
"Q",
"q",
"M",
"L",
"w",
"d",
"D",
"e",
"c",
"t",
"T"
];
}
class ExtendedYearParser extends Parser {
priority = 130;
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;
}
incompatibleTokens = ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"];
}
class QuarterParser extends Parser {
priority = 120;
parse(dateString, token, match2) {
switch (token) {
// 1, 2, 3, 4
case "Q":
case "QQ":
return parseNDigits(token.length, dateString);
// 1st, 2nd, 3rd, 4th
case "Qo":
return match2.ordinalNumber(dateString, { unit: "quarter" });
// Q1, Q2, Q3, Q4
case "QQQ":
return match2.quarter(dateString, {
width: "abbreviated",
context: "formatting"
}) || match2.quarter(dateString, {
width: "narrow",
context: "formatting"
});
// 1, 2, 3, 4 (narrow quarter; could be not numerical)
case "QQQQQ":
return match2.quarter(dateString, {
width: "narrow",
context: "formatting"
});
// 1st quarter, 2nd quarter, ...
case "QQQQ":
default:
return match2.quarter(dateString, {
width: "wide",
context: "formatting"
}) || match2.quarter(dateString, {
width: "abbreviated",
context: "formatting"
}) || match2.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;
}
incompatibleTokens = [
"Y",
"R",
"q",
"M",
"L",
"w",
"I",
"d",
"D",
"i",
"e",
"c",
"t",
"T"
];
}
class StandAloneQuarterParser extends Parser {
priority = 120;
parse(dateString, token, match2) {
switch (token) {
// 1, 2, 3, 4
case "q":
case "qq":
return parseNDigits(token.length, dateString);
// 1st, 2nd, 3rd, 4th
case "qo":
return match2.ordinalNumber(dateString, { unit: "quarter" });
// Q1, Q2, Q3, Q4
case "qqq":
return match2.quarter(dateString, {
width: "abbreviated",
context: "standalone"
}) || match2.quarter(dateString, {
width: "narrow",
context: "standalone"
});
// 1, 2, 3, 4 (narrow quarter; could be not numerical)
case "qqqqq":
return match2.quarter(dateString, {
width: "narrow",
context: "standalone"
});
// 1st quarter, 2nd quarter, ...
case "qqqq":
default:
return match2.quarter(dateString, {
width: "wide",
context: "standalone"
}) || match2.quarter(dateString, {
width: "abbreviated",
context: "standalone"
}) || match2.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;
}
incompatibleTokens = [
"Y",
"R",
"Q",
"M",
"L",
"w",
"I",
"d",
"D",
"i",
"e",
"c",
"t",
"T"
];
}
class MonthParser extends Parser {
incompatibleTokens = [
"Y",
"R",
"q",
"Q",
"L",
"w",
"I",
"D",
"i",
"e",
"c",
"t",
"T"
];
priority = 110;
parse(dateString, token, match2) {
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(
match2.ordinalNumber(dateString, {
unit: "month"
}),
valueCallback
);
// Jan, Feb, ..., Dec
case "MMM":
return match2.month(dateString, {
width: "abbreviated",
context: "formatting"
}) || match2.month(dateString, { width: "narrow", context: "formatting" });
// J, F, ..., D
case "MMMMM":
return match2.month(dateString, {
width: "narrow",
context: "formatting"
});
// January, February, ..., December
case "MMMM":
default:
return match2.month(dateString, { width: "wide", context: "formatting" }) || match2.month(dateString, {
width: "abbreviated",
context: "formatting"
}) || match2.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;
}
}
class StandAloneMonthParser extends Parser {
priority = 110;
parse(dateString, token, match2) {
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(
match2.ordinalNumber(dateString, {
unit: "month"
}),
valueCallback
);
// Jan, Feb, ..., Dec
case "LLL":
return match2.month(dateString, {
width: "abbreviated",
context: "standalone"
}) || match2.month(dateString, { width: "narrow", context: "standalone" });
// J, F, ..., D
case "LLLLL":
return match2.month(dateString, {
width: "narrow",
context: "standalone"
});
// January, February, ..., December
case "LLLL":
default:
return match2.month(dateString, { width: "wide", context: "standalone" }) || match2.month(dateString, {
width: "abbreviated",
context: "standalone"
}) || match2.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;
}
incompatibleTokens = [
"Y",
"R",
"q",
"Q",
"M",
"w",
"I",
"D",
"i",
"e",
"c",
"t",
"T"
];
}
function startOfWeekYear(date, options) {
const defaultOptions2 = getDefaultOptions$1();
const firstWeekContainsDate = options?.firstWeekContainsDate ?? options?.locale?.options?.firstWeekContainsDate ?? defaultOptions2.firstWeekContainsDate ?? defaultOptions2.locale?.options?.firstWeekContainsDate ?? 1;
const year = getWeekYear(date, options);
const firstWeek = constructFrom(options?.in || date, 0);
firstWeek.setFullYear(year, 0, firstWeekContainsDate);
firstWeek.setHours(0, 0, 0, 0);
const _date = startOfWeek(firstWeek, options);
return _date;
}
function getWeek(date, options) {
const _date = toDate(date, options?.in);
const diff = +startOfWeek(_date, options) - +startOfWeekYear(_date, options);
return Math.round(diff / millisecondsInWeek) + 1;
}
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);
}
class LocalWeekParser extends Parser {
priority = 100;
parse(dateString, token, match2) {
switch (token) {
case "w":
return parseNumericPattern(numericPatterns.week, dateString);
case "wo":
return match2.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);
}
incompatibleTokens = [
"y",
"R",
"u",
"q",
"Q",
"M",
"L",
"I",
"d",
"D",
"i",
"t",
"T"
];
}
function getISOWeekYear(date, options) {
const _date = toDate(date, options?.in);
const year = _date.getFullYear();
const fourthOfJanuaryOfNextYear = constructFrom(_date, 0);
fourthOfJanuaryOfNextYear.setFullYear(year + 1, 0, 4);
fourthOfJanuaryOfNextYear.setHours(0, 0, 0, 0);
const startOfNextYear = startOfISOWeek(fourthOfJanuaryOfNextYear);
const fourthOfJanuaryOfThisYear = constructFrom(_date, 0);
fourthOfJanuaryOfThisYear.setFullYear(year, 0, 4);
fourthOfJanuaryOfThisYear.setHours(0, 0, 0, 0);
const startOfThisYear = startOfISOWeek(fourthOfJanuaryOfThisYear);
if (_date.getTime() >= startOfNextYear.getTime()) {
return year + 1;
} else if (_date.getTime() >= startOfThisYear.getTime()) {
return year;
} else {
return year - 1;
}
}
function startOfISOWeekYear(date, options) {
const year = getISOWeekYear(date, options);
const fourthOfJanuary = constructFrom(date, 0);
fourthOfJanuary.setFullYear(year, 0, 4);
fourthOfJanuary.setHours(0, 0, 0, 0);
return startOfISOWeek(fourthOfJanuary);
}
function getISOWeek(date, options) {
const _date = toDate(date, options?.in);
const diff = +startOfISOWeek(_date) - +startOfISOWeekYear(_date);
return Math.round(diff / millisecondsInWeek) + 1;
}
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;
}
class ISOWeekParser extends Parser {
priority = 100;
parse(dateString, token, match2) {
switch (token) {
case "I":
return parseNumericPattern(numericPatterns.week, dateString);
case "Io":
return match2.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));
}
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
];
class DateParser extends Parser {
priority = 90;
subPriority = 1;
parse(dateString, token, match2) {
switch (token) {
case "d":
return parseNumericPattern(numericPatterns.date, dateString);
case "do":
return match2.ordinalNumber(dateString, { unit: "date" });
default:
return parseNDigits(token.length, dateString);
}
}
validate(date, value) {
const year = date.getFullYear();
const isLeapYear = isLeapYearIndex(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;
}
incompatibleTokens = [
"Y",
"R",
"q",
"Q",
"w",
"I",
"D",
"i",
"e",
"c",
"t",
"T"
];
}
class DayOfYearParser extends Parser {
priority = 90;
subpriority = 1;
parse(dateString, token, match2) {
switch (token) {
case "D":
case "DD":
return parseNumericPattern(numericPatterns.dayOfYear, dateString);
case "Do":
return match2.ordinalNumber(dateString, { unit: "date" });
default:
return parseNDigits(token.length, dateString);
}
}
validate(date, value) {
const year = date.getFullYear();
const isLeapYear = isLeapYearIndex(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;
}
incompatibleTokens = [
"Y",
"R",
"q",
"Q",
"M",
"L",
"w",
"I",
"d",
"E",
"i",
"e",
"c",
"t",
"T"
];
}
function addDays(date, amount, options) {
const _date = toDate(date, options?.in);
if (isNaN(amount)) return constructFrom(options?.in || date, NaN);
if (!amount) return _date;
_date.setDate(_date.getDate() + amount);
return _date;
}
function setDay(date, day, options) {
const defaultOptions2 = getDefaultOptions$1();
const weekStartsOn = options?.weekStartsOn ?? options?.locale?.options?.weekStartsOn ?? defaultOptions2.weekStartsOn ?? defaultOptions2.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);
}
class DayParser extends Parser {
priority = 90;
parse(dateString, token, match2) {
switch (token) {
// Tue
case "E":
case "EE":
case "EEE":
return match2.day(dateString, {
width: "abbreviated",
context: "formatting"
}) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
// T
case "EEEEE":
return match2.day(dateString, {
width: "narrow",
context: "formatting"
});
// Tu
case "EEEEEE":
return match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
// Tuesday
case "EEEE":
default:
return match2.day(dateString, { width: "wide", context: "formatting" }) || match2.day(dateString, {
width: "abbreviated",
context: "formatting"
}) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.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;
}
incompatibleTokens = ["D", "i", "e", "c", "t", "T"];
}
class LocalDayParser extends Parser {
priority = 90;
parse(dateString, token, match2, options) {
const valueCallback = (value) => {
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(
match2.ordinalNumber(dateString, {
unit: "day"
}),
valueCallback
);
// Tue
case "eee":
return match2.day(dateString, {
width: "abbreviated",
context: "formatting"
}) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
// T
case "eeeee":
return match2.day(dateString, {
width: "narrow",
context: "formatting"
});
// Tu
case "eeeeee":
return match2.day(dateString, { width: "short", context: "formatting" }) || match2.day(dateString, { width: "narrow", context: "formatting" });
// Tuesday
case "eeee":
default:
return match2.day(dateString, { width: "wide", context: "formatting" }) || match2.day(dateString, {
width: "abbreviated",
context: "formatting"
}) || match2.day(dateString, { width: "short", context: "formatting" }) || match2.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;
}
incompatibleTokens = [
"y",
"R",
"u",
"q",
"Q",
"M",
"L",
"I",
"d",
"D",
"E",
"i",
"c",
"t",
"T"
];
}
class StandAloneLocalDayParser extends Parser {
priority = 90;
parse(dateString, token, match2, options) {
const valueCallback = (value) => {
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(
match2.ordinalNumber(dateString, {
unit: "day"
}),
valueCallback
);
// Tue
case "ccc":
return match2.day(dateString, {
width: "abbreviated",
context: "standalone"
}) || match2.day(dateString, { width: "short", context: "standalone" }) || match2.day(dateString, { width: "narrow", context: "standalone" });
// T
case "ccccc":
return match2.day(dateString, {
width: "narrow",
context: "standalone"
});
// Tu
case "cccccc":
return match2.day(dateString, { width: "short", context: "standalone" }) || match2.day(dateString, { width: "narrow", context: "standalone" });
// Tuesday
case "cccc":
default:
return match2.day(dateString, { width: "wide", context: "standalone" }) || match2.day(dateString, {
width: "abbreviated",
context: "standalone"
}) || match2.day(dateString, { width: "short", context: "standalone" }) || match2.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;
}
incompatibleTokens = [
"y",
"R",
"u",
"q",
"Q",
"M",
"L",
"I",
"d",
"D",
"E",
"i",
"e",
"t",
"T"
];
}
function getISODay(date, options) {
const day = toDate(date, options?.in).getDay();
return day === 0 ? 7 : day;
}
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);
}
class ISODayParser extends Parser {
priority = 90;
parse(dateString, token, match2) {
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 match2.ordinalNumber(dateString, { unit: "day" });
// Tue
case "iii":
return mapValue(
match2.day(dateString, {
width: "abbreviated",
context: "formatting"
}) || match2.day(dateString, {
width: "short",
context: "formatting"
}) || match2.day(dateString, {
width: "narrow",
context: "formatting"
}),
valueCallback
);
// T
case "iiiii":
return mapValue(
match2.day(dateString, {
width: "narrow",
context: "formatting"
}),
valueCallback
);
// Tu
case "iiiiii":
return mapValue(
match2.day(dateString, {
width: "short",
context: "formatting"
}) || match2.day(dateString, {
width: "narrow",
context: "formatting"
}),
valueCallback
);
// Tuesday
case "iiii":
default:
return mapValue(
match2.day(dateString, {
width: "wide",
context: "formatting"
}) || match2.day(dateString, {
width: "abbreviated",
context: "formatting"
}) || match2.day(dateString, {
width: "short",
context: "formatting"
}) || match2.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;
}
incompatibleTokens = [
"y",
"Y",
"u",
"q",
"Q",
"M",
"L",
"w",
"d",
"D",
"E",
"e",
"c",
"t",
"T"
];
}
class AMPMParser extends Parser {
priority = 80;
parse(dateString, token, match2) {
switch (token) {
case "a":
case "aa":
case "aaa":
return match2.dayPeriod(dateString, {
width: "abbreviated",
context: "formatting"
}) || match2.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
case "aaaaa":
return match2.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
case "aaaa":
default:
return match2.dayPeriod(dateString, {
width: "wide",
context: "formatting"
}) || match2.dayPeriod(dateString, {
width: "abbreviated",
context: "formatting"
}) || match2.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
}
}
set(date, _flags, value) {
date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
return date;
}
incompatibleTokens = ["b", "B", "H", "k", "t", "T"];
}
class AMPMMidnightParser extends Parser {
priority = 80;
parse(dateString, token, match2) {
switch (token) {
case "b":
case "bb":
case "bbb":
return match2.dayPeriod(dateString, {
width: "abbreviated",
context: "formatting"
}) || match2.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
case "bbbbb":
return match2.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
case "bbbb":
default:
return match2.dayPeriod(dateString, {
width: "wide",
context: "formatting"
}) || match2.dayPeriod(dateString, {
width: "abbreviated",
context: "formatting"
}) || match2.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
}
}
set(date, _flags, value) {
date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
return date;
}
incompatibleTokens = ["a", "B", "H", "k", "t", "T"];
}
class DayPeriodParser extends Parser {
priority = 80;
parse(dateString, token, match2) {
switch (token) {
case "B":
case "BB":
case "BBB":
return match2.dayPeriod(dateString, {
width: "abbreviated",
context: "formatting"
}) || match2.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
case "BBBBB":
return match2.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
case "BBBB":
default:
return match2.dayPeriod(dateString, {
width: "wide",
context: "formatting"
}) || match2.dayPeriod(dateString, {
width: "abbreviated",
context: "formatting"
}) || match2.dayPeriod(dateString, {
width: "narrow",
context: "formatting"
});
}
}
set(date, _flags, value) {
date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
return date;
}
incompatibleTokens = ["a", "b", "t", "T"];
}
class Hour1to12Parser extends Parser {
priority = 70;
parse(dateString, token, match2) {
switch (token) {
case "h":
return parseNumericPattern(numericPatterns.hour12h, dateString);
case "ho":
return match2.ordinalNumber(dateString, { unit: "hour" });
default:
return parseNDigits(token.length, dateString);
}
}
validate(_date, value) {
return value >= 1 && value <= 12;
}
set(date, _flags, value) {
const isPM = date.getHours() >= 12;
if (isPM && value < 12) {
date.setHours(value + 12, 0, 0, 0);
} else if (!isPM && value === 12) {
date.setHours(0, 0, 0, 0);
} else {
date.setHours(value, 0, 0, 0);
}
return date;
}
incompatibleTokens = ["H", "K", "k", "t", "T"];
}
class Hour0to23Parser extends Parser {
priority = 70;
parse(dateString, token, match2) {
switch (token) {
case "H":
return parseNumericPattern(numericPatterns.hour23h, dateString);
case "Ho":
return match2.ordinalNumber(dateString, { unit: "hour" });
default:
return parseNDigits(token.length, dateString);
}
}
validate(_date, value) {
return value >= 0 && value <= 23;
}
set(date, _flags, value) {
date.setHours(value, 0, 0, 0);
return date;
}
incompatibleTokens = ["a", "b", "h", "K", "k", "t", "T"];
}
class Hour0To11Parser extends Parser {
priority = 70;
parse(dateString, token, match2) {
switch (token) {
case "K":
return parseNumericPattern(numericPatterns.hour11h, dateString);
case "Ko":
return match2.ordinalNumber(dateString, { unit: "hour" });
default:
return parseNDigits(token.length, dateString);
}
}
validate(_date, value) {
return value >= 0 && value <= 11;
}
set(date, _flags, value) {
const isPM = date.getHours() >= 12;
if (isPM && value < 12) {
date.setHours(value + 12, 0, 0, 0);
} else {
date.setHours(value, 0, 0, 0);
}
return date;
}
incompatibleTokens = ["h", "H", "k", "t", "T"];
}
class Hour1To24Parser extends Parser {
priority = 70;
parse(dateString, token, match2) {
switch (token) {
case "k":
return parseNumericPattern(numericPatterns.hour24h, dateString);
case "ko":
return match2.ordinalNumber(dateString, { unit: "hour" });
default:
return parseNDigits(token.length, dateString);
}
}
validate(_date, value) {
return value >= 1 && value <= 24;
}
set(date, _flags, value) {
const hours = value <= 24 ? value % 24 : value;
date.setHours(hours, 0, 0, 0);
return date;
}
incompatibleTokens = ["a", "b", "h", "H", "K", "t", "T"];
}
class MinuteParser extends Parser {
priority = 60;
parse(dateString, token, match2) {
switch (token) {
case "m":
return parseNumericPattern(numericPatterns.minute, dateString);
case "mo":
return match2.ordinalNumber(dateString, { unit: "minute" });
default:
return parseNDigits(token.length, dateString);
}
}
validate(_date, value) {
return value >= 0 && value <= 59;
}
set(date, _flags, value) {
date.setMinutes(value, 0, 0);
return date;
}
incompatibleTokens = ["t", "T"];
}
class SecondParser extends Parser {
priority = 50;
parse(dateString, token, match2) {
switch (token) {
case "s":
return parseNumericPattern(numericPatterns.second, dateString);
case "so":
return match2.ordinalNumber(dateString, { unit: "second" });
default:
return parseNDigits(token.length, dateString);
}
}
validate(_date, value) {
return value >= 0 && value <= 59;
}
set(date, _flags, value) {
date.setSeconds(value, 0);
return date;
}
incompatibleTokens = ["t", "T"];
}
class FractionOfSecondParser extends Parser {
priority = 30;
parse(dateString, token) {
const valueCallback = (value) => Math.trunc(value * Math.pow(10, -token.length + 3));
return mapValue(parseNDigits(token.length, dateString), valueCallback);
}
set(date, _flags, value) {
date.setMilliseconds(value);
return date;
}
incompatibleTokens = ["t", "T"];
}
function getTimezoneOffsetInMilliseconds(date) {
const _date = toDate(date);
const utcDate = new Date(
Date.UTC(
_date.getFullYear(),
_date.getMonth(),
_date.getDate(),
_date.getHours(),
_date.getMinutes(),
_date.getSeconds(),
_date.getMilliseconds()
)
);
utcDate.setUTCFullYear(_date.getFullYear());
return +date - +utcDate;
}
class ISOTimezoneWithZParser extends Parser {
priority = 10;
parse(dateString, token) {
switch (token) {
case "X":
return parseTimezonePattern(
timezonePatterns.basicOptionalMinutes,
dateString
);
case "XX":
return parseTimezonePattern(timezonePatterns.basic, dateString);
case "XXXX":
return parseTimezonePattern(
timezonePatterns.basicOptionalSeconds,
dateString
);
case "XXXXX":
return parseTimezonePattern(
timezonePatterns.extendedOptionalSeconds,
dateString
);
case "XXX":
default:
return parseTimezonePattern(timezonePatterns.extended, dateString);
}
}
set(date, flags, value) {
if (flags.timestampIsSet) return date;
return constructFrom(
date,
date.getTime() - getTimezoneOffsetInMilliseconds(date) - value
);
}
incompatibleTokens = ["t", "T", "x"];
}
class ISOTimezoneParser extends Parser {
priority = 10;
parse(dateString, token) {
switch (token) {
case "x":
return parseTimezonePattern(
timezonePatterns.basicOptionalMinutes,
dateString
);
case "xx":
return parseTimezonePattern(timezonePatterns.basic, dateString);
case "xxxx":
return parseTimezonePattern(
timezonePatterns.basicOptionalSeconds,
dateString
);
case "xxxxx":
return parseTimezonePattern(
timezonePatterns.extendedOptionalSeconds,
dateString
);
case "xxx":
default:
return parseTimezonePattern(timezonePatterns.extended, dateString);
}
}
set(date, flags, value) {
if (flags.timestampIsSet) return date;
return constructFrom(
date,
date.getTime() - getTimezoneOffsetInMilliseconds(date) - value
);
}
incompatibleTokens = ["t", "T", "X"];
}
class TimestampSecondsParser extends Parser {
priority = 40;
parse(dateString) {
return parseAnyDigitsSigned(dateString);
}
set(date, _flags, value) {
return [constructFrom(date, value * 1e3), { timestampIsSet: true }];
}
incompatibleTokens = "*";
}
class TimestampMillisecondsParser extends Parser {
priority = 20;
parse(dateString) {
return parseAnyDigitsSigned(dateString);
}
set(date, _flags, value) {
return [constructFrom(date, value), { timestampIsSet: true }];
}
incompatibleTokens = "*";
}
const parsers = {
G: new EraParser(),
y: new YearParser(),
Y: new LocalWeekYearParser(),
R: new ISOWeekYearParser(),
u: new ExtendedYearParser(),
Q: new QuarterParser(),
q: new StandAloneQuarterParser(),
M: new MonthParser(),
L: new StandAloneMonthParser(),
w: new LocalWeekParser(),
I: new ISOWeekParser(),
d: new DateParser(),
D: new DayOfYearParser(),
E: new DayParser(),
e: new LocalDayParser(),
c: new StandAloneLocalDayParser(),
i: new ISODayParser(),
a: new AMPMParser(),
b: new AMPMMidnightParser(),
B: new DayPeriodParser(),
h: new Hour1to12Parser(),
H: new Hour0to23Parser(),
K: new Hour0To11Parser(),
k: new Hour1To24Parser(),
m: new MinuteParser(),
s: new SecondParser(),
S: new FractionOfSecondParser(),
X: new ISOTimezoneWithZParser(),
x: new ISOTimezoneParser(),
t: new TimestampSecondsParser(),
T: new TimestampMillisecondsParser()
};
const formattingTokensRegExp = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
const longFormattingTokensRegExp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
const escapedStringRegExp = /^'([^]*?)'?$/;
const doubleQuoteRegExp = /''/g;
const notWhitespaceRegExp = /\S/;
const unescapedLatinCharacterRegExp = /[a-zA-Z]/;
function parse(dateStr, formatStr, referenceDate, options) {
const invalidDate = () => constructFrom(options?.in || referenceDate, NaN);
const defaultOptions2 = getDefaultOptions();
const locale = options?.locale ?? defaultOptions2.locale ?? enUS;
const firstWeekContainsDate = options?.firstWeekContainsDate ?? options?.locale?.options?.firstWeekContainsDate ?? defaultOptions2.firstWeekContainsDate ?? defaultOptions2.locale?.options?.firstWeekContainsDate ?? 1;
const weekStartsOn = options?.weekStartsOn ?? options?.locale?.options?.weekStartsOn ?? defaultOptions2.weekStartsOn ?? defaultOptions2.locale?.options?.weekStartsOn ?? 0;
if (!formatStr)
return dateStr ? invalidDate() : toDate(referenceDate, options?.in);
const subFnOptions = {
firstWeekContainsDate,
weekStartsOn,
locale
};
const setters = [new DateTimezoneSetter(options?.in, referenceDate)];
const tokens = formatStr.match(longFormattingTokensRegExp).map((substring) => {
const firstCharacter = substring[0];
if (firstCharacter in longFormatters) {
const longFormatter = longFormatters[firstCharacter];
return longFormatter(substring, locale.formatLong);
}
return substring;
}).join("").match(formattingTokensRegExp);
const usedTokens = [];
for (let token of tokens) {
if (!options?.useAdditionalWeekYearTokens && isProtectedWeekYearToken(token)) {
warnOrThrowProtectedError(token, formatStr, dateStr);
}
if (!options?.useAdditionalDayOfYearTokens && isProtectedDayOfYearToken(token)) {
warnOrThrowProtectedError(token, formatStr, dateStr);
}
const firstCharacter = token[0];
const parser = parsers[firstCharacter];
if (parser) {
const { incompatibleTokens } = parser;
if (Array.isArray(incompatibleTokens)) {
const incompatibleToken = usedTokens.find(
(usedToken) => incompatibleTokens.includes(usedToken.token) || usedToken.token === firstCharacter
);
if (incompatibleToken) {
throw new RangeError(
`The format string mustn't contain \`${incompatibleToken.fullToken}\` and \`${token}\` at the same time`
);
}
} else if (parser.incompatibleTokens === "*" && usedTokens.length > 0) {
throw new RangeError(
`The format string mustn't contain \`${token}\` and any other token at the same time`
);
}
usedTokens.push({ token: firstCharacter, fullToken: token });
const parseResult = parser.run(
dateStr,
token,
locale.match,
subFnOptions
);
if (!parseResult) {
return invalidDate();
}
setters.push(parseResult.setter);
dateStr = parseResult.rest;
} else {
if (firstCharacter.match(unescapedLatinCharacterRegExp)) {
throw new RangeError(
"Format string contains an unescaped latin alphabet character `" + firstCharacter + "`"
);
}
if (token === "''") {
token = "'";
} else if (firstCharacter === "'") {
token = cleanEscapedString(token);
}
if (dateStr.indexOf(token) === 0) {
dateStr = dateStr.slice(token.length);
} else {
return invalidDate();
}
}
}
if (dateStr.length > 0 && notWhitespaceRegExp.test(dateStr)) {
return invalidDate();
}
const uniquePrioritySetters = setters.map((setter) => setter.priority).sort((a, b) => b - a).filter((priority, index, array) => array.indexOf(priority) === index).map(
(priority) => setters.filter((setter) => setter.priority === priority).sort((a, b) => b.subPriority - a.subPriority)
).map((setterArray) => setterArray[0]);
let date = toDate(referenceDate, options?.in);
if (isNaN(+date)) return invalidDate();
const flags = {};
for (const setter of uniquePrioritySetters) {
if (!setter.validate(date, subFnOptions)) {
return invalidDate();
}
const result = setter.set(date, flags, subFnOptions);
if (Array.isArray(result)) {
date = result[0];
Object.assign(flags, result[1]);
} else {
date = result;
}
}
return date;
}
function cleanEscapedString(input) {
return input.match(escapedStringRegExp)[1].replace(doubleQuoteRegExp, "'");
}
register(t14);
function getDateFormat(locale) {
if (locale.code.split("-")[0] === "de") {
return "P";
}
return "PP";
}
function getTimeFormat() {
return "p";
}
function getDateTimeFormat(locale) {
return getDateFormat(locale) + getTimeFormat();
}
function getWeekFormat() {
return "RRRR-II";
}
function getMonthFormat(locale) {
return guessFormat(locale.code, true);
}
function getYearFormat(locale) {
return guessFormat(locale.code, false);
}
function guessFormat(localeCode, includeMonth) {
const sampleDate = new Date(2026, 0, 1);
const formatOptions = {
year: "numeric",
// Specify because other calendar systems are not supported
calendar: "gregory"
};
if (includeMonth) {
formatOptions.month = "2-digit";
}
const formatter = Intl.DateTimeFormat(localeCode, formatOptions);
const parts = formatter.formatToParts(sampleDate);
const partStrings = parts.map((part) => {
switch (part.type) {
case "month":
return "MM";
case "year":
return "yyyy";
case "literal":
return escapeLiteraForFormatString(part.value);
// Everything else is not expected and supported.
default:
return "";
}
});
return partStrings.join("");
}
function escapeLiteraForFormatString(literalValue) {
literalValue = literalValue.replaceAll(/'/g, "''");
return literalValue.replaceAll(/[A-Za-z]+/g, (latinCharSeq) => `'${latinCharSeq}'`);
}
const loader = {};
loader["af"] = async () => (await import("date-fns/locale/af")).af;
loader["ar-DZ"] = async () => (await import("date-fns/locale/ar-DZ")).arDZ;
loader["ar-EG"] = async () => (await import("date-fns/locale/ar-EG")).arEG;
loader["ar-MA"] = async () => (await import("date-fns/locale/ar-MA")).arMA;
loader["ar-SA"] = async () => (await import("date-fns/locale/ar-SA")).arSA;
loader["ar-TN"] = async () => (await import("date-fns/locale/ar-TN")).arTN;
loader["ar"] = async () => (await import("date-fns/locale/ar")).ar;
loader["az"] = async () => (await import("date-fns/locale/az")).az;
loader["be-tarask"] = async () => (await import("date-fns/locale/be-tarask")).beTarasak;
loader["be"] = async () => (await import("date-fns/locale/be")).be;
loader["bg"] = async () => (await import("date-fns/locale/bg")).bg;
loader["bn"] = async () => (await import("date-fns/locale/bn")).bn;
loader["bs"] = async () => (await import("date-fns/locale/bs")).bs;
loader["ca"] = async () => (await import("date-fns/locale/ca")).ca;
loader["ckb"] = async () => (await import("date-fns/locale/ckb")).ckb;
loader["cs"] = async () => (await import("date-fns/locale/cs")).cs;
loader["cy"] = async () => (await import("date-fns/locale/cy")).cy;
loader["da"] = async () => (await import("date-fns/locale/da")).da;
loader["de-AT"] = async () => (await import("date-fns/locale/de-AT")).deAT;
loader["de"] = async () => (await import("date-fns/locale/de")).de;
loader["el"] = async () => (await import("date-fns/locale/el")).el;
loader["en-AU"] = async () => (await import("date-fns/locale/en-AU")).enAU;
loader["en-CA"] = async () => (await import("date-fns/locale/en-CA")).enCA;
loader["en-GB"] = async () => (await import("date-fns/locale/en-GB")).enGB;
loader["en-IE"] = async () => (await import("date-fns/locale/en-IE")).enIE;
loader["en-IN"] = async () => (await import("date-fns/locale/en-IN")).enIN;
loader["en-NZ"] = async () => (await import("date-fns/locale/en-NZ")).enNZ;
loader["en-ZA"] = async () => (await import("date-fns/locale/en-ZA")).enZA;
loader["eo"] = async () => (await import("date-fns/locale/eo")).eo;
loader["es"] = async () => (await import("date-fns/locale/es")).es;
loader["et"] = async () => (await import("date-fns/locale/et")).et;
loader["eu"] = async () => (await import("date-fns/locale/eu")).eu;
loader["fa-IR"] = async () => (await import("date-fns/locale/fa-IR")).faIR;
loader["fi"] = async () => (await import("date-fns/locale/fi")).fi;
loader["fr-CA"] = async () => (await import("date-fns/locale/fr-CA")).frCA;
loader["fr-CH"] = async () => (await import("date-fns/locale/fr-CH")).frCH;
loader["fr"] = async () => (await import("date-fns/locale/fr")).fr;
loader["fy"] = async () => (await import("date-fns/locale/fy")).fy;
loader["gd"] = async () => (await import("date-fns/locale/gd")).gd;
loader["gl"] = async () => (await import("date-fns/locale/gl")).gl;
loader["gu"] = async () => (await import("date-fns/locale/gu")).gu;
loader["he"] = async () => (await import("date-fns/locale/he")).he;
loader["hi"] = async () => (await import("date-fns/locale/hi")).hi;
loader["hr"] = async () => (await import("date-fns/locale/hr")).hr;
loader["ht"] = async () => (await import("date-fns/locale/ht")).ht;
loader["hu"] = async () => (await import("date-fns/locale/hu")).hu;
loader["hy"] = async () => (await import("date-fns/locale/hy")).hy;
loader["id"] = async () => (await import("date-fns/locale/id")).id;
loader["is"] = async () => (await import("date-fns/locale/is")).is;
loader["it-CH"] = async () => (await import("date-fns/locale/it-CH")).itCH;
loader["it"] = async () => (await import("date-fns/locale/it")).it;
loader["ja-Hira"] = async () => (await import("date-fns/locale/ja-Hira")).jaHira;
loader["ja"] = async () => (await import("date-fns/locale/ja")).ja;
loader["ka"] = async () => (await import("date-fns/locale/ka")).ka;
loader["kk"] = async () => (await import("date-fns/locale/kk")).kk;
loader["km"] = async () => (await import("date-fns/locale/km")).km;
loader["kn"] = async () => (await import("date-fns/locale/kn")).kn;
loader["ko"] = async () => (await import("date-fns/locale/ko")).ko;
loader["lb"] = async () => (await import("date-fns/locale/lb")).lb;
loader["lt"] = async () => (await import("date-fns/locale/lt")).lt;
loader["lv"] = async () => (await import("date-fns/locale/lv")).lv;
loader["mk"] = async () => (await import("date-fns/locale/mk")).mk;
loader["mn"] = async () => (await import("date-fns/locale/mn")).mn;
loader["ms"] = async () => (await import("date-fns/locale/ms")).ms;
loader["mt"] = async () => (await import("date-fns/locale/mt")).mt;
loader["nb"] = async () => (await import("date-fns/locale/nb")).nb;
loader["nl-BE"] = async () => (await import("date-fns/locale/nl-BE")).nlBE;
loader["nl"] = async () => (await import("date-fns/locale/nl")).nl;
loader["nn"] = async () => (await import("date-fns/locale/nn")).nn;
loader["oc"] = async () => (await import("date-fns/locale/oc")).oc;
loader["pl"] = async () => (await import("date-fns/locale/pl")).pl;
loader["pt-BR"] = async () => (await import("date-fns/locale/pt-BR")).ptBR;
loader["pt"] = async () => (await import("date-fns/locale/pt")).pt;
loader["ro"] = async () => (await import("date-fns/locale/ro")).ro;
loader["ru"] = async () => (await import("date-fns/locale/ru")).ru;
loader["se"] = async () => (await import("date-fns/locale/se")).se;
loader["sk"] = async () => (await import("date-fns/locale/sk")).sk;
loader["sl"] = async () => (await import("date-fns/locale/sl")).sl;
loader["sq"] = async () => (await import("date-fns/locale/sq")).sq;
loader["sr-Latn"] = async () => (await import("date-fns/locale/sr-Latn")).srLatn;
loader["sr"] = async () => (await import("date-fns/locale/sr")).sr;
loader["sv"] = async () => (await import("date-fns/locale/sv")).sv;
loader["ta"] = async () => (await import("date-fns/locale/ta")).ta;
loader["te"] = async () => (await import("date-fns/locale/te")).te;
loader["th"] = async () => (await import("date-fns/locale/th")).th;
loader["tr"] = async () => (await import("date-fns/locale/tr")).tr;
loader["ug"] = async () => (await import("date-fns/locale/ug")).ug;
loader["uk"] = async () => (await import("date-fns/locale/uk")).uk;
loader["uz-Cyrl"] = async () => (await import("date-fns/locale/uz-Cyrl")).uzCyrl;
loader["uz"] = async () => (await import("date-fns/locale/uz")).uz;
loader["vi"] = async () => (await import("date-fns/locale/vi")).vi;
loader["zh-CN"] = async () => (await import("date-fns/locale/zh-CN")).zhCN;
loader["zh-HK"] = async () => (await import("date-fns/locale/zh-HK")).zhHK;
loader["zh-TW"] = async () => (await import("date-fns/locale/zh-TW")).zhTW;
/*!
* SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
*/
const FALLBACK_LOCALE = enUS$1;
let cachedLocale;
function useDateFnsLocale() {
const localeCode = getCanonicalLocale();
if (localeCode === FALLBACK_LOCALE.code) {
return {
isLoading: ref(false),
locale: ref(FALLBACK_LOCALE)
};
}
if (cachedLocale === void 0) {
cachedLocale = loadDateFnsLocale(localeCode);
}
if (cachedLocale instanceof Promise) {
const isLoading = ref(true);
const locale = ref(FALLBACK_LOCALE);
cachedLocale.then((loadedLocale) => {
cachedLocale = loadedLocale;
isLoading.value = false;
locale.value = cachedLocale;
});
return {
isLoading,
locale
};
}
return {
isLoading: ref(false),
locale: ref(cachedLocale)
};
}
async function loadDateFnsLocale(localeCode) {
if (localeCode in loader) {
try {
return await loader[localeCode]();
} catch (error) {
logger.warn("Failed to load locale.", { localeCode, error });
return FALLBACK_LOCALE;
}
}
if (localeCode.includes("-")) {
const shortLocale = localeCode.split("-")[0];
return loadDateFnsLocale(shortLocale);
}
logger.warn("Found no locale to load.", { localeCode });
return FALLBACK_LOCALE;
}
const _hoisted_1 = { class: "vue-date-time-picker__wrapper" };
const _hoisted_2 = {
ref: "target",
class: "vue-date-time-picker__wrapper vue-date-time-picker__wrapper--teleport"
};
const _sfc_main = /* @__PURE__ */ defineComponent({
__name: "NcDateTimePicker",
props: /* @__PURE__ */ mergeModels({
appendToBody: { type: Boolean },
ariaLabel: { default: t("Datepicker input") },
ariaLabelMenu: { default: t("Datepicker menu") },
clearable: { type: Boolean },
confirm: { type: Boolean },
format: { type: [String, Function], default: void 0 },
locale: { default: void 0 },
max: { default: void 0 },
min: { default: void 0 },
minuteStep: { default: 10 },
modelValue: { default: null },
placeholder: { default: void 0 },
showTimezoneSelect: { type: Boolean },
showWeekNumber: { type: Boolean },
type: { default: "date" },
inline: { type: Boolean, default: false }
}, {
"timezoneId": { default: "UTC" },
"timezoneIdModifiers": {}
}),
emits: /* @__PURE__ */ mergeModels(["update:modelValue", "update:timezoneId", "blur"], ["update:timezoneId"]),
setup(__props, { emit: __emit }) {
const timezoneId = useModel(__props, "timezoneId");
const props = __props;
const emit = __emit;
const realLocale = getCanonicalLocale();
watchEffect(() => {
if (props.locale !== void 0) {
warn("[NcDateTimePicker] The `locale` property is no longer used and will be ignored.");
}
});
const targetElement = useTemplateRef("target");
const pickerInstance = useTemplateRef("picker");
const value = computed(() => {
if (props.modelValue === null && props.clearable) {
return null;
}
if (props.type === "week") {
const date = props.modelValue instanceof Date ? props.modelValue : /* @__PURE__ */ new Date();
const end = new Date(date);
end.setUTCDate(date.getUTCDate() + 6);
return [date, end];
} else if (props.type === "year") {
const date = props.modelValue instanceof Date ? props.modelValue : /* @__PURE__ */ new Date();
return date.getUTCFullYear();
} else if (props.type === "month") {
const date = props.modelValue instanceof Date ? props.modelValue : /* @__PURE__ */ new Date();
return { year: date.getUTCFullYear(), month: date.getUTCMonth() };
} else if (props.type === "time") {
const time = props.modelValue instanceof Date ? props.modelValue : /* @__PURE__ */ new Date();
return {
hours: time.getHours(),
minutes: time.getMinutes(),
seconds: time.getSeconds()
};
} else if (props.type === "time-range") {
const time = [props.modelValue].flat();
if (time.length !== 2) {
const start = /* @__PURE__ */ new Date();
const end = new Date(start);
end.setHours(end.getHours() + 1);
time.splice(0, 2, start, end);
}
return time.map((date) => ({
hours: date.getHours(),
minutes: date.getMinutes(),
seconds: date.getSeconds()
}));
} else if (props.type.endsWith("-range")) {
if (props.modelValue === void 0) {
const start = /* @__PURE__ */ new Date();
const end = new Date(start);
end.setUTCDate(start.getUTCDate() + 7);
return [start, end];
}
return props.modelValue;
}
return props.modelValue ?? /* @__PURE__ */ new Date();
});
const placeholderFallback = computed(() => {
if (props.type === "date") {
return t("Select date");
} else if (props.type === "time") {
return t("Select time");
} else if (props.type === "datetime") {
return t("Select date and time");
} else if (props.type === "week") {
return t("Select week");
} else if (props.type === "month") {
return t("Select month");
} else if (props.type === "year") {
return t("Select year");
} else if (props.type.endsWith("-range")) {
return t("Select time range");
}
return t("Select date and time");
});
const { isLoading: dateFnsLocaleIsLoading, locale: dateFnsLocale } = useDateFnsLocale();
watch(dateFnsLocale, () => {
pickerInstance.value?.parseModel();
}, {
// Apply only after new locale was reaplied to VueDatePicker.
flush: "post"
});
const realFormat = computed(() => {
if (props.format) {
return props.format;
}
switch (props.type) {
case "date":
case "date-range":
return getDateFormat(dateFnsLocale.value);
case "time":
case "time-range":
return getTimeFormat();
case "datetime":
case "datetime-range":
return getDateTimeFormat(dateFnsLocale.value);
case "month":
return getMonthFormat(dateFnsLocale.value);
case "year":
return getYearFormat(dateFnsLocale.value);
case "week":
return getWeekFormat();
}
return void 0;
});
const textInput = computed(() => {
const realFormatVal = realFormat.value;
if (typeof realFormatVal === "function") {
return false;
}
if (typeof realFormatVal === "string") {
return {
// This should not be required in Vuepic because `format` is automatically used for parsing.
// But v11 has a bug because the format string ist cut off wrongly.
// This is fixed in v12.1.0 and can then be simplified.
// See https://github.com/Vuepic/vue-datepicker/issues/1208
format: (value2) => {
return parse(value2, realFormatVal, /* @__PURE__ */ new Date(), { locale: dateFnsLocale.value });
}
};
}
return true;
});
const pickerType = computed(() => ({
timePicker: props.type === "time" || props.type === "time-range",
yearPicker: props.type === "year",
monthPicker: props.type === "month",
weekPicker: props.type === "week",
range: props.type.endsWith("-range") && {
// do not use partial ranges (meaning after selecting the start [Date, null] will be emitted)
// if this is needed someday we can enable it,
// but its not covered by our component interface (props / events) documentation so just disabled for now.
partialRange: false
},
// Show additional time picker only for 'datetime*'.
// 'month', 'year', 'time*' do not support it anyway.
// But for 'date*' and 'week' it has to be excplicitly disabled.
enableTimePicker: props.type === "datetime" || props.type === "datetime-range",
flow: props.type === "datetime" ? ["calendar", "time"] : void 0
}));
const minTime = computed(() => props.min && { hours: props.min.getHours(), minutes: props.min.getMinutes(), seconds: props.min.getSeconds() });
const maxTime = computed(() => props.max && { hours: props.max.getHours(), minutes: props.max.getMinutes(), seconds: props.max.getSeconds() });
function onUpdateModelValue(value2) {
if (value2 === null) {
return emit("update:modelValue", null);
}
if (props.type === "time") {
emit("update:modelValue", formatLibraryTime(value2));
} else if (props.type === "time-range") {
const start = formatLibraryTime(value2[0]);
const end = formatLibraryTime(value2[1]);
if (end.getTime() < start.getTime()) {
end.setDate(end.getDate() + 1);
}
emit("update:modelValue", [start, end]);
} else if (props.type === "month") {
const data = value2;
emit("update:modelValue", new Date(data.year, data.month, 1));
} else if (props.type === "year") {
emit("update:modelValue", new Date(value2, 0));
} else if (props.type === "week") {
emit("update:modelValue", value2[0]);
} else {
emit("update:modelValue", value2);
}
}
function formatLibraryTime(time) {
const date = /* @__PURE__ */ new Date();
date.setHours(time.hours);
date.setMinutes(time.minutes);
date.setSeconds(time.seconds);
return date;
}
const weekStart = getFirstDay();
const dayNames = [...getDayNamesMin()];
for (let i = 0; i < weekStart; i++) {
dayNames.push(dayNames.shift());
}
const weekNumName = t("W");
const ariaLabels = computed(() => ({
toggleOverlay: t("Toggle overlay"),
menu: props.ariaLabelMenu,
input: props.ariaLabel,
openTimePicker: t("Open time picker"),
closeTimePicker: t("Close time Picker"),
incrementValue: (type) => {
if (type === "hours") {
return t("Increment hours");
} else if (type === "minutes") {
return t("Increment minutes");
}
return t("Increment seconds");
},
decrementValue: (type) => {
if (type === "hours") {
return t("Decrement hours");
} else if (type === "minutes") {
return t("Decrement minutes");
}
return t("Decrement seconds");
},
openTpOverlay: (type) => {
if (type === "hours") {
return t("Open hours overlay");
} else if (type === "minutes") {
return t("Open minutes overlay");
}
return t("Open seconds overlay");
},
amPmButton: t("Switch AM/PM mode"),
openYearsOverlay: t("Open years overlay"),
openMonthsOverlay: t("Open months overlay"),
nextMonth: t("Next month"),
prevMonth: t("Previous month"),
nextYear: t("Next year"),
prevYear: t("Previous year"),
weekDay: (day) => getDayNames()[day],
clearInput: t("Clear value"),
calendarIcon: t("Calendar icon"),
timePicker: t("Time picker"),
monthPicker: (overlay) => overlay ? t("Month picker overlay") : t("Month picker"),
yearPicker: (overlay) => overlay ? t("Year picker overlay") : t("Year picker")
}));
function selectDate() {
pickerInstance.value.selectDate();
}
function cancelSelection() {
pickerInstance.value.closeMenu();
}
const calcMinMaxTime = computed(() => {
if (props.type === "datetime") {
return {
minDate: props.min,
maxDate: props.max,
minTime: props.min && value.value && sameDay(props.min, value.value) ? minTime.value : void 0,
maxTime: props.max && value.value && sameDay(props.max, value.value) ? maxTime.value : void 0
};
}
if (props.type === "datetime-range") {
return {
minDate: props.min,
maxDate: props.max,
minTime: props.min && value.value ? sameDay(props.min, value.value[0]) ? minTime.value : void 0 : void 0,
maxTime: props.max && value.value ? sameDay(props.max, value.value[1]) ? maxTime.value : void 0 : void 0
};
}
if (props.type === "time" || props.type === "time-range") {
return {
minTime: props.min ? minTime.value : void 0,
maxTime: props.max ? maxTime.value : void 0
};
}
return {
minDate: props.min,
maxDate: props.max
};
});
function sameDay(a, b) {
return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
}
return (_ctx, _cache) => {
return openBlock(), createElementBlock("div", _hoisted_1, [
createVNode(unref(VueDatePicker), mergeProps({
ref: "picker",
"aria-labels": ariaLabels.value,
autoApply: !__props.confirm,
class: ["vue-date-time-picker", { "vue-date-time-picker--clearable": __props.clearable }],
cancelText: unref(t)("Cancel"),
clearable: __props.clearable,
dayNames,
placeholder: __props.placeholder ?? placeholderFallback.value,
format: realFormat.value,
locale: unref(realLocale),
formatLocale: unref(dateFnsLocale),
readonly: unref(dateFnsLocaleIsLoading),
minDate: calcMinMaxTime.value.minDate,
maxDate: calcMinMaxTime.value.maxDate,
minTime: calcMinMaxTime.value.minTime,
maxTime: calcMinMaxTime.value.maxTime,
minutesIncrement: __props.minuteStep,
modelValue: value.value,
nowButtonLabel: unref(t)("Now"),
selectText: unref(t)("Pick"),
sixWeeks: "fair",
inline: __props.inline,
teleport: __props.appendToBody ? targetElement.value || void 0 : false,
textInput: textInput.value,
weekNumName: unref(weekNumName),
weekNumbers: __props.showWeekNumber ? { type: "iso" } : void 0,
weekStart: unref(weekStart)
}, pickerType.value, {
"onUpdate:modelValue": onUpdateModelValue,
onBlur: _cache[1] || (_cache[1] = ($event) => emit("blur"))
}), createSlots({
"action-buttons": withCtx(() => [
createVNode(unref(NcButton), {
size: "small",
variant: "tertiary",
onClick: cancelSelection
}, {
default: withCtx(() => [
createTextVNode(toDisplayString(unref(t)("Cancel")), 1)
]),
_: 1
}),
createVNode(unref(NcButton), {
size: "small",
variant: "primary",
onClick: selectDate
}, {
default: withCtx(() => [
createTextVNode(toDisplayString(unref(t)("Pick")), 1)
]),
_: 1
})
]),
"clear-icon": withCtx(({ clear }) => [
createVNode(unref(NcButton), {
"aria-label": unref(t)("Clear value"),
variant: "tertiary-no-background",
onClick: clear
}, {
icon: withCtx(() => [
createVNode(NcIconSvgWrapper, {
inline: "",
path: unref(mdiClose),
size: 20
}, null, 8, ["path"])
]),
_: 1
}, 8, ["aria-label", "onClick"])
]),
"input-icon": withCtx(() => [
createVNode(NcIconSvgWrapper, {
path: unref(mdiCalendarBlank),
size: 20
}, null, 8, ["path"])
]),
"clock-icon": withCtx(() => [
createVNode(NcIconSvgWrapper, {
inline: "",
path: unref(mdiClock),
size: 20
}, null, 8, ["path"])
]),
"arrow-left": withCtx(() => [
createVNode(NcIconSvgWrapper, {
inline: "",
path: unref(mdiChevronLeft),
size: 20
}, null, 8, ["path"])
]),
"arrow-right": withCtx(() => [
createVNode(NcIconSvgWrapper, {
inline: "",
path: unref(mdiChevronRight),
size: 20
}, null, 8, ["path"])
]),
"arrow-down": withCtx(() => [
createVNode(NcIconSvgWrapper, {
inline: "",
path: unref(mdiChevronDown),
size: 20
}, null, 8, ["path"])
]),
"arrow-up": withCtx(() => [
createVNode(NcIconSvgWrapper, {
inline: "",
path: unref(mdiChevronUp),
size: 20
}, null, 8, ["path"])
]),
_: 2
}, [
__props.showTimezoneSelect ? {
name: "action-extra",
fn: withCtx(() => [
createVNode(_sfc_main$1, {
modelValue: timezoneId.value,
"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => timezoneId.value = $event),
class: "vue-date-time-picker__timezone",
appendToBody: false,
inputLabel: unref(t)("Time zone")
}, null, 8, ["modelValue", "inputLabel"])
]),
key: "0"
} : void 0
]), 1040, ["aria-labels", "autoApply", "class", "cancelText", "clearable", "placeholder", "format", "locale", "formatLocale", "readonly", "minDate", "maxDate", "minTime", "maxTime", "minutesIncrement", "modelValue", "nowButtonLabel", "selectText", "inline", "teleport", "textInput", "weekNumName", "weekNumbers", "weekStart"]),
(openBlock(), createBlock(Teleport, {
to: "body",
disabled: !__props.appendToBody
}, [
createElementVNode("div", _hoisted_2, null, 512)
], 8, ["disabled"]))
]);
};
}
});
const NcDateTimePicker = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-ed61636a"]]);
export {
NcDateTimePicker as N
};
//# sourceMappingURL=NcDateTimePicker.mjs.map