1511 lines
40 KiB
JavaScript
1511 lines
40 KiB
JavaScript
import {
|
|
IN_BROWSER,
|
|
clamp,
|
|
consoleWarn,
|
|
convertToUnit,
|
|
createRange,
|
|
defineComponent,
|
|
findChildrenWithProvide,
|
|
genericComponent,
|
|
getCurrentInstance,
|
|
getUid,
|
|
mergeDeep,
|
|
padStart,
|
|
propsFactory,
|
|
refElement,
|
|
templateRef,
|
|
useLocale,
|
|
useRtl
|
|
} from "./chunk-OGLFEP4I.js";
|
|
import {
|
|
computed,
|
|
createVNode,
|
|
h,
|
|
inject,
|
|
mergeProps,
|
|
onActivated,
|
|
onBeforeUnmount,
|
|
onDeactivated,
|
|
onMounted,
|
|
provide,
|
|
reactive,
|
|
readonly,
|
|
ref,
|
|
shallowRef,
|
|
unref,
|
|
watch
|
|
} from "./chunk-TF6X5W6F.js";
|
|
|
|
// node_modules/vuetify/lib/composables/date/adapters/vuetify.mjs
|
|
var firstDay = {
|
|
"001": 1,
|
|
AD: 1,
|
|
AE: 6,
|
|
AF: 6,
|
|
AG: 0,
|
|
AI: 1,
|
|
AL: 1,
|
|
AM: 1,
|
|
AN: 1,
|
|
AR: 1,
|
|
AS: 0,
|
|
AT: 1,
|
|
AU: 1,
|
|
AX: 1,
|
|
AZ: 1,
|
|
BA: 1,
|
|
BD: 0,
|
|
BE: 1,
|
|
BG: 1,
|
|
BH: 6,
|
|
BM: 1,
|
|
BN: 1,
|
|
BR: 0,
|
|
BS: 0,
|
|
BT: 0,
|
|
BW: 0,
|
|
BY: 1,
|
|
BZ: 0,
|
|
CA: 0,
|
|
CH: 1,
|
|
CL: 1,
|
|
CM: 1,
|
|
CN: 1,
|
|
CO: 0,
|
|
CR: 1,
|
|
CY: 1,
|
|
CZ: 1,
|
|
DE: 1,
|
|
DJ: 6,
|
|
DK: 1,
|
|
DM: 0,
|
|
DO: 0,
|
|
DZ: 6,
|
|
EC: 1,
|
|
EE: 1,
|
|
EG: 6,
|
|
ES: 1,
|
|
ET: 0,
|
|
FI: 1,
|
|
FJ: 1,
|
|
FO: 1,
|
|
FR: 1,
|
|
GB: 1,
|
|
"GB-alt-variant": 0,
|
|
GE: 1,
|
|
GF: 1,
|
|
GP: 1,
|
|
GR: 1,
|
|
GT: 0,
|
|
GU: 0,
|
|
HK: 0,
|
|
HN: 0,
|
|
HR: 1,
|
|
HU: 1,
|
|
ID: 0,
|
|
IE: 1,
|
|
IL: 0,
|
|
IN: 0,
|
|
IQ: 6,
|
|
IR: 6,
|
|
IS: 1,
|
|
IT: 1,
|
|
JM: 0,
|
|
JO: 6,
|
|
JP: 0,
|
|
KE: 0,
|
|
KG: 1,
|
|
KH: 0,
|
|
KR: 0,
|
|
KW: 6,
|
|
KZ: 1,
|
|
LA: 0,
|
|
LB: 1,
|
|
LI: 1,
|
|
LK: 1,
|
|
LT: 1,
|
|
LU: 1,
|
|
LV: 1,
|
|
LY: 6,
|
|
MC: 1,
|
|
MD: 1,
|
|
ME: 1,
|
|
MH: 0,
|
|
MK: 1,
|
|
MM: 0,
|
|
MN: 1,
|
|
MO: 0,
|
|
MQ: 1,
|
|
MT: 0,
|
|
MV: 5,
|
|
MX: 0,
|
|
MY: 1,
|
|
MZ: 0,
|
|
NI: 0,
|
|
NL: 1,
|
|
NO: 1,
|
|
NP: 0,
|
|
NZ: 1,
|
|
OM: 6,
|
|
PA: 0,
|
|
PE: 0,
|
|
PH: 0,
|
|
PK: 0,
|
|
PL: 1,
|
|
PR: 0,
|
|
PT: 0,
|
|
PY: 0,
|
|
QA: 6,
|
|
RE: 1,
|
|
RO: 1,
|
|
RS: 1,
|
|
RU: 1,
|
|
SA: 0,
|
|
SD: 6,
|
|
SE: 1,
|
|
SG: 0,
|
|
SI: 1,
|
|
SK: 1,
|
|
SM: 1,
|
|
SV: 0,
|
|
SY: 6,
|
|
TH: 0,
|
|
TJ: 1,
|
|
TM: 1,
|
|
TR: 1,
|
|
TT: 0,
|
|
TW: 0,
|
|
UA: 1,
|
|
UM: 0,
|
|
US: 0,
|
|
UY: 1,
|
|
UZ: 1,
|
|
VA: 1,
|
|
VE: 0,
|
|
VI: 0,
|
|
VN: 1,
|
|
WS: 0,
|
|
XK: 1,
|
|
YE: 0,
|
|
ZA: 0,
|
|
ZW: 0
|
|
};
|
|
function getWeekArray(date2, locale, firstDayOfWeek) {
|
|
const weeks = [];
|
|
let currentWeek = [];
|
|
const firstDayOfMonth = startOfMonth(date2);
|
|
const lastDayOfMonth = endOfMonth(date2);
|
|
const first = firstDayOfWeek ?? firstDay[locale.slice(-2).toUpperCase()] ?? 0;
|
|
const firstDayWeekIndex = (firstDayOfMonth.getDay() - first + 7) % 7;
|
|
const lastDayWeekIndex = (lastDayOfMonth.getDay() - first + 7) % 7;
|
|
for (let i = 0; i < firstDayWeekIndex; i++) {
|
|
const adjacentDay = new Date(firstDayOfMonth);
|
|
adjacentDay.setDate(adjacentDay.getDate() - (firstDayWeekIndex - i));
|
|
currentWeek.push(adjacentDay);
|
|
}
|
|
for (let i = 1; i <= lastDayOfMonth.getDate(); i++) {
|
|
const day = new Date(date2.getFullYear(), date2.getMonth(), i);
|
|
currentWeek.push(day);
|
|
if (currentWeek.length === 7) {
|
|
weeks.push(currentWeek);
|
|
currentWeek = [];
|
|
}
|
|
}
|
|
for (let i = 1; i < 7 - lastDayWeekIndex; i++) {
|
|
const adjacentDay = new Date(lastDayOfMonth);
|
|
adjacentDay.setDate(adjacentDay.getDate() + i);
|
|
currentWeek.push(adjacentDay);
|
|
}
|
|
if (currentWeek.length > 0) {
|
|
weeks.push(currentWeek);
|
|
}
|
|
return weeks;
|
|
}
|
|
function startOfWeek(date2, locale, firstDayOfWeek) {
|
|
const day = firstDayOfWeek ?? firstDay[locale.slice(-2).toUpperCase()] ?? 0;
|
|
const d = new Date(date2);
|
|
while (d.getDay() !== day) {
|
|
d.setDate(d.getDate() - 1);
|
|
}
|
|
return d;
|
|
}
|
|
function endOfWeek(date2, locale) {
|
|
const d = new Date(date2);
|
|
const lastDay = ((firstDay[locale.slice(-2).toUpperCase()] ?? 0) + 6) % 7;
|
|
while (d.getDay() !== lastDay) {
|
|
d.setDate(d.getDate() + 1);
|
|
}
|
|
return d;
|
|
}
|
|
function startOfMonth(date2) {
|
|
return new Date(date2.getFullYear(), date2.getMonth(), 1);
|
|
}
|
|
function endOfMonth(date2) {
|
|
return new Date(date2.getFullYear(), date2.getMonth() + 1, 0);
|
|
}
|
|
function parseLocalDate(value) {
|
|
const parts = value.split("-").map(Number);
|
|
return new Date(parts[0], parts[1] - 1, parts[2]);
|
|
}
|
|
var _YYYMMDD = /^([12]\d{3}-([1-9]|0[1-9]|1[0-2])-([1-9]|0[1-9]|[12]\d|3[01]))$/;
|
|
function date(value) {
|
|
if (value == null) return /* @__PURE__ */ new Date();
|
|
if (value instanceof Date) return value;
|
|
if (typeof value === "string") {
|
|
let parsed;
|
|
if (_YYYMMDD.test(value)) {
|
|
return parseLocalDate(value);
|
|
} else {
|
|
parsed = Date.parse(value);
|
|
}
|
|
if (!isNaN(parsed)) return new Date(parsed);
|
|
}
|
|
return null;
|
|
}
|
|
var sundayJanuarySecond2000 = new Date(2e3, 0, 2);
|
|
function getWeekdays(locale, firstDayOfWeek) {
|
|
const daysFromSunday = firstDayOfWeek ?? firstDay[locale.slice(-2).toUpperCase()] ?? 0;
|
|
return createRange(7).map((i) => {
|
|
const weekday = new Date(sundayJanuarySecond2000);
|
|
weekday.setDate(sundayJanuarySecond2000.getDate() + daysFromSunday + i);
|
|
return new Intl.DateTimeFormat(locale, {
|
|
weekday: "narrow"
|
|
}).format(weekday);
|
|
});
|
|
}
|
|
function format(value, formatString, locale, formats) {
|
|
const newDate = date(value) ?? /* @__PURE__ */ new Date();
|
|
const customFormat = formats == null ? void 0 : formats[formatString];
|
|
if (typeof customFormat === "function") {
|
|
return customFormat(newDate, formatString, locale);
|
|
}
|
|
let options = {};
|
|
switch (formatString) {
|
|
case "fullDate":
|
|
options = {
|
|
year: "numeric",
|
|
month: "long",
|
|
day: "numeric"
|
|
};
|
|
break;
|
|
case "fullDateWithWeekday":
|
|
options = {
|
|
weekday: "long",
|
|
year: "numeric",
|
|
month: "long",
|
|
day: "numeric"
|
|
};
|
|
break;
|
|
case "normalDate":
|
|
const day = newDate.getDate();
|
|
const month = new Intl.DateTimeFormat(locale, {
|
|
month: "long"
|
|
}).format(newDate);
|
|
return `${day} ${month}`;
|
|
case "normalDateWithWeekday":
|
|
options = {
|
|
weekday: "short",
|
|
day: "numeric",
|
|
month: "short"
|
|
};
|
|
break;
|
|
case "shortDate":
|
|
options = {
|
|
month: "short",
|
|
day: "numeric"
|
|
};
|
|
break;
|
|
case "year":
|
|
options = {
|
|
year: "numeric"
|
|
};
|
|
break;
|
|
case "month":
|
|
options = {
|
|
month: "long"
|
|
};
|
|
break;
|
|
case "monthShort":
|
|
options = {
|
|
month: "short"
|
|
};
|
|
break;
|
|
case "monthAndYear":
|
|
options = {
|
|
month: "long",
|
|
year: "numeric"
|
|
};
|
|
break;
|
|
case "monthAndDate":
|
|
options = {
|
|
month: "long",
|
|
day: "numeric"
|
|
};
|
|
break;
|
|
case "weekday":
|
|
options = {
|
|
weekday: "long"
|
|
};
|
|
break;
|
|
case "weekdayShort":
|
|
options = {
|
|
weekday: "short"
|
|
};
|
|
break;
|
|
case "dayOfMonth":
|
|
return new Intl.NumberFormat(locale).format(newDate.getDate());
|
|
case "hours12h":
|
|
options = {
|
|
hour: "numeric",
|
|
hour12: true
|
|
};
|
|
break;
|
|
case "hours24h":
|
|
options = {
|
|
hour: "numeric",
|
|
hour12: false
|
|
};
|
|
break;
|
|
case "minutes":
|
|
options = {
|
|
minute: "numeric"
|
|
};
|
|
break;
|
|
case "seconds":
|
|
options = {
|
|
second: "numeric"
|
|
};
|
|
break;
|
|
case "fullTime":
|
|
options = {
|
|
hour: "numeric",
|
|
minute: "numeric"
|
|
};
|
|
break;
|
|
case "fullTime12h":
|
|
options = {
|
|
hour: "numeric",
|
|
minute: "numeric",
|
|
hour12: true
|
|
};
|
|
break;
|
|
case "fullTime24h":
|
|
options = {
|
|
hour: "numeric",
|
|
minute: "numeric",
|
|
hour12: false
|
|
};
|
|
break;
|
|
case "fullDateTime":
|
|
options = {
|
|
year: "numeric",
|
|
month: "short",
|
|
day: "numeric",
|
|
hour: "numeric",
|
|
minute: "numeric"
|
|
};
|
|
break;
|
|
case "fullDateTime12h":
|
|
options = {
|
|
year: "numeric",
|
|
month: "short",
|
|
day: "numeric",
|
|
hour: "numeric",
|
|
minute: "numeric",
|
|
hour12: true
|
|
};
|
|
break;
|
|
case "fullDateTime24h":
|
|
options = {
|
|
year: "numeric",
|
|
month: "short",
|
|
day: "numeric",
|
|
hour: "numeric",
|
|
minute: "numeric",
|
|
hour12: false
|
|
};
|
|
break;
|
|
case "keyboardDate":
|
|
options = {
|
|
year: "numeric",
|
|
month: "2-digit",
|
|
day: "2-digit"
|
|
};
|
|
break;
|
|
case "keyboardDateTime":
|
|
options = {
|
|
year: "numeric",
|
|
month: "2-digit",
|
|
day: "2-digit",
|
|
hour: "numeric",
|
|
minute: "numeric"
|
|
};
|
|
return new Intl.DateTimeFormat(locale, options).format(newDate).replace(/, /g, " ");
|
|
case "keyboardDateTime12h":
|
|
options = {
|
|
year: "numeric",
|
|
month: "2-digit",
|
|
day: "2-digit",
|
|
hour: "numeric",
|
|
minute: "numeric",
|
|
hour12: true
|
|
};
|
|
return new Intl.DateTimeFormat(locale, options).format(newDate).replace(/, /g, " ");
|
|
case "keyboardDateTime24h":
|
|
options = {
|
|
year: "numeric",
|
|
month: "2-digit",
|
|
day: "2-digit",
|
|
hour: "numeric",
|
|
minute: "numeric",
|
|
hour12: false
|
|
};
|
|
return new Intl.DateTimeFormat(locale, options).format(newDate).replace(/, /g, " ");
|
|
default:
|
|
options = customFormat ?? {
|
|
timeZone: "UTC",
|
|
timeZoneName: "short"
|
|
};
|
|
}
|
|
return new Intl.DateTimeFormat(locale, options).format(newDate);
|
|
}
|
|
function toISO(adapter, value) {
|
|
const date2 = adapter.toJsDate(value);
|
|
const year = date2.getFullYear();
|
|
const month = padStart(String(date2.getMonth() + 1), 2, "0");
|
|
const day = padStart(String(date2.getDate()), 2, "0");
|
|
return `${year}-${month}-${day}`;
|
|
}
|
|
function parseISO(value) {
|
|
const [year, month, day] = value.split("-").map(Number);
|
|
return new Date(year, month - 1, day);
|
|
}
|
|
function addMinutes(date2, amount) {
|
|
const d = new Date(date2);
|
|
d.setMinutes(d.getMinutes() + amount);
|
|
return d;
|
|
}
|
|
function addHours(date2, amount) {
|
|
const d = new Date(date2);
|
|
d.setHours(d.getHours() + amount);
|
|
return d;
|
|
}
|
|
function addDays(date2, amount) {
|
|
const d = new Date(date2);
|
|
d.setDate(d.getDate() + amount);
|
|
return d;
|
|
}
|
|
function addWeeks(date2, amount) {
|
|
const d = new Date(date2);
|
|
d.setDate(d.getDate() + amount * 7);
|
|
return d;
|
|
}
|
|
function addMonths(date2, amount) {
|
|
const d = new Date(date2);
|
|
d.setDate(1);
|
|
d.setMonth(d.getMonth() + amount);
|
|
return d;
|
|
}
|
|
function getYear(date2) {
|
|
return date2.getFullYear();
|
|
}
|
|
function getMonth(date2) {
|
|
return date2.getMonth();
|
|
}
|
|
function getDate(date2) {
|
|
return date2.getDate();
|
|
}
|
|
function getNextMonth(date2) {
|
|
return new Date(date2.getFullYear(), date2.getMonth() + 1, 1);
|
|
}
|
|
function getPreviousMonth(date2) {
|
|
return new Date(date2.getFullYear(), date2.getMonth() - 1, 1);
|
|
}
|
|
function getHours(date2) {
|
|
return date2.getHours();
|
|
}
|
|
function getMinutes(date2) {
|
|
return date2.getMinutes();
|
|
}
|
|
function startOfYear(date2) {
|
|
return new Date(date2.getFullYear(), 0, 1);
|
|
}
|
|
function endOfYear(date2) {
|
|
return new Date(date2.getFullYear(), 11, 31);
|
|
}
|
|
function isWithinRange(date2, range) {
|
|
return isAfter(date2, range[0]) && isBefore(date2, range[1]);
|
|
}
|
|
function isValid(date2) {
|
|
const d = new Date(date2);
|
|
return d instanceof Date && !isNaN(d.getTime());
|
|
}
|
|
function isAfter(date2, comparing) {
|
|
return date2.getTime() > comparing.getTime();
|
|
}
|
|
function isAfterDay(date2, comparing) {
|
|
return isAfter(startOfDay(date2), startOfDay(comparing));
|
|
}
|
|
function isBefore(date2, comparing) {
|
|
return date2.getTime() < comparing.getTime();
|
|
}
|
|
function isEqual(date2, comparing) {
|
|
return date2.getTime() === comparing.getTime();
|
|
}
|
|
function isSameDay(date2, comparing) {
|
|
return date2.getDate() === comparing.getDate() && date2.getMonth() === comparing.getMonth() && date2.getFullYear() === comparing.getFullYear();
|
|
}
|
|
function isSameMonth(date2, comparing) {
|
|
return date2.getMonth() === comparing.getMonth() && date2.getFullYear() === comparing.getFullYear();
|
|
}
|
|
function isSameYear(date2, comparing) {
|
|
return date2.getFullYear() === comparing.getFullYear();
|
|
}
|
|
function getDiff(date2, comparing, unit) {
|
|
const d = new Date(date2);
|
|
const c = new Date(comparing);
|
|
switch (unit) {
|
|
case "years":
|
|
return d.getFullYear() - c.getFullYear();
|
|
case "quarters":
|
|
return Math.floor((d.getMonth() - c.getMonth() + (d.getFullYear() - c.getFullYear()) * 12) / 4);
|
|
case "months":
|
|
return d.getMonth() - c.getMonth() + (d.getFullYear() - c.getFullYear()) * 12;
|
|
case "weeks":
|
|
return Math.floor((d.getTime() - c.getTime()) / (1e3 * 60 * 60 * 24 * 7));
|
|
case "days":
|
|
return Math.floor((d.getTime() - c.getTime()) / (1e3 * 60 * 60 * 24));
|
|
case "hours":
|
|
return Math.floor((d.getTime() - c.getTime()) / (1e3 * 60 * 60));
|
|
case "minutes":
|
|
return Math.floor((d.getTime() - c.getTime()) / (1e3 * 60));
|
|
case "seconds":
|
|
return Math.floor((d.getTime() - c.getTime()) / 1e3);
|
|
default: {
|
|
return d.getTime() - c.getTime();
|
|
}
|
|
}
|
|
}
|
|
function setHours(date2, count) {
|
|
const d = new Date(date2);
|
|
d.setHours(count);
|
|
return d;
|
|
}
|
|
function setMinutes(date2, count) {
|
|
const d = new Date(date2);
|
|
d.setMinutes(count);
|
|
return d;
|
|
}
|
|
function setMonth(date2, count) {
|
|
const d = new Date(date2);
|
|
d.setMonth(count);
|
|
return d;
|
|
}
|
|
function setDate(date2, day) {
|
|
const d = new Date(date2);
|
|
d.setDate(day);
|
|
return d;
|
|
}
|
|
function setYear(date2, year) {
|
|
const d = new Date(date2);
|
|
d.setFullYear(year);
|
|
return d;
|
|
}
|
|
function startOfDay(date2) {
|
|
return new Date(date2.getFullYear(), date2.getMonth(), date2.getDate(), 0, 0, 0, 0);
|
|
}
|
|
function endOfDay(date2) {
|
|
return new Date(date2.getFullYear(), date2.getMonth(), date2.getDate(), 23, 59, 59, 999);
|
|
}
|
|
var VuetifyDateAdapter = class {
|
|
constructor(options) {
|
|
this.locale = options.locale;
|
|
this.formats = options.formats;
|
|
}
|
|
date(value) {
|
|
return date(value);
|
|
}
|
|
toJsDate(date2) {
|
|
return date2;
|
|
}
|
|
toISO(date2) {
|
|
return toISO(this, date2);
|
|
}
|
|
parseISO(date2) {
|
|
return parseISO(date2);
|
|
}
|
|
addMinutes(date2, amount) {
|
|
return addMinutes(date2, amount);
|
|
}
|
|
addHours(date2, amount) {
|
|
return addHours(date2, amount);
|
|
}
|
|
addDays(date2, amount) {
|
|
return addDays(date2, amount);
|
|
}
|
|
addWeeks(date2, amount) {
|
|
return addWeeks(date2, amount);
|
|
}
|
|
addMonths(date2, amount) {
|
|
return addMonths(date2, amount);
|
|
}
|
|
getWeekArray(date2, firstDayOfWeek) {
|
|
return getWeekArray(date2, this.locale, firstDayOfWeek ? Number(firstDayOfWeek) : void 0);
|
|
}
|
|
startOfWeek(date2, firstDayOfWeek) {
|
|
return startOfWeek(date2, this.locale, firstDayOfWeek ? Number(firstDayOfWeek) : void 0);
|
|
}
|
|
endOfWeek(date2) {
|
|
return endOfWeek(date2, this.locale);
|
|
}
|
|
startOfMonth(date2) {
|
|
return startOfMonth(date2);
|
|
}
|
|
endOfMonth(date2) {
|
|
return endOfMonth(date2);
|
|
}
|
|
format(date2, formatString) {
|
|
return format(date2, formatString, this.locale, this.formats);
|
|
}
|
|
isEqual(date2, comparing) {
|
|
return isEqual(date2, comparing);
|
|
}
|
|
isValid(date2) {
|
|
return isValid(date2);
|
|
}
|
|
isWithinRange(date2, range) {
|
|
return isWithinRange(date2, range);
|
|
}
|
|
isAfter(date2, comparing) {
|
|
return isAfter(date2, comparing);
|
|
}
|
|
isAfterDay(date2, comparing) {
|
|
return isAfterDay(date2, comparing);
|
|
}
|
|
isBefore(date2, comparing) {
|
|
return !isAfter(date2, comparing) && !isEqual(date2, comparing);
|
|
}
|
|
isSameDay(date2, comparing) {
|
|
return isSameDay(date2, comparing);
|
|
}
|
|
isSameMonth(date2, comparing) {
|
|
return isSameMonth(date2, comparing);
|
|
}
|
|
isSameYear(date2, comparing) {
|
|
return isSameYear(date2, comparing);
|
|
}
|
|
setMinutes(date2, count) {
|
|
return setMinutes(date2, count);
|
|
}
|
|
setHours(date2, count) {
|
|
return setHours(date2, count);
|
|
}
|
|
setMonth(date2, count) {
|
|
return setMonth(date2, count);
|
|
}
|
|
setDate(date2, day) {
|
|
return setDate(date2, day);
|
|
}
|
|
setYear(date2, year) {
|
|
return setYear(date2, year);
|
|
}
|
|
getDiff(date2, comparing, unit) {
|
|
return getDiff(date2, comparing, unit);
|
|
}
|
|
getWeekdays(firstDayOfWeek) {
|
|
return getWeekdays(this.locale, firstDayOfWeek ? Number(firstDayOfWeek) : void 0);
|
|
}
|
|
getYear(date2) {
|
|
return getYear(date2);
|
|
}
|
|
getMonth(date2) {
|
|
return getMonth(date2);
|
|
}
|
|
getDate(date2) {
|
|
return getDate(date2);
|
|
}
|
|
getNextMonth(date2) {
|
|
return getNextMonth(date2);
|
|
}
|
|
getPreviousMonth(date2) {
|
|
return getPreviousMonth(date2);
|
|
}
|
|
getHours(date2) {
|
|
return getHours(date2);
|
|
}
|
|
getMinutes(date2) {
|
|
return getMinutes(date2);
|
|
}
|
|
startOfDay(date2) {
|
|
return startOfDay(date2);
|
|
}
|
|
endOfDay(date2) {
|
|
return endOfDay(date2);
|
|
}
|
|
startOfYear(date2) {
|
|
return startOfYear(date2);
|
|
}
|
|
endOfYear(date2) {
|
|
return endOfYear(date2);
|
|
}
|
|
};
|
|
|
|
// node_modules/vuetify/lib/composables/date/date.mjs
|
|
var DateOptionsSymbol = Symbol.for("vuetify:date-options");
|
|
var DateAdapterSymbol = Symbol.for("vuetify:date-adapter");
|
|
function createDate(options, locale) {
|
|
const _options = mergeDeep({
|
|
adapter: VuetifyDateAdapter,
|
|
locale: {
|
|
af: "af-ZA",
|
|
// ar: '', # not the same value for all variants
|
|
bg: "bg-BG",
|
|
ca: "ca-ES",
|
|
ckb: "",
|
|
cs: "cs-CZ",
|
|
de: "de-DE",
|
|
el: "el-GR",
|
|
en: "en-US",
|
|
// es: '', # not the same value for all variants
|
|
et: "et-EE",
|
|
fa: "fa-IR",
|
|
fi: "fi-FI",
|
|
// fr: '', #not the same value for all variants
|
|
hr: "hr-HR",
|
|
hu: "hu-HU",
|
|
he: "he-IL",
|
|
id: "id-ID",
|
|
it: "it-IT",
|
|
ja: "ja-JP",
|
|
ko: "ko-KR",
|
|
lv: "lv-LV",
|
|
lt: "lt-LT",
|
|
nl: "nl-NL",
|
|
no: "no-NO",
|
|
pl: "pl-PL",
|
|
pt: "pt-PT",
|
|
ro: "ro-RO",
|
|
ru: "ru-RU",
|
|
sk: "sk-SK",
|
|
sl: "sl-SI",
|
|
srCyrl: "sr-SP",
|
|
srLatn: "sr-SP",
|
|
sv: "sv-SE",
|
|
th: "th-TH",
|
|
tr: "tr-TR",
|
|
az: "az-AZ",
|
|
uk: "uk-UA",
|
|
vi: "vi-VN",
|
|
zhHans: "zh-CN",
|
|
zhHant: "zh-TW"
|
|
}
|
|
}, options);
|
|
return {
|
|
options: _options,
|
|
instance: createInstance(_options, locale)
|
|
};
|
|
}
|
|
function createInstance(options, locale) {
|
|
const instance = reactive(typeof options.adapter === "function" ? new options.adapter({
|
|
locale: options.locale[locale.current.value] ?? locale.current.value,
|
|
formats: options.formats
|
|
}) : options.adapter);
|
|
watch(locale.current, (value) => {
|
|
instance.locale = options.locale[value] ?? value ?? instance.locale;
|
|
});
|
|
return instance;
|
|
}
|
|
function useDate() {
|
|
const options = inject(DateOptionsSymbol);
|
|
if (!options) throw new Error("[Vuetify] Could not find injected date options");
|
|
const locale = useLocale();
|
|
return createInstance(options, locale);
|
|
}
|
|
function getWeek(adapter, value) {
|
|
const date2 = adapter.toJsDate(value);
|
|
let year = date2.getFullYear();
|
|
let d1w1 = new Date(year, 0, 1);
|
|
if (date2 < d1w1) {
|
|
year = year - 1;
|
|
d1w1 = new Date(year, 0, 1);
|
|
} else {
|
|
const tv = new Date(year + 1, 0, 1);
|
|
if (date2 >= tv) {
|
|
year = year + 1;
|
|
d1w1 = tv;
|
|
}
|
|
}
|
|
const diffTime = Math.abs(date2.getTime() - d1w1.getTime());
|
|
const diffDays = Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
|
|
return Math.floor(diffDays / 7) + 1;
|
|
}
|
|
|
|
// node_modules/vuetify/lib/composables/goto.mjs
|
|
var GoToSymbol = Symbol.for("vuetify:goto");
|
|
function genDefaults() {
|
|
return {
|
|
container: void 0,
|
|
duration: 300,
|
|
layout: false,
|
|
offset: 0,
|
|
easing: "easeInOutCubic",
|
|
patterns: {
|
|
linear: (t) => t,
|
|
easeInQuad: (t) => t ** 2,
|
|
easeOutQuad: (t) => t * (2 - t),
|
|
easeInOutQuad: (t) => t < 0.5 ? 2 * t ** 2 : -1 + (4 - 2 * t) * t,
|
|
easeInCubic: (t) => t ** 3,
|
|
easeOutCubic: (t) => --t ** 3 + 1,
|
|
easeInOutCubic: (t) => t < 0.5 ? 4 * t ** 3 : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1,
|
|
easeInQuart: (t) => t ** 4,
|
|
easeOutQuart: (t) => 1 - --t ** 4,
|
|
easeInOutQuart: (t) => t < 0.5 ? 8 * t ** 4 : 1 - 8 * --t ** 4,
|
|
easeInQuint: (t) => t ** 5,
|
|
easeOutQuint: (t) => 1 + --t ** 5,
|
|
easeInOutQuint: (t) => t < 0.5 ? 16 * t ** 5 : 1 + 16 * --t ** 5
|
|
}
|
|
};
|
|
}
|
|
function getContainer(el) {
|
|
return getTarget(el) ?? (document.scrollingElement || document.body);
|
|
}
|
|
function getTarget(el) {
|
|
return typeof el === "string" ? document.querySelector(el) : refElement(el);
|
|
}
|
|
function getOffset(target, horizontal, rtl) {
|
|
if (typeof target === "number") return horizontal && rtl ? -target : target;
|
|
let el = getTarget(target);
|
|
let totalOffset = 0;
|
|
while (el) {
|
|
totalOffset += horizontal ? el.offsetLeft : el.offsetTop;
|
|
el = el.offsetParent;
|
|
}
|
|
return totalOffset;
|
|
}
|
|
function createGoTo(options, locale) {
|
|
return {
|
|
rtl: locale.isRtl,
|
|
options: mergeDeep(genDefaults(), options)
|
|
};
|
|
}
|
|
async function scrollTo(_target, _options, horizontal, goTo) {
|
|
const property = horizontal ? "scrollLeft" : "scrollTop";
|
|
const options = mergeDeep((goTo == null ? void 0 : goTo.options) ?? genDefaults(), _options);
|
|
const rtl = goTo == null ? void 0 : goTo.rtl.value;
|
|
const target = (typeof _target === "number" ? _target : getTarget(_target)) ?? 0;
|
|
const container = options.container === "parent" && target instanceof HTMLElement ? target.parentElement : getContainer(options.container);
|
|
const ease = typeof options.easing === "function" ? options.easing : options.patterns[options.easing];
|
|
if (!ease) throw new TypeError(`Easing function "${options.easing}" not found.`);
|
|
let targetLocation;
|
|
if (typeof target === "number") {
|
|
targetLocation = getOffset(target, horizontal, rtl);
|
|
} else {
|
|
targetLocation = getOffset(target, horizontal, rtl) - getOffset(container, horizontal, rtl);
|
|
if (options.layout) {
|
|
const styles = window.getComputedStyle(target);
|
|
const layoutOffset = styles.getPropertyValue("--v-layout-top");
|
|
if (layoutOffset) targetLocation -= parseInt(layoutOffset, 10);
|
|
}
|
|
}
|
|
targetLocation += options.offset;
|
|
targetLocation = clampTarget(container, targetLocation, !!rtl, !!horizontal);
|
|
const startLocation = container[property] ?? 0;
|
|
if (targetLocation === startLocation) return Promise.resolve(targetLocation);
|
|
const startTime = performance.now();
|
|
return new Promise((resolve) => requestAnimationFrame(function step(currentTime) {
|
|
const timeElapsed = currentTime - startTime;
|
|
const progress = timeElapsed / options.duration;
|
|
const location = Math.floor(startLocation + (targetLocation - startLocation) * ease(clamp(progress, 0, 1)));
|
|
container[property] = location;
|
|
if (progress >= 1 && Math.abs(location - container[property]) < 10) {
|
|
return resolve(targetLocation);
|
|
} else if (progress > 2) {
|
|
consoleWarn("Scroll target is not reachable");
|
|
return resolve(container[property]);
|
|
}
|
|
requestAnimationFrame(step);
|
|
}));
|
|
}
|
|
function useGoTo() {
|
|
let _options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
|
|
const goToInstance = inject(GoToSymbol);
|
|
const {
|
|
isRtl
|
|
} = useRtl();
|
|
if (!goToInstance) throw new Error("[Vuetify] Could not find injected goto instance");
|
|
const goTo = {
|
|
...goToInstance,
|
|
// can be set via VLocaleProvider
|
|
rtl: computed(() => goToInstance.rtl.value || isRtl.value)
|
|
};
|
|
async function go(target, options) {
|
|
return scrollTo(target, mergeDeep(_options, options), false, goTo);
|
|
}
|
|
go.horizontal = async (target, options) => {
|
|
return scrollTo(target, mergeDeep(_options, options), true, goTo);
|
|
};
|
|
return go;
|
|
}
|
|
function clampTarget(container, value, rtl, horizontal) {
|
|
const {
|
|
scrollWidth,
|
|
scrollHeight
|
|
} = container;
|
|
const [containerWidth, containerHeight] = container === document.scrollingElement ? [window.innerWidth, window.innerHeight] : [container.offsetWidth, container.offsetHeight];
|
|
let min;
|
|
let max;
|
|
if (horizontal) {
|
|
if (rtl) {
|
|
min = -(scrollWidth - containerWidth);
|
|
max = 0;
|
|
} else {
|
|
min = 0;
|
|
max = scrollWidth - containerWidth;
|
|
}
|
|
} else {
|
|
min = 0;
|
|
max = scrollHeight + -containerHeight;
|
|
}
|
|
return Math.max(Math.min(value, max), min);
|
|
}
|
|
|
|
// node_modules/vuetify/lib/iconsets/mdi.mjs
|
|
var aliases = {
|
|
collapse: "mdi-chevron-up",
|
|
complete: "mdi-check",
|
|
cancel: "mdi-close-circle",
|
|
close: "mdi-close",
|
|
delete: "mdi-close-circle",
|
|
// delete (e.g. v-chip close)
|
|
clear: "mdi-close-circle",
|
|
success: "mdi-check-circle",
|
|
info: "mdi-information",
|
|
warning: "mdi-alert-circle",
|
|
error: "mdi-close-circle",
|
|
prev: "mdi-chevron-left",
|
|
next: "mdi-chevron-right",
|
|
checkboxOn: "mdi-checkbox-marked",
|
|
checkboxOff: "mdi-checkbox-blank-outline",
|
|
checkboxIndeterminate: "mdi-minus-box",
|
|
delimiter: "mdi-circle",
|
|
// for carousel
|
|
sortAsc: "mdi-arrow-up",
|
|
sortDesc: "mdi-arrow-down",
|
|
expand: "mdi-chevron-down",
|
|
menu: "mdi-menu",
|
|
subgroup: "mdi-menu-down",
|
|
dropdown: "mdi-menu-down",
|
|
radioOn: "mdi-radiobox-marked",
|
|
radioOff: "mdi-radiobox-blank",
|
|
edit: "mdi-pencil",
|
|
ratingEmpty: "mdi-star-outline",
|
|
ratingFull: "mdi-star",
|
|
ratingHalf: "mdi-star-half-full",
|
|
loading: "mdi-cached",
|
|
first: "mdi-page-first",
|
|
last: "mdi-page-last",
|
|
unfold: "mdi-unfold-more-horizontal",
|
|
file: "mdi-paperclip",
|
|
plus: "mdi-plus",
|
|
minus: "mdi-minus",
|
|
calendar: "mdi-calendar",
|
|
treeviewCollapse: "mdi-menu-down",
|
|
treeviewExpand: "mdi-menu-right",
|
|
eyeDropper: "mdi-eyedropper",
|
|
upload: "mdi-cloud-upload"
|
|
};
|
|
var mdi = {
|
|
// Not using mergeProps here, functional components merge props by default (?)
|
|
component: (props) => h(VClassIcon, {
|
|
...props,
|
|
class: "mdi"
|
|
})
|
|
};
|
|
|
|
// node_modules/vuetify/lib/composables/icons.mjs
|
|
var IconValue = [String, Function, Object, Array];
|
|
var IconSymbol = Symbol.for("vuetify:icons");
|
|
var makeIconProps = propsFactory({
|
|
icon: {
|
|
type: IconValue
|
|
},
|
|
// Could not remove this and use makeTagProps, types complained because it is not required
|
|
tag: {
|
|
type: String,
|
|
required: true
|
|
}
|
|
}, "icon");
|
|
var VComponentIcon = genericComponent()({
|
|
name: "VComponentIcon",
|
|
props: makeIconProps(),
|
|
setup(props, _ref) {
|
|
let {
|
|
slots
|
|
} = _ref;
|
|
return () => {
|
|
const Icon = props.icon;
|
|
return createVNode(props.tag, null, {
|
|
default: () => {
|
|
var _a;
|
|
return [props.icon ? createVNode(Icon, null, null) : (_a = slots.default) == null ? void 0 : _a.call(slots)];
|
|
}
|
|
});
|
|
};
|
|
}
|
|
});
|
|
var VSvgIcon = defineComponent({
|
|
name: "VSvgIcon",
|
|
inheritAttrs: false,
|
|
props: makeIconProps(),
|
|
setup(props, _ref2) {
|
|
let {
|
|
attrs
|
|
} = _ref2;
|
|
return () => {
|
|
return createVNode(props.tag, mergeProps(attrs, {
|
|
"style": null
|
|
}), {
|
|
default: () => [createVNode("svg", {
|
|
"class": "v-icon__svg",
|
|
"xmlns": "http://www.w3.org/2000/svg",
|
|
"viewBox": "0 0 24 24",
|
|
"role": "img",
|
|
"aria-hidden": "true"
|
|
}, [Array.isArray(props.icon) ? props.icon.map((path) => Array.isArray(path) ? createVNode("path", {
|
|
"d": path[0],
|
|
"fill-opacity": path[1]
|
|
}, null) : createVNode("path", {
|
|
"d": path
|
|
}, null)) : createVNode("path", {
|
|
"d": props.icon
|
|
}, null)])]
|
|
});
|
|
};
|
|
}
|
|
});
|
|
var VLigatureIcon = defineComponent({
|
|
name: "VLigatureIcon",
|
|
props: makeIconProps(),
|
|
setup(props) {
|
|
return () => {
|
|
return createVNode(props.tag, null, {
|
|
default: () => [props.icon]
|
|
});
|
|
};
|
|
}
|
|
});
|
|
var VClassIcon = defineComponent({
|
|
name: "VClassIcon",
|
|
props: makeIconProps(),
|
|
setup(props) {
|
|
return () => {
|
|
return createVNode(props.tag, {
|
|
"class": props.icon
|
|
}, null);
|
|
};
|
|
}
|
|
});
|
|
function genDefaults2() {
|
|
return {
|
|
svg: {
|
|
component: VSvgIcon
|
|
},
|
|
class: {
|
|
component: VClassIcon
|
|
}
|
|
};
|
|
}
|
|
function createIcons(options) {
|
|
const sets = genDefaults2();
|
|
const defaultSet = (options == null ? void 0 : options.defaultSet) ?? "mdi";
|
|
if (defaultSet === "mdi" && !sets.mdi) {
|
|
sets.mdi = mdi;
|
|
}
|
|
return mergeDeep({
|
|
defaultSet,
|
|
sets,
|
|
aliases: {
|
|
...aliases,
|
|
/* eslint-disable max-len */
|
|
vuetify: ["M8.2241 14.2009L12 21L22 3H14.4459L8.2241 14.2009Z", ["M7.26303 12.4733L7.00113 12L2 3H12.5261C12.5261 3 12.5261 3 12.5261 3L7.26303 12.4733Z", 0.6]],
|
|
"vuetify-outline": "svg:M7.26 12.47 12.53 3H2L7.26 12.47ZM14.45 3 8.22 14.2 12 21 22 3H14.45ZM18.6 5 12 16.88 10.51 14.2 15.62 5ZM7.26 8.35 5.4 5H9.13L7.26 8.35Z",
|
|
"vuetify-play": ["m6.376 13.184-4.11-7.192C1.505 4.66 2.467 3 4.003 3h8.532l-.953 1.576-.006.01-.396.677c-.429.732-.214 1.507.194 2.015.404.503 1.092.878 1.869.806a3.72 3.72 0 0 1 1.005.022c.276.053.434.143.523.237.138.146.38.635-.25 2.09-.893 1.63-1.553 1.722-1.847 1.677-.213-.033-.468-.158-.756-.406a4.95 4.95 0 0 1-.8-.927c-.39-.564-1.04-.84-1.66-.846-.625-.006-1.316.27-1.693.921l-.478.826-.911 1.506Z", ["M9.093 11.552c.046-.079.144-.15.32-.148a.53.53 0 0 1 .43.207c.285.414.636.847 1.046 1.2.405.35.914.662 1.516.754 1.334.205 2.502-.698 3.48-2.495l.014-.028.013-.03c.687-1.574.774-2.852-.005-3.675-.37-.391-.861-.586-1.333-.676a5.243 5.243 0 0 0-1.447-.044c-.173.016-.393-.073-.54-.257-.145-.18-.127-.316-.082-.392l.393-.672L14.287 3h5.71c1.536 0 2.499 1.659 1.737 2.992l-7.997 13.996c-.768 1.344-2.706 1.344-3.473 0l-3.037-5.314 1.377-2.278.004-.006.004-.007.481-.831Z", 0.6]]
|
|
/* eslint-enable max-len */
|
|
}
|
|
}, options);
|
|
}
|
|
var useIcon = (props) => {
|
|
const icons = inject(IconSymbol);
|
|
if (!icons) throw new Error("Missing Vuetify Icons provide!");
|
|
const iconData = computed(() => {
|
|
var _a;
|
|
const iconAlias = unref(props);
|
|
if (!iconAlias) return {
|
|
component: VComponentIcon
|
|
};
|
|
let icon = iconAlias;
|
|
if (typeof icon === "string") {
|
|
icon = icon.trim();
|
|
if (icon.startsWith("$")) {
|
|
icon = (_a = icons.aliases) == null ? void 0 : _a[icon.slice(1)];
|
|
}
|
|
}
|
|
if (!icon) consoleWarn(`Could not find aliased icon "${iconAlias}"`);
|
|
if (Array.isArray(icon)) {
|
|
return {
|
|
component: VSvgIcon,
|
|
icon
|
|
};
|
|
} else if (typeof icon !== "string") {
|
|
return {
|
|
component: VComponentIcon,
|
|
icon
|
|
};
|
|
}
|
|
const iconSetName = Object.keys(icons.sets).find((setName) => typeof icon === "string" && icon.startsWith(`${setName}:`));
|
|
const iconName = iconSetName ? icon.slice(iconSetName.length + 1) : icon;
|
|
const iconSet = icons.sets[iconSetName ?? icons.defaultSet];
|
|
return {
|
|
component: iconSet.component,
|
|
icon: iconName
|
|
};
|
|
});
|
|
return {
|
|
iconData
|
|
};
|
|
};
|
|
|
|
// node_modules/vuetify/lib/composables/resizeObserver.mjs
|
|
function useResizeObserver(callback) {
|
|
let box = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "content";
|
|
const resizeRef = templateRef();
|
|
const contentRect = ref();
|
|
if (IN_BROWSER) {
|
|
const observer = new ResizeObserver((entries) => {
|
|
callback == null ? void 0 : callback(entries, observer);
|
|
if (!entries.length) return;
|
|
if (box === "content") {
|
|
contentRect.value = entries[0].contentRect;
|
|
} else {
|
|
contentRect.value = entries[0].target.getBoundingClientRect();
|
|
}
|
|
});
|
|
onBeforeUnmount(() => {
|
|
observer.disconnect();
|
|
});
|
|
watch(() => resizeRef.el, (newValue, oldValue) => {
|
|
if (oldValue) {
|
|
observer.unobserve(oldValue);
|
|
contentRect.value = void 0;
|
|
}
|
|
if (newValue) observer.observe(newValue);
|
|
}, {
|
|
flush: "post"
|
|
});
|
|
}
|
|
return {
|
|
resizeRef,
|
|
contentRect: readonly(contentRect)
|
|
};
|
|
}
|
|
|
|
// node_modules/vuetify/lib/composables/layout.mjs
|
|
var VuetifyLayoutKey = Symbol.for("vuetify:layout");
|
|
var VuetifyLayoutItemKey = Symbol.for("vuetify:layout-item");
|
|
var ROOT_ZINDEX = 1e3;
|
|
var makeLayoutProps = propsFactory({
|
|
overlaps: {
|
|
type: Array,
|
|
default: () => []
|
|
},
|
|
fullHeight: Boolean
|
|
}, "layout");
|
|
var makeLayoutItemProps = propsFactory({
|
|
name: {
|
|
type: String
|
|
},
|
|
order: {
|
|
type: [Number, String],
|
|
default: 0
|
|
},
|
|
absolute: Boolean
|
|
}, "layout-item");
|
|
function useLayout() {
|
|
const layout = inject(VuetifyLayoutKey);
|
|
if (!layout) throw new Error("[Vuetify] Could not find injected layout");
|
|
return {
|
|
getLayoutItem: layout.getLayoutItem,
|
|
mainRect: layout.mainRect,
|
|
mainStyles: layout.mainStyles
|
|
};
|
|
}
|
|
function useLayoutItem(options) {
|
|
const layout = inject(VuetifyLayoutKey);
|
|
if (!layout) throw new Error("[Vuetify] Could not find injected layout");
|
|
const id = options.id ?? `layout-item-${getUid()}`;
|
|
const vm = getCurrentInstance("useLayoutItem");
|
|
provide(VuetifyLayoutItemKey, {
|
|
id
|
|
});
|
|
const isKeptAlive = shallowRef(false);
|
|
onDeactivated(() => isKeptAlive.value = true);
|
|
onActivated(() => isKeptAlive.value = false);
|
|
const {
|
|
layoutItemStyles,
|
|
layoutItemScrimStyles
|
|
} = layout.register(vm, {
|
|
...options,
|
|
active: computed(() => isKeptAlive.value ? false : options.active.value),
|
|
id
|
|
});
|
|
onBeforeUnmount(() => layout.unregister(id));
|
|
return {
|
|
layoutItemStyles,
|
|
layoutRect: layout.layoutRect,
|
|
layoutItemScrimStyles
|
|
};
|
|
}
|
|
var generateLayers = (layout, positions, layoutSizes, activeItems) => {
|
|
let previousLayer = {
|
|
top: 0,
|
|
left: 0,
|
|
right: 0,
|
|
bottom: 0
|
|
};
|
|
const layers = [{
|
|
id: "",
|
|
layer: {
|
|
...previousLayer
|
|
}
|
|
}];
|
|
for (const id of layout) {
|
|
const position = positions.get(id);
|
|
const amount = layoutSizes.get(id);
|
|
const active = activeItems.get(id);
|
|
if (!position || !amount || !active) continue;
|
|
const layer = {
|
|
...previousLayer,
|
|
[position.value]: parseInt(previousLayer[position.value], 10) + (active.value ? parseInt(amount.value, 10) : 0)
|
|
};
|
|
layers.push({
|
|
id,
|
|
layer
|
|
});
|
|
previousLayer = layer;
|
|
}
|
|
return layers;
|
|
};
|
|
function createLayout(props) {
|
|
const parentLayout = inject(VuetifyLayoutKey, null);
|
|
const rootZIndex = computed(() => parentLayout ? parentLayout.rootZIndex.value - 100 : ROOT_ZINDEX);
|
|
const registered = ref([]);
|
|
const positions = reactive(/* @__PURE__ */ new Map());
|
|
const layoutSizes = reactive(/* @__PURE__ */ new Map());
|
|
const priorities = reactive(/* @__PURE__ */ new Map());
|
|
const activeItems = reactive(/* @__PURE__ */ new Map());
|
|
const disabledTransitions = reactive(/* @__PURE__ */ new Map());
|
|
const {
|
|
resizeRef,
|
|
contentRect: layoutRect
|
|
} = useResizeObserver();
|
|
const computedOverlaps = computed(() => {
|
|
const map = /* @__PURE__ */ new Map();
|
|
const overlaps = props.overlaps ?? [];
|
|
for (const overlap of overlaps.filter((item) => item.includes(":"))) {
|
|
const [top, bottom] = overlap.split(":");
|
|
if (!registered.value.includes(top) || !registered.value.includes(bottom)) continue;
|
|
const topPosition = positions.get(top);
|
|
const bottomPosition = positions.get(bottom);
|
|
const topAmount = layoutSizes.get(top);
|
|
const bottomAmount = layoutSizes.get(bottom);
|
|
if (!topPosition || !bottomPosition || !topAmount || !bottomAmount) continue;
|
|
map.set(bottom, {
|
|
position: topPosition.value,
|
|
amount: parseInt(topAmount.value, 10)
|
|
});
|
|
map.set(top, {
|
|
position: bottomPosition.value,
|
|
amount: -parseInt(bottomAmount.value, 10)
|
|
});
|
|
}
|
|
return map;
|
|
});
|
|
const layers = computed(() => {
|
|
const uniquePriorities = [...new Set([...priorities.values()].map((p) => p.value))].sort((a, b) => a - b);
|
|
const layout = [];
|
|
for (const p of uniquePriorities) {
|
|
const items2 = registered.value.filter((id) => {
|
|
var _a;
|
|
return ((_a = priorities.get(id)) == null ? void 0 : _a.value) === p;
|
|
});
|
|
layout.push(...items2);
|
|
}
|
|
return generateLayers(layout, positions, layoutSizes, activeItems);
|
|
});
|
|
const transitionsEnabled = computed(() => {
|
|
return !Array.from(disabledTransitions.values()).some((ref2) => ref2.value);
|
|
});
|
|
const mainRect = computed(() => {
|
|
return layers.value[layers.value.length - 1].layer;
|
|
});
|
|
const mainStyles = computed(() => {
|
|
return {
|
|
"--v-layout-left": convertToUnit(mainRect.value.left),
|
|
"--v-layout-right": convertToUnit(mainRect.value.right),
|
|
"--v-layout-top": convertToUnit(mainRect.value.top),
|
|
"--v-layout-bottom": convertToUnit(mainRect.value.bottom),
|
|
...transitionsEnabled.value ? void 0 : {
|
|
transition: "none"
|
|
}
|
|
};
|
|
});
|
|
const items = computed(() => {
|
|
return layers.value.slice(1).map((_ref, index) => {
|
|
let {
|
|
id
|
|
} = _ref;
|
|
const {
|
|
layer
|
|
} = layers.value[index];
|
|
const size = layoutSizes.get(id);
|
|
const position = positions.get(id);
|
|
return {
|
|
id,
|
|
...layer,
|
|
size: Number(size.value),
|
|
position: position.value
|
|
};
|
|
});
|
|
});
|
|
const getLayoutItem = (id) => {
|
|
return items.value.find((item) => item.id === id);
|
|
};
|
|
const rootVm = getCurrentInstance("createLayout");
|
|
const isMounted = shallowRef(false);
|
|
onMounted(() => {
|
|
isMounted.value = true;
|
|
});
|
|
provide(VuetifyLayoutKey, {
|
|
register: (vm, _ref2) => {
|
|
let {
|
|
id,
|
|
order,
|
|
position,
|
|
layoutSize,
|
|
elementSize,
|
|
active,
|
|
disableTransitions,
|
|
absolute
|
|
} = _ref2;
|
|
priorities.set(id, order);
|
|
positions.set(id, position);
|
|
layoutSizes.set(id, layoutSize);
|
|
activeItems.set(id, active);
|
|
disableTransitions && disabledTransitions.set(id, disableTransitions);
|
|
const instances = findChildrenWithProvide(VuetifyLayoutItemKey, rootVm == null ? void 0 : rootVm.vnode);
|
|
const instanceIndex = instances.indexOf(vm);
|
|
if (instanceIndex > -1) registered.value.splice(instanceIndex, 0, id);
|
|
else registered.value.push(id);
|
|
const index = computed(() => items.value.findIndex((i) => i.id === id));
|
|
const zIndex = computed(() => rootZIndex.value + layers.value.length * 2 - index.value * 2);
|
|
const layoutItemStyles = computed(() => {
|
|
const isHorizontal = position.value === "left" || position.value === "right";
|
|
const isOppositeHorizontal = position.value === "right";
|
|
const isOppositeVertical = position.value === "bottom";
|
|
const size = elementSize.value ?? layoutSize.value;
|
|
const unit = size === 0 ? "%" : "px";
|
|
const styles = {
|
|
[position.value]: 0,
|
|
zIndex: zIndex.value,
|
|
transform: `translate${isHorizontal ? "X" : "Y"}(${(active.value ? 0 : -(size === 0 ? 100 : size)) * (isOppositeHorizontal || isOppositeVertical ? -1 : 1)}${unit})`,
|
|
position: absolute.value || rootZIndex.value !== ROOT_ZINDEX ? "absolute" : "fixed",
|
|
...transitionsEnabled.value ? void 0 : {
|
|
transition: "none"
|
|
}
|
|
};
|
|
if (!isMounted.value) return styles;
|
|
const item = items.value[index.value];
|
|
if (!item) throw new Error(`[Vuetify] Could not find layout item "${id}"`);
|
|
const overlap = computedOverlaps.value.get(id);
|
|
if (overlap) {
|
|
item[overlap.position] += overlap.amount;
|
|
}
|
|
return {
|
|
...styles,
|
|
height: isHorizontal ? `calc(100% - ${item.top}px - ${item.bottom}px)` : elementSize.value ? `${elementSize.value}px` : void 0,
|
|
left: isOppositeHorizontal ? void 0 : `${item.left}px`,
|
|
right: isOppositeHorizontal ? `${item.right}px` : void 0,
|
|
top: position.value !== "bottom" ? `${item.top}px` : void 0,
|
|
bottom: position.value !== "top" ? `${item.bottom}px` : void 0,
|
|
width: !isHorizontal ? `calc(100% - ${item.left}px - ${item.right}px)` : elementSize.value ? `${elementSize.value}px` : void 0
|
|
};
|
|
});
|
|
const layoutItemScrimStyles = computed(() => ({
|
|
zIndex: zIndex.value - 1
|
|
}));
|
|
return {
|
|
layoutItemStyles,
|
|
layoutItemScrimStyles,
|
|
zIndex
|
|
};
|
|
},
|
|
unregister: (id) => {
|
|
priorities.delete(id);
|
|
positions.delete(id);
|
|
layoutSizes.delete(id);
|
|
activeItems.delete(id);
|
|
disabledTransitions.delete(id);
|
|
registered.value = registered.value.filter((v) => v !== id);
|
|
},
|
|
mainRect,
|
|
mainStyles,
|
|
getLayoutItem,
|
|
items,
|
|
layoutRect,
|
|
rootZIndex
|
|
});
|
|
const layoutClasses = computed(() => ["v-layout", {
|
|
"v-layout--full-height": props.fullHeight
|
|
}]);
|
|
const layoutStyles = computed(() => ({
|
|
zIndex: parentLayout ? rootZIndex.value : void 0,
|
|
position: parentLayout ? "relative" : void 0,
|
|
overflow: parentLayout ? "hidden" : void 0
|
|
}));
|
|
return {
|
|
layoutClasses,
|
|
layoutStyles,
|
|
getLayoutItem,
|
|
items,
|
|
layoutRect,
|
|
layoutRef: resizeRef
|
|
};
|
|
}
|
|
|
|
export {
|
|
DateOptionsSymbol,
|
|
DateAdapterSymbol,
|
|
createDate,
|
|
useDate,
|
|
getWeek,
|
|
GoToSymbol,
|
|
createGoTo,
|
|
useGoTo,
|
|
IconValue,
|
|
IconSymbol,
|
|
VComponentIcon,
|
|
VSvgIcon,
|
|
VLigatureIcon,
|
|
VClassIcon,
|
|
createIcons,
|
|
useIcon,
|
|
useResizeObserver,
|
|
VuetifyLayoutKey,
|
|
makeLayoutProps,
|
|
makeLayoutItemProps,
|
|
useLayout,
|
|
useLayoutItem,
|
|
createLayout
|
|
};
|
|
//# sourceMappingURL=chunk-ZVAJS2IE.js.map
|