poptong
83b162d2bd
Some checks failed
🚀 Deploy - Demo / deployment (push) Has been cancelled
- 웹훅 URL을 https://admin.youtooplay.com/webhook로 변경 - Nginx 리버스 프록시 설정 파일 추가 - 배포 가이드 업데이트
9722 lines
305 KiB
JavaScript
9722 lines
305 KiB
JavaScript
import { computed, defineComponent as defineComponent$1, inject as inject$1, provide, ref, unref, warn, createVNode, Transition, mergeProps, isRef, hasInjectionContext, toRef, shallowRef, watch, nextTick, withDirectives, Fragment, resolveDirective, capitalize, h, camelize, TransitionGroup, Teleport, vShow, watchEffect, reactive, resolveDynamicComponent, getCurrentInstance as getCurrentInstance$1, onScopeDispose, toRaw, Text, readonly, isVNode, Comment, toRefs, effectScope, version as version$1, defineAsyncComponent, shallowReactive, Suspense, useSSRContext, createApp, withCtx, createTextVNode, createBlock, createCommentVNode, openBlock, onErrorCaptured, onServerPrefetch, isReadonly, isShallow, isReactive, getCurrentScope, createElementBlock, createElementVNode } from 'vue';
|
||
import { l as hasProtocol, m as isScriptProtocol, n as joinURL, o as destr, p as klona, w as withQuery, s as sanitizeStatusCode, q as parse, t as getRequestHeader, v as isEqual$1, x as setCookie, g as getCookie, y as deleteCookie, z as getContext, $ as $fetch, A as defu, B as createHooks, c as createError$1, C as toRouteMatcher, D as createRouter$1, E as getRequestHeaders } from '../nitro/nitro.mjs';
|
||
import { b as baseURL } from '../routes/renderer.mjs';
|
||
import { createPinia, setActivePinia, shouldHydrate } from 'pinia';
|
||
import { CapoPlugin } from 'unhead';
|
||
import { defineHeadPlugin } from '@unhead/shared';
|
||
import { useRoute as useRoute$2, RouterView, createMemoryHistory, createRouter, START_LOCATION } from 'vue-router';
|
||
import { ssrRenderComponent, ssrRenderAttrs, ssrInterpolate, ssrRenderStyle, ssrRenderSuspense, ssrRenderVNode } from 'vue/server-renderer';
|
||
import 'node:http';
|
||
import 'node:https';
|
||
import 'node:events';
|
||
import 'node:buffer';
|
||
import 'node:fs';
|
||
import 'node:path';
|
||
import 'node:crypto';
|
||
import 'node:url';
|
||
import 'vue-bundle-renderer/runtime';
|
||
import 'devalue';
|
||
import '@unhead/ssr';
|
||
|
||
if (!globalThis.$fetch) {
|
||
globalThis.$fetch = $fetch.create({
|
||
baseURL: baseURL()
|
||
});
|
||
}
|
||
const appLayoutTransition = false;
|
||
const appPageTransition = false;
|
||
const appKeepalive = false;
|
||
const nuxtLinkDefaults = { "componentName": "NuxtLink", "prefetch": true, "prefetchOn": { "visibility": true } };
|
||
const nuxtDefaultErrorValue = null;
|
||
const appId = "nuxt-app";
|
||
function getNuxtAppCtx(id = appId) {
|
||
return getContext(id, {
|
||
asyncContext: false
|
||
});
|
||
}
|
||
const NuxtPluginIndicator = "__nuxt_plugin";
|
||
function createNuxtApp(options) {
|
||
var _a;
|
||
let hydratingCount = 0;
|
||
const nuxtApp = {
|
||
_id: options.id || appId || "nuxt-app",
|
||
_scope: effectScope(),
|
||
provide: void 0,
|
||
globalName: "nuxt",
|
||
versions: {
|
||
get nuxt() {
|
||
return "3.14.1592";
|
||
},
|
||
get vue() {
|
||
return nuxtApp.vueApp.version;
|
||
}
|
||
},
|
||
payload: shallowReactive({
|
||
...((_a = options.ssrContext) == null ? void 0 : _a.payload) || {},
|
||
data: shallowReactive({}),
|
||
state: reactive({}),
|
||
once: /* @__PURE__ */ new Set(),
|
||
_errors: shallowReactive({})
|
||
}),
|
||
static: {
|
||
data: {}
|
||
},
|
||
runWithContext(fn) {
|
||
if (nuxtApp._scope.active && !getCurrentScope()) {
|
||
return nuxtApp._scope.run(() => callWithNuxt(nuxtApp, fn));
|
||
}
|
||
return callWithNuxt(nuxtApp, fn);
|
||
},
|
||
isHydrating: false,
|
||
deferHydration() {
|
||
if (!nuxtApp.isHydrating) {
|
||
return () => {
|
||
};
|
||
}
|
||
hydratingCount++;
|
||
let called = false;
|
||
return () => {
|
||
if (called) {
|
||
return;
|
||
}
|
||
called = true;
|
||
hydratingCount--;
|
||
if (hydratingCount === 0) {
|
||
nuxtApp.isHydrating = false;
|
||
return nuxtApp.callHook("app:suspense:resolve");
|
||
}
|
||
};
|
||
},
|
||
_asyncDataPromises: {},
|
||
_asyncData: shallowReactive({}),
|
||
_payloadRevivers: {},
|
||
...options
|
||
};
|
||
{
|
||
nuxtApp.payload.serverRendered = true;
|
||
}
|
||
if (nuxtApp.ssrContext) {
|
||
nuxtApp.payload.path = nuxtApp.ssrContext.url;
|
||
nuxtApp.ssrContext.nuxt = nuxtApp;
|
||
nuxtApp.ssrContext.payload = nuxtApp.payload;
|
||
nuxtApp.ssrContext.config = {
|
||
public: nuxtApp.ssrContext.runtimeConfig.public,
|
||
app: nuxtApp.ssrContext.runtimeConfig.app
|
||
};
|
||
}
|
||
nuxtApp.hooks = createHooks();
|
||
nuxtApp.hook = nuxtApp.hooks.hook;
|
||
{
|
||
const contextCaller = async function(hooks, args) {
|
||
for (const hook of hooks) {
|
||
await nuxtApp.runWithContext(() => hook(...args));
|
||
}
|
||
};
|
||
nuxtApp.hooks.callHook = (name, ...args) => nuxtApp.hooks.callHookWith(contextCaller, name, ...args);
|
||
}
|
||
nuxtApp.callHook = nuxtApp.hooks.callHook;
|
||
nuxtApp.provide = (name, value) => {
|
||
const $name = "$" + name;
|
||
defineGetter(nuxtApp, $name, value);
|
||
defineGetter(nuxtApp.vueApp.config.globalProperties, $name, value);
|
||
};
|
||
defineGetter(nuxtApp.vueApp, "$nuxt", nuxtApp);
|
||
defineGetter(nuxtApp.vueApp.config.globalProperties, "$nuxt", nuxtApp);
|
||
const runtimeConfig = options.ssrContext.runtimeConfig;
|
||
nuxtApp.provide("config", runtimeConfig);
|
||
return nuxtApp;
|
||
}
|
||
function registerPluginHooks(nuxtApp, plugin2) {
|
||
if (plugin2.hooks) {
|
||
nuxtApp.hooks.addHooks(plugin2.hooks);
|
||
}
|
||
}
|
||
async function applyPlugin(nuxtApp, plugin2) {
|
||
if (typeof plugin2 === "function") {
|
||
const { provide: provide2 } = await nuxtApp.runWithContext(() => plugin2(nuxtApp)) || {};
|
||
if (provide2 && typeof provide2 === "object") {
|
||
for (const key in provide2) {
|
||
nuxtApp.provide(key, provide2[key]);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
async function applyPlugins(nuxtApp, plugins2) {
|
||
var _a, _b, _c, _d;
|
||
const resolvedPlugins = [];
|
||
const unresolvedPlugins = [];
|
||
const parallels = [];
|
||
const errors = [];
|
||
let promiseDepth = 0;
|
||
async function executePlugin(plugin2) {
|
||
var _a2;
|
||
const unresolvedPluginsForThisPlugin = ((_a2 = plugin2.dependsOn) == null ? void 0 : _a2.filter((name) => plugins2.some((p) => p._name === name) && !resolvedPlugins.includes(name))) ?? [];
|
||
if (unresolvedPluginsForThisPlugin.length > 0) {
|
||
unresolvedPlugins.push([new Set(unresolvedPluginsForThisPlugin), plugin2]);
|
||
} else {
|
||
const promise = applyPlugin(nuxtApp, plugin2).then(async () => {
|
||
if (plugin2._name) {
|
||
resolvedPlugins.push(plugin2._name);
|
||
await Promise.all(unresolvedPlugins.map(async ([dependsOn, unexecutedPlugin]) => {
|
||
if (dependsOn.has(plugin2._name)) {
|
||
dependsOn.delete(plugin2._name);
|
||
if (dependsOn.size === 0) {
|
||
promiseDepth++;
|
||
await executePlugin(unexecutedPlugin);
|
||
}
|
||
}
|
||
}));
|
||
}
|
||
});
|
||
if (plugin2.parallel) {
|
||
parallels.push(promise.catch((e) => errors.push(e)));
|
||
} else {
|
||
await promise;
|
||
}
|
||
}
|
||
}
|
||
for (const plugin2 of plugins2) {
|
||
if (((_a = nuxtApp.ssrContext) == null ? void 0 : _a.islandContext) && ((_b = plugin2.env) == null ? void 0 : _b.islands) === false) {
|
||
continue;
|
||
}
|
||
registerPluginHooks(nuxtApp, plugin2);
|
||
}
|
||
for (const plugin2 of plugins2) {
|
||
if (((_c = nuxtApp.ssrContext) == null ? void 0 : _c.islandContext) && ((_d = plugin2.env) == null ? void 0 : _d.islands) === false) {
|
||
continue;
|
||
}
|
||
await executePlugin(plugin2);
|
||
}
|
||
await Promise.all(parallels);
|
||
if (promiseDepth) {
|
||
for (let i = 0; i < promiseDepth; i++) {
|
||
await Promise.all(parallels);
|
||
}
|
||
}
|
||
if (errors.length) {
|
||
throw errors[0];
|
||
}
|
||
}
|
||
// @__NO_SIDE_EFFECTS__
|
||
function defineNuxtPlugin(plugin2) {
|
||
if (typeof plugin2 === "function") {
|
||
return plugin2;
|
||
}
|
||
const _name = plugin2._name || plugin2.name;
|
||
delete plugin2.name;
|
||
return Object.assign(plugin2.setup || (() => {
|
||
}), plugin2, { [NuxtPluginIndicator]: true, _name });
|
||
}
|
||
const definePayloadPlugin = defineNuxtPlugin;
|
||
function callWithNuxt(nuxt, setup, args) {
|
||
const fn = () => setup();
|
||
const nuxtAppCtx = getNuxtAppCtx(nuxt._id);
|
||
{
|
||
return nuxt.vueApp.runWithContext(() => nuxtAppCtx.callAsync(nuxt, fn));
|
||
}
|
||
}
|
||
function tryUseNuxtApp(id) {
|
||
var _a;
|
||
let nuxtAppInstance;
|
||
if (hasInjectionContext()) {
|
||
nuxtAppInstance = (_a = getCurrentInstance$1()) == null ? void 0 : _a.appContext.app.$nuxt;
|
||
}
|
||
nuxtAppInstance = nuxtAppInstance || getNuxtAppCtx(id).tryUse();
|
||
return nuxtAppInstance || null;
|
||
}
|
||
function useNuxtApp(id) {
|
||
const nuxtAppInstance = tryUseNuxtApp(id);
|
||
if (!nuxtAppInstance) {
|
||
{
|
||
throw new Error("[nuxt] instance unavailable");
|
||
}
|
||
}
|
||
return nuxtAppInstance;
|
||
}
|
||
// @__NO_SIDE_EFFECTS__
|
||
function useRuntimeConfig(_event) {
|
||
return useNuxtApp().$config;
|
||
}
|
||
function defineGetter(obj, key, val) {
|
||
Object.defineProperty(obj, key, { get: () => val });
|
||
}
|
||
const LayoutMetaSymbol = Symbol("layout-meta");
|
||
const PageRouteSymbol = Symbol("route");
|
||
const useRouter$1 = () => {
|
||
var _a;
|
||
return (_a = useNuxtApp()) == null ? void 0 : _a.$router;
|
||
};
|
||
const useRoute$1 = () => {
|
||
if (hasInjectionContext()) {
|
||
return inject$1(PageRouteSymbol, useNuxtApp()._route);
|
||
}
|
||
return useNuxtApp()._route;
|
||
};
|
||
// @__NO_SIDE_EFFECTS__
|
||
function defineNuxtRouteMiddleware(middleware) {
|
||
return middleware;
|
||
}
|
||
const isProcessingMiddleware = () => {
|
||
try {
|
||
if (useNuxtApp()._processingMiddleware) {
|
||
return true;
|
||
}
|
||
} catch {
|
||
return false;
|
||
}
|
||
return false;
|
||
};
|
||
const URL_QUOTE_RE = /"/g;
|
||
const navigateTo = (to, options) => {
|
||
if (!to) {
|
||
to = "/";
|
||
}
|
||
const toPath = typeof to === "string" ? to : "path" in to ? resolveRouteObject(to) : useRouter$1().resolve(to).href;
|
||
const isExternalHost = hasProtocol(toPath, { acceptRelative: true });
|
||
const isExternal = (options == null ? void 0 : options.external) || isExternalHost;
|
||
if (isExternal) {
|
||
if (!(options == null ? void 0 : options.external)) {
|
||
throw new Error("Navigating to an external URL is not allowed by default. Use `navigateTo(url, { external: true })`.");
|
||
}
|
||
const { protocol } = new URL(toPath, "http://localhost");
|
||
if (protocol && isScriptProtocol(protocol)) {
|
||
throw new Error(`Cannot navigate to a URL with '${protocol}' protocol.`);
|
||
}
|
||
}
|
||
const inMiddleware = isProcessingMiddleware();
|
||
const router = useRouter$1();
|
||
const nuxtApp = useNuxtApp();
|
||
{
|
||
if (nuxtApp.ssrContext) {
|
||
const fullPath = typeof to === "string" || isExternal ? toPath : router.resolve(to).fullPath || "/";
|
||
const location2 = isExternal ? toPath : joinURL((/* @__PURE__ */ useRuntimeConfig()).app.baseURL, fullPath);
|
||
const redirect = async function(response) {
|
||
await nuxtApp.callHook("app:redirected");
|
||
const encodedLoc = location2.replace(URL_QUOTE_RE, "%22");
|
||
const encodedHeader = encodeURL(location2, isExternalHost);
|
||
nuxtApp.ssrContext._renderResponse = {
|
||
statusCode: sanitizeStatusCode((options == null ? void 0 : options.redirectCode) || 302, 302),
|
||
body: `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=${encodedLoc}"></head></html>`,
|
||
headers: { location: encodedHeader }
|
||
};
|
||
return response;
|
||
};
|
||
if (!isExternal && inMiddleware) {
|
||
router.afterEach((final) => final.fullPath === fullPath ? redirect(false) : void 0);
|
||
return to;
|
||
}
|
||
return redirect(!inMiddleware ? void 0 : (
|
||
/* abort route navigation */
|
||
false
|
||
));
|
||
}
|
||
}
|
||
if (isExternal) {
|
||
nuxtApp._scope.stop();
|
||
if (options == null ? void 0 : options.replace) {
|
||
(void 0).replace(toPath);
|
||
} else {
|
||
(void 0).href = toPath;
|
||
}
|
||
if (inMiddleware) {
|
||
if (!nuxtApp.isHydrating) {
|
||
return false;
|
||
}
|
||
return new Promise(() => {
|
||
});
|
||
}
|
||
return Promise.resolve();
|
||
}
|
||
return (options == null ? void 0 : options.replace) ? router.replace(to) : router.push(to);
|
||
};
|
||
function resolveRouteObject(to) {
|
||
return withQuery(to.path || "", to.query || {}) + (to.hash || "");
|
||
}
|
||
function encodeURL(location2, isExternalHost = false) {
|
||
const url = new URL(location2, "http://localhost");
|
||
if (!isExternalHost) {
|
||
return url.pathname + url.search + url.hash;
|
||
}
|
||
if (location2.startsWith("//")) {
|
||
return url.toString().replace(url.protocol, "");
|
||
}
|
||
return url.toString();
|
||
}
|
||
const NUXT_ERROR_SIGNATURE = "__nuxt_error";
|
||
const useError = () => toRef(useNuxtApp().payload, "error");
|
||
const showError = (error) => {
|
||
const nuxtError = createError(error);
|
||
try {
|
||
const nuxtApp = useNuxtApp();
|
||
const error2 = useError();
|
||
if (false) ;
|
||
error2.value = error2.value || nuxtError;
|
||
} catch {
|
||
throw nuxtError;
|
||
}
|
||
return nuxtError;
|
||
};
|
||
const clearError = async (options = {}) => {
|
||
const nuxtApp = useNuxtApp();
|
||
const error = useError();
|
||
nuxtApp.callHook("app:error:cleared", options);
|
||
if (options.redirect) {
|
||
await useRouter$1().replace(options.redirect);
|
||
}
|
||
error.value = nuxtDefaultErrorValue;
|
||
};
|
||
const isNuxtError = (error) => !!error && typeof error === "object" && NUXT_ERROR_SIGNATURE in error;
|
||
const createError = (error) => {
|
||
const nuxtError = createError$1(error);
|
||
Object.defineProperty(nuxtError, NUXT_ERROR_SIGNATURE, {
|
||
value: true,
|
||
configurable: false,
|
||
writable: false
|
||
});
|
||
return nuxtError;
|
||
};
|
||
version$1[0] === "3";
|
||
function resolveUnref(r) {
|
||
return typeof r === "function" ? r() : unref(r);
|
||
}
|
||
function resolveUnrefHeadInput(ref2) {
|
||
if (ref2 instanceof Promise || ref2 instanceof Date || ref2 instanceof RegExp)
|
||
return ref2;
|
||
const root = resolveUnref(ref2);
|
||
if (!ref2 || !root)
|
||
return root;
|
||
if (Array.isArray(root))
|
||
return root.map((r) => resolveUnrefHeadInput(r));
|
||
if (typeof root === "object") {
|
||
const resolved = {};
|
||
for (const k in root) {
|
||
if (!Object.prototype.hasOwnProperty.call(root, k)) {
|
||
continue;
|
||
}
|
||
if (k === "titleTemplate" || k[0] === "o" && k[1] === "n") {
|
||
resolved[k] = unref(root[k]);
|
||
continue;
|
||
}
|
||
resolved[k] = resolveUnrefHeadInput(root[k]);
|
||
}
|
||
return resolved;
|
||
}
|
||
return root;
|
||
}
|
||
defineHeadPlugin({
|
||
hooks: {
|
||
"entries:resolve": (ctx) => {
|
||
for (const entry2 of ctx.entries)
|
||
entry2.resolvedInput = resolveUnrefHeadInput(entry2.input);
|
||
}
|
||
}
|
||
});
|
||
const _global = typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
|
||
const globalKey$1 = "__unhead_injection_handler__";
|
||
function setHeadInjectionHandler(handler) {
|
||
_global[globalKey$1] = handler;
|
||
}
|
||
async function getRouteRules(url) {
|
||
{
|
||
const _routeRulesMatcher = toRouteMatcher(
|
||
createRouter$1({ routes: (/* @__PURE__ */ useRuntimeConfig()).nitro.routeRules })
|
||
);
|
||
return defu({}, ..._routeRulesMatcher.matchAll(url).reverse());
|
||
}
|
||
}
|
||
function definePayloadReducer(name, reduce) {
|
||
{
|
||
useNuxtApp().ssrContext._payloadReducers[name] = reduce;
|
||
}
|
||
}
|
||
const payloadPlugin = definePayloadPlugin(() => {
|
||
definePayloadReducer(
|
||
"skipHydrate",
|
||
// We need to return something truthy to be treated as a match
|
||
(data) => !shouldHydrate(data) && 1
|
||
);
|
||
});
|
||
[CapoPlugin({ track: true })];
|
||
const unhead_KgADcZ0jPj = /* @__PURE__ */ defineNuxtPlugin({
|
||
name: "nuxt:head",
|
||
enforce: "pre",
|
||
setup(nuxtApp) {
|
||
const head = nuxtApp.ssrContext.head;
|
||
setHeadInjectionHandler(
|
||
// need a fresh instance of the nuxt app to avoid parallel requests interfering with each other
|
||
() => useNuxtApp().vueApp._context.provides.usehead
|
||
);
|
||
nuxtApp.vueApp.use(head);
|
||
}
|
||
});
|
||
function createContext(opts = {}) {
|
||
let currentInstance;
|
||
let isSingleton = false;
|
||
const checkConflict = (instance) => {
|
||
if (currentInstance && currentInstance !== instance) {
|
||
throw new Error("Context conflict");
|
||
}
|
||
};
|
||
let als;
|
||
if (opts.asyncContext) {
|
||
const _AsyncLocalStorage = opts.AsyncLocalStorage || globalThis.AsyncLocalStorage;
|
||
if (_AsyncLocalStorage) {
|
||
als = new _AsyncLocalStorage();
|
||
} else {
|
||
console.warn("[unctx] `AsyncLocalStorage` is not provided.");
|
||
}
|
||
}
|
||
const _getCurrentInstance = () => {
|
||
if (als) {
|
||
const instance = als.getStore();
|
||
if (instance !== void 0) {
|
||
return instance;
|
||
}
|
||
}
|
||
return currentInstance;
|
||
};
|
||
return {
|
||
use: () => {
|
||
const _instance = _getCurrentInstance();
|
||
if (_instance === void 0) {
|
||
throw new Error("Context is not available");
|
||
}
|
||
return _instance;
|
||
},
|
||
tryUse: () => {
|
||
return _getCurrentInstance();
|
||
},
|
||
set: (instance, replace2) => {
|
||
if (!replace2) {
|
||
checkConflict(instance);
|
||
}
|
||
currentInstance = instance;
|
||
isSingleton = true;
|
||
},
|
||
unset: () => {
|
||
currentInstance = void 0;
|
||
isSingleton = false;
|
||
},
|
||
call: (instance, callback) => {
|
||
checkConflict(instance);
|
||
currentInstance = instance;
|
||
try {
|
||
return als ? als.run(instance, callback) : callback();
|
||
} finally {
|
||
if (!isSingleton) {
|
||
currentInstance = void 0;
|
||
}
|
||
}
|
||
},
|
||
async callAsync(instance, callback) {
|
||
currentInstance = instance;
|
||
const onRestore = () => {
|
||
currentInstance = instance;
|
||
};
|
||
const onLeave = () => currentInstance === instance ? onRestore : void 0;
|
||
asyncHandlers.add(onLeave);
|
||
try {
|
||
const r = als ? als.run(instance, callback) : callback();
|
||
if (!isSingleton) {
|
||
currentInstance = void 0;
|
||
}
|
||
return await r;
|
||
} finally {
|
||
asyncHandlers.delete(onLeave);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
function createNamespace(defaultOpts = {}) {
|
||
const contexts = {};
|
||
return {
|
||
get(key, opts = {}) {
|
||
if (!contexts[key]) {
|
||
contexts[key] = createContext({ ...defaultOpts, ...opts });
|
||
}
|
||
return contexts[key];
|
||
}
|
||
};
|
||
}
|
||
const _globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof global !== "undefined" ? global : {};
|
||
const globalKey = "__unctx__";
|
||
_globalThis[globalKey] || (_globalThis[globalKey] = createNamespace());
|
||
const asyncHandlersKey = "__unctx_async_handlers__";
|
||
const asyncHandlers = _globalThis[asyncHandlersKey] || (_globalThis[asyncHandlersKey] = /* @__PURE__ */ new Set());
|
||
function executeAsync(function_) {
|
||
const restores = [];
|
||
for (const leaveHandler of asyncHandlers) {
|
||
const restore2 = leaveHandler();
|
||
if (restore2) {
|
||
restores.push(restore2);
|
||
}
|
||
}
|
||
const restore = () => {
|
||
for (const restore2 of restores) {
|
||
restore2();
|
||
}
|
||
};
|
||
let awaitable = function_();
|
||
if (awaitable && typeof awaitable === "object" && "catch" in awaitable) {
|
||
awaitable = awaitable.catch((error) => {
|
||
restore();
|
||
throw error;
|
||
});
|
||
}
|
||
return [awaitable, restore];
|
||
}
|
||
const ROUTE_KEY_PARENTHESES_RE$1 = /(:\w+)\([^)]+\)/g;
|
||
const ROUTE_KEY_SYMBOLS_RE$1 = /(:\w+)[?+*]/g;
|
||
const ROUTE_KEY_NORMAL_RE$1 = /:\w+/g;
|
||
const interpolatePath = (route, match) => {
|
||
return match.path.replace(ROUTE_KEY_PARENTHESES_RE$1, "$1").replace(ROUTE_KEY_SYMBOLS_RE$1, "$1").replace(ROUTE_KEY_NORMAL_RE$1, (r) => {
|
||
var _a;
|
||
return ((_a = route.params[r.slice(1)]) == null ? void 0 : _a.toString()) || "";
|
||
});
|
||
};
|
||
const generateRouteKey$1 = (routeProps, override) => {
|
||
const matchedRoute = routeProps.route.matched.find((m) => {
|
||
var _a;
|
||
return ((_a = m.components) == null ? void 0 : _a.default) === routeProps.Component.type;
|
||
});
|
||
const source = override ?? (matchedRoute == null ? void 0 : matchedRoute.meta.key) ?? (matchedRoute && interpolatePath(routeProps.route, matchedRoute));
|
||
return typeof source === "function" ? source(routeProps.route) : source;
|
||
};
|
||
const wrapInKeepAlive = (props, children) => {
|
||
return { default: () => children };
|
||
};
|
||
function toArray(value) {
|
||
return Array.isArray(value) ? value : [value];
|
||
}
|
||
const __nuxt_page_meta$5 = {
|
||
middleware: "auth"
|
||
};
|
||
const __nuxt_page_meta$4 = {
|
||
middleware: "auth"
|
||
};
|
||
const __nuxt_page_meta$3 = {
|
||
middleware: "auth"
|
||
};
|
||
const __nuxt_page_meta$2 = {
|
||
layout: "blank",
|
||
middleware: "guest"
|
||
};
|
||
const __nuxt_page_meta$1 = {
|
||
layout: "blank",
|
||
middleware: "guest"
|
||
};
|
||
const __nuxt_page_meta = {
|
||
middleware: "auth"
|
||
};
|
||
const _routes = [
|
||
{
|
||
name: "account-settings",
|
||
path: "/account-settings",
|
||
component: () => import('./account-settings-BQznxZuU.mjs')
|
||
},
|
||
{
|
||
name: "cards",
|
||
path: "/cards",
|
||
meta: __nuxt_page_meta$5 || {},
|
||
component: () => import('./cards-_QfDIPNa.mjs')
|
||
},
|
||
{
|
||
name: "dashboard",
|
||
path: "/dashboard",
|
||
meta: __nuxt_page_meta$4 || {},
|
||
component: () => import('./dashboard-DIw14Lwt.mjs')
|
||
},
|
||
{
|
||
name: "form-layouts",
|
||
path: "/form-layouts",
|
||
meta: __nuxt_page_meta$3 || {},
|
||
component: () => import('./form-layouts-CTRCMT6u.mjs')
|
||
},
|
||
{
|
||
name: "icons",
|
||
path: "/icons",
|
||
component: () => import('./icons-4rFVWfzn.mjs')
|
||
},
|
||
{
|
||
name: "login",
|
||
path: "/login",
|
||
meta: __nuxt_page_meta$2 || {},
|
||
component: () => import('./login-BwTR74Z-.mjs')
|
||
},
|
||
{
|
||
name: "register",
|
||
path: "/register",
|
||
meta: __nuxt_page_meta$1 || {},
|
||
component: () => import('./register-Dm3ZIgcF.mjs')
|
||
},
|
||
{
|
||
name: "tables",
|
||
path: "/tables",
|
||
meta: __nuxt_page_meta || {},
|
||
component: () => import('./tables-Qmz6ULZO.mjs')
|
||
},
|
||
{
|
||
name: "typography",
|
||
path: "/typography",
|
||
component: () => import('./typography-C-9CLLLs.mjs')
|
||
}
|
||
];
|
||
const _wrapIf = (component, props, slots) => {
|
||
props = props === true ? {} : props;
|
||
return { default: () => {
|
||
var _a;
|
||
return props ? h(component, props, slots) : (_a = slots.default) == null ? void 0 : _a.call(slots);
|
||
} };
|
||
};
|
||
const ROUTE_KEY_PARENTHESES_RE = /(:\w+)\([^)]+\)/g;
|
||
const ROUTE_KEY_SYMBOLS_RE = /(:\w+)[?+*]/g;
|
||
const ROUTE_KEY_NORMAL_RE = /:\w+/g;
|
||
function generateRouteKey(route) {
|
||
const source = (route == null ? void 0 : route.meta.key) ?? route.path.replace(ROUTE_KEY_PARENTHESES_RE, "$1").replace(ROUTE_KEY_SYMBOLS_RE, "$1").replace(ROUTE_KEY_NORMAL_RE, (r) => {
|
||
var _a;
|
||
return ((_a = route.params[r.slice(1)]) == null ? void 0 : _a.toString()) || "";
|
||
});
|
||
return typeof source === "function" ? source(route) : source;
|
||
}
|
||
function isChangingPage(to, from) {
|
||
if (to === from || from === START_LOCATION) {
|
||
return false;
|
||
}
|
||
if (generateRouteKey(to) !== generateRouteKey(from)) {
|
||
return true;
|
||
}
|
||
const areComponentsSame = to.matched.every(
|
||
(comp, index) => {
|
||
var _a, _b;
|
||
return comp.components && comp.components.default === ((_b = (_a = from.matched[index]) == null ? void 0 : _a.components) == null ? void 0 : _b.default);
|
||
}
|
||
);
|
||
if (areComponentsSame) {
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
const routerOptions0 = {
|
||
scrollBehavior(to, from, savedPosition) {
|
||
var _a;
|
||
const nuxtApp = useNuxtApp();
|
||
const behavior = ((_a = useRouter$1().options) == null ? void 0 : _a.scrollBehaviorType) ?? "auto";
|
||
let position = savedPosition || void 0;
|
||
const routeAllowsScrollToTop = typeof to.meta.scrollToTop === "function" ? to.meta.scrollToTop(to, from) : to.meta.scrollToTop;
|
||
if (!position && from && to && routeAllowsScrollToTop !== false && isChangingPage(to, from)) {
|
||
position = { left: 0, top: 0 };
|
||
}
|
||
if (to.path === from.path) {
|
||
if (from.hash && !to.hash) {
|
||
return { left: 0, top: 0 };
|
||
}
|
||
if (to.hash) {
|
||
return { el: to.hash, top: _getHashElementScrollMarginTop(to.hash), behavior };
|
||
}
|
||
return false;
|
||
}
|
||
const hasTransition = (route) => !!(route.meta.pageTransition ?? appPageTransition);
|
||
const hookToWait = hasTransition(from) && hasTransition(to) ? "page:transition:finish" : "page:finish";
|
||
return new Promise((resolve) => {
|
||
nuxtApp.hooks.hookOnce(hookToWait, async () => {
|
||
await new Promise((resolve2) => setTimeout(resolve2, 0));
|
||
if (to.hash) {
|
||
position = { el: to.hash, top: _getHashElementScrollMarginTop(to.hash), behavior };
|
||
}
|
||
resolve(position);
|
||
});
|
||
});
|
||
}
|
||
};
|
||
function _getHashElementScrollMarginTop(selector) {
|
||
try {
|
||
const elem = (void 0).querySelector(selector);
|
||
if (elem) {
|
||
return (Number.parseFloat(getComputedStyle(elem).scrollMarginTop) || 0) + (Number.parseFloat(getComputedStyle((void 0).documentElement).scrollPaddingTop) || 0);
|
||
}
|
||
} catch {
|
||
}
|
||
return 0;
|
||
}
|
||
const routerOptions1 = {
|
||
routes: (scannedRoutes) => [
|
||
...scannedRoutes,
|
||
{
|
||
path: "/",
|
||
name: "index",
|
||
redirect: "/login"
|
||
}
|
||
]
|
||
};
|
||
const configRouterOptions = {
|
||
hashMode: false,
|
||
scrollBehaviorType: "auto"
|
||
};
|
||
const routerOptions = {
|
||
...configRouterOptions,
|
||
...routerOptions0,
|
||
...routerOptions1
|
||
};
|
||
const validate = /* @__PURE__ */ defineNuxtRouteMiddleware(async (to) => {
|
||
var _a;
|
||
let __temp, __restore;
|
||
if (!((_a = to.meta) == null ? void 0 : _a.validate)) {
|
||
return;
|
||
}
|
||
const nuxtApp = useNuxtApp();
|
||
const router = useRouter$1();
|
||
const result = ([__temp, __restore] = executeAsync(() => Promise.resolve(to.meta.validate(to))), __temp = await __temp, __restore(), __temp);
|
||
if (result === true) {
|
||
return;
|
||
}
|
||
const error = createError({
|
||
statusCode: result && result.statusCode || 404,
|
||
statusMessage: result && result.statusMessage || `Page Not Found: ${to.fullPath}`,
|
||
data: {
|
||
path: to.fullPath
|
||
}
|
||
});
|
||
const unsub = router.beforeResolve((final) => {
|
||
unsub();
|
||
if (final === to) {
|
||
const unsub2 = router.afterEach(async () => {
|
||
unsub2();
|
||
await nuxtApp.runWithContext(() => showError(error));
|
||
});
|
||
return false;
|
||
}
|
||
});
|
||
});
|
||
const manifest_45route_45rule = /* @__PURE__ */ defineNuxtRouteMiddleware(async (to) => {
|
||
{
|
||
return;
|
||
}
|
||
});
|
||
const globalMiddleware = [
|
||
validate,
|
||
manifest_45route_45rule
|
||
];
|
||
const namedMiddleware = {
|
||
auth: () => import('./auth-1-RRzcPb.mjs'),
|
||
guest: () => import('./guest-BVuhP81c.mjs')
|
||
};
|
||
const plugin$1 = /* @__PURE__ */ defineNuxtPlugin({
|
||
name: "nuxt:router",
|
||
enforce: "pre",
|
||
async setup(nuxtApp) {
|
||
var _a, _b, _c;
|
||
let __temp, __restore;
|
||
let routerBase = (/* @__PURE__ */ useRuntimeConfig()).app.baseURL;
|
||
if (routerOptions.hashMode && !routerBase.includes("#")) {
|
||
routerBase += "#";
|
||
}
|
||
const history = ((_a = routerOptions.history) == null ? void 0 : _a.call(routerOptions, routerBase)) ?? createMemoryHistory(routerBase);
|
||
const routes = routerOptions.routes ? ([__temp, __restore] = executeAsync(() => routerOptions.routes(_routes)), __temp = await __temp, __restore(), __temp) ?? _routes : _routes;
|
||
let startPosition;
|
||
const router = createRouter({
|
||
...routerOptions,
|
||
scrollBehavior: (to, from, savedPosition) => {
|
||
if (from === START_LOCATION) {
|
||
startPosition = savedPosition;
|
||
return;
|
||
}
|
||
if (routerOptions.scrollBehavior) {
|
||
router.options.scrollBehavior = routerOptions.scrollBehavior;
|
||
if ("scrollRestoration" in (void 0).history) {
|
||
const unsub = router.beforeEach(() => {
|
||
unsub();
|
||
(void 0).history.scrollRestoration = "manual";
|
||
});
|
||
}
|
||
return routerOptions.scrollBehavior(to, START_LOCATION, startPosition || savedPosition);
|
||
}
|
||
},
|
||
history,
|
||
routes
|
||
});
|
||
nuxtApp.vueApp.use(router);
|
||
const previousRoute = shallowRef(router.currentRoute.value);
|
||
router.afterEach((_to, from) => {
|
||
previousRoute.value = from;
|
||
});
|
||
Object.defineProperty(nuxtApp.vueApp.config.globalProperties, "previousRoute", {
|
||
get: () => previousRoute.value
|
||
});
|
||
const initialURL = nuxtApp.ssrContext.url;
|
||
const _route = shallowRef(router.currentRoute.value);
|
||
const syncCurrentRoute = () => {
|
||
_route.value = router.currentRoute.value;
|
||
};
|
||
nuxtApp.hook("page:finish", syncCurrentRoute);
|
||
router.afterEach((to, from) => {
|
||
var _a2, _b2, _c2, _d;
|
||
if (((_b2 = (_a2 = to.matched[0]) == null ? void 0 : _a2.components) == null ? void 0 : _b2.default) === ((_d = (_c2 = from.matched[0]) == null ? void 0 : _c2.components) == null ? void 0 : _d.default)) {
|
||
syncCurrentRoute();
|
||
}
|
||
});
|
||
const route = {};
|
||
for (const key in _route.value) {
|
||
Object.defineProperty(route, key, {
|
||
get: () => _route.value[key],
|
||
enumerable: true
|
||
});
|
||
}
|
||
nuxtApp._route = shallowReactive(route);
|
||
nuxtApp._middleware = nuxtApp._middleware || {
|
||
global: [],
|
||
named: {}
|
||
};
|
||
useError();
|
||
if (!((_b = nuxtApp.ssrContext) == null ? void 0 : _b.islandContext)) {
|
||
router.afterEach(async (to, _from, failure) => {
|
||
delete nuxtApp._processingMiddleware;
|
||
if (failure) {
|
||
await nuxtApp.callHook("page:loading:end");
|
||
}
|
||
if ((failure == null ? void 0 : failure.type) === 4) {
|
||
return;
|
||
}
|
||
if (to.redirectedFrom && to.fullPath !== initialURL) {
|
||
await nuxtApp.runWithContext(() => navigateTo(to.fullPath || "/"));
|
||
}
|
||
});
|
||
}
|
||
try {
|
||
if (true) {
|
||
;
|
||
[__temp, __restore] = executeAsync(() => router.push(initialURL)), await __temp, __restore();
|
||
;
|
||
}
|
||
;
|
||
[__temp, __restore] = executeAsync(() => router.isReady()), await __temp, __restore();
|
||
;
|
||
} catch (error2) {
|
||
[__temp, __restore] = executeAsync(() => nuxtApp.runWithContext(() => showError(error2))), await __temp, __restore();
|
||
}
|
||
const resolvedInitialRoute = router.currentRoute.value;
|
||
syncCurrentRoute();
|
||
if ((_c = nuxtApp.ssrContext) == null ? void 0 : _c.islandContext) {
|
||
return { provide: { router } };
|
||
}
|
||
const initialLayout = nuxtApp.payload.state._layout;
|
||
router.beforeEach(async (to, from) => {
|
||
var _a2, _b2;
|
||
await nuxtApp.callHook("page:loading:start");
|
||
to.meta = reactive(to.meta);
|
||
if (nuxtApp.isHydrating && initialLayout && !isReadonly(to.meta.layout)) {
|
||
to.meta.layout = initialLayout;
|
||
}
|
||
nuxtApp._processingMiddleware = true;
|
||
if (!((_a2 = nuxtApp.ssrContext) == null ? void 0 : _a2.islandContext)) {
|
||
const middlewareEntries = /* @__PURE__ */ new Set([...globalMiddleware, ...nuxtApp._middleware.global]);
|
||
for (const component of to.matched) {
|
||
const componentMiddleware = component.meta.middleware;
|
||
if (!componentMiddleware) {
|
||
continue;
|
||
}
|
||
for (const entry2 of toArray(componentMiddleware)) {
|
||
middlewareEntries.add(entry2);
|
||
}
|
||
}
|
||
{
|
||
const routeRules = await nuxtApp.runWithContext(() => getRouteRules(to.path));
|
||
if (routeRules.appMiddleware) {
|
||
for (const key in routeRules.appMiddleware) {
|
||
if (routeRules.appMiddleware[key]) {
|
||
middlewareEntries.add(key);
|
||
} else {
|
||
middlewareEntries.delete(key);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
for (const entry2 of middlewareEntries) {
|
||
const middleware = typeof entry2 === "string" ? nuxtApp._middleware.named[entry2] || await ((_b2 = namedMiddleware[entry2]) == null ? void 0 : _b2.call(namedMiddleware).then((r) => r.default || r)) : entry2;
|
||
if (!middleware) {
|
||
throw new Error(`Unknown route middleware: '${entry2}'.`);
|
||
}
|
||
const result = await nuxtApp.runWithContext(() => middleware(to, from));
|
||
{
|
||
if (result === false || result instanceof Error) {
|
||
const error2 = result || createError$1({
|
||
statusCode: 404,
|
||
statusMessage: `Page Not Found: ${initialURL}`
|
||
});
|
||
await nuxtApp.runWithContext(() => showError(error2));
|
||
return false;
|
||
}
|
||
}
|
||
if (result === true) {
|
||
continue;
|
||
}
|
||
if (result || result === false) {
|
||
return result;
|
||
}
|
||
}
|
||
}
|
||
});
|
||
router.onError(async () => {
|
||
delete nuxtApp._processingMiddleware;
|
||
await nuxtApp.callHook("page:loading:end");
|
||
});
|
||
router.afterEach(async (to, _from) => {
|
||
if (to.matched.length === 0) {
|
||
await nuxtApp.runWithContext(() => showError(createError$1({
|
||
statusCode: 404,
|
||
fatal: false,
|
||
statusMessage: `Page not found: ${to.fullPath}`,
|
||
data: {
|
||
path: to.fullPath
|
||
}
|
||
})));
|
||
}
|
||
});
|
||
nuxtApp.hooks.hookOnce("app:created", async () => {
|
||
try {
|
||
if ("name" in resolvedInitialRoute) {
|
||
resolvedInitialRoute.name = void 0;
|
||
}
|
||
await router.replace({
|
||
...resolvedInitialRoute,
|
||
force: true
|
||
});
|
||
router.options.scrollBehavior = routerOptions.scrollBehavior;
|
||
} catch (error2) {
|
||
await nuxtApp.runWithContext(() => showError(error2));
|
||
}
|
||
});
|
||
return { provide: { router } };
|
||
}
|
||
});
|
||
const reducers = [
|
||
["NuxtError", (data) => isNuxtError(data) && data.toJSON()],
|
||
["EmptyShallowRef", (data) => isRef(data) && isShallow(data) && !data.value && (typeof data.value === "bigint" ? "0n" : JSON.stringify(data.value) || "_")],
|
||
["EmptyRef", (data) => isRef(data) && !data.value && (typeof data.value === "bigint" ? "0n" : JSON.stringify(data.value) || "_")],
|
||
["ShallowRef", (data) => isRef(data) && isShallow(data) && data.value],
|
||
["ShallowReactive", (data) => isReactive(data) && isShallow(data) && toRaw(data)],
|
||
["Ref", (data) => isRef(data) && data.value],
|
||
["Reactive", (data) => isReactive(data) && toRaw(data)]
|
||
];
|
||
const revive_payload_server_eJ33V7gbc6 = /* @__PURE__ */ defineNuxtPlugin({
|
||
name: "nuxt:revive-payload:server",
|
||
setup() {
|
||
for (const [reducer, fn] of reducers) {
|
||
definePayloadReducer(reducer, fn);
|
||
}
|
||
}
|
||
});
|
||
function useRequestEvent(nuxtApp = useNuxtApp()) {
|
||
var _a;
|
||
return (_a = nuxtApp.ssrContext) == null ? void 0 : _a.event;
|
||
}
|
||
function useRequestHeaders(include) {
|
||
const event = useRequestEvent();
|
||
const _headers = event ? getRequestHeaders(event) : {};
|
||
{
|
||
return _headers;
|
||
}
|
||
}
|
||
const CookieDefaults = {
|
||
path: "/",
|
||
watch: true,
|
||
decode: (val) => destr(decodeURIComponent(val)),
|
||
encode: (val) => encodeURIComponent(typeof val === "string" ? val : JSON.stringify(val))
|
||
};
|
||
function useCookie(name, _opts) {
|
||
var _a;
|
||
const opts = { ...CookieDefaults, ..._opts };
|
||
opts.filter ?? (opts.filter = (key) => key === name);
|
||
const cookies = readRawCookies(opts) || {};
|
||
let delay;
|
||
if (opts.maxAge !== void 0) {
|
||
delay = opts.maxAge * 1e3;
|
||
} else if (opts.expires) {
|
||
delay = opts.expires.getTime() - Date.now();
|
||
}
|
||
const hasExpired = delay !== void 0 && delay <= 0;
|
||
const cookieValue = klona(hasExpired ? void 0 : cookies[name] ?? ((_a = opts.default) == null ? void 0 : _a.call(opts)));
|
||
const cookie = ref(cookieValue);
|
||
{
|
||
const nuxtApp = useNuxtApp();
|
||
const writeFinalCookieValue = () => {
|
||
if (opts.readonly || isEqual$1(cookie.value, cookies[name])) {
|
||
return;
|
||
}
|
||
nuxtApp._cookies || (nuxtApp._cookies = {});
|
||
if (name in nuxtApp._cookies) {
|
||
if (isEqual$1(cookie.value, nuxtApp._cookies[name])) {
|
||
return;
|
||
}
|
||
}
|
||
nuxtApp._cookies[name] = cookie.value;
|
||
writeServerCookie(useRequestEvent(nuxtApp), name, cookie.value, opts);
|
||
};
|
||
const unhook = nuxtApp.hooks.hookOnce("app:rendered", writeFinalCookieValue);
|
||
nuxtApp.hooks.hookOnce("app:error", () => {
|
||
unhook();
|
||
return writeFinalCookieValue();
|
||
});
|
||
}
|
||
return cookie;
|
||
}
|
||
function readRawCookies(opts = {}) {
|
||
{
|
||
return parse(getRequestHeader(useRequestEvent(), "cookie") || "", opts);
|
||
}
|
||
}
|
||
function writeServerCookie(event, name, value, opts = {}) {
|
||
if (event) {
|
||
if (value !== null && value !== void 0) {
|
||
return setCookie(event, name, value, opts);
|
||
}
|
||
if (getCookie(event, name) !== void 0) {
|
||
return deleteCookie(event, name, opts);
|
||
}
|
||
}
|
||
}
|
||
const plugin = /* @__PURE__ */ defineNuxtPlugin({
|
||
name: "pinia",
|
||
setup(nuxtApp) {
|
||
const pinia = createPinia();
|
||
nuxtApp.vueApp.use(pinia);
|
||
setActivePinia(pinia);
|
||
{
|
||
nuxtApp.payload.pinia = toRaw(pinia.state.value);
|
||
}
|
||
return {
|
||
provide: {
|
||
pinia
|
||
}
|
||
};
|
||
}
|
||
});
|
||
const components_plugin_KR1HBZs4kY = /* @__PURE__ */ defineNuxtPlugin({
|
||
name: "nuxt:global-components"
|
||
});
|
||
const REGEX_CRAWLER = new RegExp(/Googlebot\/|Googlebot-Mobile|Googlebot-Image|Googlebot-News|Googlebot-Video|AdsBot-Google([^-]|$)|AdsBot-Google-Mobile|Feedfetcher-Google|Mediapartners-Google|Mediapartners \(Googlebot\)|APIs-Google|Google-InspectionTool|Storebot-Google|GoogleOther|bingbot|Slurp|[wW]get|LinkedInBot|Python-urllib|python-requests|aiohttp|httpx|libwww-perl|httpunit|Nutch|Go-http-client|phpcrawl|msnbot|jyxobot|FAST-WebCrawler|FAST Enterprise Crawler|BIGLOTRON|Teoma|convera|seekbot|Gigabot|Gigablast|exabot|ia_archiver|GingerCrawler|webmon |HTTrack|grub\.org|UsineNouvelleCrawler|antibot|netresearchserver|speedy|fluffy|findlink|msrbot|panscient|yacybot|AISearchBot|ips-agent|tagoobot|MJ12bot|woriobot|yanga|buzzbot|mlbot|yandex\.com\/bots|purebot|Linguee Bot|CyberPatrol|voilabot|Baiduspider|citeseerxbot|spbot|twengabot|postrank|Turnitin|scribdbot|page2rss|sitebot|linkdex|Adidxbot|ezooms|dotbot|Mail\.RU_Bot|discobot|heritrix|findthatfile|europarchive\.org|NerdByNature\.Bot|(sistrix|SISTRIX) [cC]rawler|Ahrefs(Bot|SiteAudit)|fuelbot|CrunchBot|IndeedBot|mappydata|woobot|ZoominfoBot|PrivacyAwareBot|Multiviewbot|SWIMGBot|Grobbot|eright|Apercite|semanticbot|Aboundex|domaincrawler|wbsearchbot|summify|CCBot|edisterbot|SeznamBot|ec2linkfinder|gslfbot|aiHitBot|intelium_bot|facebookexternalhit|Yeti|RetrevoPageAnalyzer|lb-spider|Sogou|lssbot|careerbot|wotbox|wocbot|ichiro|DuckDuckBot|lssrocketcrawler|drupact|webcompanycrawler|acoonbot|openindexspider|gnam gnam spider|web-archive-net\.com\.bot|backlinkcrawler|coccoc|integromedb|content crawler spider|toplistbot|it2media-domain-crawler|ip-web-crawler\.com|siteexplorer\.info|elisabot|proximic|changedetection|arabot|WeSEE:Search|niki-bot|CrystalSemanticsBot|rogerbot|360Spider|psbot|InterfaxScanBot|CC Metadata Scaper|g00g1e\.net|GrapeshotCrawler|urlappendbot|brainobot|fr-crawler|binlar|SimpleCrawler|Twitterbot|cXensebot|smtbot|bnf\.fr_bot|A6-Indexer|ADmantX|Facebot|OrangeBot\/|memorybot|AdvBot|MegaIndex|SemanticScholarBot|ltx71|nerdybot|xovibot|BUbiNG|Qwantify|archive\.org_bot|Applebot|TweetmemeBot|crawler4j|findxbot|S[eE][mM]rushBot|yoozBot|lipperhey|Y!J|Domain Re-Animator Bot|AddThis|Screaming Frog SEO Spider|MetaURI|Scrapy|Livelap[bB]ot|OpenHoseBot|CapsuleChecker|collection@infegy\.com|IstellaBot|DeuSu\/|betaBot|Cliqzbot\/|MojeekBot\/|netEstate NE Crawler|SafeSearch microdata crawler|Gluten Free Crawler\/|Sonic|Sysomos|Trove|deadlinkchecker|Slack-ImgProxy|Embedly|RankActiveLinkBot|iskanie|SafeDNSBot|SkypeUriPreview|Veoozbot|Slackbot|redditbot|datagnionbot|Google-Adwords-Instant|adbeat_bot|WhatsApp|contxbot|pinterest\.com\/bot|electricmonk|GarlikCrawler|BingPreview\/|vebidoobot|FemtosearchBot|Yahoo Link Preview|MetaJobBot|DomainStatsBot|mindUpBot|Daum\/|Jugendschutzprogramm-Crawler|Xenu Link Sleuth|Pcore-HTTP|moatbot|KosmioBot|[pP]ingdom|AppInsights|PhantomJS|Gowikibot|PiplBot|Discordbot|TelegramBot|Jetslide|newsharecounts|James BOT|Bark[rR]owler|TinEye|SocialRankIOBot|trendictionbot|Ocarinabot|epicbot|Primalbot|DuckDuckGo-Favicons-Bot|GnowitNewsbot|Leikibot|LinkArchiver|YaK\/|PaperLiBot|Digg Deeper|dcrawl|Snacktory|AndersPinkBot|Fyrebot|EveryoneSocialBot|Mediatoolkitbot|Luminator-robots|ExtLinksBot|SurveyBot|NING\/|okhttp|Nuzzel|omgili|PocketParser|YisouSpider|um-LN|ToutiaoSpider|MuckRack|Jamie's Spider|AHC\/|NetcraftSurveyAgent|Laserlikebot|^Apache-HttpClient|AppEngine-Google|Jetty|Upflow|Thinklab|Traackr\.com|Twurly|Mastodon|http_get|DnyzBot|botify|007ac9 Crawler|BehloolBot|BrandVerity|check_http|BDCbot|ZumBot|EZID|ICC-Crawler|ArchiveBot|^LCC |filterdb\.iss\.net\/crawler|BLP_bbot|BomboraBot|Buck\/|Companybook-Crawler|Genieo|magpie-crawler|MeltwaterNews|Moreover|newspaper\/|ScoutJet|(^| )sentry\/|StorygizeBot|UptimeRobot|OutclicksBot|seoscanners|Hatena|Google Web Preview|MauiBot|AlphaBot|SBL-BOT|IAS crawler|adscanner|Netvibes|acapbot|Baidu-YunGuanCe|bitlybot|blogmuraBot|Bot\.AraTurka\.com|bot-pge\.chlooe\.com|BoxcarBot|BTWebClient|ContextAd Bot|Digincore bot|Disqus|Feedly|Fetch\/|Fever|Flamingo_SearchEngine|FlipboardProxy|g2reader-bot|G2 Web Services|imrbot|K7MLWCBot|Kemvibot|Landau-Media-Spider|linkapediabot|vkShare|Siteimprove\.com|BLEXBot\/|DareBoost|ZuperlistBot\/|Miniflux\/|Feedspot|Diffbot\/|SEOkicks|tracemyfile|Nimbostratus-Bot|zgrab|PR-CY\.RU|AdsTxtCrawler|Datafeedwatch|Zabbix|TangibleeBot|google-xrawler|axios|Amazon CloudFront|Pulsepoint|CloudFlare-AlwaysOnline|Google-Structured-Data-Testing-Tool|WordupInfoSearch|WebDataStats|HttpUrlConnection|ZoomBot|VelenPublicWebCrawler|MoodleBot|jpg-newsbot|outbrain|W3C_Validator|Validator\.nu|W3C-checklink|W3C-mobileOK|W3C_I18n-Checker|FeedValidator|W3C_CSS_Validator|W3C_Unicorn|Google-PhysicalWeb|Blackboard|ICBot\/|BazQux|Twingly|Rivva|Experibot|awesomecrawler|Dataprovider\.com|GroupHigh\/|theoldreader\.com|AnyEvent|Uptimebot\.org|Nmap Scripting Engine|2ip\.ru|Clickagy|Caliperbot|MBCrawler|online-webceo-bot|B2B Bot|AddSearchBot|Google Favicon|HubSpot|Chrome-Lighthouse|HeadlessChrome|CheckMarkNetwork\/|www\.uptime\.com|Streamline3Bot\/|serpstatbot\/|MixnodeCache\/|^curl|SimpleScraper|RSSingBot|Jooblebot|fedoraplanet|Friendica|NextCloud|Tiny Tiny RSS|RegionStuttgartBot|Bytespider|Datanyze|Google-Site-Verification|TrendsmapResolver|tweetedtimes|NTENTbot|Gwene|SimplePie|SearchAtlas|Superfeedr|feedbot|UT-Dorkbot|Amazonbot|SerendeputyBot|Eyeotabot|officestorebot|Neticle Crawler|SurdotlyBot|LinkisBot|AwarioSmartBot|AwarioRssBot|RyteBot|FreeWebMonitoring SiteChecker|AspiegelBot|NAVER Blog Rssbot|zenback bot|SentiBot|Domains Project\/|Pandalytics|VKRobot|bidswitchbot|tigerbot|NIXStatsbot|Atom Feed Robot|[Cc]urebot|PagePeeker\/|Vigil\/|rssbot\/|startmebot\/|JobboerseBot|seewithkids|NINJA bot|Cutbot|BublupBot|BrandONbot|RidderBot|Taboolabot|Dubbotbot|FindITAnswersbot|infoobot|Refindbot|BlogTraffic\/\d\.\d+ Feed-Fetcher|SeobilityBot|Cincraw|Dragonbot|VoluumDSP-content-bot|FreshRSS|BitBot|^PHP-Curl-Class|Google-Certificates-Bridge|centurybot|Viber|e\.ventures Investment Crawler|evc-batch|PetalBot|virustotal|(^| )PTST\/|minicrawler|Cookiebot|trovitBot|seostar\.co|IonCrawl|Uptime-Kuma|Seekport|FreshpingBot|Feedbin|CriteoBot|Snap URL Preview Service|Better Uptime Bot|RuxitSynthetic|Google-Read-Aloud|Valve\/Steam|OdklBot\/|GPTBot|ChatGPT-User|YandexRenderResourcesBot\/|LightspeedSystemsCrawler|ev-crawler\/|BitSightBot\/|woorankreview\/|Google-Safety|AwarioBot|DataForSeoBot|Linespider|WellKnownBot|A Patent Crawler|StractBot|search\.marginalia\.nu|YouBot|Nicecrawler|Neevabot|BrightEdge Crawler|SiteCheckerBotCrawler|TombaPublicWebCrawler|CrawlyProjectCrawler|KomodiaBot|KStandBot|CISPA Webcrawler|MTRobot|hyscore\.io|AlexandriaOrgBot|2ip bot|Yellowbrandprotectionbot|SEOlizer|vuhuvBot|INETDEX-BOT|Synapse|t3versionsBot|deepnoc|Cocolyzebot|hypestat|ReverseEngineeringBot|sempi\.tech|Iframely|MetaInspector|node-fetch|lkxscan|python-opengraph|OpenGraphCheck|developers\.google\.com\/\+\/web\/snippet|SenutoBot|MaCoCu|NewsBlur|inoreader|NetSystemsResearch|PageThing|WordPress\/|PhxBot|ImagesiftBot|Expanse|InternetMeasurement|^BW\/|GeedoBot|Audisto Crawler|PerplexityBot\/|[cC]laude[bB]ot|Monsidobot|GroupMeBot|Vercelbot|vercel-screenshot/);
|
||
const REGEX_MOBILE1 = /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|FBAN|FBAV|fennec|hiptop|iemobile|ip(hone|od)|Instagram|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i;
|
||
const REGEX_MOBILE2 = /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i;
|
||
const REGEX_MOBILE_OR_TABLET1 = /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|FBAN|FBAV|fennec|hiptop|iemobile|ip(hone|od)|Instagram|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i;
|
||
const REGEX_MOBILE_OR_TABLET2 = /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i;
|
||
function isMobile(userAgent) {
|
||
return REGEX_MOBILE1.test(userAgent) || REGEX_MOBILE2.test(userAgent.slice(0, 4));
|
||
}
|
||
function isMobileOrTablet(userAgent) {
|
||
return REGEX_MOBILE_OR_TABLET1.test(userAgent) || REGEX_MOBILE_OR_TABLET2.test(userAgent.slice(0, 4));
|
||
}
|
||
function isIos(userAgent) {
|
||
return /iPad|iPhone|iPod/.test(userAgent);
|
||
}
|
||
function isAndroid(userAgent) {
|
||
return /android/i.test(userAgent);
|
||
}
|
||
function isWindows(userAgent) {
|
||
return /Windows/.test(userAgent);
|
||
}
|
||
function isMacOS(userAgent) {
|
||
return /Mac OS X/.test(userAgent);
|
||
}
|
||
const browsers = [
|
||
{ name: "Samsung", regex: /SamsungBrowser/i },
|
||
{ name: "Edge", regex: /edg(?:[ea]|ios)?\//i },
|
||
{ name: "Firefox", regex: /firefox|iceweasel|fxios/i },
|
||
{ name: "Chrome", regex: /chrome|crios|crmo/i },
|
||
{ name: "Safari", regex: /safari|applewebkit/i }
|
||
];
|
||
function getBrowserName(userAgent) {
|
||
for (const browser of browsers) {
|
||
if (browser.regex.test(userAgent)) {
|
||
return browser.name;
|
||
}
|
||
}
|
||
return "";
|
||
}
|
||
function generateFlags(userAgent, headers = {}) {
|
||
let mobile = false;
|
||
let mobileOrTablet = false;
|
||
let ios = false;
|
||
let android = false;
|
||
if (userAgent === "Amazon CloudFront") {
|
||
if (headers["cloudfront-is-mobile-viewer"] === "true") {
|
||
mobile = true;
|
||
mobileOrTablet = true;
|
||
}
|
||
if (headers["cloudfront-is-tablet-viewer"] === "true") {
|
||
mobile = false;
|
||
mobileOrTablet = true;
|
||
}
|
||
if (headers["cloudfront-is-desktop-viewer"] === "true") {
|
||
mobile = false;
|
||
mobileOrTablet = false;
|
||
}
|
||
if (headers["cloudfront-is-ios-viewer"] === "true") {
|
||
ios = true;
|
||
}
|
||
if (headers["cloudfront-is-android-viewer"] === "true") {
|
||
android = true;
|
||
}
|
||
} else if (headers && headers["cf-device-type"]) {
|
||
switch (headers["cf-device-type"]) {
|
||
case "mobile":
|
||
mobile = true;
|
||
mobileOrTablet = true;
|
||
break;
|
||
case "tablet":
|
||
mobile = false;
|
||
mobileOrTablet = true;
|
||
break;
|
||
case "desktop":
|
||
mobile = false;
|
||
mobileOrTablet = false;
|
||
break;
|
||
}
|
||
} else {
|
||
mobile = isMobile(userAgent);
|
||
mobileOrTablet = isMobileOrTablet(userAgent);
|
||
ios = isIos(userAgent);
|
||
android = isAndroid(userAgent);
|
||
}
|
||
const windows = isWindows(userAgent);
|
||
const macOS = isMacOS(userAgent);
|
||
const browserName = getBrowserName(userAgent);
|
||
const isSafari = browserName === "Safari";
|
||
const isFirefox = browserName === "Firefox";
|
||
const isEdge = browserName === "Edge";
|
||
const isChrome = browserName === "Chrome";
|
||
const isSamsung = browserName === "Samsung";
|
||
const isCrawler = REGEX_CRAWLER.test(userAgent);
|
||
return {
|
||
userAgent,
|
||
isMobile: mobile,
|
||
isMobileOrTablet: mobileOrTablet,
|
||
isTablet: !mobile && mobileOrTablet,
|
||
isDesktop: !mobileOrTablet,
|
||
isIos: ios,
|
||
isAndroid: android,
|
||
isWindows: windows,
|
||
isMacOS: macOS,
|
||
isApple: macOS || ios,
|
||
isDesktopOrTablet: !mobile,
|
||
isSafari,
|
||
isFirefox,
|
||
isEdge,
|
||
isChrome,
|
||
isSamsung,
|
||
isCrawler
|
||
};
|
||
}
|
||
const plugin_ghbUAjaD3n = /* @__PURE__ */ defineNuxtPlugin(() => {
|
||
const runtimeConfig = /* @__PURE__ */ useRuntimeConfig();
|
||
const defaultUserAgent = runtimeConfig.public.device.defaultUserAgent;
|
||
let flags;
|
||
{
|
||
const headers = useRequestHeaders();
|
||
const userAgent = headers["user-agent"] || defaultUserAgent;
|
||
flags = reactive(generateFlags(userAgent, headers));
|
||
}
|
||
return {
|
||
provide: {
|
||
device: flags
|
||
}
|
||
};
|
||
});
|
||
function useToggleScope(source, fn) {
|
||
let scope;
|
||
function start() {
|
||
scope = effectScope();
|
||
scope.run(() => fn.length ? fn(() => {
|
||
scope == null ? void 0 : scope.stop();
|
||
start();
|
||
}) : fn());
|
||
}
|
||
watch(source, (active) => {
|
||
if (active && !scope) {
|
||
start();
|
||
} else if (!active) {
|
||
scope == null ? void 0 : scope.stop();
|
||
scope = void 0;
|
||
}
|
||
}, {
|
||
immediate: true
|
||
});
|
||
onScopeDispose(() => {
|
||
scope == null ? void 0 : scope.stop();
|
||
});
|
||
}
|
||
const IN_BROWSER = false;
|
||
const SUPPORTS_TOUCH = IN_BROWSER;
|
||
function getNestedValue(obj, path, fallback) {
|
||
const last = path.length - 1;
|
||
if (last < 0) return obj === void 0 ? fallback : obj;
|
||
for (let i = 0; i < last; i++) {
|
||
if (obj == null) {
|
||
return fallback;
|
||
}
|
||
obj = obj[path[i]];
|
||
}
|
||
if (obj == null) return fallback;
|
||
return obj[path[last]] === void 0 ? fallback : obj[path[last]];
|
||
}
|
||
function deepEqual(a, b) {
|
||
if (a === b) return true;
|
||
if (a instanceof Date && b instanceof Date && a.getTime() !== b.getTime()) {
|
||
return false;
|
||
}
|
||
if (a !== Object(a) || b !== Object(b)) {
|
||
return false;
|
||
}
|
||
const props = Object.keys(a);
|
||
if (props.length !== Object.keys(b).length) {
|
||
return false;
|
||
}
|
||
return props.every((p) => deepEqual(a[p], b[p]));
|
||
}
|
||
function getObjectValueByPath(obj, path, fallback) {
|
||
if (obj == null || !path || typeof path !== "string") return fallback;
|
||
if (obj[path] !== void 0) return obj[path];
|
||
path = path.replace(/\[(\w+)\]/g, ".$1");
|
||
path = path.replace(/^\./, "");
|
||
return getNestedValue(obj, path.split("."), fallback);
|
||
}
|
||
function getPropertyFromItem(item, property, fallback) {
|
||
if (property === true) return item === void 0 ? fallback : item;
|
||
if (property == null || typeof property === "boolean") return fallback;
|
||
if (item !== Object(item)) {
|
||
if (typeof property !== "function") return fallback;
|
||
const value2 = property(item, fallback);
|
||
return typeof value2 === "undefined" ? fallback : value2;
|
||
}
|
||
if (typeof property === "string") return getObjectValueByPath(item, property, fallback);
|
||
if (Array.isArray(property)) return getNestedValue(item, property, fallback);
|
||
if (typeof property !== "function") return fallback;
|
||
const value = property(item, fallback);
|
||
return typeof value === "undefined" ? fallback : value;
|
||
}
|
||
function createRange(length) {
|
||
let start = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
|
||
return Array.from({
|
||
length
|
||
}, (v, k) => start + k);
|
||
}
|
||
function convertToUnit(str) {
|
||
let unit = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "px";
|
||
if (str == null || str === "") {
|
||
return void 0;
|
||
} else if (isNaN(+str)) {
|
||
return String(str);
|
||
} else if (!isFinite(+str)) {
|
||
return void 0;
|
||
} else {
|
||
return `${Number(str)}${unit}`;
|
||
}
|
||
}
|
||
function isObject(obj) {
|
||
return obj !== null && typeof obj === "object" && !Array.isArray(obj);
|
||
}
|
||
function isPlainObject(obj) {
|
||
let proto;
|
||
return obj !== null && typeof obj === "object" && ((proto = Object.getPrototypeOf(obj)) === Object.prototype || proto === null);
|
||
}
|
||
function refElement(obj) {
|
||
if (obj && "$el" in obj) {
|
||
const el = obj.$el;
|
||
if ((el == null ? void 0 : el.nodeType) === Node.TEXT_NODE) {
|
||
return el.nextElementSibling;
|
||
}
|
||
return el;
|
||
}
|
||
return obj;
|
||
}
|
||
const keyCodes = Object.freeze({
|
||
enter: 13,
|
||
tab: 9,
|
||
delete: 46,
|
||
esc: 27,
|
||
space: 32,
|
||
up: 38,
|
||
down: 40,
|
||
left: 37,
|
||
right: 39,
|
||
end: 35,
|
||
home: 36,
|
||
del: 46,
|
||
backspace: 8,
|
||
insert: 45,
|
||
pageup: 33,
|
||
pagedown: 34,
|
||
shift: 16
|
||
});
|
||
const keyValues = Object.freeze({
|
||
enter: "Enter",
|
||
tab: "Tab",
|
||
delete: "Delete",
|
||
esc: "Escape",
|
||
space: "Space",
|
||
up: "ArrowUp",
|
||
down: "ArrowDown",
|
||
left: "ArrowLeft",
|
||
right: "ArrowRight",
|
||
end: "End",
|
||
home: "Home",
|
||
del: "Delete",
|
||
backspace: "Backspace",
|
||
insert: "Insert",
|
||
pageup: "PageUp",
|
||
pagedown: "PageDown",
|
||
shift: "Shift"
|
||
});
|
||
function keys(o) {
|
||
return Object.keys(o);
|
||
}
|
||
function has(obj, key) {
|
||
return key.every((k) => obj.hasOwnProperty(k));
|
||
}
|
||
function pick(obj, paths) {
|
||
const found = {};
|
||
const keys2 = new Set(Object.keys(obj));
|
||
for (const path of paths) {
|
||
if (keys2.has(path)) {
|
||
found[path] = obj[path];
|
||
}
|
||
}
|
||
return found;
|
||
}
|
||
function pickWithRest(obj, paths, exclude) {
|
||
const found = /* @__PURE__ */ Object.create(null);
|
||
const rest = /* @__PURE__ */ Object.create(null);
|
||
for (const key in obj) {
|
||
if (paths.some((path) => path instanceof RegExp ? path.test(key) : path === key) && true) {
|
||
found[key] = obj[key];
|
||
} else {
|
||
rest[key] = obj[key];
|
||
}
|
||
}
|
||
return [found, rest];
|
||
}
|
||
function omit(obj, exclude) {
|
||
const clone = {
|
||
...obj
|
||
};
|
||
exclude.forEach((prop) => delete clone[prop]);
|
||
return clone;
|
||
}
|
||
function only(obj, include) {
|
||
const clone = {};
|
||
include.forEach((prop) => clone[prop] = obj[prop]);
|
||
return clone;
|
||
}
|
||
const onRE = /^on[^a-z]/;
|
||
const isOn = (key) => onRE.test(key);
|
||
const bubblingEvents = ["onAfterscriptexecute", "onAnimationcancel", "onAnimationend", "onAnimationiteration", "onAnimationstart", "onAuxclick", "onBeforeinput", "onBeforescriptexecute", "onChange", "onClick", "onCompositionend", "onCompositionstart", "onCompositionupdate", "onContextmenu", "onCopy", "onCut", "onDblclick", "onFocusin", "onFocusout", "onFullscreenchange", "onFullscreenerror", "onGesturechange", "onGestureend", "onGesturestart", "onGotpointercapture", "onInput", "onKeydown", "onKeypress", "onKeyup", "onLostpointercapture", "onMousedown", "onMousemove", "onMouseout", "onMouseover", "onMouseup", "onMousewheel", "onPaste", "onPointercancel", "onPointerdown", "onPointerenter", "onPointerleave", "onPointermove", "onPointerout", "onPointerover", "onPointerup", "onReset", "onSelect", "onSubmit", "onTouchcancel", "onTouchend", "onTouchmove", "onTouchstart", "onTransitioncancel", "onTransitionend", "onTransitionrun", "onTransitionstart", "onWheel"];
|
||
function filterInputAttrs(attrs) {
|
||
const [events, props] = pickWithRest(attrs, [onRE]);
|
||
const inputEvents = omit(events, bubblingEvents);
|
||
const [rootAttrs, inputAttrs] = pickWithRest(props, ["class", "style", "id", /^data-/]);
|
||
Object.assign(rootAttrs, events);
|
||
Object.assign(inputAttrs, inputEvents);
|
||
return [rootAttrs, inputAttrs];
|
||
}
|
||
function wrapInArray(v) {
|
||
return v == null ? [] : Array.isArray(v) ? v : [v];
|
||
}
|
||
function debounce(fn, delay) {
|
||
let timeoutId = 0;
|
||
const wrap = function() {
|
||
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
||
args[_key] = arguments[_key];
|
||
}
|
||
clearTimeout(timeoutId);
|
||
timeoutId = setTimeout(() => fn(...args), unref(delay));
|
||
};
|
||
wrap.clear = () => {
|
||
clearTimeout(timeoutId);
|
||
};
|
||
wrap.immediate = fn;
|
||
return wrap;
|
||
}
|
||
function clamp(value) {
|
||
let min = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
|
||
let max = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1;
|
||
return Math.max(min, Math.min(max, value));
|
||
}
|
||
function padEnd(str, length) {
|
||
let char = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "0";
|
||
return str + char.repeat(Math.max(0, length - str.length));
|
||
}
|
||
function padStart(str, length) {
|
||
let char = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "0";
|
||
return char.repeat(Math.max(0, length - str.length)) + str;
|
||
}
|
||
function chunk(str) {
|
||
let size = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1;
|
||
const chunked = [];
|
||
let index = 0;
|
||
while (index < str.length) {
|
||
chunked.push(str.substr(index, size));
|
||
index += size;
|
||
}
|
||
return chunked;
|
||
}
|
||
function mergeDeep() {
|
||
let source = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
|
||
let target = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
|
||
let arrayFn = arguments.length > 2 ? arguments[2] : void 0;
|
||
const out = {};
|
||
for (const key in source) {
|
||
out[key] = source[key];
|
||
}
|
||
for (const key in target) {
|
||
const sourceProperty = source[key];
|
||
const targetProperty = target[key];
|
||
if (isPlainObject(sourceProperty) && isPlainObject(targetProperty)) {
|
||
out[key] = mergeDeep(sourceProperty, targetProperty, arrayFn);
|
||
continue;
|
||
}
|
||
if (arrayFn && Array.isArray(sourceProperty) && Array.isArray(targetProperty)) {
|
||
out[key] = arrayFn(sourceProperty, targetProperty);
|
||
continue;
|
||
}
|
||
out[key] = targetProperty;
|
||
}
|
||
return out;
|
||
}
|
||
function flattenFragments(nodes) {
|
||
return nodes.map((node) => {
|
||
if (node.type === Fragment) {
|
||
return flattenFragments(node.children);
|
||
} else {
|
||
return node;
|
||
}
|
||
}).flat();
|
||
}
|
||
function toKebabCase() {
|
||
let str = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
|
||
if (toKebabCase.cache.has(str)) return toKebabCase.cache.get(str);
|
||
const kebab = str.replace(/[^a-z]/gi, "-").replace(/\B([A-Z])/g, "-$1").toLowerCase();
|
||
toKebabCase.cache.set(str, kebab);
|
||
return kebab;
|
||
}
|
||
toKebabCase.cache = /* @__PURE__ */ new Map();
|
||
function findChildrenWithProvide(key, vnode) {
|
||
if (!vnode || typeof vnode !== "object") return [];
|
||
if (Array.isArray(vnode)) {
|
||
return vnode.map((child) => findChildrenWithProvide(key, child)).flat(1);
|
||
} else if (vnode.suspense) {
|
||
return findChildrenWithProvide(key, vnode.ssContent);
|
||
} else if (Array.isArray(vnode.children)) {
|
||
return vnode.children.map((child) => findChildrenWithProvide(key, child)).flat(1);
|
||
} else if (vnode.component) {
|
||
if (Object.getOwnPropertySymbols(vnode.component.provides).includes(key)) {
|
||
return [vnode.component];
|
||
} else if (vnode.component.subTree) {
|
||
return findChildrenWithProvide(key, vnode.component.subTree).flat(1);
|
||
}
|
||
}
|
||
return [];
|
||
}
|
||
function destructComputed(getter) {
|
||
const refs = reactive({});
|
||
const base = computed(getter);
|
||
watchEffect(() => {
|
||
for (const key in base.value) {
|
||
refs[key] = base.value[key];
|
||
}
|
||
}, {
|
||
flush: "sync"
|
||
});
|
||
return toRefs(refs);
|
||
}
|
||
function includes(arr, val) {
|
||
return arr.includes(val);
|
||
}
|
||
const EventProp = () => [Function, Array];
|
||
function hasEvent(props, name) {
|
||
name = "on" + capitalize(name);
|
||
return !!(props[name] || props[`${name}Once`] || props[`${name}Capture`] || props[`${name}OnceCapture`] || props[`${name}CaptureOnce`]);
|
||
}
|
||
function callEvent(handler) {
|
||
for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
|
||
args[_key2 - 1] = arguments[_key2];
|
||
}
|
||
if (Array.isArray(handler)) {
|
||
for (const h2 of handler) {
|
||
h2(...args);
|
||
}
|
||
} else if (typeof handler === "function") {
|
||
handler(...args);
|
||
}
|
||
}
|
||
function focusableChildren(el) {
|
||
let filterByTabIndex = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
|
||
const targets = ["button", "[href]", 'input:not([type="hidden"])', "select", "textarea", "[tabindex]"].map((s) => `${s}${filterByTabIndex ? ':not([tabindex="-1"])' : ""}:not([disabled])`).join(", ");
|
||
return [...el.querySelectorAll(targets)];
|
||
}
|
||
function getNextElement(elements, location, condition) {
|
||
let _el;
|
||
let idx = elements.indexOf((void 0).activeElement);
|
||
const inc = location === "next" ? 1 : -1;
|
||
do {
|
||
idx += inc;
|
||
_el = elements[idx];
|
||
} while ((!_el || _el.offsetParent == null || !((condition == null ? void 0 : condition(_el)) ?? true)) && idx < elements.length && idx >= 0);
|
||
return _el;
|
||
}
|
||
function focusChild(el, location) {
|
||
var _a, _b, _c, _d;
|
||
const focusable = focusableChildren(el);
|
||
if (!location) {
|
||
if (el === (void 0).activeElement || !el.contains((void 0).activeElement)) {
|
||
(_a = focusable[0]) == null ? void 0 : _a.focus();
|
||
}
|
||
} else if (location === "first") {
|
||
(_b = focusable[0]) == null ? void 0 : _b.focus();
|
||
} else if (location === "last") {
|
||
(_c = focusable.at(-1)) == null ? void 0 : _c.focus();
|
||
} else if (typeof location === "number") {
|
||
(_d = focusable[location]) == null ? void 0 : _d.focus();
|
||
} else {
|
||
const _el = getNextElement(focusable, location);
|
||
if (_el) _el.focus();
|
||
else focusChild(el, location === "next" ? "first" : "last");
|
||
}
|
||
}
|
||
function isEmpty(val) {
|
||
return val === null || val === void 0 || typeof val === "string" && val.trim() === "";
|
||
}
|
||
function matchesSelector(el, selector) {
|
||
return null;
|
||
}
|
||
function ensureValidVNode(vnodes) {
|
||
return vnodes.some((child) => {
|
||
if (!isVNode(child)) return true;
|
||
if (child.type === Comment) return false;
|
||
return child.type !== Fragment || ensureValidVNode(child.children);
|
||
}) ? vnodes : null;
|
||
}
|
||
function defer(timeout, cb) {
|
||
{
|
||
cb();
|
||
return () => {
|
||
};
|
||
}
|
||
}
|
||
function isClickInsideElement(event, targetDiv) {
|
||
const mouseX = event.clientX;
|
||
const mouseY = event.clientY;
|
||
const divRect = targetDiv.getBoundingClientRect();
|
||
const divLeft = divRect.left;
|
||
const divTop = divRect.top;
|
||
const divRight = divRect.right;
|
||
const divBottom = divRect.bottom;
|
||
return mouseX >= divLeft && mouseX <= divRight && mouseY >= divTop && mouseY <= divBottom;
|
||
}
|
||
function templateRef() {
|
||
const el = shallowRef();
|
||
const fn = (target) => {
|
||
el.value = target;
|
||
};
|
||
Object.defineProperty(fn, "value", {
|
||
enumerable: true,
|
||
get: () => el.value,
|
||
set: (val) => el.value = val
|
||
});
|
||
Object.defineProperty(fn, "el", {
|
||
enumerable: true,
|
||
get: () => refElement(el.value)
|
||
});
|
||
return fn;
|
||
}
|
||
function checkPrintable(e) {
|
||
const isPrintableChar = e.key.length === 1;
|
||
const noModifier = !e.ctrlKey && !e.metaKey && !e.altKey;
|
||
return isPrintableChar && noModifier;
|
||
}
|
||
const block = ["top", "bottom"];
|
||
const inline = ["start", "end", "left", "right"];
|
||
function parseAnchor(anchor, isRtl) {
|
||
let [side, align] = anchor.split(" ");
|
||
if (!align) {
|
||
align = includes(block, side) ? "start" : includes(inline, side) ? "top" : "center";
|
||
}
|
||
return {
|
||
side: toPhysical(side, isRtl),
|
||
align: toPhysical(align, isRtl)
|
||
};
|
||
}
|
||
function toPhysical(str, isRtl) {
|
||
if (str === "start") return isRtl ? "right" : "left";
|
||
if (str === "end") return isRtl ? "left" : "right";
|
||
return str;
|
||
}
|
||
function flipSide(anchor) {
|
||
return {
|
||
side: {
|
||
center: "center",
|
||
top: "bottom",
|
||
bottom: "top",
|
||
left: "right",
|
||
right: "left"
|
||
}[anchor.side],
|
||
align: anchor.align
|
||
};
|
||
}
|
||
function flipAlign(anchor) {
|
||
return {
|
||
side: anchor.side,
|
||
align: {
|
||
center: "center",
|
||
top: "bottom",
|
||
bottom: "top",
|
||
left: "right",
|
||
right: "left"
|
||
}[anchor.align]
|
||
};
|
||
}
|
||
function flipCorner(anchor) {
|
||
return {
|
||
side: anchor.align,
|
||
align: anchor.side
|
||
};
|
||
}
|
||
function getAxis(anchor) {
|
||
return includes(block, anchor.side) ? "y" : "x";
|
||
}
|
||
class Box {
|
||
constructor(_ref) {
|
||
let {
|
||
x,
|
||
y,
|
||
width,
|
||
height
|
||
} = _ref;
|
||
this.x = x;
|
||
this.y = y;
|
||
this.width = width;
|
||
this.height = height;
|
||
}
|
||
get top() {
|
||
return this.y;
|
||
}
|
||
get bottom() {
|
||
return this.y + this.height;
|
||
}
|
||
get left() {
|
||
return this.x;
|
||
}
|
||
get right() {
|
||
return this.x + this.width;
|
||
}
|
||
}
|
||
function getOverflow(a, b) {
|
||
return {
|
||
x: {
|
||
before: Math.max(0, b.left - a.left),
|
||
after: Math.max(0, a.right - b.right)
|
||
},
|
||
y: {
|
||
before: Math.max(0, b.top - a.top),
|
||
after: Math.max(0, a.bottom - b.bottom)
|
||
}
|
||
};
|
||
}
|
||
function getTargetBox(target) {
|
||
if (Array.isArray(target)) {
|
||
return new Box({
|
||
x: target[0],
|
||
y: target[1],
|
||
width: 0,
|
||
height: 0
|
||
});
|
||
} else {
|
||
return target.getBoundingClientRect();
|
||
}
|
||
}
|
||
function nullifyTransforms(el) {
|
||
const rect = el.getBoundingClientRect();
|
||
const style = getComputedStyle(el);
|
||
const tx = style.transform;
|
||
if (tx) {
|
||
let ta, sx, sy, dx, dy;
|
||
if (tx.startsWith("matrix3d(")) {
|
||
ta = tx.slice(9, -1).split(/, /);
|
||
sx = +ta[0];
|
||
sy = +ta[5];
|
||
dx = +ta[12];
|
||
dy = +ta[13];
|
||
} else if (tx.startsWith("matrix(")) {
|
||
ta = tx.slice(7, -1).split(/, /);
|
||
sx = +ta[0];
|
||
sy = +ta[3];
|
||
dx = +ta[4];
|
||
dy = +ta[5];
|
||
} else {
|
||
return new Box(rect);
|
||
}
|
||
const to = style.transformOrigin;
|
||
const x = rect.x - dx - (1 - sx) * parseFloat(to);
|
||
const y = rect.y - dy - (1 - sy) * parseFloat(to.slice(to.indexOf(" ") + 1));
|
||
const w = sx ? rect.width / sx : el.offsetWidth + 1;
|
||
const h2 = sy ? rect.height / sy : el.offsetHeight + 1;
|
||
return new Box({
|
||
x,
|
||
y,
|
||
width: w,
|
||
height: h2
|
||
});
|
||
} else {
|
||
return new Box(rect);
|
||
}
|
||
}
|
||
function animate(el, keyframes, options) {
|
||
if (typeof el.animate === "undefined") return {
|
||
finished: Promise.resolve()
|
||
};
|
||
let animation;
|
||
try {
|
||
animation = el.animate(keyframes, options);
|
||
} catch (err) {
|
||
return {
|
||
finished: Promise.resolve()
|
||
};
|
||
}
|
||
if (typeof animation.finished === "undefined") {
|
||
animation.finished = new Promise((resolve) => {
|
||
animation.onfinish = () => {
|
||
resolve(animation);
|
||
};
|
||
});
|
||
}
|
||
return animation;
|
||
}
|
||
const mainTRC = 2.4;
|
||
const Rco = 0.2126729;
|
||
const Gco = 0.7151522;
|
||
const Bco = 0.072175;
|
||
const normBG = 0.55;
|
||
const normTXT = 0.58;
|
||
const revTXT = 0.57;
|
||
const revBG = 0.62;
|
||
const blkThrs = 0.03;
|
||
const blkClmp = 1.45;
|
||
const deltaYmin = 5e-4;
|
||
const scaleBoW = 1.25;
|
||
const scaleWoB = 1.25;
|
||
const loConThresh = 0.078;
|
||
const loConFactor = 12.82051282051282;
|
||
const loConOffset = 0.06;
|
||
const loClip = 1e-3;
|
||
function APCAcontrast(text, background) {
|
||
const Rtxt = (text.r / 255) ** mainTRC;
|
||
const Gtxt = (text.g / 255) ** mainTRC;
|
||
const Btxt = (text.b / 255) ** mainTRC;
|
||
const Rbg = (background.r / 255) ** mainTRC;
|
||
const Gbg = (background.g / 255) ** mainTRC;
|
||
const Bbg = (background.b / 255) ** mainTRC;
|
||
let Ytxt = Rtxt * Rco + Gtxt * Gco + Btxt * Bco;
|
||
let Ybg = Rbg * Rco + Gbg * Gco + Bbg * Bco;
|
||
if (Ytxt <= blkThrs) Ytxt += (blkThrs - Ytxt) ** blkClmp;
|
||
if (Ybg <= blkThrs) Ybg += (blkThrs - Ybg) ** blkClmp;
|
||
if (Math.abs(Ybg - Ytxt) < deltaYmin) return 0;
|
||
let outputContrast;
|
||
if (Ybg > Ytxt) {
|
||
const SAPC = (Ybg ** normBG - Ytxt ** normTXT) * scaleBoW;
|
||
outputContrast = SAPC < loClip ? 0 : SAPC < loConThresh ? SAPC - SAPC * loConFactor * loConOffset : SAPC - loConOffset;
|
||
} else {
|
||
const SAPC = (Ybg ** revBG - Ytxt ** revTXT) * scaleWoB;
|
||
outputContrast = SAPC > -loClip ? 0 : SAPC > -loConThresh ? SAPC - SAPC * loConFactor * loConOffset : SAPC + loConOffset;
|
||
}
|
||
return outputContrast * 100;
|
||
}
|
||
function consoleWarn(message) {
|
||
warn(`Vuetify: ${message}`);
|
||
}
|
||
function consoleError(message) {
|
||
warn(`Vuetify error: ${message}`);
|
||
}
|
||
function deprecate(original, replacement) {
|
||
replacement = Array.isArray(replacement) ? replacement.slice(0, -1).map((s) => `'${s}'`).join(", ") + ` or '${replacement.at(-1)}'` : `'${replacement}'`;
|
||
warn(`[Vuetify UPGRADE] '${original}' is deprecated, use ${replacement} instead.`);
|
||
}
|
||
const delta = 0.20689655172413793;
|
||
const cielabForwardTransform = (t) => t > delta ** 3 ? Math.cbrt(t) : t / (3 * delta ** 2) + 4 / 29;
|
||
const cielabReverseTransform = (t) => t > delta ? t ** 3 : 3 * delta ** 2 * (t - 4 / 29);
|
||
function fromXYZ$1(xyz) {
|
||
const transform2 = cielabForwardTransform;
|
||
const transformedY = transform2(xyz[1]);
|
||
return [116 * transformedY - 16, 500 * (transform2(xyz[0] / 0.95047) - transformedY), 200 * (transformedY - transform2(xyz[2] / 1.08883))];
|
||
}
|
||
function toXYZ$1(lab) {
|
||
const transform2 = cielabReverseTransform;
|
||
const Ln = (lab[0] + 16) / 116;
|
||
return [transform2(Ln + lab[1] / 500) * 0.95047, transform2(Ln), transform2(Ln - lab[2] / 200) * 1.08883];
|
||
}
|
||
const srgbForwardMatrix = [[3.2406, -1.5372, -0.4986], [-0.9689, 1.8758, 0.0415], [0.0557, -0.204, 1.057]];
|
||
const srgbForwardTransform = (C) => C <= 31308e-7 ? C * 12.92 : 1.055 * C ** (1 / 2.4) - 0.055;
|
||
const srgbReverseMatrix = [[0.4124, 0.3576, 0.1805], [0.2126, 0.7152, 0.0722], [0.0193, 0.1192, 0.9505]];
|
||
const srgbReverseTransform = (C) => C <= 0.04045 ? C / 12.92 : ((C + 0.055) / 1.055) ** 2.4;
|
||
function fromXYZ(xyz) {
|
||
const rgb = Array(3);
|
||
const transform2 = srgbForwardTransform;
|
||
const matrix = srgbForwardMatrix;
|
||
for (let i = 0; i < 3; ++i) {
|
||
rgb[i] = Math.round(clamp(transform2(matrix[i][0] * xyz[0] + matrix[i][1] * xyz[1] + matrix[i][2] * xyz[2])) * 255);
|
||
}
|
||
return {
|
||
r: rgb[0],
|
||
g: rgb[1],
|
||
b: rgb[2]
|
||
};
|
||
}
|
||
function toXYZ(_ref) {
|
||
let {
|
||
r,
|
||
g,
|
||
b
|
||
} = _ref;
|
||
const xyz = [0, 0, 0];
|
||
const transform2 = srgbReverseTransform;
|
||
const matrix = srgbReverseMatrix;
|
||
r = transform2(r / 255);
|
||
g = transform2(g / 255);
|
||
b = transform2(b / 255);
|
||
for (let i = 0; i < 3; ++i) {
|
||
xyz[i] = matrix[i][0] * r + matrix[i][1] * g + matrix[i][2] * b;
|
||
}
|
||
return xyz;
|
||
}
|
||
function isCssColor(color) {
|
||
return !!color && /^(#|var\(--|(rgb|hsl)a?\()/.test(color);
|
||
}
|
||
function isParsableColor(color) {
|
||
return isCssColor(color) && !/^((rgb|hsl)a?\()?var\(--/.test(color);
|
||
}
|
||
const cssColorRe = /^(?<fn>(?:rgb|hsl)a?)\((?<values>.+)\)/;
|
||
const mappers = {
|
||
rgb: (r, g, b, a) => ({
|
||
r,
|
||
g,
|
||
b,
|
||
a
|
||
}),
|
||
rgba: (r, g, b, a) => ({
|
||
r,
|
||
g,
|
||
b,
|
||
a
|
||
}),
|
||
hsl: (h2, s, l, a) => HSLtoRGB({
|
||
h: h2,
|
||
s,
|
||
l,
|
||
a
|
||
}),
|
||
hsla: (h2, s, l, a) => HSLtoRGB({
|
||
h: h2,
|
||
s,
|
||
l,
|
||
a
|
||
}),
|
||
hsv: (h2, s, v, a) => HSVtoRGB({
|
||
h: h2,
|
||
s,
|
||
v,
|
||
a
|
||
}),
|
||
hsva: (h2, s, v, a) => HSVtoRGB({
|
||
h: h2,
|
||
s,
|
||
v,
|
||
a
|
||
})
|
||
};
|
||
function parseColor(color) {
|
||
if (typeof color === "number") {
|
||
if (isNaN(color) || color < 0 || color > 16777215) {
|
||
consoleWarn(`'${color}' is not a valid hex color`);
|
||
}
|
||
return {
|
||
r: (color & 16711680) >> 16,
|
||
g: (color & 65280) >> 8,
|
||
b: color & 255
|
||
};
|
||
} else if (typeof color === "string" && cssColorRe.test(color)) {
|
||
const {
|
||
groups
|
||
} = color.match(cssColorRe);
|
||
const {
|
||
fn,
|
||
values
|
||
} = groups;
|
||
const realValues = values.split(/,\s*/).map((v) => {
|
||
if (v.endsWith("%") && ["hsl", "hsla", "hsv", "hsva"].includes(fn)) {
|
||
return parseFloat(v) / 100;
|
||
} else {
|
||
return parseFloat(v);
|
||
}
|
||
});
|
||
return mappers[fn](...realValues);
|
||
} else if (typeof color === "string") {
|
||
let hex = color.startsWith("#") ? color.slice(1) : color;
|
||
if ([3, 4].includes(hex.length)) {
|
||
hex = hex.split("").map((char) => char + char).join("");
|
||
} else if (![6, 8].includes(hex.length)) {
|
||
consoleWarn(`'${color}' is not a valid hex(a) color`);
|
||
}
|
||
const int = parseInt(hex, 16);
|
||
if (isNaN(int) || int < 0 || int > 4294967295) {
|
||
consoleWarn(`'${color}' is not a valid hex(a) color`);
|
||
}
|
||
return HexToRGB(hex);
|
||
} else if (typeof color === "object") {
|
||
if (has(color, ["r", "g", "b"])) {
|
||
return color;
|
||
} else if (has(color, ["h", "s", "l"])) {
|
||
return HSVtoRGB(HSLtoHSV(color));
|
||
} else if (has(color, ["h", "s", "v"])) {
|
||
return HSVtoRGB(color);
|
||
}
|
||
}
|
||
throw new TypeError(`Invalid color: ${color == null ? color : String(color) || color.constructor.name}
|
||
Expected #hex, #hexa, rgb(), rgba(), hsl(), hsla(), object or number`);
|
||
}
|
||
function HSVtoRGB(hsva) {
|
||
const {
|
||
h: h2,
|
||
s,
|
||
v,
|
||
a
|
||
} = hsva;
|
||
const f = (n) => {
|
||
const k = (n + h2 / 60) % 6;
|
||
return v - v * s * Math.max(Math.min(k, 4 - k, 1), 0);
|
||
};
|
||
const rgb = [f(5), f(3), f(1)].map((v2) => Math.round(v2 * 255));
|
||
return {
|
||
r: rgb[0],
|
||
g: rgb[1],
|
||
b: rgb[2],
|
||
a
|
||
};
|
||
}
|
||
function HSLtoRGB(hsla) {
|
||
return HSVtoRGB(HSLtoHSV(hsla));
|
||
}
|
||
function HSLtoHSV(hsl) {
|
||
const {
|
||
h: h2,
|
||
s,
|
||
l,
|
||
a
|
||
} = hsl;
|
||
const v = l + s * Math.min(l, 1 - l);
|
||
const sprime = v === 0 ? 0 : 2 - 2 * l / v;
|
||
return {
|
||
h: h2,
|
||
s: sprime,
|
||
v,
|
||
a
|
||
};
|
||
}
|
||
function toHex(v) {
|
||
const h2 = Math.round(v).toString(16);
|
||
return ("00".substr(0, 2 - h2.length) + h2).toUpperCase();
|
||
}
|
||
function RGBtoHex(_ref2) {
|
||
let {
|
||
r,
|
||
g,
|
||
b,
|
||
a
|
||
} = _ref2;
|
||
return `#${[toHex(r), toHex(g), toHex(b), a !== void 0 ? toHex(Math.round(a * 255)) : ""].join("")}`;
|
||
}
|
||
function HexToRGB(hex) {
|
||
hex = parseHex(hex);
|
||
let [r, g, b, a] = chunk(hex, 2).map((c) => parseInt(c, 16));
|
||
a = a === void 0 ? a : a / 255;
|
||
return {
|
||
r,
|
||
g,
|
||
b,
|
||
a
|
||
};
|
||
}
|
||
function parseHex(hex) {
|
||
if (hex.startsWith("#")) {
|
||
hex = hex.slice(1);
|
||
}
|
||
hex = hex.replace(/([^0-9a-f])/gi, "F");
|
||
if (hex.length === 3 || hex.length === 4) {
|
||
hex = hex.split("").map((x) => x + x).join("");
|
||
}
|
||
if (hex.length !== 6) {
|
||
hex = padEnd(padEnd(hex, 6), 8, "F");
|
||
}
|
||
return hex;
|
||
}
|
||
function lighten(value, amount) {
|
||
const lab = fromXYZ$1(toXYZ(value));
|
||
lab[0] = lab[0] + amount * 10;
|
||
return fromXYZ(toXYZ$1(lab));
|
||
}
|
||
function darken(value, amount) {
|
||
const lab = fromXYZ$1(toXYZ(value));
|
||
lab[0] = lab[0] - amount * 10;
|
||
return fromXYZ(toXYZ$1(lab));
|
||
}
|
||
function getLuma(color) {
|
||
const rgb = parseColor(color);
|
||
return toXYZ(rgb)[1];
|
||
}
|
||
function getForeground(color) {
|
||
const blackContrast = Math.abs(APCAcontrast(parseColor(0), parseColor(color)));
|
||
const whiteContrast = Math.abs(APCAcontrast(parseColor(16777215), parseColor(color)));
|
||
return whiteContrast > Math.min(blackContrast, 50) ? "#fff" : "#000";
|
||
}
|
||
function propsFactory(props, source) {
|
||
return (defaults2) => {
|
||
return Object.keys(props).reduce((obj, prop) => {
|
||
const isObjectDefinition = typeof props[prop] === "object" && props[prop] != null && !Array.isArray(props[prop]);
|
||
const definition = isObjectDefinition ? props[prop] : {
|
||
type: props[prop]
|
||
};
|
||
if (defaults2 && prop in defaults2) {
|
||
obj[prop] = {
|
||
...definition,
|
||
default: defaults2[prop]
|
||
};
|
||
} else {
|
||
obj[prop] = definition;
|
||
}
|
||
if (source && !obj[prop].source) {
|
||
obj[prop].source = source;
|
||
}
|
||
return obj;
|
||
}, {});
|
||
};
|
||
}
|
||
const makeComponentProps = propsFactory({
|
||
class: [String, Array, Object],
|
||
style: {
|
||
type: [String, Array, Object],
|
||
default: null
|
||
}
|
||
}, "component");
|
||
function getCurrentInstance(name, message) {
|
||
const vm = getCurrentInstance$1();
|
||
if (!vm) {
|
||
throw new Error(`[Vuetify] ${name} ${"must be called from inside a setup function"}`);
|
||
}
|
||
return vm;
|
||
}
|
||
function getCurrentInstanceName() {
|
||
let name = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "composables";
|
||
const vm = getCurrentInstance(name).type;
|
||
return toKebabCase((vm == null ? void 0 : vm.aliasName) || (vm == null ? void 0 : vm.name));
|
||
}
|
||
let _uid = 0;
|
||
let _map = /* @__PURE__ */ new WeakMap();
|
||
function getUid() {
|
||
const vm = getCurrentInstance("getUid");
|
||
if (_map.has(vm)) return _map.get(vm);
|
||
else {
|
||
const uid = _uid++;
|
||
_map.set(vm, uid);
|
||
return uid;
|
||
}
|
||
}
|
||
getUid.reset = () => {
|
||
_uid = 0;
|
||
_map = /* @__PURE__ */ new WeakMap();
|
||
};
|
||
function injectSelf(key) {
|
||
let vm = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstance("injectSelf");
|
||
const {
|
||
provides
|
||
} = vm;
|
||
if (provides && key in provides) {
|
||
return provides[key];
|
||
}
|
||
return void 0;
|
||
}
|
||
const DefaultsSymbol = Symbol.for("vuetify:defaults");
|
||
function createDefaults(options) {
|
||
return ref(options);
|
||
}
|
||
function injectDefaults() {
|
||
const defaults2 = inject$1(DefaultsSymbol);
|
||
if (!defaults2) throw new Error("[Vuetify] Could not find defaults instance");
|
||
return defaults2;
|
||
}
|
||
function provideDefaults(defaults2, options) {
|
||
const injectedDefaults = injectDefaults();
|
||
const providedDefaults = ref(defaults2);
|
||
const newDefaults = computed(() => {
|
||
const disabled = unref(options == null ? void 0 : options.disabled);
|
||
if (disabled) return injectedDefaults.value;
|
||
const scoped = unref(options == null ? void 0 : options.scoped);
|
||
const reset = unref(options == null ? void 0 : options.reset);
|
||
const root = unref(options == null ? void 0 : options.root);
|
||
if (providedDefaults.value == null && !(scoped || reset || root)) return injectedDefaults.value;
|
||
let properties = mergeDeep(providedDefaults.value, {
|
||
prev: injectedDefaults.value
|
||
});
|
||
if (scoped) return properties;
|
||
if (reset || root) {
|
||
const len = Number(reset || Infinity);
|
||
for (let i = 0; i <= len; i++) {
|
||
if (!properties || !("prev" in properties)) {
|
||
break;
|
||
}
|
||
properties = properties.prev;
|
||
}
|
||
if (properties && typeof root === "string" && root in properties) {
|
||
properties = mergeDeep(mergeDeep(properties, {
|
||
prev: properties
|
||
}), properties[root]);
|
||
}
|
||
return properties;
|
||
}
|
||
return properties.prev ? mergeDeep(properties.prev, properties) : properties;
|
||
});
|
||
provide(DefaultsSymbol, newDefaults);
|
||
return newDefaults;
|
||
}
|
||
function propIsDefined(vnode, prop) {
|
||
var _a, _b;
|
||
return typeof ((_a = vnode.props) == null ? void 0 : _a[prop]) !== "undefined" || typeof ((_b = vnode.props) == null ? void 0 : _b[toKebabCase(prop)]) !== "undefined";
|
||
}
|
||
function internalUseDefaults() {
|
||
let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
|
||
let name = arguments.length > 1 ? arguments[1] : void 0;
|
||
let defaults2 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : injectDefaults();
|
||
const vm = getCurrentInstance("useDefaults");
|
||
name = name ?? vm.type.name ?? vm.type.__name;
|
||
if (!name) {
|
||
throw new Error("[Vuetify] Could not determine component name");
|
||
}
|
||
const componentDefaults = computed(() => {
|
||
var _a;
|
||
return (_a = defaults2.value) == null ? void 0 : _a[props._as ?? name];
|
||
});
|
||
const _props = new Proxy(props, {
|
||
get(target, prop) {
|
||
var _a, _b, _c, _d, _e, _f, _g;
|
||
const propValue = Reflect.get(target, prop);
|
||
if (prop === "class" || prop === "style") {
|
||
return [(_a = componentDefaults.value) == null ? void 0 : _a[prop], propValue].filter((v) => v != null);
|
||
} else if (typeof prop === "string" && !propIsDefined(vm.vnode, prop)) {
|
||
return ((_b = componentDefaults.value) == null ? void 0 : _b[prop]) !== void 0 ? (_c = componentDefaults.value) == null ? void 0 : _c[prop] : ((_e = (_d = defaults2.value) == null ? void 0 : _d.global) == null ? void 0 : _e[prop]) !== void 0 ? (_g = (_f = defaults2.value) == null ? void 0 : _f.global) == null ? void 0 : _g[prop] : propValue;
|
||
}
|
||
return propValue;
|
||
}
|
||
});
|
||
const _subcomponentDefaults = shallowRef();
|
||
watchEffect(() => {
|
||
if (componentDefaults.value) {
|
||
const subComponents = Object.entries(componentDefaults.value).filter((_ref) => {
|
||
let [key] = _ref;
|
||
return key.startsWith(key[0].toUpperCase());
|
||
});
|
||
_subcomponentDefaults.value = subComponents.length ? Object.fromEntries(subComponents) : void 0;
|
||
} else {
|
||
_subcomponentDefaults.value = void 0;
|
||
}
|
||
});
|
||
function provideSubDefaults() {
|
||
const injected = injectSelf(DefaultsSymbol, vm);
|
||
provide(DefaultsSymbol, computed(() => {
|
||
return _subcomponentDefaults.value ? mergeDeep((injected == null ? void 0 : injected.value) ?? {}, _subcomponentDefaults.value) : injected == null ? void 0 : injected.value;
|
||
}));
|
||
}
|
||
return {
|
||
props: _props,
|
||
provideSubDefaults
|
||
};
|
||
}
|
||
function defineComponent(options) {
|
||
options._setup = options._setup ?? options.setup;
|
||
if (!options.name) {
|
||
consoleWarn("The component is missing an explicit name, unable to generate default prop value");
|
||
return options;
|
||
}
|
||
if (options._setup) {
|
||
options.props = propsFactory(options.props ?? {}, options.name)();
|
||
const propKeys = Object.keys(options.props).filter((key) => key !== "class" && key !== "style");
|
||
options.filterProps = function filterProps(props) {
|
||
return pick(props, propKeys);
|
||
};
|
||
options.props._as = String;
|
||
options.setup = function setup(props, ctx) {
|
||
const defaults2 = injectDefaults();
|
||
if (!defaults2.value) return options._setup(props, ctx);
|
||
const {
|
||
props: _props,
|
||
provideSubDefaults
|
||
} = internalUseDefaults(props, props._as ?? options.name, defaults2);
|
||
const setupBindings = options._setup(_props, ctx);
|
||
provideSubDefaults();
|
||
return setupBindings;
|
||
};
|
||
}
|
||
return options;
|
||
}
|
||
function genericComponent() {
|
||
let exposeDefaults = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
|
||
return (options) => (exposeDefaults ? defineComponent : defineComponent$1)(options);
|
||
}
|
||
function defineFunctionalComponent(props, render2) {
|
||
render2.props = props;
|
||
return render2;
|
||
}
|
||
function createSimpleFunctional(klass) {
|
||
let tag = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "div";
|
||
let name = arguments.length > 2 ? arguments[2] : void 0;
|
||
return genericComponent()({
|
||
name: name ?? capitalize(camelize(klass.replace(/__/g, "-"))),
|
||
props: {
|
||
tag: {
|
||
type: String,
|
||
default: tag
|
||
},
|
||
...makeComponentProps()
|
||
},
|
||
setup(props, _ref) {
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
return () => {
|
||
var _a;
|
||
return h(props.tag, {
|
||
class: [klass, props.class],
|
||
style: props.style
|
||
}, (_a = slots.default) == null ? void 0 : _a.call(slots));
|
||
};
|
||
}
|
||
});
|
||
}
|
||
function attachedRoot(node) {
|
||
if (typeof node.getRootNode !== "function") {
|
||
while (node.parentNode) node = node.parentNode;
|
||
if (node !== void 0) return null;
|
||
return void 0;
|
||
}
|
||
const root = node.getRootNode();
|
||
if (root !== void 0 && root.getRootNode({
|
||
composed: true
|
||
}) !== void 0) return null;
|
||
return root;
|
||
}
|
||
const standardEasing = "cubic-bezier(0.4, 0, 0.2, 1)";
|
||
const deceleratedEasing = "cubic-bezier(0.0, 0, 0.2, 1)";
|
||
const acceleratedEasing = "cubic-bezier(0.4, 0, 1, 1)";
|
||
function getScrollParent(el) {
|
||
let includeHidden = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
|
||
while (el) {
|
||
if (includeHidden ? isPotentiallyScrollable(el) : hasScrollbar(el)) return el;
|
||
el = el.parentElement;
|
||
}
|
||
return (void 0).scrollingElement;
|
||
}
|
||
function getScrollParents(el, stopAt) {
|
||
const elements = [];
|
||
if (stopAt && el && !stopAt.contains(el)) return elements;
|
||
while (el) {
|
||
if (hasScrollbar(el)) elements.push(el);
|
||
if (el === stopAt) break;
|
||
el = el.parentElement;
|
||
}
|
||
return elements;
|
||
}
|
||
function hasScrollbar(el) {
|
||
if (!el || el.nodeType !== Node.ELEMENT_NODE) return false;
|
||
const style = (void 0).getComputedStyle(el);
|
||
return style.overflowY === "scroll" || style.overflowY === "auto" && el.scrollHeight > el.clientHeight;
|
||
}
|
||
function isPotentiallyScrollable(el) {
|
||
if (!el || el.nodeType !== Node.ELEMENT_NODE) return false;
|
||
const style = (void 0).getComputedStyle(el);
|
||
return ["scroll", "auto"].includes(style.overflowY);
|
||
}
|
||
function isFixedPosition(el) {
|
||
while (el) {
|
||
if ((void 0).getComputedStyle(el).position === "fixed") {
|
||
return true;
|
||
}
|
||
el = el.offsetParent;
|
||
}
|
||
return false;
|
||
}
|
||
function useRender(render2) {
|
||
const vm = getCurrentInstance("useRender");
|
||
vm.render = render2;
|
||
}
|
||
function useProxiedModel(props, prop, defaultValue) {
|
||
let transformIn = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : (v) => v;
|
||
let transformOut = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : (v) => v;
|
||
const vm = getCurrentInstance("useProxiedModel");
|
||
const internal = ref(props[prop] !== void 0 ? props[prop] : defaultValue);
|
||
const kebabProp = toKebabCase(prop);
|
||
const checkKebab = kebabProp !== prop;
|
||
const isControlled = checkKebab ? computed(() => {
|
||
var _a, _b, _c, _d;
|
||
void props[prop];
|
||
return !!((((_a = vm.vnode.props) == null ? void 0 : _a.hasOwnProperty(prop)) || ((_b = vm.vnode.props) == null ? void 0 : _b.hasOwnProperty(kebabProp))) && (((_c = vm.vnode.props) == null ? void 0 : _c.hasOwnProperty(`onUpdate:${prop}`)) || ((_d = vm.vnode.props) == null ? void 0 : _d.hasOwnProperty(`onUpdate:${kebabProp}`))));
|
||
}) : computed(() => {
|
||
var _a, _b;
|
||
void props[prop];
|
||
return !!(((_a = vm.vnode.props) == null ? void 0 : _a.hasOwnProperty(prop)) && ((_b = vm.vnode.props) == null ? void 0 : _b.hasOwnProperty(`onUpdate:${prop}`)));
|
||
});
|
||
useToggleScope(() => !isControlled.value, () => {
|
||
watch(() => props[prop], (val) => {
|
||
internal.value = val;
|
||
});
|
||
});
|
||
const model = computed({
|
||
get() {
|
||
const externalValue = props[prop];
|
||
return transformIn(isControlled.value ? externalValue : internal.value);
|
||
},
|
||
set(internalValue) {
|
||
const newValue = transformOut(internalValue);
|
||
const value = toRaw(isControlled.value ? props[prop] : internal.value);
|
||
if (value === newValue || transformIn(value) === internalValue) {
|
||
return;
|
||
}
|
||
internal.value = newValue;
|
||
vm == null ? void 0 : vm.emit(`update:${prop}`, newValue);
|
||
}
|
||
});
|
||
Object.defineProperty(model, "externalValue", {
|
||
get: () => isControlled.value ? props[prop] : internal.value
|
||
});
|
||
return model;
|
||
}
|
||
const en = {
|
||
badge: "Badge",
|
||
open: "Open",
|
||
close: "Close",
|
||
dismiss: "Dismiss",
|
||
confirmEdit: {
|
||
ok: "OK",
|
||
cancel: "Cancel"
|
||
},
|
||
dataIterator: {
|
||
noResultsText: "No matching records found",
|
||
loadingText: "Loading items..."
|
||
},
|
||
dataTable: {
|
||
itemsPerPageText: "Rows per page:",
|
||
ariaLabel: {
|
||
sortDescending: "Sorted descending.",
|
||
sortAscending: "Sorted ascending.",
|
||
sortNone: "Not sorted.",
|
||
activateNone: "Activate to remove sorting.",
|
||
activateDescending: "Activate to sort descending.",
|
||
activateAscending: "Activate to sort ascending."
|
||
},
|
||
sortBy: "Sort by"
|
||
},
|
||
dataFooter: {
|
||
itemsPerPageText: "Items per page:",
|
||
itemsPerPageAll: "All",
|
||
nextPage: "Next page",
|
||
prevPage: "Previous page",
|
||
firstPage: "First page",
|
||
lastPage: "Last page",
|
||
pageText: "{0}-{1} of {2}"
|
||
},
|
||
dateRangeInput: {
|
||
divider: "to"
|
||
},
|
||
datePicker: {
|
||
itemsSelected: "{0} selected",
|
||
range: {
|
||
title: "Select dates",
|
||
header: "Enter dates"
|
||
},
|
||
title: "Select date",
|
||
header: "Enter date",
|
||
input: {
|
||
placeholder: "Enter date"
|
||
}
|
||
},
|
||
noDataText: "No data available",
|
||
carousel: {
|
||
prev: "Previous visual",
|
||
next: "Next visual",
|
||
ariaLabel: {
|
||
delimiter: "Carousel slide {0} of {1}"
|
||
}
|
||
},
|
||
calendar: {
|
||
moreEvents: "{0} more",
|
||
today: "Today"
|
||
},
|
||
input: {
|
||
clear: "Clear {0}",
|
||
prependAction: "{0} prepended action",
|
||
appendAction: "{0} appended action",
|
||
otp: "Please enter OTP character {0}"
|
||
},
|
||
fileInput: {
|
||
counter: "{0} files",
|
||
counterSize: "{0} files ({1} in total)"
|
||
},
|
||
timePicker: {
|
||
am: "AM",
|
||
pm: "PM",
|
||
title: "Select Time"
|
||
},
|
||
pagination: {
|
||
ariaLabel: {
|
||
root: "Pagination Navigation",
|
||
next: "Next page",
|
||
previous: "Previous page",
|
||
page: "Go to page {0}",
|
||
currentPage: "Page {0}, Current page",
|
||
first: "First page",
|
||
last: "Last page"
|
||
}
|
||
},
|
||
stepper: {
|
||
next: "Next",
|
||
prev: "Previous"
|
||
},
|
||
rating: {
|
||
ariaLabel: {
|
||
item: "Rating {0} of {1}"
|
||
}
|
||
},
|
||
loading: "Loading...",
|
||
infiniteScroll: {
|
||
loadMore: "Load more",
|
||
empty: "No more"
|
||
}
|
||
};
|
||
const LANG_PREFIX = "$vuetify.";
|
||
const replace = (str, params) => {
|
||
return str.replace(/\{(\d+)\}/g, (match, index) => {
|
||
return String(params[+index]);
|
||
});
|
||
};
|
||
const createTranslateFunction = (current, fallback, messages) => {
|
||
return function(key) {
|
||
for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
||
params[_key - 1] = arguments[_key];
|
||
}
|
||
if (!key.startsWith(LANG_PREFIX)) {
|
||
return replace(key, params);
|
||
}
|
||
const shortKey = key.replace(LANG_PREFIX, "");
|
||
const currentLocale = current.value && messages.value[current.value];
|
||
const fallbackLocale = fallback.value && messages.value[fallback.value];
|
||
let str = getObjectValueByPath(currentLocale, shortKey, null);
|
||
if (!str) {
|
||
consoleWarn(`Translation key "${key}" not found in "${current.value}", trying fallback locale`);
|
||
str = getObjectValueByPath(fallbackLocale, shortKey, null);
|
||
}
|
||
if (!str) {
|
||
consoleError(`Translation key "${key}" not found in fallback`);
|
||
str = key;
|
||
}
|
||
if (typeof str !== "string") {
|
||
consoleError(`Translation key "${key}" has a non-string value`);
|
||
str = key;
|
||
}
|
||
return replace(str, params);
|
||
};
|
||
};
|
||
function createNumberFunction(current, fallback) {
|
||
return (value, options) => {
|
||
const numberFormat = new Intl.NumberFormat([current.value, fallback.value], options);
|
||
return numberFormat.format(value);
|
||
};
|
||
}
|
||
function useProvided(props, prop, provided) {
|
||
const internal = useProxiedModel(props, prop, props[prop] ?? provided.value);
|
||
internal.value = props[prop] ?? provided.value;
|
||
watch(provided, (v) => {
|
||
if (props[prop] == null) {
|
||
internal.value = provided.value;
|
||
}
|
||
});
|
||
return internal;
|
||
}
|
||
function createProvideFunction(state) {
|
||
return (props) => {
|
||
const current = useProvided(props, "locale", state.current);
|
||
const fallback = useProvided(props, "fallback", state.fallback);
|
||
const messages = useProvided(props, "messages", state.messages);
|
||
return {
|
||
name: "vuetify",
|
||
current,
|
||
fallback,
|
||
messages,
|
||
t: createTranslateFunction(current, fallback, messages),
|
||
n: createNumberFunction(current, fallback),
|
||
provide: createProvideFunction({
|
||
current,
|
||
fallback,
|
||
messages
|
||
})
|
||
};
|
||
};
|
||
}
|
||
function createVuetifyAdapter(options) {
|
||
const current = shallowRef((options == null ? void 0 : options.locale) ?? "en");
|
||
const fallback = shallowRef((options == null ? void 0 : options.fallback) ?? "en");
|
||
const messages = ref({
|
||
en,
|
||
...options == null ? void 0 : options.messages
|
||
});
|
||
return {
|
||
name: "vuetify",
|
||
current,
|
||
fallback,
|
||
messages,
|
||
t: createTranslateFunction(current, fallback, messages),
|
||
n: createNumberFunction(current, fallback),
|
||
provide: createProvideFunction({
|
||
current,
|
||
fallback,
|
||
messages
|
||
})
|
||
};
|
||
}
|
||
const LocaleSymbol = Symbol.for("vuetify:locale");
|
||
function isLocaleInstance(obj) {
|
||
return obj.name != null;
|
||
}
|
||
function createLocale(options) {
|
||
const i18n = (options == null ? void 0 : options.adapter) && isLocaleInstance(options == null ? void 0 : options.adapter) ? options == null ? void 0 : options.adapter : createVuetifyAdapter(options);
|
||
const rtl = createRtl(i18n, options);
|
||
return {
|
||
...i18n,
|
||
...rtl
|
||
};
|
||
}
|
||
function useLocale() {
|
||
const locale = inject$1(LocaleSymbol);
|
||
if (!locale) throw new Error("[Vuetify] Could not find injected locale instance");
|
||
return locale;
|
||
}
|
||
function genDefaults$3() {
|
||
return {
|
||
af: false,
|
||
ar: true,
|
||
bg: false,
|
||
ca: false,
|
||
ckb: false,
|
||
cs: false,
|
||
de: false,
|
||
el: false,
|
||
en: false,
|
||
es: false,
|
||
et: false,
|
||
fa: true,
|
||
fi: false,
|
||
fr: false,
|
||
hr: false,
|
||
hu: false,
|
||
he: true,
|
||
id: false,
|
||
it: false,
|
||
ja: false,
|
||
km: false,
|
||
ko: false,
|
||
lv: false,
|
||
lt: false,
|
||
nl: false,
|
||
no: false,
|
||
pl: false,
|
||
pt: false,
|
||
ro: false,
|
||
ru: false,
|
||
sk: false,
|
||
sl: false,
|
||
srCyrl: false,
|
||
srLatn: false,
|
||
sv: false,
|
||
th: false,
|
||
tr: false,
|
||
az: false,
|
||
uk: false,
|
||
vi: false,
|
||
zhHans: false,
|
||
zhHant: false
|
||
};
|
||
}
|
||
function createRtl(i18n, options) {
|
||
const rtl = ref((options == null ? void 0 : options.rtl) ?? genDefaults$3());
|
||
const isRtl = computed(() => rtl.value[i18n.current.value] ?? false);
|
||
return {
|
||
isRtl,
|
||
rtl,
|
||
rtlClasses: computed(() => `v-locale--is-${isRtl.value ? "rtl" : "ltr"}`)
|
||
};
|
||
}
|
||
function useRtl() {
|
||
const locale = inject$1(LocaleSymbol);
|
||
if (!locale) throw new Error("[Vuetify] Could not find injected rtl instance");
|
||
return {
|
||
isRtl: locale.isRtl,
|
||
rtlClasses: locale.rtlClasses
|
||
};
|
||
}
|
||
const 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]);
|
||
}
|
||
const _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;
|
||
}
|
||
const 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",
|
||
second: "numeric",
|
||
hour12: true
|
||
};
|
||
break;
|
||
case "fullTime12h":
|
||
options = {
|
||
hour: "numeric",
|
||
minute: "numeric",
|
||
second: "numeric",
|
||
hour12: true
|
||
};
|
||
break;
|
||
case "fullTime24h":
|
||
options = {
|
||
hour: "numeric",
|
||
minute: "numeric",
|
||
second: "numeric",
|
||
hour12: false
|
||
};
|
||
break;
|
||
case "fullDateTime":
|
||
options = {
|
||
year: "numeric",
|
||
month: "long",
|
||
day: "numeric",
|
||
hour: "numeric",
|
||
minute: "numeric",
|
||
second: "numeric",
|
||
hour12: true
|
||
};
|
||
break;
|
||
case "fullDateTime12h":
|
||
options = {
|
||
year: "numeric",
|
||
month: "long",
|
||
day: "numeric",
|
||
hour: "numeric",
|
||
minute: "numeric",
|
||
second: "numeric",
|
||
hour12: true
|
||
};
|
||
break;
|
||
case "fullDateTime24h":
|
||
options = {
|
||
year: "numeric",
|
||
month: "long",
|
||
day: "numeric",
|
||
hour: "numeric",
|
||
minute: "numeric",
|
||
second: "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",
|
||
second: "numeric",
|
||
hour12: false
|
||
};
|
||
break;
|
||
case "keyboardDateTime12h":
|
||
options = {
|
||
year: "numeric",
|
||
month: "2-digit",
|
||
day: "2-digit",
|
||
hour: "numeric",
|
||
minute: "numeric",
|
||
second: "numeric",
|
||
hour12: true
|
||
};
|
||
break;
|
||
case "keyboardDateTime24h":
|
||
options = {
|
||
year: "numeric",
|
||
month: "2-digit",
|
||
day: "2-digit",
|
||
hour: "numeric",
|
||
minute: "numeric",
|
||
second: "numeric",
|
||
hour12: false
|
||
};
|
||
break;
|
||
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);
|
||
}
|
||
class VuetifyDateAdapter {
|
||
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);
|
||
}
|
||
}
|
||
const DateOptionsSymbol = Symbol.for("vuetify:date-options");
|
||
const 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;
|
||
}
|
||
const breakpoints = ["sm", "md", "lg", "xl", "xxl"];
|
||
const DisplaySymbol = Symbol.for("vuetify:display");
|
||
const defaultDisplayOptions = {
|
||
mobileBreakpoint: "lg",
|
||
thresholds: {
|
||
xs: 0,
|
||
sm: 600,
|
||
md: 960,
|
||
lg: 1280,
|
||
xl: 1920,
|
||
xxl: 2560
|
||
}
|
||
};
|
||
const parseDisplayOptions = function() {
|
||
let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : defaultDisplayOptions;
|
||
return mergeDeep(defaultDisplayOptions, options);
|
||
};
|
||
function getClientWidth(ssr) {
|
||
return typeof ssr === "object" && ssr.clientWidth || 0;
|
||
}
|
||
function getClientHeight(ssr) {
|
||
return typeof ssr === "object" && ssr.clientHeight || 0;
|
||
}
|
||
function getPlatform(ssr) {
|
||
const userAgent = "ssr";
|
||
function match(regexp) {
|
||
return Boolean(userAgent.match(regexp));
|
||
}
|
||
const android = match(/android/i);
|
||
const ios = match(/iphone|ipad|ipod/i);
|
||
const cordova = match(/cordova/i);
|
||
const electron = match(/electron/i);
|
||
const chrome = match(/chrome/i);
|
||
const edge = match(/edge/i);
|
||
const firefox = match(/firefox/i);
|
||
const opera = match(/opera/i);
|
||
const win = match(/win/i);
|
||
const mac = match(/mac/i);
|
||
const linux = match(/linux/i);
|
||
return {
|
||
android,
|
||
ios,
|
||
cordova,
|
||
electron,
|
||
chrome,
|
||
edge,
|
||
firefox,
|
||
opera,
|
||
win,
|
||
mac,
|
||
linux,
|
||
touch: SUPPORTS_TOUCH,
|
||
ssr: userAgent === "ssr"
|
||
};
|
||
}
|
||
function createDisplay(options, ssr) {
|
||
const {
|
||
thresholds,
|
||
mobileBreakpoint
|
||
} = parseDisplayOptions(options);
|
||
const height = shallowRef(getClientHeight(ssr));
|
||
const platform = shallowRef(getPlatform());
|
||
const state = reactive({});
|
||
const width = shallowRef(getClientWidth(ssr));
|
||
function updateSize() {
|
||
height.value = getClientHeight();
|
||
width.value = getClientWidth();
|
||
}
|
||
function update() {
|
||
updateSize();
|
||
platform.value = getPlatform();
|
||
}
|
||
watchEffect(() => {
|
||
const xs = width.value < thresholds.sm;
|
||
const sm = width.value < thresholds.md && !xs;
|
||
const md = width.value < thresholds.lg && !(sm || xs);
|
||
const lg = width.value < thresholds.xl && !(md || sm || xs);
|
||
const xl = width.value < thresholds.xxl && !(lg || md || sm || xs);
|
||
const xxl = width.value >= thresholds.xxl;
|
||
const name = xs ? "xs" : sm ? "sm" : md ? "md" : lg ? "lg" : xl ? "xl" : "xxl";
|
||
const breakpointValue = typeof mobileBreakpoint === "number" ? mobileBreakpoint : thresholds[mobileBreakpoint];
|
||
const mobile = width.value < breakpointValue;
|
||
state.xs = xs;
|
||
state.sm = sm;
|
||
state.md = md;
|
||
state.lg = lg;
|
||
state.xl = xl;
|
||
state.xxl = xxl;
|
||
state.smAndUp = !xs;
|
||
state.mdAndUp = !(xs || sm);
|
||
state.lgAndUp = !(xs || sm || md);
|
||
state.xlAndUp = !(xs || sm || md || lg);
|
||
state.smAndDown = !(md || lg || xl || xxl);
|
||
state.mdAndDown = !(lg || xl || xxl);
|
||
state.lgAndDown = !(xl || xxl);
|
||
state.xlAndDown = !xxl;
|
||
state.name = name;
|
||
state.height = height.value;
|
||
state.width = width.value;
|
||
state.mobile = mobile;
|
||
state.mobileBreakpoint = mobileBreakpoint;
|
||
state.platform = platform.value;
|
||
state.thresholds = thresholds;
|
||
});
|
||
return {
|
||
...toRefs(state),
|
||
update,
|
||
ssr: !!ssr
|
||
};
|
||
}
|
||
const makeDisplayProps = propsFactory({
|
||
mobile: {
|
||
type: Boolean,
|
||
default: false
|
||
},
|
||
mobileBreakpoint: [Number, String]
|
||
}, "display");
|
||
function useDisplay() {
|
||
let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
|
||
let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
|
||
const display = inject$1(DisplaySymbol);
|
||
if (!display) throw new Error("Could not find Vuetify display injection");
|
||
const mobile = computed(() => {
|
||
if (props.mobile != null) return props.mobile;
|
||
if (!props.mobileBreakpoint) return display.mobile.value;
|
||
const breakpointValue = typeof props.mobileBreakpoint === "number" ? props.mobileBreakpoint : display.thresholds.value[props.mobileBreakpoint];
|
||
return display.width.value < breakpointValue;
|
||
});
|
||
const displayClasses = computed(() => {
|
||
if (!name) return {};
|
||
return {
|
||
[`${name}--mobile`]: mobile.value
|
||
};
|
||
});
|
||
return {
|
||
...display,
|
||
displayClasses,
|
||
mobile
|
||
};
|
||
}
|
||
const GoToSymbol = Symbol.for("vuetify:goto");
|
||
function genDefaults$2() {
|
||
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$1(el) ?? ((void 0).scrollingElement || (void 0).body);
|
||
}
|
||
function getTarget$1(el) {
|
||
return typeof el === "string" ? (void 0).querySelector(el) : refElement(el);
|
||
}
|
||
function getOffset$1(target, horizontal, rtl) {
|
||
if (typeof target === "number") return horizontal && rtl ? -target : target;
|
||
let el = getTarget$1(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$2(), options)
|
||
};
|
||
}
|
||
async function scrollTo(_target, _options, horizontal, goTo) {
|
||
const property = horizontal ? "scrollLeft" : "scrollTop";
|
||
const options = mergeDeep((goTo == null ? void 0 : goTo.options) ?? genDefaults$2(), _options);
|
||
const rtl = goTo == null ? void 0 : goTo.rtl.value;
|
||
const target = (typeof _target === "number" ? _target : getTarget$1(_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$1(target, horizontal, rtl);
|
||
} else {
|
||
targetLocation = getOffset$1(target, horizontal, rtl) - getOffset$1(container, horizontal, rtl);
|
||
if (options.layout) {
|
||
const styles = (void 0).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$1(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 === (void 0).scrollingElement ? [(void 0).innerWidth, (void 0).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);
|
||
}
|
||
const aliases$1 = {
|
||
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"
|
||
};
|
||
const mdi = {
|
||
// Not using mergeProps here, functional components merge props by default (?)
|
||
component: (props) => h(VClassIcon, {
|
||
...props,
|
||
class: "mdi"
|
||
})
|
||
};
|
||
const IconValue = [String, Function, Object, Array];
|
||
const IconSymbol = Symbol.for("vuetify:icons");
|
||
const 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");
|
||
const 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)];
|
||
}
|
||
});
|
||
};
|
||
}
|
||
});
|
||
const 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)])]
|
||
});
|
||
};
|
||
}
|
||
});
|
||
defineComponent({
|
||
name: "VLigatureIcon",
|
||
props: makeIconProps(),
|
||
setup(props) {
|
||
return () => {
|
||
return createVNode(props.tag, null, {
|
||
default: () => [props.icon]
|
||
});
|
||
};
|
||
}
|
||
});
|
||
const VClassIcon = defineComponent({
|
||
name: "VClassIcon",
|
||
props: makeIconProps(),
|
||
setup(props) {
|
||
return () => {
|
||
return createVNode(props.tag, {
|
||
"class": props.icon
|
||
}, null);
|
||
};
|
||
}
|
||
});
|
||
function genDefaults$1() {
|
||
return {
|
||
svg: {
|
||
component: VSvgIcon
|
||
},
|
||
class: {
|
||
component: VClassIcon
|
||
}
|
||
};
|
||
}
|
||
function createIcons(options) {
|
||
const sets = genDefaults$1();
|
||
const defaultSet = (options == null ? void 0 : options.defaultSet) ?? "mdi";
|
||
if (defaultSet === "mdi" && !sets.mdi) {
|
||
sets.mdi = mdi;
|
||
}
|
||
return mergeDeep({
|
||
defaultSet,
|
||
sets,
|
||
aliases: {
|
||
...aliases$1,
|
||
/* 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);
|
||
}
|
||
const useIcon = (props) => {
|
||
const icons2 = inject$1(IconSymbol);
|
||
if (!icons2) 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 = icons2.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(icons2.sets).find((setName) => typeof icon === "string" && icon.startsWith(`${setName}:`));
|
||
const iconName = iconSetName ? icon.slice(iconSetName.length + 1) : icon;
|
||
const iconSet = icons2.sets[iconSetName ?? icons2.defaultSet];
|
||
return {
|
||
component: iconSet.component,
|
||
icon: iconName
|
||
};
|
||
});
|
||
return {
|
||
iconData
|
||
};
|
||
};
|
||
const ThemeSymbol = Symbol.for("vuetify:theme");
|
||
const makeThemeProps = propsFactory({
|
||
theme: String
|
||
}, "theme");
|
||
function genDefaults() {
|
||
return {
|
||
defaultTheme: "light",
|
||
variations: {
|
||
colors: [],
|
||
lighten: 0,
|
||
darken: 0
|
||
},
|
||
themes: {
|
||
light: {
|
||
dark: false,
|
||
colors: {
|
||
background: "#FFFFFF",
|
||
surface: "#FFFFFF",
|
||
"surface-bright": "#FFFFFF",
|
||
"surface-light": "#EEEEEE",
|
||
"surface-variant": "#424242",
|
||
"on-surface-variant": "#EEEEEE",
|
||
primary: "#1867C0",
|
||
"primary-darken-1": "#1F5592",
|
||
secondary: "#48A9A6",
|
||
"secondary-darken-1": "#018786",
|
||
error: "#B00020",
|
||
info: "#2196F3",
|
||
success: "#4CAF50",
|
||
warning: "#FB8C00"
|
||
},
|
||
variables: {
|
||
"border-color": "#000000",
|
||
"border-opacity": 0.12,
|
||
"high-emphasis-opacity": 0.87,
|
||
"medium-emphasis-opacity": 0.6,
|
||
"disabled-opacity": 0.38,
|
||
"idle-opacity": 0.04,
|
||
"hover-opacity": 0.04,
|
||
"focus-opacity": 0.12,
|
||
"selected-opacity": 0.08,
|
||
"activated-opacity": 0.12,
|
||
"pressed-opacity": 0.12,
|
||
"dragged-opacity": 0.08,
|
||
"theme-kbd": "#212529",
|
||
"theme-on-kbd": "#FFFFFF",
|
||
"theme-code": "#F5F5F5",
|
||
"theme-on-code": "#000000"
|
||
}
|
||
},
|
||
dark: {
|
||
dark: true,
|
||
colors: {
|
||
background: "#121212",
|
||
surface: "#212121",
|
||
"surface-bright": "#ccbfd6",
|
||
"surface-light": "#424242",
|
||
"surface-variant": "#a3a3a3",
|
||
"on-surface-variant": "#424242",
|
||
primary: "#2196F3",
|
||
"primary-darken-1": "#277CC1",
|
||
secondary: "#54B6B2",
|
||
"secondary-darken-1": "#48A9A6",
|
||
error: "#CF6679",
|
||
info: "#2196F3",
|
||
success: "#4CAF50",
|
||
warning: "#FB8C00"
|
||
},
|
||
variables: {
|
||
"border-color": "#FFFFFF",
|
||
"border-opacity": 0.12,
|
||
"high-emphasis-opacity": 1,
|
||
"medium-emphasis-opacity": 0.7,
|
||
"disabled-opacity": 0.5,
|
||
"idle-opacity": 0.1,
|
||
"hover-opacity": 0.04,
|
||
"focus-opacity": 0.12,
|
||
"selected-opacity": 0.08,
|
||
"activated-opacity": 0.12,
|
||
"pressed-opacity": 0.16,
|
||
"dragged-opacity": 0.08,
|
||
"theme-kbd": "#212529",
|
||
"theme-on-kbd": "#FFFFFF",
|
||
"theme-code": "#343434",
|
||
"theme-on-code": "#CCCCCC"
|
||
}
|
||
}
|
||
}
|
||
};
|
||
}
|
||
function parseThemeOptions() {
|
||
var _a, _b;
|
||
let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : genDefaults();
|
||
const defaults2 = genDefaults();
|
||
if (!options) return {
|
||
...defaults2,
|
||
isDisabled: true
|
||
};
|
||
const themes2 = {};
|
||
for (const [key, theme] of Object.entries(options.themes ?? {})) {
|
||
const defaultTheme = theme.dark || key === "dark" ? (_a = defaults2.themes) == null ? void 0 : _a.dark : (_b = defaults2.themes) == null ? void 0 : _b.light;
|
||
themes2[key] = mergeDeep(defaultTheme, theme);
|
||
}
|
||
return mergeDeep(defaults2, {
|
||
...options,
|
||
themes: themes2
|
||
});
|
||
}
|
||
function createTheme(options) {
|
||
const parsedOptions = parseThemeOptions(options);
|
||
const name = ref(parsedOptions.defaultTheme);
|
||
const themes2 = ref(parsedOptions.themes);
|
||
const computedThemes = computed(() => {
|
||
const acc = {};
|
||
for (const [name2, original] of Object.entries(themes2.value)) {
|
||
const theme = acc[name2] = {
|
||
...original,
|
||
colors: {
|
||
...original.colors
|
||
}
|
||
};
|
||
if (parsedOptions.variations) {
|
||
for (const name3 of parsedOptions.variations.colors) {
|
||
const color = theme.colors[name3];
|
||
if (!color) continue;
|
||
for (const variation of ["lighten", "darken"]) {
|
||
const fn = variation === "lighten" ? lighten : darken;
|
||
for (const amount of createRange(parsedOptions.variations[variation], 1)) {
|
||
theme.colors[`${name3}-${variation}-${amount}`] = RGBtoHex(fn(parseColor(color), amount));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
for (const color of Object.keys(theme.colors)) {
|
||
if (/^on-[a-z]/.test(color) || theme.colors[`on-${color}`]) continue;
|
||
const onColor = `on-${color}`;
|
||
const colorVal = parseColor(theme.colors[color]);
|
||
theme.colors[onColor] = getForeground(colorVal);
|
||
}
|
||
}
|
||
return acc;
|
||
});
|
||
const current = computed(() => computedThemes.value[name.value]);
|
||
const styles = computed(() => {
|
||
var _a;
|
||
const lines = [];
|
||
if ((_a = current.value) == null ? void 0 : _a.dark) {
|
||
createCssClass(lines, ":root", ["color-scheme: dark"]);
|
||
}
|
||
createCssClass(lines, ":root", genCssVariables(current.value));
|
||
for (const [themeName, theme] of Object.entries(computedThemes.value)) {
|
||
createCssClass(lines, `.v-theme--${themeName}`, [`color-scheme: ${theme.dark ? "dark" : "normal"}`, ...genCssVariables(theme)]);
|
||
}
|
||
const bgLines = [];
|
||
const fgLines = [];
|
||
const colors = new Set(Object.values(computedThemes.value).flatMap((theme) => Object.keys(theme.colors)));
|
||
for (const key of colors) {
|
||
if (/^on-[a-z]/.test(key)) {
|
||
createCssClass(fgLines, `.${key}`, [`color: rgb(var(--v-theme-${key})) !important`]);
|
||
} else {
|
||
createCssClass(bgLines, `.bg-${key}`, [`--v-theme-overlay-multiplier: var(--v-theme-${key}-overlay-multiplier)`, `background-color: rgb(var(--v-theme-${key})) !important`, `color: rgb(var(--v-theme-on-${key})) !important`]);
|
||
createCssClass(fgLines, `.text-${key}`, [`color: rgb(var(--v-theme-${key})) !important`]);
|
||
createCssClass(fgLines, `.border-${key}`, [`--v-border-color: var(--v-theme-${key})`]);
|
||
}
|
||
}
|
||
lines.push(...bgLines, ...fgLines);
|
||
return lines.map((str, i) => i === 0 ? str : ` ${str}`).join("");
|
||
});
|
||
function getHead() {
|
||
return {
|
||
style: [{
|
||
children: styles.value,
|
||
id: "vuetify-theme-stylesheet",
|
||
nonce: parsedOptions.cspNonce || false
|
||
}]
|
||
};
|
||
}
|
||
function install(app) {
|
||
if (parsedOptions.isDisabled) return;
|
||
const head = app._context.provides.usehead;
|
||
if (head) {
|
||
if (head.push) {
|
||
head.push(getHead);
|
||
} else {
|
||
{
|
||
head.addHeadObjs(getHead());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
const themeClasses = computed(() => parsedOptions.isDisabled ? void 0 : `v-theme--${name.value}`);
|
||
return {
|
||
install,
|
||
isDisabled: parsedOptions.isDisabled,
|
||
name,
|
||
themes: themes2,
|
||
current,
|
||
computedThemes,
|
||
themeClasses,
|
||
styles,
|
||
global: {
|
||
name,
|
||
current
|
||
}
|
||
};
|
||
}
|
||
function provideTheme(props) {
|
||
getCurrentInstance("provideTheme");
|
||
const theme = inject$1(ThemeSymbol, null);
|
||
if (!theme) throw new Error("Could not find Vuetify theme injection");
|
||
const name = computed(() => {
|
||
return props.theme ?? theme.name.value;
|
||
});
|
||
const current = computed(() => theme.themes.value[name.value]);
|
||
const themeClasses = computed(() => theme.isDisabled ? void 0 : `v-theme--${name.value}`);
|
||
const newTheme = {
|
||
...theme,
|
||
name,
|
||
current,
|
||
themeClasses
|
||
};
|
||
provide(ThemeSymbol, newTheme);
|
||
return newTheme;
|
||
}
|
||
function useTheme() {
|
||
getCurrentInstance("useTheme");
|
||
const theme = inject$1(ThemeSymbol, null);
|
||
if (!theme) throw new Error("Could not find Vuetify theme injection");
|
||
return theme;
|
||
}
|
||
function createCssClass(lines, selector, content) {
|
||
lines.push(`${selector} {
|
||
`, ...content.map((line) => ` ${line};
|
||
`), "}\n");
|
||
}
|
||
function genCssVariables(theme) {
|
||
const lightOverlay = theme.dark ? 2 : 1;
|
||
const darkOverlay = theme.dark ? 1 : 2;
|
||
const variables = [];
|
||
for (const [key, value] of Object.entries(theme.colors)) {
|
||
const rgb = parseColor(value);
|
||
variables.push(`--v-theme-${key}: ${rgb.r},${rgb.g},${rgb.b}`);
|
||
if (!key.startsWith("on-")) {
|
||
variables.push(`--v-theme-${key}-overlay-multiplier: ${getLuma(value) > 0.18 ? lightOverlay : darkOverlay}`);
|
||
}
|
||
}
|
||
for (const [key, value] of Object.entries(theme.variables)) {
|
||
const color = typeof value === "string" && value.startsWith("#") ? parseColor(value) : void 0;
|
||
const rgb = color ? `${color.r}, ${color.g}, ${color.b}` : void 0;
|
||
variables.push(`--v-${key}: ${rgb ?? value}`);
|
||
}
|
||
return variables;
|
||
}
|
||
function useResizeObserver(callback) {
|
||
const resizeRef = templateRef();
|
||
const contentRect = ref();
|
||
return {
|
||
resizeRef,
|
||
contentRect: readonly(contentRect)
|
||
};
|
||
}
|
||
const VuetifyLayoutKey = Symbol.for("vuetify:layout");
|
||
const VuetifyLayoutItemKey = Symbol.for("vuetify:layout-item");
|
||
const ROOT_ZINDEX = 1e3;
|
||
const makeLayoutProps = propsFactory({
|
||
overlaps: {
|
||
type: Array,
|
||
default: () => []
|
||
},
|
||
fullHeight: Boolean
|
||
}, "layout");
|
||
const 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$1(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);
|
||
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
|
||
};
|
||
}
|
||
function createVuetify() {
|
||
let vuetify = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
|
||
const {
|
||
blueprint,
|
||
...rest
|
||
} = vuetify;
|
||
const options = mergeDeep(blueprint, rest);
|
||
const {
|
||
aliases: aliases2 = {},
|
||
components = {},
|
||
directives = {}
|
||
} = options;
|
||
const defaults2 = createDefaults(options.defaults);
|
||
const display = createDisplay(options.display, options.ssr);
|
||
const theme = createTheme(options.theme);
|
||
const icons2 = createIcons(options.icons);
|
||
const locale = createLocale(options.locale);
|
||
const date2 = createDate(options.date, locale);
|
||
const goTo = createGoTo(options.goTo, locale);
|
||
const install = (app) => {
|
||
for (const key in directives) {
|
||
app.directive(key, directives[key]);
|
||
}
|
||
for (const key in components) {
|
||
app.component(key, components[key]);
|
||
}
|
||
for (const key in aliases2) {
|
||
app.component(key, defineComponent({
|
||
...aliases2[key],
|
||
name: key,
|
||
aliasName: aliases2[key].name
|
||
}));
|
||
}
|
||
theme.install(app);
|
||
app.provide(DefaultsSymbol, defaults2);
|
||
app.provide(DisplaySymbol, display);
|
||
app.provide(ThemeSymbol, theme);
|
||
app.provide(IconSymbol, icons2);
|
||
app.provide(LocaleSymbol, locale);
|
||
app.provide(DateOptionsSymbol, date2.options);
|
||
app.provide(DateAdapterSymbol, date2.instance);
|
||
app.provide(GoToSymbol, goTo);
|
||
getUid.reset();
|
||
{
|
||
app.mixin({
|
||
computed: {
|
||
$vuetify() {
|
||
return reactive({
|
||
defaults: inject.call(this, DefaultsSymbol),
|
||
display: inject.call(this, DisplaySymbol),
|
||
theme: inject.call(this, ThemeSymbol),
|
||
icons: inject.call(this, IconSymbol),
|
||
locale: inject.call(this, LocaleSymbol),
|
||
date: inject.call(this, DateAdapterSymbol)
|
||
});
|
||
}
|
||
}
|
||
});
|
||
}
|
||
};
|
||
return {
|
||
install,
|
||
defaults: defaults2,
|
||
display,
|
||
theme,
|
||
icons: icons2,
|
||
locale,
|
||
date: date2,
|
||
goTo
|
||
};
|
||
}
|
||
const version = "3.7.5";
|
||
createVuetify.version = version;
|
||
function inject(key) {
|
||
var _a, _b;
|
||
const vm = this.$;
|
||
const provides = ((_a = vm.parent) == null ? void 0 : _a.provides) ?? ((_b = vm.vnode.appContext) == null ? void 0 : _b.provides);
|
||
if (provides && key in provides) {
|
||
return provides[key];
|
||
}
|
||
}
|
||
const makeBorderProps = propsFactory({
|
||
border: [Boolean, Number, String]
|
||
}, "border");
|
||
function useBorder(props) {
|
||
let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
|
||
const borderClasses = computed(() => {
|
||
const border = isRef(props) ? props.value : props.border;
|
||
const classes = [];
|
||
if (border === true || border === "") {
|
||
classes.push(`${name}--border`);
|
||
} else if (typeof border === "string" || border === 0) {
|
||
for (const value of String(border).split(" ")) {
|
||
classes.push(`border-${value}`);
|
||
}
|
||
}
|
||
return classes;
|
||
});
|
||
return {
|
||
borderClasses
|
||
};
|
||
}
|
||
const allowedDensities = [null, "default", "comfortable", "compact"];
|
||
const makeDensityProps = propsFactory({
|
||
density: {
|
||
type: String,
|
||
default: "default",
|
||
validator: (v) => allowedDensities.includes(v)
|
||
}
|
||
}, "density");
|
||
function useDensity(props) {
|
||
let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
|
||
const densityClasses = computed(() => {
|
||
return `${name}--density-${props.density}`;
|
||
});
|
||
return {
|
||
densityClasses
|
||
};
|
||
}
|
||
const makeElevationProps = propsFactory({
|
||
elevation: {
|
||
type: [Number, String],
|
||
validator(v) {
|
||
const value = parseInt(v);
|
||
return !isNaN(value) && value >= 0 && // Material Design has a maximum elevation of 24
|
||
// https://material.io/design/environment/elevation.html#default-elevations
|
||
value <= 24;
|
||
}
|
||
}
|
||
}, "elevation");
|
||
function useElevation(props) {
|
||
const elevationClasses = computed(() => {
|
||
const elevation = isRef(props) ? props.value : props.elevation;
|
||
const classes = [];
|
||
if (elevation == null) return classes;
|
||
classes.push(`elevation-${elevation}`);
|
||
return classes;
|
||
});
|
||
return {
|
||
elevationClasses
|
||
};
|
||
}
|
||
const makeRoundedProps = propsFactory({
|
||
rounded: {
|
||
type: [Boolean, Number, String],
|
||
default: void 0
|
||
},
|
||
tile: Boolean
|
||
}, "rounded");
|
||
function useRounded(props) {
|
||
let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
|
||
const roundedClasses = computed(() => {
|
||
const rounded = isRef(props) ? props.value : props.rounded;
|
||
const tile = isRef(props) ? props.value : props.tile;
|
||
const classes = [];
|
||
if (rounded === true || rounded === "") {
|
||
classes.push(`${name}--rounded`);
|
||
} else if (typeof rounded === "string" || rounded === 0) {
|
||
for (const value of String(rounded).split(" ")) {
|
||
classes.push(`rounded-${value}`);
|
||
}
|
||
} else if (tile || rounded === false) {
|
||
classes.push("rounded-0");
|
||
}
|
||
return classes;
|
||
});
|
||
return {
|
||
roundedClasses
|
||
};
|
||
}
|
||
const makeTagProps = propsFactory({
|
||
tag: {
|
||
type: String,
|
||
default: "div"
|
||
}
|
||
}, "tag");
|
||
function useColor(colors) {
|
||
return destructComputed(() => {
|
||
const classes = [];
|
||
const styles = {};
|
||
if (colors.value.background) {
|
||
if (isCssColor(colors.value.background)) {
|
||
styles.backgroundColor = colors.value.background;
|
||
if (!colors.value.text && isParsableColor(colors.value.background)) {
|
||
const backgroundColor = parseColor(colors.value.background);
|
||
if (backgroundColor.a == null || backgroundColor.a === 1) {
|
||
const textColor = getForeground(backgroundColor);
|
||
styles.color = textColor;
|
||
styles.caretColor = textColor;
|
||
}
|
||
}
|
||
} else {
|
||
classes.push(`bg-${colors.value.background}`);
|
||
}
|
||
}
|
||
if (colors.value.text) {
|
||
if (isCssColor(colors.value.text)) {
|
||
styles.color = colors.value.text;
|
||
styles.caretColor = colors.value.text;
|
||
} else {
|
||
classes.push(`text-${colors.value.text}`);
|
||
}
|
||
}
|
||
return {
|
||
colorClasses: classes,
|
||
colorStyles: styles
|
||
};
|
||
});
|
||
}
|
||
function useTextColor(props, name) {
|
||
const colors = computed(() => ({
|
||
text: isRef(props) ? props.value : name ? props[name] : null
|
||
}));
|
||
const {
|
||
colorClasses: textColorClasses,
|
||
colorStyles: textColorStyles
|
||
} = useColor(colors);
|
||
return {
|
||
textColorClasses,
|
||
textColorStyles
|
||
};
|
||
}
|
||
function useBackgroundColor(props, name) {
|
||
const colors = computed(() => ({
|
||
background: isRef(props) ? props.value : name ? props[name] : null
|
||
}));
|
||
const {
|
||
colorClasses: backgroundColorClasses,
|
||
colorStyles: backgroundColorStyles
|
||
} = useColor(colors);
|
||
return {
|
||
backgroundColorClasses,
|
||
backgroundColorStyles
|
||
};
|
||
}
|
||
const allowedVariants = ["elevated", "flat", "tonal", "outlined", "text", "plain"];
|
||
function genOverlays(isClickable, name) {
|
||
return createVNode(Fragment, null, [isClickable && createVNode("span", {
|
||
"key": "overlay",
|
||
"class": `${name}__overlay`
|
||
}, null), createVNode("span", {
|
||
"key": "underlay",
|
||
"class": `${name}__underlay`
|
||
}, null)]);
|
||
}
|
||
const makeVariantProps = propsFactory({
|
||
color: String,
|
||
variant: {
|
||
type: String,
|
||
default: "elevated",
|
||
validator: (v) => allowedVariants.includes(v)
|
||
}
|
||
}, "variant");
|
||
function useVariant(props) {
|
||
let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
|
||
const variantClasses = computed(() => {
|
||
const {
|
||
variant
|
||
} = unref(props);
|
||
return `${name}--variant-${variant}`;
|
||
});
|
||
const {
|
||
colorClasses,
|
||
colorStyles
|
||
} = useColor(computed(() => {
|
||
const {
|
||
variant,
|
||
color
|
||
} = unref(props);
|
||
return {
|
||
[["elevated", "flat"].includes(variant) ? "background" : "text"]: color
|
||
};
|
||
}));
|
||
return {
|
||
colorClasses,
|
||
colorStyles,
|
||
variantClasses
|
||
};
|
||
}
|
||
const makeVBtnGroupProps = propsFactory({
|
||
baseColor: String,
|
||
divided: Boolean,
|
||
...makeBorderProps(),
|
||
...makeComponentProps(),
|
||
...makeDensityProps(),
|
||
...makeElevationProps(),
|
||
...makeRoundedProps(),
|
||
...makeTagProps(),
|
||
...makeThemeProps(),
|
||
...makeVariantProps()
|
||
}, "VBtnGroup");
|
||
const VBtnGroup = genericComponent()({
|
||
name: "VBtnGroup",
|
||
props: makeVBtnGroupProps(),
|
||
setup(props, _ref) {
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
const {
|
||
themeClasses
|
||
} = provideTheme(props);
|
||
const {
|
||
densityClasses
|
||
} = useDensity(props);
|
||
const {
|
||
borderClasses
|
||
} = useBorder(props);
|
||
const {
|
||
elevationClasses
|
||
} = useElevation(props);
|
||
const {
|
||
roundedClasses
|
||
} = useRounded(props);
|
||
provideDefaults({
|
||
VBtn: {
|
||
height: "auto",
|
||
baseColor: toRef(props, "baseColor"),
|
||
color: toRef(props, "color"),
|
||
density: toRef(props, "density"),
|
||
flat: true,
|
||
variant: toRef(props, "variant")
|
||
}
|
||
});
|
||
useRender(() => {
|
||
return createVNode(props.tag, {
|
||
"class": ["v-btn-group", {
|
||
"v-btn-group--divided": props.divided
|
||
}, themeClasses.value, borderClasses.value, densityClasses.value, elevationClasses.value, roundedClasses.value, props.class],
|
||
"style": props.style
|
||
}, slots);
|
||
});
|
||
}
|
||
});
|
||
const makeGroupProps = propsFactory({
|
||
modelValue: {
|
||
type: null,
|
||
default: void 0
|
||
},
|
||
multiple: Boolean,
|
||
mandatory: [Boolean, String],
|
||
max: Number,
|
||
selectedClass: String,
|
||
disabled: Boolean
|
||
}, "group");
|
||
const makeGroupItemProps = propsFactory({
|
||
value: null,
|
||
disabled: Boolean,
|
||
selectedClass: String
|
||
}, "group-item");
|
||
function useGroupItem(props, injectKey) {
|
||
let required = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
|
||
const vm = getCurrentInstance("useGroupItem");
|
||
if (!vm) {
|
||
throw new Error("[Vuetify] useGroupItem composable must be used inside a component setup function");
|
||
}
|
||
const id = getUid();
|
||
provide(Symbol.for(`${injectKey.description}:id`), id);
|
||
const group = inject$1(injectKey, null);
|
||
if (!group) {
|
||
if (!required) return group;
|
||
throw new Error(`[Vuetify] Could not find useGroup injection with symbol ${injectKey.description}`);
|
||
}
|
||
const value = toRef(props, "value");
|
||
const disabled = computed(() => !!(group.disabled.value || props.disabled));
|
||
group.register({
|
||
id,
|
||
value,
|
||
disabled
|
||
}, vm);
|
||
const isSelected = computed(() => {
|
||
return group.isSelected(id);
|
||
});
|
||
const isFirst = computed(() => {
|
||
return group.items.value[0].id === id;
|
||
});
|
||
const isLast = computed(() => {
|
||
return group.items.value[group.items.value.length - 1].id === id;
|
||
});
|
||
const selectedClass = computed(() => isSelected.value && [group.selectedClass.value, props.selectedClass]);
|
||
watch(isSelected, (value2) => {
|
||
vm.emit("group:selected", {
|
||
value: value2
|
||
});
|
||
}, {
|
||
flush: "sync"
|
||
});
|
||
return {
|
||
id,
|
||
isSelected,
|
||
isFirst,
|
||
isLast,
|
||
toggle: () => group.select(id, !isSelected.value),
|
||
select: (value2) => group.select(id, value2),
|
||
selectedClass,
|
||
value,
|
||
disabled,
|
||
group
|
||
};
|
||
}
|
||
function useGroup(props, injectKey) {
|
||
const items = reactive([]);
|
||
const selected = useProxiedModel(props, "modelValue", [], (v) => {
|
||
if (v == null) return [];
|
||
return getIds(items, wrapInArray(v));
|
||
}, (v) => {
|
||
const arr = getValues(items, v);
|
||
return props.multiple ? arr : arr[0];
|
||
});
|
||
const groupVm = getCurrentInstance("useGroup");
|
||
function register(item, vm) {
|
||
const unwrapped = item;
|
||
const key = Symbol.for(`${injectKey.description}:id`);
|
||
const children = findChildrenWithProvide(key, groupVm == null ? void 0 : groupVm.vnode);
|
||
const index = children.indexOf(vm);
|
||
if (unref(unwrapped.value) == null) {
|
||
unwrapped.value = index;
|
||
unwrapped.useIndexAsValue = true;
|
||
}
|
||
if (index > -1) {
|
||
items.splice(index, 0, unwrapped);
|
||
} else {
|
||
items.push(unwrapped);
|
||
}
|
||
}
|
||
function unregister(id) {
|
||
forceMandatoryValue();
|
||
const index = items.findIndex((item) => item.id === id);
|
||
items.splice(index, 1);
|
||
}
|
||
function forceMandatoryValue() {
|
||
const item = items.find((item2) => !item2.disabled);
|
||
if (item && props.mandatory === "force" && !selected.value.length) {
|
||
selected.value = [item.id];
|
||
}
|
||
}
|
||
function select(id, value) {
|
||
const item = items.find((item2) => item2.id === id);
|
||
if (value && (item == null ? void 0 : item.disabled)) return;
|
||
if (props.multiple) {
|
||
const internalValue = selected.value.slice();
|
||
const index = internalValue.findIndex((v) => v === id);
|
||
const isSelected = ~index;
|
||
value = value ?? !isSelected;
|
||
if (isSelected && props.mandatory && internalValue.length <= 1) return;
|
||
if (!isSelected && props.max != null && internalValue.length + 1 > props.max) return;
|
||
if (index < 0 && value) internalValue.push(id);
|
||
else if (index >= 0 && !value) internalValue.splice(index, 1);
|
||
selected.value = internalValue;
|
||
} else {
|
||
const isSelected = selected.value.includes(id);
|
||
if (props.mandatory && isSelected) return;
|
||
selected.value = value ?? !isSelected ? [id] : [];
|
||
}
|
||
}
|
||
function step(offset) {
|
||
if (props.multiple) consoleWarn('This method is not supported when using "multiple" prop');
|
||
if (!selected.value.length) {
|
||
const item = items.find((item2) => !item2.disabled);
|
||
item && (selected.value = [item.id]);
|
||
} else {
|
||
const currentId = selected.value[0];
|
||
const currentIndex = items.findIndex((i) => i.id === currentId);
|
||
let newIndex = (currentIndex + offset) % items.length;
|
||
let newItem = items[newIndex];
|
||
while (newItem.disabled && newIndex !== currentIndex) {
|
||
newIndex = (newIndex + offset) % items.length;
|
||
newItem = items[newIndex];
|
||
}
|
||
if (newItem.disabled) return;
|
||
selected.value = [items[newIndex].id];
|
||
}
|
||
}
|
||
const state = {
|
||
register,
|
||
unregister,
|
||
selected,
|
||
select,
|
||
disabled: toRef(props, "disabled"),
|
||
prev: () => step(items.length - 1),
|
||
next: () => step(1),
|
||
isSelected: (id) => selected.value.includes(id),
|
||
selectedClass: computed(() => props.selectedClass),
|
||
items: computed(() => items),
|
||
getItemIndex: (value) => getItemIndex(items, value)
|
||
};
|
||
provide(injectKey, state);
|
||
return state;
|
||
}
|
||
function getItemIndex(items, value) {
|
||
const ids = getIds(items, [value]);
|
||
if (!ids.length) return -1;
|
||
return items.findIndex((item) => item.id === ids[0]);
|
||
}
|
||
function getIds(items, modelValue) {
|
||
const ids = [];
|
||
modelValue.forEach((value) => {
|
||
const item = items.find((item2) => deepEqual(value, item2.value));
|
||
const itemByIndex = items[value];
|
||
if ((item == null ? void 0 : item.value) != null) {
|
||
ids.push(item.id);
|
||
} else if (itemByIndex != null) {
|
||
ids.push(itemByIndex.id);
|
||
}
|
||
});
|
||
return ids;
|
||
}
|
||
function getValues(items, ids) {
|
||
const values = [];
|
||
ids.forEach((id) => {
|
||
const itemIndex = items.findIndex((item) => item.id === id);
|
||
if (~itemIndex) {
|
||
const item = items[itemIndex];
|
||
values.push(item.value != null ? item.value : itemIndex);
|
||
}
|
||
});
|
||
return values;
|
||
}
|
||
const VBtnToggleSymbol = Symbol.for("vuetify:v-btn-toggle");
|
||
const makeVBtnToggleProps = propsFactory({
|
||
...makeVBtnGroupProps(),
|
||
...makeGroupProps()
|
||
}, "VBtnToggle");
|
||
genericComponent()({
|
||
name: "VBtnToggle",
|
||
props: makeVBtnToggleProps(),
|
||
emits: {
|
||
"update:modelValue": (value) => true
|
||
},
|
||
setup(props, _ref) {
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
const {
|
||
isSelected,
|
||
next,
|
||
prev,
|
||
select,
|
||
selected
|
||
} = useGroup(props, VBtnToggleSymbol);
|
||
useRender(() => {
|
||
const btnGroupProps = VBtnGroup.filterProps(props);
|
||
return createVNode(VBtnGroup, mergeProps({
|
||
"class": ["v-btn-toggle", props.class]
|
||
}, btnGroupProps, {
|
||
"style": props.style
|
||
}), {
|
||
default: () => {
|
||
var _a;
|
||
return [(_a = slots.default) == null ? void 0 : _a.call(slots, {
|
||
isSelected,
|
||
next,
|
||
prev,
|
||
select,
|
||
selected
|
||
})];
|
||
}
|
||
});
|
||
});
|
||
return {
|
||
next,
|
||
prev,
|
||
select
|
||
};
|
||
}
|
||
});
|
||
const makeVDefaultsProviderProps = propsFactory({
|
||
defaults: Object,
|
||
disabled: Boolean,
|
||
reset: [Number, String],
|
||
root: [Boolean, String],
|
||
scoped: Boolean
|
||
}, "VDefaultsProvider");
|
||
const VDefaultsProvider = genericComponent(false)({
|
||
name: "VDefaultsProvider",
|
||
props: makeVDefaultsProviderProps(),
|
||
setup(props, _ref) {
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
const {
|
||
defaults: defaults2,
|
||
disabled,
|
||
reset,
|
||
root,
|
||
scoped
|
||
} = toRefs(props);
|
||
provideDefaults(defaults2, {
|
||
reset,
|
||
root,
|
||
scoped,
|
||
disabled
|
||
});
|
||
return () => {
|
||
var _a;
|
||
return (_a = slots.default) == null ? void 0 : _a.call(slots);
|
||
};
|
||
}
|
||
});
|
||
const predefinedSizes = ["x-small", "small", "default", "large", "x-large"];
|
||
const makeSizeProps = propsFactory({
|
||
size: {
|
||
type: [String, Number],
|
||
default: "default"
|
||
}
|
||
}, "size");
|
||
function useSize(props) {
|
||
let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
|
||
return destructComputed(() => {
|
||
let sizeClasses;
|
||
let sizeStyles;
|
||
if (includes(predefinedSizes, props.size)) {
|
||
sizeClasses = `${name}--size-${props.size}`;
|
||
} else if (props.size) {
|
||
sizeStyles = {
|
||
width: convertToUnit(props.size),
|
||
height: convertToUnit(props.size)
|
||
};
|
||
}
|
||
return {
|
||
sizeClasses,
|
||
sizeStyles
|
||
};
|
||
});
|
||
}
|
||
const makeVIconProps = propsFactory({
|
||
color: String,
|
||
disabled: Boolean,
|
||
start: Boolean,
|
||
end: Boolean,
|
||
icon: IconValue,
|
||
...makeComponentProps(),
|
||
...makeSizeProps(),
|
||
...makeTagProps({
|
||
tag: "i"
|
||
}),
|
||
...makeThemeProps()
|
||
}, "VIcon");
|
||
const VIcon = genericComponent()({
|
||
name: "VIcon",
|
||
props: makeVIconProps(),
|
||
setup(props, _ref) {
|
||
let {
|
||
attrs,
|
||
slots
|
||
} = _ref;
|
||
const slotIcon = ref();
|
||
const {
|
||
themeClasses
|
||
} = provideTheme(props);
|
||
const {
|
||
iconData
|
||
} = useIcon(computed(() => slotIcon.value || props.icon));
|
||
const {
|
||
sizeClasses
|
||
} = useSize(props);
|
||
const {
|
||
textColorClasses,
|
||
textColorStyles
|
||
} = useTextColor(toRef(props, "color"));
|
||
useRender(() => {
|
||
var _a, _b;
|
||
const slotValue = (_a = slots.default) == null ? void 0 : _a.call(slots);
|
||
if (slotValue) {
|
||
slotIcon.value = (_b = flattenFragments(slotValue).filter((node) => node.type === Text && node.children && typeof node.children === "string")[0]) == null ? void 0 : _b.children;
|
||
}
|
||
const hasClick = !!(attrs.onClick || attrs.onClickOnce);
|
||
return createVNode(iconData.value.component, {
|
||
"tag": props.tag,
|
||
"icon": iconData.value.icon,
|
||
"class": ["v-icon", "notranslate", themeClasses.value, sizeClasses.value, textColorClasses.value, {
|
||
"v-icon--clickable": hasClick,
|
||
"v-icon--disabled": props.disabled,
|
||
"v-icon--start": props.start,
|
||
"v-icon--end": props.end
|
||
}, props.class],
|
||
"style": [!sizeClasses.value ? {
|
||
fontSize: convertToUnit(props.size),
|
||
height: convertToUnit(props.size),
|
||
width: convertToUnit(props.size)
|
||
} : void 0, textColorStyles.value, props.style],
|
||
"role": hasClick ? "button" : void 0,
|
||
"aria-hidden": !hasClick,
|
||
"tabindex": hasClick ? props.disabled ? -1 : 0 : void 0
|
||
}, {
|
||
default: () => [slotValue]
|
||
});
|
||
});
|
||
return {};
|
||
}
|
||
});
|
||
function useIntersectionObserver(callback, options) {
|
||
const intersectionRef = ref();
|
||
const isIntersecting = shallowRef(false);
|
||
return {
|
||
intersectionRef,
|
||
isIntersecting
|
||
};
|
||
}
|
||
const makeVProgressCircularProps = propsFactory({
|
||
bgColor: String,
|
||
color: String,
|
||
indeterminate: [Boolean, String],
|
||
modelValue: {
|
||
type: [Number, String],
|
||
default: 0
|
||
},
|
||
rotate: {
|
||
type: [Number, String],
|
||
default: 0
|
||
},
|
||
width: {
|
||
type: [Number, String],
|
||
default: 4
|
||
},
|
||
...makeComponentProps(),
|
||
...makeSizeProps(),
|
||
...makeTagProps({
|
||
tag: "div"
|
||
}),
|
||
...makeThemeProps()
|
||
}, "VProgressCircular");
|
||
const VProgressCircular = genericComponent()({
|
||
name: "VProgressCircular",
|
||
props: makeVProgressCircularProps(),
|
||
setup(props, _ref) {
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
const MAGIC_RADIUS_CONSTANT = 20;
|
||
const CIRCUMFERENCE = 2 * Math.PI * MAGIC_RADIUS_CONSTANT;
|
||
const root = ref();
|
||
const {
|
||
themeClasses
|
||
} = provideTheme(props);
|
||
const {
|
||
sizeClasses,
|
||
sizeStyles
|
||
} = useSize(props);
|
||
const {
|
||
textColorClasses,
|
||
textColorStyles
|
||
} = useTextColor(toRef(props, "color"));
|
||
const {
|
||
textColorClasses: underlayColorClasses,
|
||
textColorStyles: underlayColorStyles
|
||
} = useTextColor(toRef(props, "bgColor"));
|
||
const {
|
||
intersectionRef,
|
||
isIntersecting
|
||
} = useIntersectionObserver();
|
||
const {
|
||
resizeRef,
|
||
contentRect
|
||
} = useResizeObserver();
|
||
const normalizedValue = computed(() => Math.max(0, Math.min(100, parseFloat(props.modelValue))));
|
||
const width = computed(() => Number(props.width));
|
||
const size = computed(() => {
|
||
return sizeStyles.value ? Number(props.size) : contentRect.value ? contentRect.value.width : Math.max(width.value, 32);
|
||
});
|
||
const diameter = computed(() => MAGIC_RADIUS_CONSTANT / (1 - width.value / size.value) * 2);
|
||
const strokeWidth = computed(() => width.value / size.value * diameter.value);
|
||
const strokeDashOffset = computed(() => convertToUnit((100 - normalizedValue.value) / 100 * CIRCUMFERENCE));
|
||
watchEffect(() => {
|
||
intersectionRef.value = root.value;
|
||
resizeRef.value = root.value;
|
||
});
|
||
useRender(() => createVNode(props.tag, {
|
||
"ref": root,
|
||
"class": ["v-progress-circular", {
|
||
"v-progress-circular--indeterminate": !!props.indeterminate,
|
||
"v-progress-circular--visible": isIntersecting.value,
|
||
"v-progress-circular--disable-shrink": props.indeterminate === "disable-shrink"
|
||
}, themeClasses.value, sizeClasses.value, textColorClasses.value, props.class],
|
||
"style": [sizeStyles.value, textColorStyles.value, props.style],
|
||
"role": "progressbar",
|
||
"aria-valuemin": "0",
|
||
"aria-valuemax": "100",
|
||
"aria-valuenow": props.indeterminate ? void 0 : normalizedValue.value
|
||
}, {
|
||
default: () => [createVNode("svg", {
|
||
"style": {
|
||
transform: `rotate(calc(-90deg + ${Number(props.rotate)}deg))`
|
||
},
|
||
"xmlns": "http://www.w3.org/2000/svg",
|
||
"viewBox": `0 0 ${diameter.value} ${diameter.value}`
|
||
}, [createVNode("circle", {
|
||
"class": ["v-progress-circular__underlay", underlayColorClasses.value],
|
||
"style": underlayColorStyles.value,
|
||
"fill": "transparent",
|
||
"cx": "50%",
|
||
"cy": "50%",
|
||
"r": MAGIC_RADIUS_CONSTANT,
|
||
"stroke-width": strokeWidth.value,
|
||
"stroke-dasharray": CIRCUMFERENCE,
|
||
"stroke-dashoffset": 0
|
||
}, null), createVNode("circle", {
|
||
"class": "v-progress-circular__overlay",
|
||
"fill": "transparent",
|
||
"cx": "50%",
|
||
"cy": "50%",
|
||
"r": MAGIC_RADIUS_CONSTANT,
|
||
"stroke-width": strokeWidth.value,
|
||
"stroke-dasharray": CIRCUMFERENCE,
|
||
"stroke-dashoffset": strokeDashOffset.value
|
||
}, null)]), slots.default && createVNode("div", {
|
||
"class": "v-progress-circular__content"
|
||
}, [slots.default({
|
||
value: normalizedValue.value
|
||
})])]
|
||
}));
|
||
return {};
|
||
}
|
||
});
|
||
const makeDimensionProps = propsFactory({
|
||
height: [Number, String],
|
||
maxHeight: [Number, String],
|
||
maxWidth: [Number, String],
|
||
minHeight: [Number, String],
|
||
minWidth: [Number, String],
|
||
width: [Number, String]
|
||
}, "dimension");
|
||
function useDimension(props) {
|
||
const dimensionStyles = computed(() => {
|
||
const styles = {};
|
||
const height = convertToUnit(props.height);
|
||
const maxHeight = convertToUnit(props.maxHeight);
|
||
const maxWidth = convertToUnit(props.maxWidth);
|
||
const minHeight = convertToUnit(props.minHeight);
|
||
const minWidth = convertToUnit(props.minWidth);
|
||
const width = convertToUnit(props.width);
|
||
if (height != null) styles.height = height;
|
||
if (maxHeight != null) styles.maxHeight = maxHeight;
|
||
if (maxWidth != null) styles.maxWidth = maxWidth;
|
||
if (minHeight != null) styles.minHeight = minHeight;
|
||
if (minWidth != null) styles.minWidth = minWidth;
|
||
if (width != null) styles.width = width;
|
||
return styles;
|
||
});
|
||
return {
|
||
dimensionStyles
|
||
};
|
||
}
|
||
const oppositeMap = {
|
||
center: "center",
|
||
top: "bottom",
|
||
bottom: "top",
|
||
left: "right",
|
||
right: "left"
|
||
};
|
||
const makeLocationProps = propsFactory({
|
||
location: String
|
||
}, "location");
|
||
function useLocation(props) {
|
||
let opposite = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
|
||
let offset = arguments.length > 2 ? arguments[2] : void 0;
|
||
const {
|
||
isRtl
|
||
} = useRtl();
|
||
const locationStyles = computed(() => {
|
||
if (!props.location) return {};
|
||
const {
|
||
side,
|
||
align
|
||
} = parseAnchor(props.location.split(" ").length > 1 ? props.location : `${props.location} center`, isRtl.value);
|
||
function getOffset2(side2) {
|
||
return offset ? offset(side2) : 0;
|
||
}
|
||
const styles = {};
|
||
if (side !== "center") {
|
||
if (opposite) styles[oppositeMap[side]] = `calc(100% - ${getOffset2(side)}px)`;
|
||
else styles[side] = 0;
|
||
}
|
||
if (align !== "center") {
|
||
if (opposite) styles[oppositeMap[align]] = `calc(100% - ${getOffset2(align)}px)`;
|
||
else styles[align] = 0;
|
||
} else {
|
||
if (side === "center") styles.top = styles.left = "50%";
|
||
else {
|
||
styles[{
|
||
top: "left",
|
||
bottom: "left",
|
||
left: "top",
|
||
right: "top"
|
||
}[side]] = "50%";
|
||
}
|
||
styles.transform = {
|
||
top: "translateX(-50%)",
|
||
bottom: "translateX(-50%)",
|
||
left: "translateY(-50%)",
|
||
right: "translateY(-50%)",
|
||
center: "translate(-50%, -50%)"
|
||
}[side];
|
||
}
|
||
return styles;
|
||
});
|
||
return {
|
||
locationStyles
|
||
};
|
||
}
|
||
const makeVProgressLinearProps = propsFactory({
|
||
absolute: Boolean,
|
||
active: {
|
||
type: Boolean,
|
||
default: true
|
||
},
|
||
bgColor: String,
|
||
bgOpacity: [Number, String],
|
||
bufferValue: {
|
||
type: [Number, String],
|
||
default: 0
|
||
},
|
||
bufferColor: String,
|
||
bufferOpacity: [Number, String],
|
||
clickable: Boolean,
|
||
color: String,
|
||
height: {
|
||
type: [Number, String],
|
||
default: 4
|
||
},
|
||
indeterminate: Boolean,
|
||
max: {
|
||
type: [Number, String],
|
||
default: 100
|
||
},
|
||
modelValue: {
|
||
type: [Number, String],
|
||
default: 0
|
||
},
|
||
opacity: [Number, String],
|
||
reverse: Boolean,
|
||
stream: Boolean,
|
||
striped: Boolean,
|
||
roundedBar: Boolean,
|
||
...makeComponentProps(),
|
||
...makeLocationProps({
|
||
location: "top"
|
||
}),
|
||
...makeRoundedProps(),
|
||
...makeTagProps(),
|
||
...makeThemeProps()
|
||
}, "VProgressLinear");
|
||
const VProgressLinear = genericComponent()({
|
||
name: "VProgressLinear",
|
||
props: makeVProgressLinearProps(),
|
||
emits: {
|
||
"update:modelValue": (value) => true
|
||
},
|
||
setup(props, _ref) {
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
const progress = useProxiedModel(props, "modelValue");
|
||
const {
|
||
isRtl,
|
||
rtlClasses
|
||
} = useRtl();
|
||
const {
|
||
themeClasses
|
||
} = provideTheme(props);
|
||
const {
|
||
locationStyles
|
||
} = useLocation(props);
|
||
const {
|
||
textColorClasses,
|
||
textColorStyles
|
||
} = useTextColor(props, "color");
|
||
const {
|
||
backgroundColorClasses,
|
||
backgroundColorStyles
|
||
} = useBackgroundColor(computed(() => props.bgColor || props.color));
|
||
const {
|
||
backgroundColorClasses: bufferColorClasses,
|
||
backgroundColorStyles: bufferColorStyles
|
||
} = useBackgroundColor(computed(() => props.bufferColor || props.bgColor || props.color));
|
||
const {
|
||
backgroundColorClasses: barColorClasses,
|
||
backgroundColorStyles: barColorStyles
|
||
} = useBackgroundColor(props, "color");
|
||
const {
|
||
roundedClasses
|
||
} = useRounded(props);
|
||
const {
|
||
intersectionRef,
|
||
isIntersecting
|
||
} = useIntersectionObserver();
|
||
const max = computed(() => parseFloat(props.max));
|
||
const height = computed(() => parseFloat(props.height));
|
||
const normalizedBuffer = computed(() => clamp(parseFloat(props.bufferValue) / max.value * 100, 0, 100));
|
||
const normalizedValue = computed(() => clamp(parseFloat(progress.value) / max.value * 100, 0, 100));
|
||
const isReversed = computed(() => isRtl.value !== props.reverse);
|
||
const transition = computed(() => props.indeterminate ? "fade-transition" : "slide-x-transition");
|
||
function handleClick(e) {
|
||
if (!intersectionRef.value) return;
|
||
const {
|
||
left,
|
||
right,
|
||
width
|
||
} = intersectionRef.value.getBoundingClientRect();
|
||
const value = isReversed.value ? width - e.clientX + (right - width) : e.clientX - left;
|
||
progress.value = Math.round(value / width * max.value);
|
||
}
|
||
useRender(() => createVNode(props.tag, {
|
||
"ref": intersectionRef,
|
||
"class": ["v-progress-linear", {
|
||
"v-progress-linear--absolute": props.absolute,
|
||
"v-progress-linear--active": props.active && isIntersecting.value,
|
||
"v-progress-linear--reverse": isReversed.value,
|
||
"v-progress-linear--rounded": props.rounded,
|
||
"v-progress-linear--rounded-bar": props.roundedBar,
|
||
"v-progress-linear--striped": props.striped
|
||
}, roundedClasses.value, themeClasses.value, rtlClasses.value, props.class],
|
||
"style": [{
|
||
bottom: props.location === "bottom" ? 0 : void 0,
|
||
top: props.location === "top" ? 0 : void 0,
|
||
height: props.active ? convertToUnit(height.value) : 0,
|
||
"--v-progress-linear-height": convertToUnit(height.value),
|
||
...props.absolute ? locationStyles.value : {}
|
||
}, props.style],
|
||
"role": "progressbar",
|
||
"aria-hidden": props.active ? "false" : "true",
|
||
"aria-valuemin": "0",
|
||
"aria-valuemax": props.max,
|
||
"aria-valuenow": props.indeterminate ? void 0 : normalizedValue.value,
|
||
"onClick": props.clickable && handleClick
|
||
}, {
|
||
default: () => [props.stream && createVNode("div", {
|
||
"key": "stream",
|
||
"class": ["v-progress-linear__stream", textColorClasses.value],
|
||
"style": {
|
||
...textColorStyles.value,
|
||
[isReversed.value ? "left" : "right"]: convertToUnit(-height.value),
|
||
borderTop: `${convertToUnit(height.value / 2)} dotted`,
|
||
opacity: parseFloat(props.bufferOpacity),
|
||
top: `calc(50% - ${convertToUnit(height.value / 4)})`,
|
||
width: convertToUnit(100 - normalizedBuffer.value, "%"),
|
||
"--v-progress-linear-stream-to": convertToUnit(height.value * (isReversed.value ? 1 : -1))
|
||
}
|
||
}, null), createVNode("div", {
|
||
"class": ["v-progress-linear__background", backgroundColorClasses.value],
|
||
"style": [backgroundColorStyles.value, {
|
||
opacity: parseFloat(props.bgOpacity),
|
||
width: props.stream ? 0 : void 0
|
||
}]
|
||
}, null), createVNode("div", {
|
||
"class": ["v-progress-linear__buffer", bufferColorClasses.value],
|
||
"style": [bufferColorStyles.value, {
|
||
opacity: parseFloat(props.bufferOpacity),
|
||
width: convertToUnit(normalizedBuffer.value, "%")
|
||
}]
|
||
}, null), createVNode(Transition, {
|
||
"name": transition.value
|
||
}, {
|
||
default: () => [!props.indeterminate ? createVNode("div", {
|
||
"class": ["v-progress-linear__determinate", barColorClasses.value],
|
||
"style": [barColorStyles.value, {
|
||
width: convertToUnit(normalizedValue.value, "%")
|
||
}]
|
||
}, null) : createVNode("div", {
|
||
"class": "v-progress-linear__indeterminate"
|
||
}, [["long", "short"].map((bar) => createVNode("div", {
|
||
"key": bar,
|
||
"class": ["v-progress-linear__indeterminate", bar, barColorClasses.value],
|
||
"style": barColorStyles.value
|
||
}, null))])]
|
||
}), slots.default && createVNode("div", {
|
||
"class": "v-progress-linear__content"
|
||
}, [slots.default({
|
||
value: normalizedValue.value,
|
||
buffer: normalizedBuffer.value
|
||
})])]
|
||
}));
|
||
return {};
|
||
}
|
||
});
|
||
const makeLoaderProps = propsFactory({
|
||
loading: [Boolean, String]
|
||
}, "loader");
|
||
function useLoader(props) {
|
||
let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
|
||
const loaderClasses = computed(() => ({
|
||
[`${name}--loading`]: props.loading
|
||
}));
|
||
return {
|
||
loaderClasses
|
||
};
|
||
}
|
||
function LoaderSlot(props, _ref) {
|
||
var _a;
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
return createVNode("div", {
|
||
"class": `${props.name}__loader`
|
||
}, [((_a = slots.default) == null ? void 0 : _a.call(slots, {
|
||
color: props.color,
|
||
isActive: props.active
|
||
})) || createVNode(VProgressLinear, {
|
||
"absolute": props.absolute,
|
||
"active": props.active,
|
||
"color": props.color,
|
||
"height": "2",
|
||
"indeterminate": true
|
||
}, null)]);
|
||
}
|
||
const positionValues = ["static", "relative", "fixed", "absolute", "sticky"];
|
||
const makePositionProps = propsFactory({
|
||
position: {
|
||
type: String,
|
||
validator: (
|
||
/* istanbul ignore next */
|
||
(v) => positionValues.includes(v)
|
||
)
|
||
}
|
||
}, "position");
|
||
function usePosition(props) {
|
||
let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
|
||
const positionClasses = computed(() => {
|
||
return props.position ? `${name}--${props.position}` : void 0;
|
||
});
|
||
return {
|
||
positionClasses
|
||
};
|
||
}
|
||
function useRoute() {
|
||
const vm = getCurrentInstance("useRoute");
|
||
return computed(() => {
|
||
var _a;
|
||
return (_a = vm == null ? void 0 : vm.proxy) == null ? void 0 : _a.$route;
|
||
});
|
||
}
|
||
function useRouter() {
|
||
var _a, _b;
|
||
return (_b = (_a = getCurrentInstance("useRouter")) == null ? void 0 : _a.proxy) == null ? void 0 : _b.$router;
|
||
}
|
||
function useLink(props, attrs) {
|
||
var _a, _b;
|
||
const RouterLink = resolveDynamicComponent("RouterLink");
|
||
const isLink = computed(() => !!(props.href || props.to));
|
||
const isClickable = computed(() => {
|
||
return (isLink == null ? void 0 : isLink.value) || hasEvent(attrs, "click") || hasEvent(props, "click");
|
||
});
|
||
if (typeof RouterLink === "string" || !("useLink" in RouterLink)) {
|
||
const href2 = toRef(props, "href");
|
||
return {
|
||
isLink,
|
||
isClickable,
|
||
href: href2,
|
||
linkProps: reactive({
|
||
href: href2
|
||
})
|
||
};
|
||
}
|
||
const linkProps = computed(() => ({
|
||
...props,
|
||
to: toRef(() => props.to || "")
|
||
}));
|
||
const routerLink = RouterLink.useLink(linkProps.value);
|
||
const link = computed(() => props.to ? routerLink : void 0);
|
||
const route = useRoute();
|
||
const isActive = computed(() => {
|
||
var _a2, _b2, _c;
|
||
if (!link.value) return false;
|
||
if (!props.exact) return ((_a2 = link.value.isActive) == null ? void 0 : _a2.value) ?? false;
|
||
if (!route.value) return ((_b2 = link.value.isExactActive) == null ? void 0 : _b2.value) ?? false;
|
||
return ((_c = link.value.isExactActive) == null ? void 0 : _c.value) && deepEqual(link.value.route.value.query, route.value.query);
|
||
});
|
||
const href = computed(() => {
|
||
var _a2;
|
||
return props.to ? (_a2 = link.value) == null ? void 0 : _a2.route.value.href : props.href;
|
||
});
|
||
return {
|
||
isLink,
|
||
isClickable,
|
||
isActive,
|
||
route: (_a = link.value) == null ? void 0 : _a.route,
|
||
navigate: (_b = link.value) == null ? void 0 : _b.navigate,
|
||
href,
|
||
linkProps: reactive({
|
||
href,
|
||
"aria-current": computed(() => isActive.value ? "page" : void 0)
|
||
})
|
||
};
|
||
}
|
||
const makeRouterProps = propsFactory({
|
||
href: String,
|
||
replace: Boolean,
|
||
to: [String, Object],
|
||
exact: Boolean
|
||
}, "router");
|
||
function useSelectLink(link, select) {
|
||
watch(() => {
|
||
var _a;
|
||
return (_a = link.isActive) == null ? void 0 : _a.value;
|
||
}, (isActive) => {
|
||
if (link.isLink.value && isActive && select) {
|
||
nextTick(() => {
|
||
select(true);
|
||
});
|
||
}
|
||
}, {
|
||
immediate: true
|
||
});
|
||
}
|
||
const stopSymbol = Symbol("rippleStop");
|
||
const DELAY_RIPPLE = 80;
|
||
function transform(el, value) {
|
||
el.style.transform = value;
|
||
el.style.webkitTransform = value;
|
||
}
|
||
function isTouchEvent(e) {
|
||
return e.constructor.name === "TouchEvent";
|
||
}
|
||
function isKeyboardEvent(e) {
|
||
return e.constructor.name === "KeyboardEvent";
|
||
}
|
||
const calculate = function(e, el) {
|
||
var _a;
|
||
let value = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
|
||
let localX = 0;
|
||
let localY = 0;
|
||
if (!isKeyboardEvent(e)) {
|
||
const offset = el.getBoundingClientRect();
|
||
const target = isTouchEvent(e) ? e.touches[e.touches.length - 1] : e;
|
||
localX = target.clientX - offset.left;
|
||
localY = target.clientY - offset.top;
|
||
}
|
||
let radius = 0;
|
||
let scale = 0.3;
|
||
if ((_a = el._ripple) == null ? void 0 : _a.circle) {
|
||
scale = 0.15;
|
||
radius = el.clientWidth / 2;
|
||
radius = value.center ? radius : radius + Math.sqrt((localX - radius) ** 2 + (localY - radius) ** 2) / 4;
|
||
} else {
|
||
radius = Math.sqrt(el.clientWidth ** 2 + el.clientHeight ** 2) / 2;
|
||
}
|
||
const centerX = `${(el.clientWidth - radius * 2) / 2}px`;
|
||
const centerY = `${(el.clientHeight - radius * 2) / 2}px`;
|
||
const x = value.center ? centerX : `${localX - radius}px`;
|
||
const y = value.center ? centerY : `${localY - radius}px`;
|
||
return {
|
||
radius,
|
||
scale,
|
||
x,
|
||
y,
|
||
centerX,
|
||
centerY
|
||
};
|
||
};
|
||
const ripples = {
|
||
/* eslint-disable max-statements */
|
||
show(e, el) {
|
||
var _a;
|
||
let value = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
|
||
if (!((_a = el == null ? void 0 : el._ripple) == null ? void 0 : _a.enabled)) {
|
||
return;
|
||
}
|
||
const container = (void 0).createElement("span");
|
||
const animation = (void 0).createElement("span");
|
||
container.appendChild(animation);
|
||
container.className = "v-ripple__container";
|
||
if (value.class) {
|
||
container.className += ` ${value.class}`;
|
||
}
|
||
const {
|
||
radius,
|
||
scale,
|
||
x,
|
||
y,
|
||
centerX,
|
||
centerY
|
||
} = calculate(e, el, value);
|
||
const size = `${radius * 2}px`;
|
||
animation.className = "v-ripple__animation";
|
||
animation.style.width = size;
|
||
animation.style.height = size;
|
||
el.appendChild(container);
|
||
const computed2 = (void 0).getComputedStyle(el);
|
||
if (computed2 && computed2.position === "static") {
|
||
el.style.position = "relative";
|
||
el.dataset.previousPosition = "static";
|
||
}
|
||
animation.classList.add("v-ripple__animation--enter");
|
||
animation.classList.add("v-ripple__animation--visible");
|
||
transform(animation, `translate(${x}, ${y}) scale3d(${scale},${scale},${scale})`);
|
||
animation.dataset.activated = String(performance.now());
|
||
setTimeout(() => {
|
||
animation.classList.remove("v-ripple__animation--enter");
|
||
animation.classList.add("v-ripple__animation--in");
|
||
transform(animation, `translate(${centerX}, ${centerY}) scale3d(1,1,1)`);
|
||
}, 0);
|
||
},
|
||
hide(el) {
|
||
var _a;
|
||
if (!((_a = el == null ? void 0 : el._ripple) == null ? void 0 : _a.enabled)) return;
|
||
const ripples2 = el.getElementsByClassName("v-ripple__animation");
|
||
if (ripples2.length === 0) return;
|
||
const animation = ripples2[ripples2.length - 1];
|
||
if (animation.dataset.isHiding) return;
|
||
else animation.dataset.isHiding = "true";
|
||
const diff = performance.now() - Number(animation.dataset.activated);
|
||
const delay = Math.max(250 - diff, 0);
|
||
setTimeout(() => {
|
||
animation.classList.remove("v-ripple__animation--in");
|
||
animation.classList.add("v-ripple__animation--out");
|
||
setTimeout(() => {
|
||
var _a2;
|
||
const ripples3 = el.getElementsByClassName("v-ripple__animation");
|
||
if (ripples3.length === 1 && el.dataset.previousPosition) {
|
||
el.style.position = el.dataset.previousPosition;
|
||
delete el.dataset.previousPosition;
|
||
}
|
||
if (((_a2 = animation.parentNode) == null ? void 0 : _a2.parentNode) === el) el.removeChild(animation.parentNode);
|
||
}, 300);
|
||
}, delay);
|
||
}
|
||
};
|
||
function isRippleEnabled(value) {
|
||
return typeof value === "undefined" || !!value;
|
||
}
|
||
function rippleShow(e) {
|
||
const value = {};
|
||
const element = e.currentTarget;
|
||
if (!(element == null ? void 0 : element._ripple) || element._ripple.touched || e[stopSymbol]) return;
|
||
e[stopSymbol] = true;
|
||
if (isTouchEvent(e)) {
|
||
element._ripple.touched = true;
|
||
element._ripple.isTouch = true;
|
||
} else {
|
||
if (element._ripple.isTouch) return;
|
||
}
|
||
value.center = element._ripple.centered || isKeyboardEvent(e);
|
||
if (element._ripple.class) {
|
||
value.class = element._ripple.class;
|
||
}
|
||
if (isTouchEvent(e)) {
|
||
if (element._ripple.showTimerCommit) return;
|
||
element._ripple.showTimerCommit = () => {
|
||
ripples.show(e, element, value);
|
||
};
|
||
element._ripple.showTimer = (void 0).setTimeout(() => {
|
||
var _a;
|
||
if ((_a = element == null ? void 0 : element._ripple) == null ? void 0 : _a.showTimerCommit) {
|
||
element._ripple.showTimerCommit();
|
||
element._ripple.showTimerCommit = null;
|
||
}
|
||
}, DELAY_RIPPLE);
|
||
} else {
|
||
ripples.show(e, element, value);
|
||
}
|
||
}
|
||
function rippleStop(e) {
|
||
e[stopSymbol] = true;
|
||
}
|
||
function rippleHide(e) {
|
||
const element = e.currentTarget;
|
||
if (!(element == null ? void 0 : element._ripple)) return;
|
||
(void 0).clearTimeout(element._ripple.showTimer);
|
||
if (e.type === "touchend" && element._ripple.showTimerCommit) {
|
||
element._ripple.showTimerCommit();
|
||
element._ripple.showTimerCommit = null;
|
||
element._ripple.showTimer = (void 0).setTimeout(() => {
|
||
rippleHide(e);
|
||
});
|
||
return;
|
||
}
|
||
(void 0).setTimeout(() => {
|
||
if (element._ripple) {
|
||
element._ripple.touched = false;
|
||
}
|
||
});
|
||
ripples.hide(element);
|
||
}
|
||
function rippleCancelShow(e) {
|
||
const element = e.currentTarget;
|
||
if (!(element == null ? void 0 : element._ripple)) return;
|
||
if (element._ripple.showTimerCommit) {
|
||
element._ripple.showTimerCommit = null;
|
||
}
|
||
(void 0).clearTimeout(element._ripple.showTimer);
|
||
}
|
||
let keyboardRipple = false;
|
||
function keyboardRippleShow(e) {
|
||
if (!keyboardRipple && (e.keyCode === keyCodes.enter || e.keyCode === keyCodes.space)) {
|
||
keyboardRipple = true;
|
||
rippleShow(e);
|
||
}
|
||
}
|
||
function keyboardRippleHide(e) {
|
||
keyboardRipple = false;
|
||
rippleHide(e);
|
||
}
|
||
function focusRippleHide(e) {
|
||
if (keyboardRipple) {
|
||
keyboardRipple = false;
|
||
rippleHide(e);
|
||
}
|
||
}
|
||
function updateRipple(el, binding, wasEnabled) {
|
||
const {
|
||
value,
|
||
modifiers
|
||
} = binding;
|
||
const enabled = isRippleEnabled(value);
|
||
if (!enabled) {
|
||
ripples.hide(el);
|
||
}
|
||
el._ripple = el._ripple ?? {};
|
||
el._ripple.enabled = enabled;
|
||
el._ripple.centered = modifiers.center;
|
||
el._ripple.circle = modifiers.circle;
|
||
if (isObject(value) && value.class) {
|
||
el._ripple.class = value.class;
|
||
}
|
||
if (enabled && !wasEnabled) {
|
||
if (modifiers.stop) {
|
||
el.addEventListener("touchstart", rippleStop, {
|
||
passive: true
|
||
});
|
||
el.addEventListener("mousedown", rippleStop);
|
||
return;
|
||
}
|
||
el.addEventListener("touchstart", rippleShow, {
|
||
passive: true
|
||
});
|
||
el.addEventListener("touchend", rippleHide, {
|
||
passive: true
|
||
});
|
||
el.addEventListener("touchmove", rippleCancelShow, {
|
||
passive: true
|
||
});
|
||
el.addEventListener("touchcancel", rippleHide);
|
||
el.addEventListener("mousedown", rippleShow);
|
||
el.addEventListener("mouseup", rippleHide);
|
||
el.addEventListener("mouseleave", rippleHide);
|
||
el.addEventListener("keydown", keyboardRippleShow);
|
||
el.addEventListener("keyup", keyboardRippleHide);
|
||
el.addEventListener("blur", focusRippleHide);
|
||
el.addEventListener("dragstart", rippleHide, {
|
||
passive: true
|
||
});
|
||
} else if (!enabled && wasEnabled) {
|
||
removeListeners(el);
|
||
}
|
||
}
|
||
function removeListeners(el) {
|
||
el.removeEventListener("mousedown", rippleShow);
|
||
el.removeEventListener("touchstart", rippleShow);
|
||
el.removeEventListener("touchend", rippleHide);
|
||
el.removeEventListener("touchmove", rippleCancelShow);
|
||
el.removeEventListener("touchcancel", rippleHide);
|
||
el.removeEventListener("mouseup", rippleHide);
|
||
el.removeEventListener("mouseleave", rippleHide);
|
||
el.removeEventListener("keydown", keyboardRippleShow);
|
||
el.removeEventListener("keyup", keyboardRippleHide);
|
||
el.removeEventListener("dragstart", rippleHide);
|
||
el.removeEventListener("blur", focusRippleHide);
|
||
}
|
||
function mounted$1(el, binding) {
|
||
updateRipple(el, binding, false);
|
||
}
|
||
function unmounted$1(el) {
|
||
delete el._ripple;
|
||
removeListeners(el);
|
||
}
|
||
function updated(el, binding) {
|
||
if (binding.value === binding.oldValue) {
|
||
return;
|
||
}
|
||
const wasEnabled = isRippleEnabled(binding.oldValue);
|
||
updateRipple(el, binding, wasEnabled);
|
||
}
|
||
const Ripple = {
|
||
mounted: mounted$1,
|
||
unmounted: unmounted$1,
|
||
updated
|
||
};
|
||
const makeVBtnProps = propsFactory({
|
||
active: {
|
||
type: Boolean,
|
||
default: void 0
|
||
},
|
||
activeColor: String,
|
||
baseColor: String,
|
||
symbol: {
|
||
type: null,
|
||
default: VBtnToggleSymbol
|
||
},
|
||
flat: Boolean,
|
||
icon: [Boolean, String, Function, Object],
|
||
prependIcon: IconValue,
|
||
appendIcon: IconValue,
|
||
block: Boolean,
|
||
readonly: Boolean,
|
||
slim: Boolean,
|
||
stacked: Boolean,
|
||
ripple: {
|
||
type: [Boolean, Object],
|
||
default: true
|
||
},
|
||
text: String,
|
||
...makeBorderProps(),
|
||
...makeComponentProps(),
|
||
...makeDensityProps(),
|
||
...makeDimensionProps(),
|
||
...makeElevationProps(),
|
||
...makeGroupItemProps(),
|
||
...makeLoaderProps(),
|
||
...makeLocationProps(),
|
||
...makePositionProps(),
|
||
...makeRoundedProps(),
|
||
...makeRouterProps(),
|
||
...makeSizeProps(),
|
||
...makeTagProps({
|
||
tag: "button"
|
||
}),
|
||
...makeThemeProps(),
|
||
...makeVariantProps({
|
||
variant: "elevated"
|
||
})
|
||
}, "VBtn");
|
||
const VBtn = genericComponent()({
|
||
name: "VBtn",
|
||
props: makeVBtnProps(),
|
||
emits: {
|
||
"group:selected": (val) => true
|
||
},
|
||
setup(props, _ref) {
|
||
let {
|
||
attrs,
|
||
slots
|
||
} = _ref;
|
||
const {
|
||
themeClasses
|
||
} = provideTheme(props);
|
||
const {
|
||
borderClasses
|
||
} = useBorder(props);
|
||
const {
|
||
densityClasses
|
||
} = useDensity(props);
|
||
const {
|
||
dimensionStyles
|
||
} = useDimension(props);
|
||
const {
|
||
elevationClasses
|
||
} = useElevation(props);
|
||
const {
|
||
loaderClasses
|
||
} = useLoader(props);
|
||
const {
|
||
locationStyles
|
||
} = useLocation(props);
|
||
const {
|
||
positionClasses
|
||
} = usePosition(props);
|
||
const {
|
||
roundedClasses
|
||
} = useRounded(props);
|
||
const {
|
||
sizeClasses,
|
||
sizeStyles
|
||
} = useSize(props);
|
||
const group = useGroupItem(props, props.symbol, false);
|
||
const link = useLink(props, attrs);
|
||
const isActive = computed(() => {
|
||
var _a;
|
||
if (props.active !== void 0) {
|
||
return props.active;
|
||
}
|
||
if (link.isLink.value) {
|
||
return (_a = link.isActive) == null ? void 0 : _a.value;
|
||
}
|
||
return group == null ? void 0 : group.isSelected.value;
|
||
});
|
||
const color = computed(() => isActive.value ? props.activeColor ?? props.color : props.color);
|
||
const variantProps = computed(() => {
|
||
var _a, _b;
|
||
const showColor = (group == null ? void 0 : group.isSelected.value) && (!link.isLink.value || ((_a = link.isActive) == null ? void 0 : _a.value)) || !group || ((_b = link.isActive) == null ? void 0 : _b.value);
|
||
return {
|
||
color: showColor ? color.value ?? props.baseColor : props.baseColor,
|
||
variant: props.variant
|
||
};
|
||
});
|
||
const {
|
||
colorClasses,
|
||
colorStyles,
|
||
variantClasses
|
||
} = useVariant(variantProps);
|
||
const isDisabled = computed(() => (group == null ? void 0 : group.disabled.value) || props.disabled);
|
||
const isElevated = computed(() => {
|
||
return props.variant === "elevated" && !(props.disabled || props.flat || props.border);
|
||
});
|
||
const valueAttr = computed(() => {
|
||
if (props.value === void 0 || typeof props.value === "symbol") return void 0;
|
||
return Object(props.value) === props.value ? JSON.stringify(props.value, null, 0) : props.value;
|
||
});
|
||
function onClick(e) {
|
||
var _a;
|
||
if (isDisabled.value || link.isLink.value && (e.metaKey || e.ctrlKey || e.shiftKey || e.button !== 0 || attrs.target === "_blank")) return;
|
||
(_a = link.navigate) == null ? void 0 : _a.call(link, e);
|
||
group == null ? void 0 : group.toggle();
|
||
}
|
||
useSelectLink(link, group == null ? void 0 : group.select);
|
||
useRender(() => {
|
||
const Tag = link.isLink.value ? "a" : props.tag;
|
||
const hasPrepend = !!(props.prependIcon || slots.prepend);
|
||
const hasAppend = !!(props.appendIcon || slots.append);
|
||
const hasIcon = !!(props.icon && props.icon !== true);
|
||
return withDirectives(createVNode(Tag, mergeProps({
|
||
"type": Tag === "a" ? void 0 : "button",
|
||
"class": ["v-btn", group == null ? void 0 : group.selectedClass.value, {
|
||
"v-btn--active": isActive.value,
|
||
"v-btn--block": props.block,
|
||
"v-btn--disabled": isDisabled.value,
|
||
"v-btn--elevated": isElevated.value,
|
||
"v-btn--flat": props.flat,
|
||
"v-btn--icon": !!props.icon,
|
||
"v-btn--loading": props.loading,
|
||
"v-btn--readonly": props.readonly,
|
||
"v-btn--slim": props.slim,
|
||
"v-btn--stacked": props.stacked
|
||
}, themeClasses.value, borderClasses.value, colorClasses.value, densityClasses.value, elevationClasses.value, loaderClasses.value, positionClasses.value, roundedClasses.value, sizeClasses.value, variantClasses.value, props.class],
|
||
"style": [colorStyles.value, dimensionStyles.value, locationStyles.value, sizeStyles.value, props.style],
|
||
"aria-busy": props.loading ? true : void 0,
|
||
"disabled": isDisabled.value || void 0,
|
||
"tabindex": props.loading || props.readonly ? -1 : void 0,
|
||
"onClick": onClick,
|
||
"value": valueAttr.value
|
||
}, link.linkProps), {
|
||
default: () => {
|
||
var _a;
|
||
return [genOverlays(true, "v-btn"), !props.icon && hasPrepend && createVNode("span", {
|
||
"key": "prepend",
|
||
"class": "v-btn__prepend"
|
||
}, [!slots.prepend ? createVNode(VIcon, {
|
||
"key": "prepend-icon",
|
||
"icon": props.prependIcon
|
||
}, null) : createVNode(VDefaultsProvider, {
|
||
"key": "prepend-defaults",
|
||
"disabled": !props.prependIcon,
|
||
"defaults": {
|
||
VIcon: {
|
||
icon: props.prependIcon
|
||
}
|
||
}
|
||
}, slots.prepend)]), createVNode("span", {
|
||
"class": "v-btn__content",
|
||
"data-no-activator": ""
|
||
}, [!slots.default && hasIcon ? createVNode(VIcon, {
|
||
"key": "content-icon",
|
||
"icon": props.icon
|
||
}, null) : createVNode(VDefaultsProvider, {
|
||
"key": "content-defaults",
|
||
"disabled": !hasIcon,
|
||
"defaults": {
|
||
VIcon: {
|
||
icon: props.icon
|
||
}
|
||
}
|
||
}, {
|
||
default: () => {
|
||
var _a2;
|
||
return [((_a2 = slots.default) == null ? void 0 : _a2.call(slots)) ?? props.text];
|
||
}
|
||
})]), !props.icon && hasAppend && createVNode("span", {
|
||
"key": "append",
|
||
"class": "v-btn__append"
|
||
}, [!slots.append ? createVNode(VIcon, {
|
||
"key": "append-icon",
|
||
"icon": props.appendIcon
|
||
}, null) : createVNode(VDefaultsProvider, {
|
||
"key": "append-defaults",
|
||
"disabled": !props.appendIcon,
|
||
"defaults": {
|
||
VIcon: {
|
||
icon: props.appendIcon
|
||
}
|
||
}
|
||
}, slots.append)]), !!props.loading && createVNode("span", {
|
||
"key": "loader",
|
||
"class": "v-btn__loader"
|
||
}, [((_a = slots.loader) == null ? void 0 : _a.call(slots)) ?? createVNode(VProgressCircular, {
|
||
"color": typeof props.loading === "boolean" ? void 0 : props.loading,
|
||
"indeterminate": true,
|
||
"width": "2"
|
||
}, null)])];
|
||
}
|
||
}), [[Ripple, !isDisabled.value && props.ripple, "", {
|
||
center: !!props.icon
|
||
}]]);
|
||
});
|
||
return {
|
||
group
|
||
};
|
||
}
|
||
});
|
||
const defaults = {
|
||
IconBtn: {
|
||
icon: true,
|
||
color: "default",
|
||
variant: "text"
|
||
},
|
||
VAlert: {
|
||
density: "comfortable",
|
||
VBtn: {
|
||
color: void 0
|
||
}
|
||
},
|
||
VAvatar: {
|
||
// ℹ️ Remove after next release
|
||
variant: "flat"
|
||
},
|
||
// VImg: {
|
||
// eager: true,
|
||
// },
|
||
VBadge: {
|
||
// set v-badge default color to primary
|
||
color: "primary"
|
||
},
|
||
VBtn: {
|
||
// set v-btn default color to primary
|
||
color: "primary",
|
||
ripple: false
|
||
},
|
||
VChip: {
|
||
label: true
|
||
},
|
||
VDataTable: {
|
||
VPagination: {
|
||
showFirstLastPage: true,
|
||
firstIcon: "bx-chevrons-left",
|
||
lastIcon: "bx-chevrons-right"
|
||
}
|
||
},
|
||
VTable: {
|
||
VCheckboxBtn: {
|
||
density: "comfortable"
|
||
}
|
||
},
|
||
VDataTableServer: {
|
||
VPagination: {
|
||
showFirstLastPage: true,
|
||
firstIcon: "bx-chevrons-left",
|
||
lastIcon: "bx-chevrons-right"
|
||
}
|
||
},
|
||
VList: {
|
||
color: "primary",
|
||
density: "compact",
|
||
VCheckboxBtn: {
|
||
density: "compact"
|
||
},
|
||
VListItem: {
|
||
ripple: false,
|
||
VAvatar: {
|
||
size: 38
|
||
}
|
||
}
|
||
},
|
||
VMenu: {
|
||
offset: "2px"
|
||
},
|
||
VPagination: {
|
||
density: "comfortable",
|
||
variant: "tonal"
|
||
},
|
||
VTabs: {
|
||
// set v-tabs default color to primary
|
||
color: "primary",
|
||
density: "comfortable",
|
||
VSlideGroup: {
|
||
showArrows: true
|
||
}
|
||
},
|
||
VTooltip: {
|
||
// set v-tooltip default location to top
|
||
location: "top"
|
||
},
|
||
VCheckboxBtn: {
|
||
color: "primary"
|
||
},
|
||
VCheckbox: {
|
||
// set v-checkbox default color to primary
|
||
color: "primary",
|
||
density: "comfortable",
|
||
hideDetails: "auto"
|
||
},
|
||
VRadioGroup: {
|
||
color: "primary",
|
||
density: "comfortable",
|
||
hideDetails: "auto"
|
||
},
|
||
VRadio: {
|
||
density: "comfortable",
|
||
hideDetails: "auto"
|
||
},
|
||
VSelect: {
|
||
variant: "outlined",
|
||
color: "primary",
|
||
density: "comfortable",
|
||
hideDetails: "auto",
|
||
VChip: {
|
||
label: true
|
||
}
|
||
},
|
||
VRangeSlider: {
|
||
// set v-range-slider default color to primary
|
||
color: "primary",
|
||
trackSize: 6,
|
||
thumbSize: 22,
|
||
density: "comfortable",
|
||
thumbLabel: true,
|
||
hideDetails: "auto"
|
||
},
|
||
VRating: {
|
||
// set v-rating default color to primary
|
||
activeColor: "warning",
|
||
color: "disabled",
|
||
emptyIcon: "bx-bxs-star"
|
||
},
|
||
VProgressLinear: {
|
||
height: 6,
|
||
roundedBar: true,
|
||
rounded: true,
|
||
bgColor: "rgba(var(--v-track-bg))",
|
||
color: "primary"
|
||
},
|
||
VSlider: {
|
||
// set v-range-slider default color to primary
|
||
color: "primary",
|
||
thumbLabel: true,
|
||
hideDetails: "auto",
|
||
thumbSize: 22,
|
||
trackSize: 6,
|
||
elevation: 4
|
||
},
|
||
VTextField: {
|
||
variant: "outlined",
|
||
density: "comfortable",
|
||
color: "primary",
|
||
hideDetails: "auto"
|
||
},
|
||
VAutocomplete: {
|
||
variant: "outlined",
|
||
color: "primary",
|
||
density: "comfortable",
|
||
hideDetails: "auto",
|
||
menuProps: {
|
||
contentClass: "app-autocomplete__content v-autocomplete__content"
|
||
},
|
||
VChip: {
|
||
label: true
|
||
}
|
||
},
|
||
VCombobox: {
|
||
variant: "outlined",
|
||
density: "comfortable",
|
||
color: "primary",
|
||
hideDetails: "auto",
|
||
VChip: {
|
||
label: true
|
||
}
|
||
},
|
||
VFileInput: {
|
||
variant: "outlined",
|
||
density: "comfortable",
|
||
color: "primary",
|
||
hideDetails: "auto",
|
||
prependIcon: "",
|
||
prependInnerIcon: "bx-link"
|
||
},
|
||
VTextarea: {
|
||
variant: "outlined",
|
||
density: "comfortable",
|
||
color: "primary",
|
||
hideDetails: "auto"
|
||
},
|
||
VSnackbar: {
|
||
VBtn: {
|
||
size: "small"
|
||
}
|
||
},
|
||
VSwitch: {
|
||
// set v-switch default color to primary
|
||
inset: true,
|
||
color: "primary",
|
||
hideDetails: "auto",
|
||
ripple: false
|
||
},
|
||
VNavigationDrawer: {
|
||
touchless: true
|
||
}
|
||
};
|
||
const _hoisted_1$4 = {
|
||
xmlns: "http://www.w3.org/2000/svg",
|
||
width: "24",
|
||
height: "24",
|
||
fill: "none"
|
||
};
|
||
function render$4(_ctx, _cache) {
|
||
return openBlock(), createElementBlock("svg", _hoisted_1$4, [..._cache[0] || (_cache[0] = [
|
||
createElementVNode("path", {
|
||
fill: "currentColor",
|
||
d: "M3 7a4 4 0 0 1 4-4h10a4 4 0 0 1 4 4v10a4 4 0 0 1-4 4H7a4 4 0 0 1-4-4z"
|
||
}, null, -1),
|
||
createElementVNode("path", {
|
||
fill: "#fff",
|
||
d: "m11 13.793-1.647-1.646-.707.707L11 15.207l4.854-4.853-.707-.707z"
|
||
}, null, -1)
|
||
])]);
|
||
}
|
||
const checkboxChecked = { render: render$4 };
|
||
const _hoisted_1$3 = {
|
||
xmlns: "http://www.w3.org/2000/svg",
|
||
width: "24",
|
||
height: "24",
|
||
fill: "none",
|
||
class: "custom-checkbox-indeterminate"
|
||
};
|
||
function render$3(_ctx, _cache) {
|
||
return openBlock(), createElementBlock("svg", _hoisted_1$3, [..._cache[0] || (_cache[0] = [
|
||
createElementVNode("path", {
|
||
fill: "currentColor",
|
||
d: "M3 7a4 4 0 0 1 4-4h10a4 4 0 0 1 4 4v10a4 4 0 0 1-4 4H7a4 4 0 0 1-4-4z"
|
||
}, null, -1),
|
||
createElementVNode("path", {
|
||
fill: "#fff",
|
||
d: "M8.5 11.5h7v1h-7z"
|
||
}, null, -1)
|
||
])]);
|
||
}
|
||
const checkboxIndeterminate = { render: render$3 };
|
||
const _hoisted_1$2 = {
|
||
xmlns: "http://www.w3.org/2000/svg",
|
||
width: "24",
|
||
height: "24",
|
||
fill: "none"
|
||
};
|
||
function render$2(_ctx, _cache) {
|
||
return openBlock(), createElementBlock("svg", _hoisted_1$2, [..._cache[0] || (_cache[0] = [
|
||
createElementVNode("path", {
|
||
stroke: "rgba(var(--v-theme-on-surface), var(--v-medium-emphasis-opacity))",
|
||
"stroke-opacity": ".7",
|
||
"stroke-width": "2",
|
||
d: "M4 7a3 3 0 0 1 3-3h10a3 3 0 0 1 3 3v10a3 3 0 0 1-3 3H7a3 3 0 0 1-3-3z"
|
||
}, null, -1)
|
||
])]);
|
||
}
|
||
const checkboxUnchecked = { render: render$2 };
|
||
const _hoisted_1$1 = {
|
||
xmlns: "http://www.w3.org/2000/svg",
|
||
width: "24",
|
||
height: "24",
|
||
fill: "none"
|
||
};
|
||
function render$1(_ctx, _cache) {
|
||
return openBlock(), createElementBlock("svg", _hoisted_1$1, [..._cache[0] || (_cache[0] = [
|
||
createElementVNode("path", {
|
||
fill: "#fff",
|
||
stroke: "currentColor",
|
||
"stroke-width": "5",
|
||
d: "M5.5 12a6.5 6.5 0 1 1 13 0 6.5 6.5 0 0 1-13 0Z"
|
||
}, null, -1)
|
||
])]);
|
||
}
|
||
const radioChecked = { render: render$1 };
|
||
const _hoisted_1 = {
|
||
xmlns: "http://www.w3.org/2000/svg",
|
||
width: "24",
|
||
height: "24",
|
||
fill: "none"
|
||
};
|
||
function render(_ctx, _cache) {
|
||
return openBlock(), createElementBlock("svg", _hoisted_1, [..._cache[0] || (_cache[0] = [
|
||
createElementVNode("path", {
|
||
stroke: "currentColor",
|
||
"stroke-opacity": ".7",
|
||
"stroke-width": "2",
|
||
d: "M4 12a8 8 0 1 1 16 0 8 8 0 0 1-16 0Z"
|
||
}, null, -1)
|
||
])]);
|
||
}
|
||
const radioUnchecked = { render };
|
||
const customIcons = {
|
||
"mdi-checkbox-blank-outline": checkboxUnchecked,
|
||
"mdi-checkbox-marked": checkboxChecked,
|
||
"mdi-minus-box": checkboxIndeterminate,
|
||
"mdi-radiobox-marked": radioChecked,
|
||
"mdi-radiobox-blank": radioUnchecked
|
||
};
|
||
const aliases = {
|
||
calendar: "bx-calendar",
|
||
collapse: "bx-chevron-up",
|
||
complete: "bx-check",
|
||
cancel: "bx-x",
|
||
close: "bx-x",
|
||
delete: "bx-bxs-x-circle",
|
||
clear: "bx-x-circle",
|
||
success: "bx-check-circle",
|
||
info: "bx-info-circle",
|
||
warning: "bx-error",
|
||
error: "bx-error-circle",
|
||
prev: "bx-chevron-left",
|
||
ratingEmpty: "bx-star",
|
||
ratingFull: "bx-bxs-star",
|
||
ratingHalf: "bx-bxs-star-half",
|
||
next: "bx-chevron-right",
|
||
delimiter: "bx-circle",
|
||
sort: "bx-up-arrow-alt",
|
||
expand: "bx-chevron-down",
|
||
menu: "bx-menu",
|
||
subgroup: "bx-caret-down",
|
||
dropdown: "bx-chevron-down",
|
||
edit: "bx-pencil",
|
||
loading: "bx-refresh",
|
||
first: "bx-skip-previous",
|
||
last: "bx-skip-next",
|
||
unfold: "bx-move-vertical",
|
||
file: "bx-paperclip",
|
||
plus: "bx-plus",
|
||
minus: "bx-minus",
|
||
sortAsc: "bx-up-arrow-alt",
|
||
sortDesc: "bx-down-arrow-alt"
|
||
};
|
||
const iconify = {
|
||
component: (props) => {
|
||
if (typeof props.icon === "string") {
|
||
const iconComponent = customIcons[props.icon];
|
||
if (iconComponent)
|
||
return h(iconComponent);
|
||
}
|
||
return h(
|
||
props.tag,
|
||
{
|
||
...props,
|
||
// As we are using class based icons
|
||
class: [props.icon],
|
||
// Remove used props from DOM rendering
|
||
tag: void 0,
|
||
icon: void 0
|
||
}
|
||
);
|
||
}
|
||
};
|
||
const icons = {
|
||
defaultSet: "iconify",
|
||
aliases,
|
||
sets: {
|
||
iconify
|
||
}
|
||
};
|
||
const staticPrimaryColor = "#696CFF";
|
||
const staticPrimaryDarkenColor = "#5E61E6";
|
||
const themes = {
|
||
light: {
|
||
dark: false,
|
||
colors: {
|
||
"primary": staticPrimaryColor,
|
||
"on-primary": "#fff",
|
||
"primary-darken-1": staticPrimaryDarkenColor,
|
||
"primary-light": "#8789FF",
|
||
"secondary": "#8592A3",
|
||
"on-secondary": "#fff",
|
||
"secondary-darken-1": "#788393",
|
||
"secondary-light": "#9DA8B5",
|
||
"success": "#71DD37",
|
||
"on-success": "#fff",
|
||
"success-darken-1": "#66C732",
|
||
"success-light": "#53D28C",
|
||
"info": "#03C3EC",
|
||
"on-info": "#fff",
|
||
"info-darken-1": "#03AFD4",
|
||
"info-light": "#35CFF0",
|
||
"warning": "#FFAB00",
|
||
"on-warning": "#fff",
|
||
"warning-darken-1": "#E69A00",
|
||
"warning-light": "#FFBC33",
|
||
"error": "#FF3E1D",
|
||
"on-error": "#fff",
|
||
"error-darken-1": "#E6381A",
|
||
"error-light": "#FF654A",
|
||
"background": "#f5f5f9",
|
||
"on-background": "#22303E",
|
||
"surface": "#fff",
|
||
"on-surface": "#22303E",
|
||
"grey-50": "#FAFAFA",
|
||
"grey-100": "#F5F5F5",
|
||
"grey-200": "#EEEEEE",
|
||
"grey-300": "#E0E0E0",
|
||
"grey-400": "#BDBDBD",
|
||
"grey-500": "#9E9E9E",
|
||
"grey-600": "#757575",
|
||
"grey-700": "#616161",
|
||
"grey-800": "#424242",
|
||
"grey-900": "#212121",
|
||
"grey-light": "#FAFAFA",
|
||
"perfect-scrollbar-thumb": "#DBDADE",
|
||
"skin-bordered-background": "#fff",
|
||
"skin-bordered-surface": "#fff",
|
||
"expansion-panel-text-custom-bg": "#fafafa"
|
||
},
|
||
variables: {
|
||
"code-color": "#d400ff",
|
||
"overlay-scrim-background": "#22303E",
|
||
"tooltip-background": "#22303E",
|
||
"overlay-scrim-opacity": 0.5,
|
||
"hover-opacity": 0.06,
|
||
"focus-opacity": 0.1,
|
||
"selected-opacity": 0.08,
|
||
"activated-opacity": 0.16,
|
||
"pressed-opacity": 0.14,
|
||
"dragged-opacity": 0.1,
|
||
"disabled-opacity": 0.4,
|
||
"border-color": "#22303E",
|
||
"border-opacity": 0.12,
|
||
"table-header-color": "#FFFFFF",
|
||
"high-emphasis-opacity": 0.9,
|
||
"medium-emphasis-opacity": 0.7,
|
||
"switch-opacity": 0.2,
|
||
"switch-disabled-track-opacity": 0.3,
|
||
"switch-disabled-thumb-opacity": 0.4,
|
||
"switch-checked-disabled-opacity": 0.3,
|
||
"track-bg": "#EEF1F3",
|
||
"chat-bg": "#F7F8F8",
|
||
// Shadows
|
||
"shadow-key-umbra-color": "#22303E",
|
||
"shadow-xs-opacity": 0.06,
|
||
"shadow-sm-opacity": 0.08,
|
||
"shadow-md-opacity": 0.1,
|
||
"shadow-lg-opacity": 0.14,
|
||
"shadow-xl-opacity": 0.18
|
||
}
|
||
},
|
||
dark: {
|
||
dark: true,
|
||
colors: {
|
||
"primary": staticPrimaryColor,
|
||
"on-primary": "#fff",
|
||
"primary-darken-1": staticPrimaryDarkenColor,
|
||
"primary-light": "#8789FF",
|
||
"secondary": "#8592A3",
|
||
"on-secondary": "#fff",
|
||
"secondary-darken-1": "#788393",
|
||
"secondary-light": "#9DA8B5",
|
||
"success": "#71DD37",
|
||
"on-success": "#fff",
|
||
"success-darken-1": "#66C732",
|
||
"success-light": "#53D28C",
|
||
"info": "#03C3EC",
|
||
"on-info": "#fff",
|
||
"info-darken-1": "#03AFD4",
|
||
"info-light": "#35CFF0",
|
||
"warning": "#FFAB00",
|
||
"on-warning": "#fff",
|
||
"warning-darken-1": "#E69A00",
|
||
"warning-light": "#FFBC33",
|
||
"error": "#FF3E1D",
|
||
"on-error": "#fff",
|
||
"error-darken-1": "#E6381A",
|
||
"error-light": "#FF654A",
|
||
"background": "#232333",
|
||
"on-background": "#E6E6F1",
|
||
"surface": "#2B2C40",
|
||
"on-surface": "#E6E6F1",
|
||
"grey-50": "#26293A",
|
||
"grey-100": "#2F3349",
|
||
"grey-200": "#26293A",
|
||
"grey-300": "#4A5072",
|
||
"grey-400": "#5E6692",
|
||
"grey-500": "#7983BB",
|
||
"grey-600": "#AAB3DE",
|
||
"grey-700": "#B6BEE3",
|
||
"grey-800": "#CFD3EC",
|
||
"grey-900": "#E7E9F6",
|
||
"grey-light": "#313246",
|
||
"perfect-scrollbar-thumb": "#4A5072",
|
||
"skin-bordered-background": "#2B2C40",
|
||
"skin-bordered-surface": "#2B2C40"
|
||
},
|
||
variables: {
|
||
"code-color": "#d400ff",
|
||
"overlay-scrim-background": "#1D1D2A",
|
||
"tooltip-background": "#E6E6F1",
|
||
"overlay-scrim-opacity": 0.6,
|
||
"hover-opacity": 0.06,
|
||
"focus-opacity": 0.1,
|
||
"selected-opacity": 0.08,
|
||
"activated-opacity": 0.16,
|
||
"pressed-opacity": 0.14,
|
||
"dragged-opacity": 0.1,
|
||
"disabled-opacity": 0.4,
|
||
"border-color": "#E6E6F1",
|
||
"border-opacity": 0.12,
|
||
"table-header-color": "#2B2C40",
|
||
"high-emphasis-opacity": 0.9,
|
||
"medium-emphasis-opacity": 0.7,
|
||
"switch-opacity": 0.4,
|
||
"switch-disabled-track-opacity": 0.4,
|
||
"switch-disabled-thumb-opacity": 0.8,
|
||
"switch-checked-disabled-opacity": 0.3,
|
||
"track-bg": "#41415F",
|
||
"chat-bg": "#20202E",
|
||
// Shadows
|
||
"shadow-key-umbra-color": "#14141D",
|
||
"shadow-xs-opacity": 0.18,
|
||
"shadow-sm-opacity": 0.2,
|
||
"shadow-md-opacity": 0.22,
|
||
"shadow-lg-opacity": 0.24,
|
||
"shadow-xl-opacity": 0.26
|
||
}
|
||
}
|
||
};
|
||
const index_kyvreQaQna = /* @__PURE__ */ defineNuxtPlugin((nuxtApp) => {
|
||
const vuetify = createVuetify({
|
||
ssr: true,
|
||
aliases: {
|
||
IconBtn: VBtn
|
||
},
|
||
defaults,
|
||
icons,
|
||
theme: {
|
||
defaultTheme: "light",
|
||
themes
|
||
}
|
||
});
|
||
nuxtApp.vueApp.use(vuetify);
|
||
});
|
||
const index_pJsEXjjc09 = /* @__PURE__ */ defineNuxtPlugin(() => {
|
||
});
|
||
const plugins = [
|
||
payloadPlugin,
|
||
unhead_KgADcZ0jPj,
|
||
plugin$1,
|
||
revive_payload_server_eJ33V7gbc6,
|
||
plugin,
|
||
components_plugin_KR1HBZs4kY,
|
||
plugin_ghbUAjaD3n,
|
||
index_kyvreQaQna,
|
||
index_pJsEXjjc09
|
||
];
|
||
const layouts = {
|
||
blank: defineAsyncComponent(() => import('./blank-Bf4PtoY-.mjs')),
|
||
"components-default-layout-with-vertical-nav": defineAsyncComponent(() => import('./DefaultLayoutWithVerticalNav-CwFd3qmL.mjs')),
|
||
"components-footer": defineAsyncComponent(() => import('./Footer-BdPuYOuS.mjs')),
|
||
"components-nav-items": defineAsyncComponent(() => import('./NavItems-BE_iATXh.mjs')),
|
||
"components-navbar-theme-switcher": defineAsyncComponent(() => import('./NavbarThemeSwitcher-B8gKKvoR.mjs')),
|
||
"components-user-profile": defineAsyncComponent(() => import('./UserProfile-D3XrMU_d.mjs')),
|
||
default: defineAsyncComponent(() => import('./default-BGiPi0E4.mjs'))
|
||
};
|
||
const LayoutLoader = defineComponent$1({
|
||
name: "LayoutLoader",
|
||
inheritAttrs: false,
|
||
props: {
|
||
name: String,
|
||
layoutProps: Object
|
||
},
|
||
setup(props, context) {
|
||
return () => h(layouts[props.name], props.layoutProps, context.slots);
|
||
}
|
||
});
|
||
const __nuxt_component_0 = defineComponent$1({
|
||
name: "NuxtLayout",
|
||
inheritAttrs: false,
|
||
props: {
|
||
name: {
|
||
type: [String, Boolean, Object],
|
||
default: null
|
||
},
|
||
fallback: {
|
||
type: [String, Object],
|
||
default: null
|
||
}
|
||
},
|
||
setup(props, context) {
|
||
const nuxtApp = useNuxtApp();
|
||
const injectedRoute = inject$1(PageRouteSymbol);
|
||
const route = injectedRoute === useRoute$1() ? useRoute$2() : injectedRoute;
|
||
const layout = computed(() => {
|
||
let layout2 = unref(props.name) ?? route.meta.layout ?? "default";
|
||
if (layout2 && !(layout2 in layouts)) {
|
||
if (props.fallback) {
|
||
layout2 = unref(props.fallback);
|
||
}
|
||
}
|
||
return layout2;
|
||
});
|
||
const layoutRef = ref();
|
||
context.expose({ layoutRef });
|
||
const done = nuxtApp.deferHydration();
|
||
return () => {
|
||
const hasLayout = layout.value && layout.value in layouts;
|
||
const transitionProps = route.meta.layoutTransition ?? appLayoutTransition;
|
||
return _wrapIf(Transition, hasLayout && transitionProps, {
|
||
default: () => h(Suspense, { suspensible: true, onResolve: () => {
|
||
nextTick(done);
|
||
} }, {
|
||
default: () => h(
|
||
LayoutProvider,
|
||
{
|
||
layoutProps: mergeProps(context.attrs, { ref: layoutRef }),
|
||
key: layout.value || void 0,
|
||
name: layout.value,
|
||
shouldProvide: !props.name,
|
||
hasTransition: !!transitionProps
|
||
},
|
||
context.slots
|
||
)
|
||
})
|
||
}).default();
|
||
};
|
||
}
|
||
});
|
||
const LayoutProvider = defineComponent$1({
|
||
name: "NuxtLayoutProvider",
|
||
inheritAttrs: false,
|
||
props: {
|
||
name: {
|
||
type: [String, Boolean]
|
||
},
|
||
layoutProps: {
|
||
type: Object
|
||
},
|
||
hasTransition: {
|
||
type: Boolean
|
||
},
|
||
shouldProvide: {
|
||
type: Boolean
|
||
}
|
||
},
|
||
setup(props, context) {
|
||
const name = props.name;
|
||
if (props.shouldProvide) {
|
||
provide(LayoutMetaSymbol, {
|
||
isCurrent: (route) => name === (route.meta.layout ?? "default")
|
||
});
|
||
}
|
||
return () => {
|
||
var _a, _b;
|
||
if (!name || typeof name === "string" && !(name in layouts)) {
|
||
return (_b = (_a = context.slots).default) == null ? void 0 : _b.call(_a);
|
||
}
|
||
return h(
|
||
LayoutLoader,
|
||
{ key: name, layoutProps: props.layoutProps, name },
|
||
context.slots
|
||
);
|
||
};
|
||
}
|
||
});
|
||
const RouteProvider = defineComponent$1({
|
||
props: {
|
||
vnode: {
|
||
type: Object,
|
||
required: true
|
||
},
|
||
route: {
|
||
type: Object,
|
||
required: true
|
||
},
|
||
vnodeRef: Object,
|
||
renderKey: String,
|
||
trackRootNodes: Boolean
|
||
},
|
||
setup(props) {
|
||
const previousKey = props.renderKey;
|
||
const previousRoute = props.route;
|
||
const route = {};
|
||
for (const key in props.route) {
|
||
Object.defineProperty(route, key, {
|
||
get: () => previousKey === props.renderKey ? props.route[key] : previousRoute[key],
|
||
enumerable: true
|
||
});
|
||
}
|
||
provide(PageRouteSymbol, shallowReactive(route));
|
||
return () => {
|
||
return h(props.vnode, { ref: props.vnodeRef });
|
||
};
|
||
}
|
||
});
|
||
const __nuxt_component_1$1 = defineComponent$1({
|
||
name: "NuxtPage",
|
||
inheritAttrs: false,
|
||
props: {
|
||
name: {
|
||
type: String
|
||
},
|
||
transition: {
|
||
type: [Boolean, Object],
|
||
default: void 0
|
||
},
|
||
keepalive: {
|
||
type: [Boolean, Object],
|
||
default: void 0
|
||
},
|
||
route: {
|
||
type: Object
|
||
},
|
||
pageKey: {
|
||
type: [Function, String],
|
||
default: null
|
||
}
|
||
},
|
||
setup(props, { attrs, slots, expose }) {
|
||
const nuxtApp = useNuxtApp();
|
||
const pageRef = ref();
|
||
const forkRoute = inject$1(PageRouteSymbol, null);
|
||
let previousPageKey;
|
||
expose({ pageRef });
|
||
inject$1(LayoutMetaSymbol, null);
|
||
let vnode;
|
||
const done = nuxtApp.deferHydration();
|
||
if (props.pageKey) {
|
||
watch(() => props.pageKey, (next, prev) => {
|
||
if (next !== prev) {
|
||
nuxtApp.callHook("page:loading:start");
|
||
}
|
||
});
|
||
}
|
||
return () => {
|
||
return h(RouterView, { name: props.name, route: props.route, ...attrs }, {
|
||
default: (routeProps) => {
|
||
if (!routeProps.Component) {
|
||
done();
|
||
return;
|
||
}
|
||
const key = generateRouteKey$1(routeProps, props.pageKey);
|
||
if (!nuxtApp.isHydrating && !hasChildrenRoutes(forkRoute, routeProps.route, routeProps.Component) && previousPageKey === key) {
|
||
nuxtApp.callHook("page:loading:end");
|
||
}
|
||
previousPageKey = key;
|
||
const hasTransition = !!(props.transition ?? routeProps.route.meta.pageTransition ?? appPageTransition);
|
||
const transitionProps = hasTransition && _mergeTransitionProps([
|
||
props.transition,
|
||
routeProps.route.meta.pageTransition,
|
||
appPageTransition,
|
||
{ onAfterLeave: () => {
|
||
nuxtApp.callHook("page:transition:finish", routeProps.Component);
|
||
} }
|
||
].filter(Boolean));
|
||
const keepaliveConfig = props.keepalive ?? routeProps.route.meta.keepalive ?? appKeepalive;
|
||
vnode = _wrapIf(
|
||
Transition,
|
||
hasTransition && transitionProps,
|
||
wrapInKeepAlive(
|
||
keepaliveConfig,
|
||
h(Suspense, {
|
||
suspensible: true,
|
||
onPending: () => nuxtApp.callHook("page:start", routeProps.Component),
|
||
onResolve: () => {
|
||
nextTick(() => nuxtApp.callHook("page:finish", routeProps.Component).then(() => nuxtApp.callHook("page:loading:end")).finally(done));
|
||
}
|
||
}, {
|
||
default: () => {
|
||
const providerVNode = h(RouteProvider, {
|
||
key: key || void 0,
|
||
vnode: slots.default ? h(Fragment, void 0, slots.default(routeProps)) : routeProps.Component,
|
||
route: routeProps.route,
|
||
renderKey: key || void 0,
|
||
trackRootNodes: hasTransition,
|
||
vnodeRef: pageRef
|
||
});
|
||
return providerVNode;
|
||
}
|
||
})
|
||
)
|
||
).default();
|
||
return vnode;
|
||
}
|
||
});
|
||
};
|
||
}
|
||
});
|
||
function _mergeTransitionProps(routeProps) {
|
||
const _props = routeProps.map((prop) => ({
|
||
...prop,
|
||
onAfterLeave: prop.onAfterLeave ? toArray(prop.onAfterLeave) : void 0
|
||
}));
|
||
return defu(..._props);
|
||
}
|
||
function hasChildrenRoutes(fork, newRoute, Component) {
|
||
if (!fork) {
|
||
return false;
|
||
}
|
||
const index = newRoute.matched.findIndex((m) => {
|
||
var _a;
|
||
return ((_a = m.components) == null ? void 0 : _a.default) === (Component == null ? void 0 : Component.type);
|
||
});
|
||
return index < newRoute.matched.length - 1;
|
||
}
|
||
const _export_sfc = (sfc, props) => {
|
||
const target = sfc.__vccOpts || sfc;
|
||
for (const [key, val] of props) {
|
||
target[key] = val;
|
||
}
|
||
return target;
|
||
};
|
||
const VCardActions = genericComponent()({
|
||
name: "VCardActions",
|
||
props: makeComponentProps(),
|
||
setup(props, _ref) {
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
provideDefaults({
|
||
VBtn: {
|
||
slim: true,
|
||
variant: "text"
|
||
}
|
||
});
|
||
useRender(() => {
|
||
var _a;
|
||
return createVNode("div", {
|
||
"class": ["v-card-actions", props.class],
|
||
"style": props.style
|
||
}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
|
||
});
|
||
return {};
|
||
}
|
||
});
|
||
const makeVCardSubtitleProps = propsFactory({
|
||
opacity: [Number, String],
|
||
...makeComponentProps(),
|
||
...makeTagProps()
|
||
}, "VCardSubtitle");
|
||
const VCardSubtitle = genericComponent()({
|
||
name: "VCardSubtitle",
|
||
props: makeVCardSubtitleProps(),
|
||
setup(props, _ref) {
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
useRender(() => createVNode(props.tag, {
|
||
"class": ["v-card-subtitle", props.class],
|
||
"style": [{
|
||
"--v-card-subtitle-opacity": props.opacity
|
||
}, props.style]
|
||
}, slots));
|
||
return {};
|
||
}
|
||
});
|
||
const VCardTitle = createSimpleFunctional("v-card-title");
|
||
function useAspectStyles(props) {
|
||
return {
|
||
aspectStyles: computed(() => {
|
||
const ratio = Number(props.aspectRatio);
|
||
return ratio ? {
|
||
paddingBottom: String(1 / ratio * 100) + "%"
|
||
} : void 0;
|
||
})
|
||
};
|
||
}
|
||
const makeVResponsiveProps = propsFactory({
|
||
aspectRatio: [String, Number],
|
||
contentClass: null,
|
||
inline: Boolean,
|
||
...makeComponentProps(),
|
||
...makeDimensionProps()
|
||
}, "VResponsive");
|
||
const VResponsive = genericComponent()({
|
||
name: "VResponsive",
|
||
props: makeVResponsiveProps(),
|
||
setup(props, _ref) {
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
const {
|
||
aspectStyles
|
||
} = useAspectStyles(props);
|
||
const {
|
||
dimensionStyles
|
||
} = useDimension(props);
|
||
useRender(() => {
|
||
var _a;
|
||
return createVNode("div", {
|
||
"class": ["v-responsive", {
|
||
"v-responsive--inline": props.inline
|
||
}, props.class],
|
||
"style": [dimensionStyles.value, props.style]
|
||
}, [createVNode("div", {
|
||
"class": "v-responsive__sizer",
|
||
"style": aspectStyles.value
|
||
}, null), (_a = slots.additional) == null ? void 0 : _a.call(slots), slots.default && createVNode("div", {
|
||
"class": ["v-responsive__content", props.contentClass]
|
||
}, [slots.default()])]);
|
||
});
|
||
return {};
|
||
}
|
||
});
|
||
const makeTransitionProps = propsFactory({
|
||
transition: {
|
||
type: [Boolean, String, Object],
|
||
default: "fade-transition",
|
||
validator: (val) => val !== true
|
||
}
|
||
}, "transition");
|
||
const MaybeTransition = (props, _ref) => {
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
const {
|
||
transition,
|
||
disabled,
|
||
group,
|
||
...rest
|
||
} = props;
|
||
const {
|
||
component = group ? TransitionGroup : Transition,
|
||
...customProps
|
||
} = typeof transition === "object" ? transition : {};
|
||
return h(component, mergeProps(typeof transition === "string" ? {
|
||
name: disabled ? "" : transition
|
||
} : customProps, typeof transition === "string" ? {} : Object.fromEntries(Object.entries({
|
||
disabled,
|
||
group
|
||
}).filter((_ref2) => {
|
||
let [_, v] = _ref2;
|
||
return v !== void 0;
|
||
})), rest), slots);
|
||
};
|
||
function mounted(el, binding) {
|
||
return;
|
||
}
|
||
function unmounted(el, binding) {
|
||
var _a;
|
||
const observe = (_a = el._observe) == null ? void 0 : _a[binding.instance.$.uid];
|
||
if (!observe) return;
|
||
observe.observer.unobserve(el);
|
||
delete el._observe[binding.instance.$.uid];
|
||
}
|
||
const Intersect = {
|
||
mounted,
|
||
unmounted
|
||
};
|
||
const makeVImgProps = propsFactory({
|
||
absolute: Boolean,
|
||
alt: String,
|
||
cover: Boolean,
|
||
color: String,
|
||
draggable: {
|
||
type: [Boolean, String],
|
||
default: void 0
|
||
},
|
||
eager: Boolean,
|
||
gradient: String,
|
||
lazySrc: String,
|
||
options: {
|
||
type: Object,
|
||
// For more information on types, navigate to:
|
||
// https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API
|
||
default: () => ({
|
||
root: void 0,
|
||
rootMargin: void 0,
|
||
threshold: void 0
|
||
})
|
||
},
|
||
sizes: String,
|
||
src: {
|
||
type: [String, Object],
|
||
default: ""
|
||
},
|
||
crossorigin: String,
|
||
referrerpolicy: String,
|
||
srcset: String,
|
||
position: String,
|
||
...makeVResponsiveProps(),
|
||
...makeComponentProps(),
|
||
...makeRoundedProps(),
|
||
...makeTransitionProps()
|
||
}, "VImg");
|
||
const VImg = genericComponent()({
|
||
name: "VImg",
|
||
directives: {
|
||
intersect: Intersect
|
||
},
|
||
props: makeVImgProps(),
|
||
emits: {
|
||
loadstart: (value) => true,
|
||
load: (value) => true,
|
||
error: (value) => true
|
||
},
|
||
setup(props, _ref) {
|
||
let {
|
||
emit,
|
||
slots
|
||
} = _ref;
|
||
const {
|
||
backgroundColorClasses,
|
||
backgroundColorStyles
|
||
} = useBackgroundColor(toRef(props, "color"));
|
||
const {
|
||
roundedClasses
|
||
} = useRounded(props);
|
||
const vm = getCurrentInstance("VImg");
|
||
const currentSrc = shallowRef("");
|
||
const image = ref();
|
||
const state = shallowRef(props.eager ? "loading" : "idle");
|
||
const naturalWidth = shallowRef();
|
||
const naturalHeight = shallowRef();
|
||
const normalisedSrc = computed(() => {
|
||
return props.src && typeof props.src === "object" ? {
|
||
src: props.src.src,
|
||
srcset: props.srcset || props.src.srcset,
|
||
lazySrc: props.lazySrc || props.src.lazySrc,
|
||
aspect: Number(props.aspectRatio || props.src.aspect || 0)
|
||
} : {
|
||
src: props.src,
|
||
srcset: props.srcset,
|
||
lazySrc: props.lazySrc,
|
||
aspect: Number(props.aspectRatio || 0)
|
||
};
|
||
});
|
||
const aspectRatio = computed(() => {
|
||
return normalisedSrc.value.aspect || naturalWidth.value / naturalHeight.value || 0;
|
||
});
|
||
watch(() => props.src, () => {
|
||
init(state.value !== "idle");
|
||
});
|
||
watch(aspectRatio, (val, oldVal) => {
|
||
if (!val && oldVal && image.value) {
|
||
pollForSize(image.value);
|
||
}
|
||
});
|
||
function init(isIntersecting) {
|
||
if (props.eager && isIntersecting) return;
|
||
state.value = "loading";
|
||
if (normalisedSrc.value.lazySrc) {
|
||
const lazyImg = new Image();
|
||
lazyImg.src = normalisedSrc.value.lazySrc;
|
||
pollForSize(lazyImg, null);
|
||
}
|
||
if (!normalisedSrc.value.src) return;
|
||
nextTick(() => {
|
||
var _a;
|
||
emit("loadstart", ((_a = image.value) == null ? void 0 : _a.currentSrc) || normalisedSrc.value.src);
|
||
setTimeout(() => {
|
||
var _a2;
|
||
if (vm.isUnmounted) return;
|
||
if ((_a2 = image.value) == null ? void 0 : _a2.complete) {
|
||
if (!image.value.naturalWidth) {
|
||
onError();
|
||
}
|
||
if (state.value === "error") return;
|
||
if (!aspectRatio.value) pollForSize(image.value, null);
|
||
if (state.value === "loading") onLoad();
|
||
} else {
|
||
if (!aspectRatio.value) pollForSize(image.value);
|
||
getSrc();
|
||
}
|
||
});
|
||
});
|
||
}
|
||
function onLoad() {
|
||
var _a;
|
||
if (vm.isUnmounted) return;
|
||
getSrc();
|
||
pollForSize(image.value);
|
||
state.value = "loaded";
|
||
emit("load", ((_a = image.value) == null ? void 0 : _a.currentSrc) || normalisedSrc.value.src);
|
||
}
|
||
function onError() {
|
||
var _a;
|
||
if (vm.isUnmounted) return;
|
||
state.value = "error";
|
||
emit("error", ((_a = image.value) == null ? void 0 : _a.currentSrc) || normalisedSrc.value.src);
|
||
}
|
||
function getSrc() {
|
||
const img = image.value;
|
||
if (img) currentSrc.value = img.currentSrc || img.src;
|
||
}
|
||
let timer = -1;
|
||
function pollForSize(img) {
|
||
let timeout = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 100;
|
||
const poll = () => {
|
||
clearTimeout(timer);
|
||
if (vm.isUnmounted) return;
|
||
const {
|
||
naturalHeight: imgHeight,
|
||
naturalWidth: imgWidth
|
||
} = img;
|
||
if (imgHeight || imgWidth) {
|
||
naturalWidth.value = imgWidth;
|
||
naturalHeight.value = imgHeight;
|
||
} else if (!img.complete && state.value === "loading" && timeout != null) {
|
||
timer = (void 0).setTimeout(poll, timeout);
|
||
} else if (img.currentSrc.endsWith(".svg") || img.currentSrc.startsWith("data:image/svg+xml")) {
|
||
naturalWidth.value = 1;
|
||
naturalHeight.value = 1;
|
||
}
|
||
};
|
||
poll();
|
||
}
|
||
const containClasses = computed(() => ({
|
||
"v-img__img--cover": props.cover,
|
||
"v-img__img--contain": !props.cover
|
||
}));
|
||
const __image = () => {
|
||
var _a;
|
||
if (!normalisedSrc.value.src || state.value === "idle") return null;
|
||
const img = createVNode("img", {
|
||
"class": ["v-img__img", containClasses.value],
|
||
"style": {
|
||
objectPosition: props.position
|
||
},
|
||
"src": normalisedSrc.value.src,
|
||
"srcset": normalisedSrc.value.srcset,
|
||
"alt": props.alt,
|
||
"crossorigin": props.crossorigin,
|
||
"referrerpolicy": props.referrerpolicy,
|
||
"draggable": props.draggable,
|
||
"sizes": props.sizes,
|
||
"ref": image,
|
||
"onLoad": onLoad,
|
||
"onError": onError
|
||
}, null);
|
||
const sources = (_a = slots.sources) == null ? void 0 : _a.call(slots);
|
||
return createVNode(MaybeTransition, {
|
||
"transition": props.transition,
|
||
"appear": true
|
||
}, {
|
||
default: () => [withDirectives(sources ? createVNode("picture", {
|
||
"class": "v-img__picture"
|
||
}, [sources, img]) : img, [[vShow, state.value === "loaded"]])]
|
||
});
|
||
};
|
||
const __preloadImage = () => createVNode(MaybeTransition, {
|
||
"transition": props.transition
|
||
}, {
|
||
default: () => [normalisedSrc.value.lazySrc && state.value !== "loaded" && createVNode("img", {
|
||
"class": ["v-img__img", "v-img__img--preload", containClasses.value],
|
||
"style": {
|
||
objectPosition: props.position
|
||
},
|
||
"src": normalisedSrc.value.lazySrc,
|
||
"alt": props.alt,
|
||
"crossorigin": props.crossorigin,
|
||
"referrerpolicy": props.referrerpolicy,
|
||
"draggable": props.draggable
|
||
}, null)]
|
||
});
|
||
const __placeholder = () => {
|
||
if (!slots.placeholder) return null;
|
||
return createVNode(MaybeTransition, {
|
||
"transition": props.transition,
|
||
"appear": true
|
||
}, {
|
||
default: () => [(state.value === "loading" || state.value === "error" && !slots.error) && createVNode("div", {
|
||
"class": "v-img__placeholder"
|
||
}, [slots.placeholder()])]
|
||
});
|
||
};
|
||
const __error = () => {
|
||
if (!slots.error) return null;
|
||
return createVNode(MaybeTransition, {
|
||
"transition": props.transition,
|
||
"appear": true
|
||
}, {
|
||
default: () => [state.value === "error" && createVNode("div", {
|
||
"class": "v-img__error"
|
||
}, [slots.error()])]
|
||
});
|
||
};
|
||
const __gradient = () => {
|
||
if (!props.gradient) return null;
|
||
return createVNode("div", {
|
||
"class": "v-img__gradient",
|
||
"style": {
|
||
backgroundImage: `linear-gradient(${props.gradient})`
|
||
}
|
||
}, null);
|
||
};
|
||
const isBooted = shallowRef(false);
|
||
{
|
||
const stop = watch(aspectRatio, (val) => {
|
||
if (val) {
|
||
requestAnimationFrame(() => {
|
||
requestAnimationFrame(() => {
|
||
isBooted.value = true;
|
||
});
|
||
});
|
||
stop();
|
||
}
|
||
});
|
||
}
|
||
useRender(() => {
|
||
const responsiveProps = VResponsive.filterProps(props);
|
||
return withDirectives(createVNode(VResponsive, mergeProps({
|
||
"class": ["v-img", {
|
||
"v-img--absolute": props.absolute,
|
||
"v-img--booting": !isBooted.value
|
||
}, backgroundColorClasses.value, roundedClasses.value, props.class],
|
||
"style": [{
|
||
width: convertToUnit(props.width === "auto" ? naturalWidth.value : props.width)
|
||
}, backgroundColorStyles.value, props.style]
|
||
}, responsiveProps, {
|
||
"aspectRatio": aspectRatio.value,
|
||
"aria-label": props.alt,
|
||
"role": props.alt ? "img" : void 0
|
||
}), {
|
||
additional: () => createVNode(Fragment, null, [createVNode(__image, null, null), createVNode(__preloadImage, null, null), createVNode(__gradient, null, null), createVNode(__placeholder, null, null), createVNode(__error, null, null)]),
|
||
default: slots.default
|
||
}), [[resolveDirective("intersect"), {
|
||
handler: init,
|
||
options: props.options
|
||
}, null, {
|
||
once: true
|
||
}]]);
|
||
});
|
||
return {
|
||
currentSrc,
|
||
image,
|
||
state,
|
||
naturalWidth,
|
||
naturalHeight
|
||
};
|
||
}
|
||
});
|
||
const makeVAvatarProps = propsFactory({
|
||
start: Boolean,
|
||
end: Boolean,
|
||
icon: IconValue,
|
||
image: String,
|
||
text: String,
|
||
...makeBorderProps(),
|
||
...makeComponentProps(),
|
||
...makeDensityProps(),
|
||
...makeRoundedProps(),
|
||
...makeSizeProps(),
|
||
...makeTagProps(),
|
||
...makeThemeProps(),
|
||
...makeVariantProps({
|
||
variant: "flat"
|
||
})
|
||
}, "VAvatar");
|
||
const VAvatar = genericComponent()({
|
||
name: "VAvatar",
|
||
props: makeVAvatarProps(),
|
||
setup(props, _ref) {
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
const {
|
||
themeClasses
|
||
} = provideTheme(props);
|
||
const {
|
||
borderClasses
|
||
} = useBorder(props);
|
||
const {
|
||
colorClasses,
|
||
colorStyles,
|
||
variantClasses
|
||
} = useVariant(props);
|
||
const {
|
||
densityClasses
|
||
} = useDensity(props);
|
||
const {
|
||
roundedClasses
|
||
} = useRounded(props);
|
||
const {
|
||
sizeClasses,
|
||
sizeStyles
|
||
} = useSize(props);
|
||
useRender(() => createVNode(props.tag, {
|
||
"class": ["v-avatar", {
|
||
"v-avatar--start": props.start,
|
||
"v-avatar--end": props.end
|
||
}, themeClasses.value, borderClasses.value, colorClasses.value, densityClasses.value, roundedClasses.value, sizeClasses.value, variantClasses.value, props.class],
|
||
"style": [colorStyles.value, sizeStyles.value, props.style]
|
||
}, {
|
||
default: () => [!slots.default ? props.image ? createVNode(VImg, {
|
||
"key": "image",
|
||
"src": props.image,
|
||
"alt": "",
|
||
"cover": true
|
||
}, null) : props.icon ? createVNode(VIcon, {
|
||
"key": "icon",
|
||
"icon": props.icon
|
||
}, null) : props.text : createVNode(VDefaultsProvider, {
|
||
"key": "content-defaults",
|
||
"defaults": {
|
||
VImg: {
|
||
cover: true,
|
||
src: props.image
|
||
},
|
||
VIcon: {
|
||
icon: props.icon
|
||
}
|
||
}
|
||
}, {
|
||
default: () => [slots.default()]
|
||
}), genOverlays(false, "v-avatar")]
|
||
}));
|
||
return {};
|
||
}
|
||
});
|
||
const makeCardItemProps = propsFactory({
|
||
appendAvatar: String,
|
||
appendIcon: IconValue,
|
||
prependAvatar: String,
|
||
prependIcon: IconValue,
|
||
subtitle: [String, Number],
|
||
title: [String, Number],
|
||
...makeComponentProps(),
|
||
...makeDensityProps()
|
||
}, "VCardItem");
|
||
const VCardItem = genericComponent()({
|
||
name: "VCardItem",
|
||
props: makeCardItemProps(),
|
||
setup(props, _ref) {
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
useRender(() => {
|
||
var _a;
|
||
const hasPrependMedia = !!(props.prependAvatar || props.prependIcon);
|
||
const hasPrepend = !!(hasPrependMedia || slots.prepend);
|
||
const hasAppendMedia = !!(props.appendAvatar || props.appendIcon);
|
||
const hasAppend = !!(hasAppendMedia || slots.append);
|
||
const hasTitle = !!(props.title != null || slots.title);
|
||
const hasSubtitle = !!(props.subtitle != null || slots.subtitle);
|
||
return createVNode("div", {
|
||
"class": ["v-card-item", props.class],
|
||
"style": props.style
|
||
}, [hasPrepend && createVNode("div", {
|
||
"key": "prepend",
|
||
"class": "v-card-item__prepend"
|
||
}, [!slots.prepend ? createVNode(Fragment, null, [props.prependAvatar && createVNode(VAvatar, {
|
||
"key": "prepend-avatar",
|
||
"density": props.density,
|
||
"image": props.prependAvatar
|
||
}, null), props.prependIcon && createVNode(VIcon, {
|
||
"key": "prepend-icon",
|
||
"density": props.density,
|
||
"icon": props.prependIcon
|
||
}, null)]) : createVNode(VDefaultsProvider, {
|
||
"key": "prepend-defaults",
|
||
"disabled": !hasPrependMedia,
|
||
"defaults": {
|
||
VAvatar: {
|
||
density: props.density,
|
||
image: props.prependAvatar
|
||
},
|
||
VIcon: {
|
||
density: props.density,
|
||
icon: props.prependIcon
|
||
}
|
||
}
|
||
}, slots.prepend)]), createVNode("div", {
|
||
"class": "v-card-item__content"
|
||
}, [hasTitle && createVNode(VCardTitle, {
|
||
"key": "title"
|
||
}, {
|
||
default: () => {
|
||
var _a2;
|
||
return [((_a2 = slots.title) == null ? void 0 : _a2.call(slots)) ?? props.title];
|
||
}
|
||
}), hasSubtitle && createVNode(VCardSubtitle, {
|
||
"key": "subtitle"
|
||
}, {
|
||
default: () => {
|
||
var _a2;
|
||
return [((_a2 = slots.subtitle) == null ? void 0 : _a2.call(slots)) ?? props.subtitle];
|
||
}
|
||
}), (_a = slots.default) == null ? void 0 : _a.call(slots)]), hasAppend && createVNode("div", {
|
||
"key": "append",
|
||
"class": "v-card-item__append"
|
||
}, [!slots.append ? createVNode(Fragment, null, [props.appendIcon && createVNode(VIcon, {
|
||
"key": "append-icon",
|
||
"density": props.density,
|
||
"icon": props.appendIcon
|
||
}, null), props.appendAvatar && createVNode(VAvatar, {
|
||
"key": "append-avatar",
|
||
"density": props.density,
|
||
"image": props.appendAvatar
|
||
}, null)]) : createVNode(VDefaultsProvider, {
|
||
"key": "append-defaults",
|
||
"disabled": !hasAppendMedia,
|
||
"defaults": {
|
||
VAvatar: {
|
||
density: props.density,
|
||
image: props.appendAvatar
|
||
},
|
||
VIcon: {
|
||
density: props.density,
|
||
icon: props.appendIcon
|
||
}
|
||
}
|
||
}, slots.append)])]);
|
||
});
|
||
return {};
|
||
}
|
||
});
|
||
const makeVCardTextProps = propsFactory({
|
||
opacity: [Number, String],
|
||
...makeComponentProps(),
|
||
...makeTagProps()
|
||
}, "VCardText");
|
||
const VCardText = genericComponent()({
|
||
name: "VCardText",
|
||
props: makeVCardTextProps(),
|
||
setup(props, _ref) {
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
useRender(() => createVNode(props.tag, {
|
||
"class": ["v-card-text", props.class],
|
||
"style": [{
|
||
"--v-card-text-opacity": props.opacity
|
||
}, props.style]
|
||
}, slots));
|
||
return {};
|
||
}
|
||
});
|
||
const makeVCardProps = propsFactory({
|
||
appendAvatar: String,
|
||
appendIcon: IconValue,
|
||
disabled: Boolean,
|
||
flat: Boolean,
|
||
hover: Boolean,
|
||
image: String,
|
||
link: {
|
||
type: Boolean,
|
||
default: void 0
|
||
},
|
||
prependAvatar: String,
|
||
prependIcon: IconValue,
|
||
ripple: {
|
||
type: [Boolean, Object],
|
||
default: true
|
||
},
|
||
subtitle: [String, Number],
|
||
text: [String, Number],
|
||
title: [String, Number],
|
||
...makeBorderProps(),
|
||
...makeComponentProps(),
|
||
...makeDensityProps(),
|
||
...makeDimensionProps(),
|
||
...makeElevationProps(),
|
||
...makeLoaderProps(),
|
||
...makeLocationProps(),
|
||
...makePositionProps(),
|
||
...makeRoundedProps(),
|
||
...makeRouterProps(),
|
||
...makeTagProps(),
|
||
...makeThemeProps(),
|
||
...makeVariantProps({
|
||
variant: "elevated"
|
||
})
|
||
}, "VCard");
|
||
const VCard = genericComponent()({
|
||
name: "VCard",
|
||
directives: {
|
||
Ripple
|
||
},
|
||
props: makeVCardProps(),
|
||
setup(props, _ref) {
|
||
let {
|
||
attrs,
|
||
slots
|
||
} = _ref;
|
||
const {
|
||
themeClasses
|
||
} = provideTheme(props);
|
||
const {
|
||
borderClasses
|
||
} = useBorder(props);
|
||
const {
|
||
colorClasses,
|
||
colorStyles,
|
||
variantClasses
|
||
} = useVariant(props);
|
||
const {
|
||
densityClasses
|
||
} = useDensity(props);
|
||
const {
|
||
dimensionStyles
|
||
} = useDimension(props);
|
||
const {
|
||
elevationClasses
|
||
} = useElevation(props);
|
||
const {
|
||
loaderClasses
|
||
} = useLoader(props);
|
||
const {
|
||
locationStyles
|
||
} = useLocation(props);
|
||
const {
|
||
positionClasses
|
||
} = usePosition(props);
|
||
const {
|
||
roundedClasses
|
||
} = useRounded(props);
|
||
const link = useLink(props, attrs);
|
||
const isLink = computed(() => props.link !== false && link.isLink.value);
|
||
const isClickable = computed(() => !props.disabled && props.link !== false && (props.link || link.isClickable.value));
|
||
useRender(() => {
|
||
const Tag = isLink.value ? "a" : props.tag;
|
||
const hasTitle = !!(slots.title || props.title != null);
|
||
const hasSubtitle = !!(slots.subtitle || props.subtitle != null);
|
||
const hasHeader = hasTitle || hasSubtitle;
|
||
const hasAppend = !!(slots.append || props.appendAvatar || props.appendIcon);
|
||
const hasPrepend = !!(slots.prepend || props.prependAvatar || props.prependIcon);
|
||
const hasImage = !!(slots.image || props.image);
|
||
const hasCardItem = hasHeader || hasPrepend || hasAppend;
|
||
const hasText = !!(slots.text || props.text != null);
|
||
return withDirectives(createVNode(Tag, mergeProps({
|
||
"class": ["v-card", {
|
||
"v-card--disabled": props.disabled,
|
||
"v-card--flat": props.flat,
|
||
"v-card--hover": props.hover && !(props.disabled || props.flat),
|
||
"v-card--link": isClickable.value
|
||
}, themeClasses.value, borderClasses.value, colorClasses.value, densityClasses.value, elevationClasses.value, loaderClasses.value, positionClasses.value, roundedClasses.value, variantClasses.value, props.class],
|
||
"style": [colorStyles.value, dimensionStyles.value, locationStyles.value, props.style],
|
||
"onClick": isClickable.value && link.navigate,
|
||
"tabindex": props.disabled ? -1 : void 0
|
||
}, link.linkProps), {
|
||
default: () => {
|
||
var _a;
|
||
return [hasImage && createVNode("div", {
|
||
"key": "image",
|
||
"class": "v-card__image"
|
||
}, [!slots.image ? createVNode(VImg, {
|
||
"key": "image-img",
|
||
"cover": true,
|
||
"src": props.image
|
||
}, null) : createVNode(VDefaultsProvider, {
|
||
"key": "image-defaults",
|
||
"disabled": !props.image,
|
||
"defaults": {
|
||
VImg: {
|
||
cover: true,
|
||
src: props.image
|
||
}
|
||
}
|
||
}, slots.image)]), createVNode(LoaderSlot, {
|
||
"name": "v-card",
|
||
"active": !!props.loading,
|
||
"color": typeof props.loading === "boolean" ? void 0 : props.loading
|
||
}, {
|
||
default: slots.loader
|
||
}), hasCardItem && createVNode(VCardItem, {
|
||
"key": "item",
|
||
"prependAvatar": props.prependAvatar,
|
||
"prependIcon": props.prependIcon,
|
||
"title": props.title,
|
||
"subtitle": props.subtitle,
|
||
"appendAvatar": props.appendAvatar,
|
||
"appendIcon": props.appendIcon
|
||
}, {
|
||
default: slots.item,
|
||
prepend: slots.prepend,
|
||
title: slots.title,
|
||
subtitle: slots.subtitle,
|
||
append: slots.append
|
||
}), hasText && createVNode(VCardText, {
|
||
"key": "text"
|
||
}, {
|
||
default: () => {
|
||
var _a2;
|
||
return [((_a2 = slots.text) == null ? void 0 : _a2.call(slots)) ?? props.text];
|
||
}
|
||
}), (_a = slots.default) == null ? void 0 : _a.call(slots), slots.actions && createVNode(VCardActions, null, {
|
||
default: slots.actions
|
||
}), genOverlays(isClickable.value, "v-card")];
|
||
}
|
||
}), [[resolveDirective("ripple"), isClickable.value && props.ripple]]);
|
||
});
|
||
return {};
|
||
}
|
||
});
|
||
const makeVDialogTransitionProps = propsFactory({
|
||
target: [Object, Array]
|
||
}, "v-dialog-transition");
|
||
const VDialogTransition = genericComponent()({
|
||
name: "VDialogTransition",
|
||
props: makeVDialogTransitionProps(),
|
||
setup(props, _ref) {
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
const functions = {
|
||
onBeforeEnter(el) {
|
||
el.style.pointerEvents = "none";
|
||
el.style.visibility = "hidden";
|
||
},
|
||
async onEnter(el, done) {
|
||
var _a;
|
||
await new Promise((resolve) => requestAnimationFrame(resolve));
|
||
await new Promise((resolve) => requestAnimationFrame(resolve));
|
||
el.style.visibility = "";
|
||
const {
|
||
x,
|
||
y,
|
||
sx,
|
||
sy,
|
||
speed
|
||
} = getDimensions(props.target, el);
|
||
const animation = animate(el, [{
|
||
transform: `translate(${x}px, ${y}px) scale(${sx}, ${sy})`,
|
||
opacity: 0
|
||
}, {}], {
|
||
duration: 225 * speed,
|
||
easing: deceleratedEasing
|
||
});
|
||
(_a = getChildren(el)) == null ? void 0 : _a.forEach((el2) => {
|
||
animate(el2, [{
|
||
opacity: 0
|
||
}, {
|
||
opacity: 0,
|
||
offset: 0.33
|
||
}, {}], {
|
||
duration: 225 * 2 * speed,
|
||
easing: standardEasing
|
||
});
|
||
});
|
||
animation.finished.then(() => done());
|
||
},
|
||
onAfterEnter(el) {
|
||
el.style.removeProperty("pointer-events");
|
||
},
|
||
onBeforeLeave(el) {
|
||
el.style.pointerEvents = "none";
|
||
},
|
||
async onLeave(el, done) {
|
||
var _a;
|
||
await new Promise((resolve) => requestAnimationFrame(resolve));
|
||
const {
|
||
x,
|
||
y,
|
||
sx,
|
||
sy,
|
||
speed
|
||
} = getDimensions(props.target, el);
|
||
const animation = animate(el, [{}, {
|
||
transform: `translate(${x}px, ${y}px) scale(${sx}, ${sy})`,
|
||
opacity: 0
|
||
}], {
|
||
duration: 125 * speed,
|
||
easing: acceleratedEasing
|
||
});
|
||
animation.finished.then(() => done());
|
||
(_a = getChildren(el)) == null ? void 0 : _a.forEach((el2) => {
|
||
animate(el2, [{}, {
|
||
opacity: 0,
|
||
offset: 0.2
|
||
}, {
|
||
opacity: 0
|
||
}], {
|
||
duration: 125 * 2 * speed,
|
||
easing: standardEasing
|
||
});
|
||
});
|
||
},
|
||
onAfterLeave(el) {
|
||
el.style.removeProperty("pointer-events");
|
||
}
|
||
};
|
||
return () => {
|
||
return props.target ? createVNode(Transition, mergeProps({
|
||
"name": "dialog-transition"
|
||
}, functions, {
|
||
"css": false
|
||
}), slots) : createVNode(Transition, {
|
||
"name": "dialog-transition"
|
||
}, slots);
|
||
};
|
||
}
|
||
});
|
||
function getChildren(el) {
|
||
var _a;
|
||
const els = (_a = el.querySelector(":scope > .v-card, :scope > .v-sheet, :scope > .v-list")) == null ? void 0 : _a.children;
|
||
return els && [...els];
|
||
}
|
||
function getDimensions(target, el) {
|
||
const targetBox = getTargetBox(target);
|
||
const elBox = nullifyTransforms(el);
|
||
const [originX, originY] = getComputedStyle(el).transformOrigin.split(" ").map((v) => parseFloat(v));
|
||
const [anchorSide, anchorOffset] = getComputedStyle(el).getPropertyValue("--v-overlay-anchor-origin").split(" ");
|
||
let offsetX = targetBox.left + targetBox.width / 2;
|
||
if (anchorSide === "left" || anchorOffset === "left") {
|
||
offsetX -= targetBox.width / 2;
|
||
} else if (anchorSide === "right" || anchorOffset === "right") {
|
||
offsetX += targetBox.width / 2;
|
||
}
|
||
let offsetY = targetBox.top + targetBox.height / 2;
|
||
if (anchorSide === "top" || anchorOffset === "top") {
|
||
offsetY -= targetBox.height / 2;
|
||
} else if (anchorSide === "bottom" || anchorOffset === "bottom") {
|
||
offsetY += targetBox.height / 2;
|
||
}
|
||
const tsx = targetBox.width / elBox.width;
|
||
const tsy = targetBox.height / elBox.height;
|
||
const maxs = Math.max(1, tsx, tsy);
|
||
const sx = tsx / maxs || 0;
|
||
const sy = tsy / maxs || 0;
|
||
const asa = elBox.width * elBox.height / ((void 0).innerWidth * (void 0).innerHeight);
|
||
const speed = asa > 0.12 ? Math.min(1.5, (asa - 0.12) * 10 + 1) : 1;
|
||
return {
|
||
x: offsetX - (originX + elBox.left),
|
||
y: offsetY - (originY + elBox.top),
|
||
sx,
|
||
sy,
|
||
speed
|
||
};
|
||
}
|
||
function elementToViewport(point, offset) {
|
||
return {
|
||
x: point.x + offset.x,
|
||
y: point.y + offset.y
|
||
};
|
||
}
|
||
function getOffset(a, b) {
|
||
return {
|
||
x: a.x - b.x,
|
||
y: a.y - b.y
|
||
};
|
||
}
|
||
function anchorToPoint(anchor, box) {
|
||
if (anchor.side === "top" || anchor.side === "bottom") {
|
||
const {
|
||
side,
|
||
align
|
||
} = anchor;
|
||
const x = align === "left" ? 0 : align === "center" ? box.width / 2 : align === "right" ? box.width : align;
|
||
const y = side === "top" ? 0 : side === "bottom" ? box.height : side;
|
||
return elementToViewport({
|
||
x,
|
||
y
|
||
}, box);
|
||
} else if (anchor.side === "left" || anchor.side === "right") {
|
||
const {
|
||
side,
|
||
align
|
||
} = anchor;
|
||
const x = side === "left" ? 0 : side === "right" ? box.width : side;
|
||
const y = align === "top" ? 0 : align === "center" ? box.height / 2 : align === "bottom" ? box.height : align;
|
||
return elementToViewport({
|
||
x,
|
||
y
|
||
}, box);
|
||
}
|
||
return elementToViewport({
|
||
x: box.width / 2,
|
||
y: box.height / 2
|
||
}, box);
|
||
}
|
||
const locationStrategies = {
|
||
static: staticLocationStrategy,
|
||
// specific viewport position, usually centered
|
||
connected: connectedLocationStrategy
|
||
// connected to a certain element
|
||
};
|
||
const makeLocationStrategyProps = propsFactory({
|
||
locationStrategy: {
|
||
type: [String, Function],
|
||
default: "static",
|
||
validator: (val) => typeof val === "function" || val in locationStrategies
|
||
},
|
||
location: {
|
||
type: String,
|
||
default: "bottom"
|
||
},
|
||
origin: {
|
||
type: String,
|
||
default: "auto"
|
||
},
|
||
offset: [Number, String, Array]
|
||
}, "VOverlay-location-strategies");
|
||
function useLocationStrategies(props, data) {
|
||
const contentStyles = ref({});
|
||
const updateLocation = ref();
|
||
return {
|
||
contentStyles,
|
||
updateLocation
|
||
};
|
||
}
|
||
function staticLocationStrategy() {
|
||
}
|
||
function getIntrinsicSize(el, isRtl) {
|
||
const contentBox = nullifyTransforms(el);
|
||
if (isRtl) {
|
||
contentBox.x += parseFloat(el.style.right || 0);
|
||
} else {
|
||
contentBox.x -= parseFloat(el.style.left || 0);
|
||
}
|
||
contentBox.y -= parseFloat(el.style.top || 0);
|
||
return contentBox;
|
||
}
|
||
function connectedLocationStrategy(data, props, contentStyles) {
|
||
const activatorFixed = Array.isArray(data.target.value) || isFixedPosition(data.target.value);
|
||
if (activatorFixed) {
|
||
Object.assign(contentStyles.value, {
|
||
position: "fixed",
|
||
top: 0,
|
||
[data.isRtl.value ? "right" : "left"]: 0
|
||
});
|
||
}
|
||
const {
|
||
preferredAnchor,
|
||
preferredOrigin
|
||
} = destructComputed(() => {
|
||
const parsedAnchor = parseAnchor(props.location, data.isRtl.value);
|
||
const parsedOrigin = props.origin === "overlap" ? parsedAnchor : props.origin === "auto" ? flipSide(parsedAnchor) : parseAnchor(props.origin, data.isRtl.value);
|
||
if (parsedAnchor.side === parsedOrigin.side && parsedAnchor.align === flipAlign(parsedOrigin).align) {
|
||
return {
|
||
preferredAnchor: flipCorner(parsedAnchor),
|
||
preferredOrigin: flipCorner(parsedOrigin)
|
||
};
|
||
} else {
|
||
return {
|
||
preferredAnchor: parsedAnchor,
|
||
preferredOrigin: parsedOrigin
|
||
};
|
||
}
|
||
});
|
||
const [minWidth, minHeight, maxWidth, maxHeight] = ["minWidth", "minHeight", "maxWidth", "maxHeight"].map((key) => {
|
||
return computed(() => {
|
||
const val = parseFloat(props[key]);
|
||
return isNaN(val) ? Infinity : val;
|
||
});
|
||
});
|
||
const offset = computed(() => {
|
||
if (Array.isArray(props.offset)) {
|
||
return props.offset;
|
||
}
|
||
if (typeof props.offset === "string") {
|
||
const offset2 = props.offset.split(" ").map(parseFloat);
|
||
if (offset2.length < 2) offset2.push(0);
|
||
return offset2;
|
||
}
|
||
return typeof props.offset === "number" ? [props.offset, 0] : [0, 0];
|
||
});
|
||
let observe = false;
|
||
const observer = new ResizeObserver(() => {
|
||
if (observe) updateLocation();
|
||
});
|
||
watch([data.target, data.contentEl], (_ref, _ref2) => {
|
||
let [newTarget, newContentEl] = _ref;
|
||
let [oldTarget, oldContentEl] = _ref2;
|
||
if (oldTarget && !Array.isArray(oldTarget)) observer.unobserve(oldTarget);
|
||
if (newTarget && !Array.isArray(newTarget)) observer.observe(newTarget);
|
||
if (oldContentEl) observer.unobserve(oldContentEl);
|
||
if (newContentEl) observer.observe(newContentEl);
|
||
}, {
|
||
immediate: true
|
||
});
|
||
onScopeDispose(() => {
|
||
observer.disconnect();
|
||
});
|
||
function updateLocation() {
|
||
observe = false;
|
||
requestAnimationFrame(() => observe = true);
|
||
if (!data.target.value || !data.contentEl.value) return;
|
||
const targetBox = getTargetBox(data.target.value);
|
||
const contentBox = getIntrinsicSize(data.contentEl.value, data.isRtl.value);
|
||
const scrollParents = getScrollParents(data.contentEl.value);
|
||
const viewportMargin = 12;
|
||
if (!scrollParents.length) {
|
||
scrollParents.push((void 0).documentElement);
|
||
if (!(data.contentEl.value.style.top && data.contentEl.value.style.left)) {
|
||
contentBox.x -= parseFloat((void 0).documentElement.style.getPropertyValue("--v-body-scroll-x") || 0);
|
||
contentBox.y -= parseFloat((void 0).documentElement.style.getPropertyValue("--v-body-scroll-y") || 0);
|
||
}
|
||
}
|
||
const viewport = scrollParents.reduce((box, el) => {
|
||
const rect = el.getBoundingClientRect();
|
||
const scrollBox = new Box({
|
||
x: el === (void 0).documentElement ? 0 : rect.x,
|
||
y: el === (void 0).documentElement ? 0 : rect.y,
|
||
width: el.clientWidth,
|
||
height: el.clientHeight
|
||
});
|
||
if (box) {
|
||
return new Box({
|
||
x: Math.max(box.left, scrollBox.left),
|
||
y: Math.max(box.top, scrollBox.top),
|
||
width: Math.min(box.right, scrollBox.right) - Math.max(box.left, scrollBox.left),
|
||
height: Math.min(box.bottom, scrollBox.bottom) - Math.max(box.top, scrollBox.top)
|
||
});
|
||
}
|
||
return scrollBox;
|
||
}, void 0);
|
||
viewport.x += viewportMargin;
|
||
viewport.y += viewportMargin;
|
||
viewport.width -= viewportMargin * 2;
|
||
viewport.height -= viewportMargin * 2;
|
||
let placement = {
|
||
anchor: preferredAnchor.value,
|
||
origin: preferredOrigin.value
|
||
};
|
||
function checkOverflow(_placement) {
|
||
const box = new Box(contentBox);
|
||
const targetPoint = anchorToPoint(_placement.anchor, targetBox);
|
||
const contentPoint = anchorToPoint(_placement.origin, box);
|
||
let {
|
||
x: x2,
|
||
y: y2
|
||
} = getOffset(targetPoint, contentPoint);
|
||
switch (_placement.anchor.side) {
|
||
case "top":
|
||
y2 -= offset.value[0];
|
||
break;
|
||
case "bottom":
|
||
y2 += offset.value[0];
|
||
break;
|
||
case "left":
|
||
x2 -= offset.value[0];
|
||
break;
|
||
case "right":
|
||
x2 += offset.value[0];
|
||
break;
|
||
}
|
||
switch (_placement.anchor.align) {
|
||
case "top":
|
||
y2 -= offset.value[1];
|
||
break;
|
||
case "bottom":
|
||
y2 += offset.value[1];
|
||
break;
|
||
case "left":
|
||
x2 -= offset.value[1];
|
||
break;
|
||
case "right":
|
||
x2 += offset.value[1];
|
||
break;
|
||
}
|
||
box.x += x2;
|
||
box.y += y2;
|
||
box.width = Math.min(box.width, maxWidth.value);
|
||
box.height = Math.min(box.height, maxHeight.value);
|
||
const overflows = getOverflow(box, viewport);
|
||
return {
|
||
overflows,
|
||
x: x2,
|
||
y: y2
|
||
};
|
||
}
|
||
let x = 0;
|
||
let y = 0;
|
||
const available = {
|
||
x: 0,
|
||
y: 0
|
||
};
|
||
const flipped = {
|
||
x: false,
|
||
y: false
|
||
};
|
||
let resets = -1;
|
||
while (true) {
|
||
if (resets++ > 10) {
|
||
consoleError("Infinite loop detected in connectedLocationStrategy");
|
||
break;
|
||
}
|
||
const {
|
||
x: _x,
|
||
y: _y,
|
||
overflows
|
||
} = checkOverflow(placement);
|
||
x += _x;
|
||
y += _y;
|
||
contentBox.x += _x;
|
||
contentBox.y += _y;
|
||
{
|
||
const axis2 = getAxis(placement.anchor);
|
||
const hasOverflowX = overflows.x.before || overflows.x.after;
|
||
const hasOverflowY = overflows.y.before || overflows.y.after;
|
||
let reset = false;
|
||
["x", "y"].forEach((key) => {
|
||
if (key === "x" && hasOverflowX && !flipped.x || key === "y" && hasOverflowY && !flipped.y) {
|
||
const newPlacement = {
|
||
anchor: {
|
||
...placement.anchor
|
||
},
|
||
origin: {
|
||
...placement.origin
|
||
}
|
||
};
|
||
const flip = key === "x" ? axis2 === "y" ? flipAlign : flipSide : axis2 === "y" ? flipSide : flipAlign;
|
||
newPlacement.anchor = flip(newPlacement.anchor);
|
||
newPlacement.origin = flip(newPlacement.origin);
|
||
const {
|
||
overflows: newOverflows
|
||
} = checkOverflow(newPlacement);
|
||
if (newOverflows[key].before <= overflows[key].before && newOverflows[key].after <= overflows[key].after || newOverflows[key].before + newOverflows[key].after < (overflows[key].before + overflows[key].after) / 2) {
|
||
placement = newPlacement;
|
||
reset = flipped[key] = true;
|
||
}
|
||
}
|
||
});
|
||
if (reset) continue;
|
||
}
|
||
if (overflows.x.before) {
|
||
x += overflows.x.before;
|
||
contentBox.x += overflows.x.before;
|
||
}
|
||
if (overflows.x.after) {
|
||
x -= overflows.x.after;
|
||
contentBox.x -= overflows.x.after;
|
||
}
|
||
if (overflows.y.before) {
|
||
y += overflows.y.before;
|
||
contentBox.y += overflows.y.before;
|
||
}
|
||
if (overflows.y.after) {
|
||
y -= overflows.y.after;
|
||
contentBox.y -= overflows.y.after;
|
||
}
|
||
{
|
||
const overflows2 = getOverflow(contentBox, viewport);
|
||
available.x = viewport.width - overflows2.x.before - overflows2.x.after;
|
||
available.y = viewport.height - overflows2.y.before - overflows2.y.after;
|
||
x += overflows2.x.before;
|
||
contentBox.x += overflows2.x.before;
|
||
y += overflows2.y.before;
|
||
contentBox.y += overflows2.y.before;
|
||
}
|
||
break;
|
||
}
|
||
const axis = getAxis(placement.anchor);
|
||
Object.assign(contentStyles.value, {
|
||
"--v-overlay-anchor-origin": `${placement.anchor.side} ${placement.anchor.align}`,
|
||
transformOrigin: `${placement.origin.side} ${placement.origin.align}`,
|
||
// transform: `translate(${pixelRound(x)}px, ${pixelRound(y)}px)`,
|
||
top: convertToUnit(pixelRound(y)),
|
||
left: data.isRtl.value ? void 0 : convertToUnit(pixelRound(x)),
|
||
right: data.isRtl.value ? convertToUnit(pixelRound(-x)) : void 0,
|
||
minWidth: convertToUnit(axis === "y" ? Math.min(minWidth.value, targetBox.width) : minWidth.value),
|
||
maxWidth: convertToUnit(pixelCeil(clamp(available.x, minWidth.value === Infinity ? 0 : minWidth.value, maxWidth.value))),
|
||
maxHeight: convertToUnit(pixelCeil(clamp(available.y, minHeight.value === Infinity ? 0 : minHeight.value, maxHeight.value)))
|
||
});
|
||
return {
|
||
available,
|
||
contentBox
|
||
};
|
||
}
|
||
watch(() => [preferredAnchor.value, preferredOrigin.value, props.offset, props.minWidth, props.minHeight, props.maxWidth, props.maxHeight], () => updateLocation());
|
||
nextTick(() => {
|
||
const result = updateLocation();
|
||
if (!result) return;
|
||
const {
|
||
available,
|
||
contentBox
|
||
} = result;
|
||
if (contentBox.height > available.y) {
|
||
requestAnimationFrame(() => {
|
||
updateLocation();
|
||
requestAnimationFrame(() => {
|
||
updateLocation();
|
||
});
|
||
});
|
||
}
|
||
});
|
||
return {
|
||
updateLocation
|
||
};
|
||
}
|
||
function pixelRound(val) {
|
||
return Math.round(val * devicePixelRatio) / devicePixelRatio;
|
||
}
|
||
function pixelCeil(val) {
|
||
return Math.ceil(val * devicePixelRatio) / devicePixelRatio;
|
||
}
|
||
let clean = true;
|
||
const frames = [];
|
||
function requestNewFrame(cb) {
|
||
if (!clean || frames.length) {
|
||
frames.push(cb);
|
||
run();
|
||
} else {
|
||
clean = false;
|
||
cb();
|
||
run();
|
||
}
|
||
}
|
||
let raf = -1;
|
||
function run() {
|
||
cancelAnimationFrame(raf);
|
||
raf = requestAnimationFrame(() => {
|
||
const frame = frames.shift();
|
||
if (frame) frame();
|
||
if (frames.length) run();
|
||
else clean = true;
|
||
});
|
||
}
|
||
const scrollStrategies = {
|
||
none: null,
|
||
close: closeScrollStrategy,
|
||
block: blockScrollStrategy,
|
||
reposition: repositionScrollStrategy
|
||
};
|
||
const makeScrollStrategyProps = propsFactory({
|
||
scrollStrategy: {
|
||
type: [String, Function],
|
||
default: "block",
|
||
validator: (val) => typeof val === "function" || val in scrollStrategies
|
||
}
|
||
}, "VOverlay-scroll-strategies");
|
||
function closeScrollStrategy(data) {
|
||
function onScroll(e) {
|
||
data.isActive.value = false;
|
||
}
|
||
bindScroll(data.targetEl.value ?? data.contentEl.value, onScroll);
|
||
}
|
||
function blockScrollStrategy(data, props) {
|
||
var _a;
|
||
const offsetParent = (_a = data.root.value) == null ? void 0 : _a.offsetParent;
|
||
const scrollElements = [.../* @__PURE__ */ new Set([...getScrollParents(data.targetEl.value, props.contained ? offsetParent : void 0), ...getScrollParents(data.contentEl.value, props.contained ? offsetParent : void 0)])].filter((el) => !el.classList.contains("v-overlay-scroll-blocked"));
|
||
const scrollbarWidth = (void 0).innerWidth - (void 0).documentElement.offsetWidth;
|
||
const scrollableParent = ((el) => hasScrollbar(el) && el)(offsetParent || (void 0).documentElement);
|
||
if (scrollableParent) {
|
||
data.root.value.classList.add("v-overlay--scroll-blocked");
|
||
}
|
||
scrollElements.forEach((el, i) => {
|
||
el.style.setProperty("--v-body-scroll-x", convertToUnit(-el.scrollLeft));
|
||
el.style.setProperty("--v-body-scroll-y", convertToUnit(-el.scrollTop));
|
||
if (el !== (void 0).documentElement) {
|
||
el.style.setProperty("--v-scrollbar-offset", convertToUnit(scrollbarWidth));
|
||
}
|
||
el.classList.add("v-overlay-scroll-blocked");
|
||
});
|
||
onScopeDispose(() => {
|
||
scrollElements.forEach((el, i) => {
|
||
const x = parseFloat(el.style.getPropertyValue("--v-body-scroll-x"));
|
||
const y = parseFloat(el.style.getPropertyValue("--v-body-scroll-y"));
|
||
const scrollBehavior = el.style.scrollBehavior;
|
||
el.style.scrollBehavior = "auto";
|
||
el.style.removeProperty("--v-body-scroll-x");
|
||
el.style.removeProperty("--v-body-scroll-y");
|
||
el.style.removeProperty("--v-scrollbar-offset");
|
||
el.classList.remove("v-overlay-scroll-blocked");
|
||
el.scrollLeft = -x;
|
||
el.scrollTop = -y;
|
||
el.style.scrollBehavior = scrollBehavior;
|
||
});
|
||
if (scrollableParent) {
|
||
data.root.value.classList.remove("v-overlay--scroll-blocked");
|
||
}
|
||
});
|
||
}
|
||
function repositionScrollStrategy(data, props, scope) {
|
||
let slow = false;
|
||
let raf2 = -1;
|
||
let ric = -1;
|
||
function update(e) {
|
||
requestNewFrame(() => {
|
||
var _a, _b;
|
||
const start = performance.now();
|
||
(_b = (_a = data.updateLocation).value) == null ? void 0 : _b.call(_a, e);
|
||
const time = performance.now() - start;
|
||
slow = time / (1e3 / 60) > 2;
|
||
});
|
||
}
|
||
ric = (typeof requestIdleCallback === "undefined" ? (cb) => cb() : requestIdleCallback)(() => {
|
||
scope.run(() => {
|
||
bindScroll(data.targetEl.value ?? data.contentEl.value, (e) => {
|
||
if (slow) {
|
||
cancelAnimationFrame(raf2);
|
||
raf2 = requestAnimationFrame(() => {
|
||
raf2 = requestAnimationFrame(() => {
|
||
update(e);
|
||
});
|
||
});
|
||
} else {
|
||
update(e);
|
||
}
|
||
});
|
||
});
|
||
});
|
||
onScopeDispose(() => {
|
||
typeof cancelIdleCallback !== "undefined" && cancelIdleCallback(ric);
|
||
cancelAnimationFrame(raf2);
|
||
});
|
||
}
|
||
function bindScroll(el, onScroll) {
|
||
const scrollElements = [void 0, ...getScrollParents(el)];
|
||
scrollElements.forEach((el2) => {
|
||
el2.addEventListener("scroll", onScroll, {
|
||
passive: true
|
||
});
|
||
});
|
||
onScopeDispose(() => {
|
||
scrollElements.forEach((el2) => {
|
||
el2.removeEventListener("scroll", onScroll);
|
||
});
|
||
});
|
||
}
|
||
const VMenuSymbol = Symbol.for("vuetify:v-menu");
|
||
const makeDelayProps = propsFactory({
|
||
closeDelay: [Number, String],
|
||
openDelay: [Number, String]
|
||
}, "delay");
|
||
function useDelay(props, cb) {
|
||
let clearDelay = () => {
|
||
};
|
||
function runDelay(isOpening) {
|
||
clearDelay == null ? void 0 : clearDelay();
|
||
const delay = Number(isOpening ? props.openDelay : props.closeDelay);
|
||
return new Promise((resolve) => {
|
||
clearDelay = defer(delay, () => {
|
||
cb == null ? void 0 : cb(isOpening);
|
||
resolve(isOpening);
|
||
});
|
||
});
|
||
}
|
||
function runOpenDelay() {
|
||
return runDelay(true);
|
||
}
|
||
function runCloseDelay() {
|
||
return runDelay(false);
|
||
}
|
||
return {
|
||
clearDelay,
|
||
runOpenDelay,
|
||
runCloseDelay
|
||
};
|
||
}
|
||
const makeActivatorProps = propsFactory({
|
||
target: [String, Object],
|
||
activator: [String, Object],
|
||
activatorProps: {
|
||
type: Object,
|
||
default: () => ({})
|
||
},
|
||
openOnClick: {
|
||
type: Boolean,
|
||
default: void 0
|
||
},
|
||
openOnHover: Boolean,
|
||
openOnFocus: {
|
||
type: Boolean,
|
||
default: void 0
|
||
},
|
||
closeOnContentClick: Boolean,
|
||
...makeDelayProps()
|
||
}, "VOverlay-activator");
|
||
function useActivator(props, _ref) {
|
||
let {
|
||
isActive,
|
||
isTop,
|
||
contentEl
|
||
} = _ref;
|
||
const vm = getCurrentInstance("useActivator");
|
||
const activatorEl = ref();
|
||
let isHovered = false;
|
||
let isFocused = false;
|
||
let firstEnter = true;
|
||
const openOnFocus = computed(() => props.openOnFocus || props.openOnFocus == null && props.openOnHover);
|
||
const openOnClick = computed(() => props.openOnClick || props.openOnClick == null && !props.openOnHover && !openOnFocus.value);
|
||
const {
|
||
runOpenDelay,
|
||
runCloseDelay
|
||
} = useDelay(props, (value) => {
|
||
if (value === (props.openOnHover && isHovered || openOnFocus.value && isFocused) && !(props.openOnHover && isActive.value && !isTop.value)) {
|
||
if (isActive.value !== value) {
|
||
firstEnter = true;
|
||
}
|
||
isActive.value = value;
|
||
}
|
||
});
|
||
const cursorTarget = ref();
|
||
const availableEvents = {
|
||
onClick: (e) => {
|
||
e.stopPropagation();
|
||
activatorEl.value = e.currentTarget || e.target;
|
||
if (!isActive.value) {
|
||
cursorTarget.value = [e.clientX, e.clientY];
|
||
}
|
||
isActive.value = !isActive.value;
|
||
},
|
||
onMouseenter: (e) => {
|
||
var _a;
|
||
if ((_a = e.sourceCapabilities) == null ? void 0 : _a.firesTouchEvents) return;
|
||
isHovered = true;
|
||
activatorEl.value = e.currentTarget || e.target;
|
||
runOpenDelay();
|
||
},
|
||
onMouseleave: (e) => {
|
||
isHovered = false;
|
||
runCloseDelay();
|
||
},
|
||
onFocus: (e) => {
|
||
if (matchesSelector(e.target) === false) ;
|
||
isFocused = true;
|
||
e.stopPropagation();
|
||
activatorEl.value = e.currentTarget || e.target;
|
||
runOpenDelay();
|
||
},
|
||
onBlur: (e) => {
|
||
isFocused = false;
|
||
e.stopPropagation();
|
||
runCloseDelay();
|
||
}
|
||
};
|
||
const activatorEvents = computed(() => {
|
||
const events = {};
|
||
if (openOnClick.value) {
|
||
events.onClick = availableEvents.onClick;
|
||
}
|
||
if (props.openOnHover) {
|
||
events.onMouseenter = availableEvents.onMouseenter;
|
||
events.onMouseleave = availableEvents.onMouseleave;
|
||
}
|
||
if (openOnFocus.value) {
|
||
events.onFocus = availableEvents.onFocus;
|
||
events.onBlur = availableEvents.onBlur;
|
||
}
|
||
return events;
|
||
});
|
||
const contentEvents = computed(() => {
|
||
const events = {};
|
||
if (props.openOnHover) {
|
||
events.onMouseenter = () => {
|
||
isHovered = true;
|
||
runOpenDelay();
|
||
};
|
||
events.onMouseleave = () => {
|
||
isHovered = false;
|
||
runCloseDelay();
|
||
};
|
||
}
|
||
if (openOnFocus.value) {
|
||
events.onFocusin = () => {
|
||
isFocused = true;
|
||
runOpenDelay();
|
||
};
|
||
events.onFocusout = () => {
|
||
isFocused = false;
|
||
runCloseDelay();
|
||
};
|
||
}
|
||
if (props.closeOnContentClick) {
|
||
const menu = inject$1(VMenuSymbol, null);
|
||
events.onClick = () => {
|
||
isActive.value = false;
|
||
menu == null ? void 0 : menu.closeParents();
|
||
};
|
||
}
|
||
return events;
|
||
});
|
||
const scrimEvents = computed(() => {
|
||
const events = {};
|
||
if (props.openOnHover) {
|
||
events.onMouseenter = () => {
|
||
if (firstEnter) {
|
||
isHovered = true;
|
||
firstEnter = false;
|
||
runOpenDelay();
|
||
}
|
||
};
|
||
events.onMouseleave = () => {
|
||
isHovered = false;
|
||
runCloseDelay();
|
||
};
|
||
}
|
||
return events;
|
||
});
|
||
watch(isTop, (val) => {
|
||
var _a;
|
||
if (val && (props.openOnHover && !isHovered && (!openOnFocus.value || !isFocused) || openOnFocus.value && !isFocused && (!props.openOnHover || !isHovered)) && !((_a = contentEl.value) == null ? void 0 : _a.contains((void 0).activeElement))) {
|
||
isActive.value = false;
|
||
}
|
||
});
|
||
watch(isActive, (val) => {
|
||
if (!val) {
|
||
setTimeout(() => {
|
||
cursorTarget.value = void 0;
|
||
});
|
||
}
|
||
}, {
|
||
flush: "post"
|
||
});
|
||
const activatorRef = templateRef();
|
||
watchEffect(() => {
|
||
if (!activatorRef.value) return;
|
||
nextTick(() => {
|
||
activatorEl.value = activatorRef.el;
|
||
});
|
||
});
|
||
const targetRef = templateRef();
|
||
const target = computed(() => {
|
||
if (props.target === "cursor" && cursorTarget.value) return cursorTarget.value;
|
||
if (targetRef.value) return targetRef.el;
|
||
return getTarget(props.target, vm) || activatorEl.value;
|
||
});
|
||
const targetEl = computed(() => {
|
||
return Array.isArray(target.value) ? void 0 : target.value;
|
||
});
|
||
watch(() => !!props.activator, (val) => {
|
||
}, {
|
||
flush: "post",
|
||
immediate: true
|
||
});
|
||
onScopeDispose(() => {
|
||
});
|
||
return {
|
||
activatorEl,
|
||
activatorRef,
|
||
target,
|
||
targetEl,
|
||
targetRef,
|
||
activatorEvents,
|
||
contentEvents,
|
||
scrimEvents
|
||
};
|
||
}
|
||
function getTarget(selector, vm) {
|
||
var _a, _b;
|
||
if (!selector) return;
|
||
let target;
|
||
if (selector === "parent") {
|
||
let el = (_b = (_a = vm == null ? void 0 : vm.proxy) == null ? void 0 : _a.$el) == null ? void 0 : _b.parentNode;
|
||
while (el == null ? void 0 : el.hasAttribute("data-no-activator")) {
|
||
el = el.parentNode;
|
||
}
|
||
target = el;
|
||
} else if (typeof selector === "string") {
|
||
target = (void 0).querySelector(selector);
|
||
} else if ("$el" in selector) {
|
||
target = selector.$el;
|
||
} else {
|
||
target = selector;
|
||
}
|
||
return target;
|
||
}
|
||
function useHydration() {
|
||
return shallowRef(false);
|
||
}
|
||
const makeLazyProps = propsFactory({
|
||
eager: Boolean
|
||
}, "lazy");
|
||
function useLazy(props, active) {
|
||
const isBooted = shallowRef(false);
|
||
const hasContent = computed(() => isBooted.value || props.eager || active.value);
|
||
watch(active, () => isBooted.value = true);
|
||
function onAfterLeave() {
|
||
if (!props.eager) isBooted.value = false;
|
||
}
|
||
return {
|
||
isBooted,
|
||
hasContent,
|
||
onAfterLeave
|
||
};
|
||
}
|
||
function useScopeId() {
|
||
const vm = getCurrentInstance("useScopeId");
|
||
const scopeId = vm.vnode.scopeId;
|
||
return {
|
||
scopeId: scopeId ? {
|
||
[scopeId]: ""
|
||
} : void 0
|
||
};
|
||
}
|
||
const StackSymbol = Symbol.for("vuetify:stack");
|
||
const globalStack = reactive([]);
|
||
function useStack(isActive, zIndex, disableGlobalStack) {
|
||
const vm = getCurrentInstance("useStack");
|
||
const createStackEntry = !disableGlobalStack;
|
||
const parent = inject$1(StackSymbol, void 0);
|
||
const stack = reactive({
|
||
activeChildren: /* @__PURE__ */ new Set()
|
||
});
|
||
provide(StackSymbol, stack);
|
||
const _zIndex = shallowRef(+zIndex.value);
|
||
useToggleScope(isActive, () => {
|
||
var _a;
|
||
const lastZIndex = (_a = globalStack.at(-1)) == null ? void 0 : _a[1];
|
||
_zIndex.value = lastZIndex ? lastZIndex + 10 : +zIndex.value;
|
||
if (createStackEntry) {
|
||
globalStack.push([vm.uid, _zIndex.value]);
|
||
}
|
||
parent == null ? void 0 : parent.activeChildren.add(vm.uid);
|
||
onScopeDispose(() => {
|
||
if (createStackEntry) {
|
||
const idx = toRaw(globalStack).findIndex((v) => v[0] === vm.uid);
|
||
globalStack.splice(idx, 1);
|
||
}
|
||
parent == null ? void 0 : parent.activeChildren.delete(vm.uid);
|
||
});
|
||
});
|
||
const globalTop = shallowRef(true);
|
||
if (createStackEntry) {
|
||
watchEffect(() => {
|
||
var _a;
|
||
const _isTop = ((_a = globalStack.at(-1)) == null ? void 0 : _a[0]) === vm.uid;
|
||
setTimeout(() => globalTop.value = _isTop);
|
||
});
|
||
}
|
||
const localTop = computed(() => !stack.activeChildren.size);
|
||
return {
|
||
globalTop: readonly(globalTop),
|
||
localTop,
|
||
stackStyles: computed(() => ({
|
||
zIndex: _zIndex.value
|
||
}))
|
||
};
|
||
}
|
||
function useTeleport(target) {
|
||
const teleportTarget = computed(() => {
|
||
target();
|
||
return void 0;
|
||
});
|
||
return {
|
||
teleportTarget
|
||
};
|
||
}
|
||
function defaultConditional() {
|
||
return true;
|
||
}
|
||
function checkEvent(e, el, binding) {
|
||
if (!e || checkIsActive(e, binding) === false) return false;
|
||
const root = attachedRoot(el);
|
||
if (typeof ShadowRoot !== "undefined" && root instanceof ShadowRoot && root.host === e.target) return false;
|
||
const elements = (typeof binding.value === "object" && binding.value.include || (() => []))();
|
||
elements.push(el);
|
||
return !elements.some((el2) => el2 == null ? void 0 : el2.contains(e.target));
|
||
}
|
||
function checkIsActive(e, binding) {
|
||
const isActive = typeof binding.value === "object" && binding.value.closeConditional || defaultConditional;
|
||
return isActive(e);
|
||
}
|
||
function directive(e, el, binding) {
|
||
const handler = typeof binding.value === "function" ? binding.value : binding.value.handler;
|
||
e.shadowTarget = e.target;
|
||
el._clickOutside.lastMousedownWasOutside && checkEvent(e, el, binding) && setTimeout(() => {
|
||
checkIsActive(e, binding) && handler && handler(e);
|
||
}, 0);
|
||
}
|
||
function handleShadow(el, callback) {
|
||
const root = attachedRoot(el);
|
||
callback(void 0);
|
||
if (typeof ShadowRoot !== "undefined" && root instanceof ShadowRoot) {
|
||
callback(root);
|
||
}
|
||
}
|
||
const ClickOutside = {
|
||
// [data-app] may not be found
|
||
// if using bind, inserted makes
|
||
// sure that the root element is
|
||
// available, iOS does not support
|
||
// clicks on body
|
||
mounted(el, binding) {
|
||
const onClick = (e) => directive(e, el, binding);
|
||
const onMousedown = (e) => {
|
||
el._clickOutside.lastMousedownWasOutside = checkEvent(e, el, binding);
|
||
};
|
||
handleShadow(el, (app) => {
|
||
app.addEventListener("click", onClick, true);
|
||
app.addEventListener("mousedown", onMousedown, true);
|
||
});
|
||
if (!el._clickOutside) {
|
||
el._clickOutside = {
|
||
lastMousedownWasOutside: false
|
||
};
|
||
}
|
||
el._clickOutside[binding.instance.$.uid] = {
|
||
onClick,
|
||
onMousedown
|
||
};
|
||
},
|
||
beforeUnmount(el, binding) {
|
||
if (!el._clickOutside) return;
|
||
handleShadow(el, (app) => {
|
||
var _a;
|
||
if (!app || !((_a = el._clickOutside) == null ? void 0 : _a[binding.instance.$.uid])) return;
|
||
const {
|
||
onClick,
|
||
onMousedown
|
||
} = el._clickOutside[binding.instance.$.uid];
|
||
app.removeEventListener("click", onClick, true);
|
||
app.removeEventListener("mousedown", onMousedown, true);
|
||
});
|
||
delete el._clickOutside[binding.instance.$.uid];
|
||
}
|
||
};
|
||
function Scrim(props) {
|
||
const {
|
||
modelValue,
|
||
color,
|
||
...rest
|
||
} = props;
|
||
return createVNode(Transition, {
|
||
"name": "fade-transition",
|
||
"appear": true
|
||
}, {
|
||
default: () => [props.modelValue && createVNode("div", mergeProps({
|
||
"class": ["v-overlay__scrim", props.color.backgroundColorClasses.value],
|
||
"style": props.color.backgroundColorStyles.value
|
||
}, rest), null)]
|
||
});
|
||
}
|
||
const makeVOverlayProps = propsFactory({
|
||
absolute: Boolean,
|
||
attach: [Boolean, String, Object],
|
||
closeOnBack: {
|
||
type: Boolean,
|
||
default: true
|
||
},
|
||
contained: Boolean,
|
||
contentClass: null,
|
||
contentProps: null,
|
||
disabled: Boolean,
|
||
opacity: [Number, String],
|
||
noClickAnimation: Boolean,
|
||
modelValue: Boolean,
|
||
persistent: Boolean,
|
||
scrim: {
|
||
type: [Boolean, String],
|
||
default: true
|
||
},
|
||
zIndex: {
|
||
type: [Number, String],
|
||
default: 2e3
|
||
},
|
||
...makeActivatorProps(),
|
||
...makeComponentProps(),
|
||
...makeDimensionProps(),
|
||
...makeLazyProps(),
|
||
...makeLocationStrategyProps(),
|
||
...makeScrollStrategyProps(),
|
||
...makeThemeProps(),
|
||
...makeTransitionProps()
|
||
}, "VOverlay");
|
||
const VOverlay = genericComponent()({
|
||
name: "VOverlay",
|
||
directives: {
|
||
ClickOutside
|
||
},
|
||
inheritAttrs: false,
|
||
props: {
|
||
_disableGlobalStack: Boolean,
|
||
...makeVOverlayProps()
|
||
},
|
||
emits: {
|
||
"click:outside": (e) => true,
|
||
"update:modelValue": (value) => true,
|
||
afterEnter: () => true,
|
||
afterLeave: () => true
|
||
},
|
||
setup(props, _ref) {
|
||
let {
|
||
slots,
|
||
attrs,
|
||
emit
|
||
} = _ref;
|
||
const vm = getCurrentInstance("VOverlay");
|
||
const root = ref();
|
||
const scrimEl = ref();
|
||
const contentEl = ref();
|
||
const model = useProxiedModel(props, "modelValue");
|
||
const isActive = computed({
|
||
get: () => model.value,
|
||
set: (v) => {
|
||
if (!(v && props.disabled)) model.value = v;
|
||
}
|
||
});
|
||
const {
|
||
themeClasses
|
||
} = provideTheme(props);
|
||
const {
|
||
rtlClasses
|
||
} = useRtl();
|
||
const {
|
||
hasContent,
|
||
onAfterLeave: _onAfterLeave
|
||
} = useLazy(props, isActive);
|
||
const scrimColor = useBackgroundColor(computed(() => {
|
||
return typeof props.scrim === "string" ? props.scrim : null;
|
||
}));
|
||
const {
|
||
globalTop,
|
||
localTop,
|
||
stackStyles
|
||
} = useStack(isActive, toRef(props, "zIndex"), props._disableGlobalStack);
|
||
const {
|
||
activatorEl,
|
||
activatorRef,
|
||
target,
|
||
targetRef,
|
||
activatorEvents,
|
||
contentEvents,
|
||
scrimEvents
|
||
} = useActivator(props, {
|
||
isActive,
|
||
isTop: localTop,
|
||
contentEl
|
||
});
|
||
const {
|
||
teleportTarget
|
||
} = useTeleport(() => {
|
||
var _a, _b, _c;
|
||
const target2 = props.attach || props.contained;
|
||
if (target2) return target2;
|
||
const rootNode = ((_a = activatorEl == null ? void 0 : activatorEl.value) == null ? void 0 : _a.getRootNode()) || ((_c = (_b = vm.proxy) == null ? void 0 : _b.$el) == null ? void 0 : _c.getRootNode());
|
||
if (rootNode instanceof ShadowRoot) return rootNode;
|
||
return false;
|
||
});
|
||
const {
|
||
dimensionStyles
|
||
} = useDimension(props);
|
||
const isMounted = useHydration();
|
||
const {
|
||
scopeId
|
||
} = useScopeId();
|
||
watch(() => props.disabled, (v) => {
|
||
if (v) isActive.value = false;
|
||
});
|
||
const {
|
||
contentStyles,
|
||
updateLocation
|
||
} = useLocationStrategies();
|
||
function onClickOutside(e) {
|
||
emit("click:outside", e);
|
||
if (!props.persistent) isActive.value = false;
|
||
else animateClick();
|
||
}
|
||
function closeConditional(e) {
|
||
return isActive.value && globalTop.value && // If using scrim, only close if clicking on it rather than anything opened on top
|
||
(!props.scrim || e.target === scrimEl.value || e instanceof MouseEvent && e.shadowTarget === scrimEl.value);
|
||
}
|
||
useRouter();
|
||
useToggleScope(() => props.closeOnBack, () => {
|
||
});
|
||
const top = ref();
|
||
watch(() => isActive.value && (props.absolute || props.contained) && teleportTarget.value == null, (val) => {
|
||
if (val) {
|
||
const scrollParent = getScrollParent(root.value);
|
||
if (scrollParent && scrollParent !== (void 0).scrollingElement) {
|
||
top.value = scrollParent.scrollTop;
|
||
}
|
||
}
|
||
});
|
||
function animateClick() {
|
||
if (props.noClickAnimation) return;
|
||
contentEl.value && animate(contentEl.value, [{
|
||
transformOrigin: "center"
|
||
}, {
|
||
transform: "scale(1.03)"
|
||
}, {
|
||
transformOrigin: "center"
|
||
}], {
|
||
duration: 150,
|
||
easing: standardEasing
|
||
});
|
||
}
|
||
function onAfterEnter() {
|
||
emit("afterEnter");
|
||
}
|
||
function onAfterLeave() {
|
||
_onAfterLeave();
|
||
emit("afterLeave");
|
||
}
|
||
useRender(() => {
|
||
var _a;
|
||
return createVNode(Fragment, null, [(_a = slots.activator) == null ? void 0 : _a.call(slots, {
|
||
isActive: isActive.value,
|
||
targetRef,
|
||
props: mergeProps({
|
||
ref: activatorRef
|
||
}, activatorEvents.value, props.activatorProps)
|
||
}), isMounted.value && hasContent.value && createVNode(Teleport, {
|
||
"disabled": !teleportTarget.value,
|
||
"to": teleportTarget.value
|
||
}, {
|
||
default: () => [createVNode("div", mergeProps({
|
||
"class": ["v-overlay", {
|
||
"v-overlay--absolute": props.absolute || props.contained,
|
||
"v-overlay--active": isActive.value,
|
||
"v-overlay--contained": props.contained
|
||
}, themeClasses.value, rtlClasses.value, props.class],
|
||
"style": [stackStyles.value, {
|
||
"--v-overlay-opacity": props.opacity,
|
||
top: convertToUnit(top.value)
|
||
}, props.style],
|
||
"ref": root
|
||
}, scopeId, attrs), [createVNode(Scrim, mergeProps({
|
||
"color": scrimColor,
|
||
"modelValue": isActive.value && !!props.scrim,
|
||
"ref": scrimEl
|
||
}, scrimEvents.value), null), createVNode(MaybeTransition, {
|
||
"appear": true,
|
||
"persisted": true,
|
||
"transition": props.transition,
|
||
"target": target.value,
|
||
"onAfterEnter": onAfterEnter,
|
||
"onAfterLeave": onAfterLeave
|
||
}, {
|
||
default: () => {
|
||
var _a2;
|
||
return [withDirectives(createVNode("div", mergeProps({
|
||
"ref": contentEl,
|
||
"class": ["v-overlay__content", props.contentClass],
|
||
"style": [dimensionStyles.value, contentStyles.value]
|
||
}, contentEvents.value, props.contentProps), [(_a2 = slots.default) == null ? void 0 : _a2.call(slots, {
|
||
isActive
|
||
})]), [[vShow, isActive.value], [resolveDirective("click-outside"), {
|
||
handler: onClickOutside,
|
||
closeConditional,
|
||
include: () => [activatorEl.value]
|
||
}]])];
|
||
}
|
||
})])]
|
||
})]);
|
||
});
|
||
return {
|
||
activatorEl,
|
||
scrimEl,
|
||
target,
|
||
animateClick,
|
||
contentEl,
|
||
globalTop,
|
||
localTop,
|
||
updateLocation
|
||
};
|
||
}
|
||
});
|
||
const Refs = Symbol("Forwarded refs");
|
||
function getDescriptor(obj, key) {
|
||
let currentObj = obj;
|
||
while (currentObj) {
|
||
const descriptor = Reflect.getOwnPropertyDescriptor(currentObj, key);
|
||
if (descriptor) return descriptor;
|
||
currentObj = Object.getPrototypeOf(currentObj);
|
||
}
|
||
return void 0;
|
||
}
|
||
function forwardRefs(target) {
|
||
for (var _len = arguments.length, refs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
||
refs[_key - 1] = arguments[_key];
|
||
}
|
||
target[Refs] = refs;
|
||
return new Proxy(target, {
|
||
get(target2, key) {
|
||
if (Reflect.has(target2, key)) {
|
||
return Reflect.get(target2, key);
|
||
}
|
||
if (typeof key === "symbol" || key.startsWith("$") || key.startsWith("__")) return;
|
||
for (const ref2 of refs) {
|
||
if (ref2.value && Reflect.has(ref2.value, key)) {
|
||
const val = Reflect.get(ref2.value, key);
|
||
return typeof val === "function" ? val.bind(ref2.value) : val;
|
||
}
|
||
}
|
||
},
|
||
has(target2, key) {
|
||
if (Reflect.has(target2, key)) {
|
||
return true;
|
||
}
|
||
if (typeof key === "symbol" || key.startsWith("$") || key.startsWith("__")) return false;
|
||
for (const ref2 of refs) {
|
||
if (ref2.value && Reflect.has(ref2.value, key)) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
},
|
||
set(target2, key, value) {
|
||
if (Reflect.has(target2, key)) {
|
||
return Reflect.set(target2, key, value);
|
||
}
|
||
if (typeof key === "symbol" || key.startsWith("$") || key.startsWith("__")) return false;
|
||
for (const ref2 of refs) {
|
||
if (ref2.value && Reflect.has(ref2.value, key)) {
|
||
return Reflect.set(ref2.value, key, value);
|
||
}
|
||
}
|
||
return false;
|
||
},
|
||
getOwnPropertyDescriptor(target2, key) {
|
||
var _a;
|
||
const descriptor = Reflect.getOwnPropertyDescriptor(target2, key);
|
||
if (descriptor) return descriptor;
|
||
if (typeof key === "symbol" || key.startsWith("$") || key.startsWith("__")) return;
|
||
for (const ref2 of refs) {
|
||
if (!ref2.value) continue;
|
||
const descriptor2 = getDescriptor(ref2.value, key) ?? ("_" in ref2.value ? getDescriptor((_a = ref2.value._) == null ? void 0 : _a.setupState, key) : void 0);
|
||
if (descriptor2) return descriptor2;
|
||
}
|
||
for (const ref2 of refs) {
|
||
const childRefs = ref2.value && ref2.value[Refs];
|
||
if (!childRefs) continue;
|
||
const queue = childRefs.slice();
|
||
while (queue.length) {
|
||
const ref3 = queue.shift();
|
||
const descriptor2 = getDescriptor(ref3.value, key);
|
||
if (descriptor2) return descriptor2;
|
||
const childRefs2 = ref3.value && ref3.value[Refs];
|
||
if (childRefs2) queue.push(...childRefs2);
|
||
}
|
||
}
|
||
return void 0;
|
||
}
|
||
});
|
||
}
|
||
const makeVMenuProps = propsFactory({
|
||
// TODO
|
||
// disableKeys: Boolean,
|
||
id: String,
|
||
submenu: Boolean,
|
||
...omit(makeVOverlayProps({
|
||
closeDelay: 250,
|
||
closeOnContentClick: true,
|
||
locationStrategy: "connected",
|
||
location: void 0,
|
||
openDelay: 300,
|
||
scrim: false,
|
||
scrollStrategy: "reposition",
|
||
transition: {
|
||
component: VDialogTransition
|
||
}
|
||
}), ["absolute"])
|
||
}, "VMenu");
|
||
const VMenu = genericComponent()({
|
||
name: "VMenu",
|
||
props: makeVMenuProps(),
|
||
emits: {
|
||
"update:modelValue": (value) => true
|
||
},
|
||
setup(props, _ref) {
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
const isActive = useProxiedModel(props, "modelValue");
|
||
const {
|
||
scopeId
|
||
} = useScopeId();
|
||
const {
|
||
isRtl
|
||
} = useRtl();
|
||
const uid = getUid();
|
||
const id = computed(() => props.id || `v-menu-${uid}`);
|
||
const overlay = ref();
|
||
const parent = inject$1(VMenuSymbol, null);
|
||
const openChildren = shallowRef(/* @__PURE__ */ new Set());
|
||
provide(VMenuSymbol, {
|
||
register() {
|
||
openChildren.value.add(uid);
|
||
},
|
||
unregister() {
|
||
openChildren.value.delete(uid);
|
||
},
|
||
closeParents(e) {
|
||
setTimeout(() => {
|
||
var _a;
|
||
if (!openChildren.value.size && !props.persistent && (e == null || ((_a = overlay.value) == null ? void 0 : _a.contentEl) && !isClickInsideElement(e, overlay.value.contentEl))) {
|
||
isActive.value = false;
|
||
parent == null ? void 0 : parent.closeParents();
|
||
}
|
||
}, 40);
|
||
}
|
||
});
|
||
watch(isActive, (val) => {
|
||
if (val) {
|
||
parent == null ? void 0 : parent.register();
|
||
} else {
|
||
parent == null ? void 0 : parent.unregister();
|
||
}
|
||
}, {
|
||
immediate: true
|
||
});
|
||
function onClickOutside(e) {
|
||
parent == null ? void 0 : parent.closeParents(e);
|
||
}
|
||
function onKeydown(e) {
|
||
var _a, _b, _c, _d, _e;
|
||
if (props.disabled) return;
|
||
if (e.key === "Tab" || e.key === "Enter" && !props.closeOnContentClick) {
|
||
if (e.key === "Enter" && (e.target instanceof HTMLTextAreaElement || e.target instanceof HTMLInputElement && !!e.target.closest("form"))) return;
|
||
if (e.key === "Enter") e.preventDefault();
|
||
const nextElement = getNextElement(focusableChildren((_a = overlay.value) == null ? void 0 : _a.contentEl, false), e.shiftKey ? "prev" : "next", (el) => el.tabIndex >= 0);
|
||
if (!nextElement) {
|
||
isActive.value = false;
|
||
(_c = (_b = overlay.value) == null ? void 0 : _b.activatorEl) == null ? void 0 : _c.focus();
|
||
}
|
||
} else if (props.submenu && e.key === (isRtl.value ? "ArrowRight" : "ArrowLeft")) {
|
||
isActive.value = false;
|
||
(_e = (_d = overlay.value) == null ? void 0 : _d.activatorEl) == null ? void 0 : _e.focus();
|
||
}
|
||
}
|
||
function onActivatorKeydown(e) {
|
||
var _a;
|
||
if (props.disabled) return;
|
||
const el = (_a = overlay.value) == null ? void 0 : _a.contentEl;
|
||
if (el && isActive.value) {
|
||
if (e.key === "ArrowDown") {
|
||
e.preventDefault();
|
||
e.stopImmediatePropagation();
|
||
focusChild(el, "next");
|
||
} else if (e.key === "ArrowUp") {
|
||
e.preventDefault();
|
||
e.stopImmediatePropagation();
|
||
focusChild(el, "prev");
|
||
} else if (props.submenu) {
|
||
if (e.key === (isRtl.value ? "ArrowRight" : "ArrowLeft")) {
|
||
isActive.value = false;
|
||
} else if (e.key === (isRtl.value ? "ArrowLeft" : "ArrowRight")) {
|
||
e.preventDefault();
|
||
focusChild(el, "first");
|
||
}
|
||
}
|
||
} else if (props.submenu ? e.key === (isRtl.value ? "ArrowLeft" : "ArrowRight") : ["ArrowDown", "ArrowUp"].includes(e.key)) {
|
||
isActive.value = true;
|
||
e.preventDefault();
|
||
setTimeout(() => setTimeout(() => onActivatorKeydown(e)));
|
||
}
|
||
}
|
||
const activatorProps = computed(() => mergeProps({
|
||
"aria-haspopup": "menu",
|
||
"aria-expanded": String(isActive.value),
|
||
"aria-owns": id.value,
|
||
onKeydown: onActivatorKeydown
|
||
}, props.activatorProps));
|
||
useRender(() => {
|
||
const overlayProps = VOverlay.filterProps(props);
|
||
return createVNode(VOverlay, mergeProps({
|
||
"ref": overlay,
|
||
"id": id.value,
|
||
"class": ["v-menu", props.class],
|
||
"style": props.style
|
||
}, overlayProps, {
|
||
"modelValue": isActive.value,
|
||
"onUpdate:modelValue": ($event) => isActive.value = $event,
|
||
"absolute": true,
|
||
"activatorProps": activatorProps.value,
|
||
"location": props.location ?? (props.submenu ? "end" : "bottom"),
|
||
"onClick:outside": onClickOutside,
|
||
"onKeydown": onKeydown
|
||
}, scopeId), {
|
||
activator: slots.activator,
|
||
default: function() {
|
||
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
||
args[_key] = arguments[_key];
|
||
}
|
||
return createVNode(VDefaultsProvider, {
|
||
"root": "VMenu"
|
||
}, {
|
||
default: () => {
|
||
var _a;
|
||
return [(_a = slots.default) == null ? void 0 : _a.call(slots, ...args)];
|
||
}
|
||
});
|
||
}
|
||
});
|
||
});
|
||
return forwardRefs({
|
||
id,
|
||
ΨopenChildren: openChildren
|
||
}, overlay);
|
||
}
|
||
});
|
||
const _sfc_main$4 = {};
|
||
function _sfc_ssrRender(_ctx, _push, _parent, _attrs) {
|
||
_push(`<a${ssrRenderAttrs(mergeProps({
|
||
color: "error",
|
||
class: "buy-now-button",
|
||
href: "https://themeselection.com/item/sneat-vuetify-nuxtjs-admin-template/",
|
||
target: "_blank",
|
||
rel: "noopener noreferrer"
|
||
}, _attrs))} data-v-7c6a1f7e> Upgrade to Pro <span class="button-inner" data-v-7c6a1f7e></span>`);
|
||
_push(ssrRenderComponent(VMenu, {
|
||
"open-on-hover": "",
|
||
activator: "parent",
|
||
offset: "15",
|
||
"max-width": "400px",
|
||
"close-on-content-click": false,
|
||
transition: "slide-y-reverse-transition"
|
||
}, {
|
||
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
||
if (_push2) {
|
||
_push2(ssrRenderComponent(VCard, null, {
|
||
default: withCtx((_2, _push3, _parent3, _scopeId2) => {
|
||
if (_push3) {
|
||
_push3(ssrRenderComponent(VImg, { src: "https://cdn.themeselection.com/ts-assets/sneat/sneat-vuetify-nuxtjs-admin-template-free/banner/banner.png" }, null, _parent3, _scopeId2));
|
||
_push3(ssrRenderComponent(VCardTitle, null, {
|
||
default: withCtx((_3, _push4, _parent4, _scopeId3) => {
|
||
if (_push4) {
|
||
_push4(`Sneat - Vuetify Admin Template`);
|
||
} else {
|
||
return [
|
||
createTextVNode("Sneat - Vuetify Admin Template")
|
||
];
|
||
}
|
||
}),
|
||
_: 1
|
||
}, _parent3, _scopeId2));
|
||
_push3(ssrRenderComponent(VCardText, null, {
|
||
default: withCtx((_3, _push4, _parent4, _scopeId3) => {
|
||
if (_push4) {
|
||
_push4(` Sneat Admin is the most developer friendly & highly customisable Admin Dashboard Template based on Vuetify. `);
|
||
} else {
|
||
return [
|
||
createTextVNode(" Sneat Admin is the most developer friendly & highly customisable Admin Dashboard Template based on Vuetify. ")
|
||
];
|
||
}
|
||
}),
|
||
_: 1
|
||
}, _parent3, _scopeId2));
|
||
_push3(ssrRenderComponent(VCardText, null, {
|
||
default: withCtx((_3, _push4, _parent4, _scopeId3) => {
|
||
if (_push4) {
|
||
_push4(`Click on below button to explore PRO version.`);
|
||
} else {
|
||
return [
|
||
createTextVNode("Click on below button to explore PRO version.")
|
||
];
|
||
}
|
||
}),
|
||
_: 1
|
||
}, _parent3, _scopeId2));
|
||
_push3(ssrRenderComponent(VCardText, null, {
|
||
default: withCtx((_3, _push4, _parent4, _scopeId3) => {
|
||
if (_push4) {
|
||
_push4(ssrRenderComponent(VBtn, {
|
||
class: "me-4",
|
||
href: "https://themeselection.com/item/sneat-vuetify-nuxtjs-admin-template/?tab=details#details",
|
||
target: "_blank",
|
||
rel: "noopener noreferrer"
|
||
}, {
|
||
default: withCtx((_4, _push5, _parent5, _scopeId4) => {
|
||
if (_push5) {
|
||
_push5(` Demo `);
|
||
} else {
|
||
return [
|
||
createTextVNode(" Demo ")
|
||
];
|
||
}
|
||
}),
|
||
_: 1
|
||
}, _parent4, _scopeId3));
|
||
_push4(ssrRenderComponent(VBtn, {
|
||
variant: "outlined",
|
||
href: "https://themeselection.com/item/sneat-vuetify-nuxtjs-admin-template/",
|
||
target: "_blank",
|
||
rel: "noopener noreferrer"
|
||
}, {
|
||
default: withCtx((_4, _push5, _parent5, _scopeId4) => {
|
||
if (_push5) {
|
||
_push5(` Download `);
|
||
} else {
|
||
return [
|
||
createTextVNode(" Download ")
|
||
];
|
||
}
|
||
}),
|
||
_: 1
|
||
}, _parent4, _scopeId3));
|
||
} else {
|
||
return [
|
||
createVNode(VBtn, {
|
||
class: "me-4",
|
||
href: "https://themeselection.com/item/sneat-vuetify-nuxtjs-admin-template/?tab=details#details",
|
||
target: "_blank",
|
||
rel: "noopener noreferrer"
|
||
}, {
|
||
default: withCtx(() => [
|
||
createTextVNode(" Demo ")
|
||
]),
|
||
_: 1
|
||
}),
|
||
createVNode(VBtn, {
|
||
variant: "outlined",
|
||
href: "https://themeselection.com/item/sneat-vuetify-nuxtjs-admin-template/",
|
||
target: "_blank",
|
||
rel: "noopener noreferrer"
|
||
}, {
|
||
default: withCtx(() => [
|
||
createTextVNode(" Download ")
|
||
]),
|
||
_: 1
|
||
})
|
||
];
|
||
}
|
||
}),
|
||
_: 1
|
||
}, _parent3, _scopeId2));
|
||
} else {
|
||
return [
|
||
createVNode(VImg, { src: "https://cdn.themeselection.com/ts-assets/sneat/sneat-vuetify-nuxtjs-admin-template-free/banner/banner.png" }),
|
||
createVNode(VCardTitle, null, {
|
||
default: withCtx(() => [
|
||
createTextVNode("Sneat - Vuetify Admin Template")
|
||
]),
|
||
_: 1
|
||
}),
|
||
createVNode(VCardText, null, {
|
||
default: withCtx(() => [
|
||
createTextVNode(" Sneat Admin is the most developer friendly & highly customisable Admin Dashboard Template based on Vuetify. ")
|
||
]),
|
||
_: 1
|
||
}),
|
||
createVNode(VCardText, null, {
|
||
default: withCtx(() => [
|
||
createTextVNode("Click on below button to explore PRO version.")
|
||
]),
|
||
_: 1
|
||
}),
|
||
createVNode(VCardText, null, {
|
||
default: withCtx(() => [
|
||
createVNode(VBtn, {
|
||
class: "me-4",
|
||
href: "https://themeselection.com/item/sneat-vuetify-nuxtjs-admin-template/?tab=details#details",
|
||
target: "_blank",
|
||
rel: "noopener noreferrer"
|
||
}, {
|
||
default: withCtx(() => [
|
||
createTextVNode(" Demo ")
|
||
]),
|
||
_: 1
|
||
}),
|
||
createVNode(VBtn, {
|
||
variant: "outlined",
|
||
href: "https://themeselection.com/item/sneat-vuetify-nuxtjs-admin-template/",
|
||
target: "_blank",
|
||
rel: "noopener noreferrer"
|
||
}, {
|
||
default: withCtx(() => [
|
||
createTextVNode(" Download ")
|
||
]),
|
||
_: 1
|
||
})
|
||
]),
|
||
_: 1
|
||
})
|
||
];
|
||
}
|
||
}),
|
||
_: 1
|
||
}, _parent2, _scopeId));
|
||
} else {
|
||
return [
|
||
createVNode(VCard, null, {
|
||
default: withCtx(() => [
|
||
createVNode(VImg, { src: "https://cdn.themeselection.com/ts-assets/sneat/sneat-vuetify-nuxtjs-admin-template-free/banner/banner.png" }),
|
||
createVNode(VCardTitle, null, {
|
||
default: withCtx(() => [
|
||
createTextVNode("Sneat - Vuetify Admin Template")
|
||
]),
|
||
_: 1
|
||
}),
|
||
createVNode(VCardText, null, {
|
||
default: withCtx(() => [
|
||
createTextVNode(" Sneat Admin is the most developer friendly & highly customisable Admin Dashboard Template based on Vuetify. ")
|
||
]),
|
||
_: 1
|
||
}),
|
||
createVNode(VCardText, null, {
|
||
default: withCtx(() => [
|
||
createTextVNode("Click on below button to explore PRO version.")
|
||
]),
|
||
_: 1
|
||
}),
|
||
createVNode(VCardText, null, {
|
||
default: withCtx(() => [
|
||
createVNode(VBtn, {
|
||
class: "me-4",
|
||
href: "https://themeselection.com/item/sneat-vuetify-nuxtjs-admin-template/?tab=details#details",
|
||
target: "_blank",
|
||
rel: "noopener noreferrer"
|
||
}, {
|
||
default: withCtx(() => [
|
||
createTextVNode(" Demo ")
|
||
]),
|
||
_: 1
|
||
}),
|
||
createVNode(VBtn, {
|
||
variant: "outlined",
|
||
href: "https://themeselection.com/item/sneat-vuetify-nuxtjs-admin-template/",
|
||
target: "_blank",
|
||
rel: "noopener noreferrer"
|
||
}, {
|
||
default: withCtx(() => [
|
||
createTextVNode(" Download ")
|
||
]),
|
||
_: 1
|
||
})
|
||
]),
|
||
_: 1
|
||
})
|
||
]),
|
||
_: 1
|
||
})
|
||
];
|
||
}
|
||
}),
|
||
_: 1
|
||
}, _parent));
|
||
_push(`</a>`);
|
||
}
|
||
const _sfc_setup$4 = _sfc_main$4.setup;
|
||
_sfc_main$4.setup = (props, ctx) => {
|
||
const ssrContext = useSSRContext();
|
||
(ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("components/UpgradeToPro.vue");
|
||
return _sfc_setup$4 ? _sfc_setup$4(props, ctx) : void 0;
|
||
};
|
||
const UpgradeToPro = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["ssrRender", _sfc_ssrRender], ["__scopeId", "data-v-7c6a1f7e"]]);
|
||
const useDevice = () => useNuxtApp().$device;
|
||
const makeVAppProps = propsFactory({
|
||
...makeComponentProps(),
|
||
...makeLayoutProps({
|
||
fullHeight: true
|
||
}),
|
||
...makeThemeProps()
|
||
}, "VApp");
|
||
const VApp = genericComponent()({
|
||
name: "VApp",
|
||
props: makeVAppProps(),
|
||
setup(props, _ref) {
|
||
let {
|
||
slots
|
||
} = _ref;
|
||
const theme = provideTheme(props);
|
||
const {
|
||
layoutClasses,
|
||
getLayoutItem,
|
||
items,
|
||
layoutRef
|
||
} = createLayout(props);
|
||
const {
|
||
rtlClasses
|
||
} = useRtl();
|
||
useRender(() => {
|
||
var _a;
|
||
return createVNode("div", {
|
||
"ref": layoutRef,
|
||
"class": ["v-application", theme.themeClasses.value, layoutClasses.value, rtlClasses.value, props.class],
|
||
"style": [props.style]
|
||
}, [createVNode("div", {
|
||
"class": "v-application__wrap"
|
||
}, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]);
|
||
});
|
||
return {
|
||
getLayoutItem,
|
||
items,
|
||
theme
|
||
};
|
||
}
|
||
});
|
||
const _sfc_main$3 = /* @__PURE__ */ defineComponent$1({
|
||
__name: "app",
|
||
__ssrInlineRender: true,
|
||
setup(__props) {
|
||
const { isMobile: isMobile2 } = useDevice();
|
||
if (isMobile2)
|
||
configStore.appContentLayoutNav = "vertical";
|
||
const token = useCookie("auth-token");
|
||
const userInfo = useCookie("user-info");
|
||
const currentUser = ref(null);
|
||
const logout = () => {
|
||
token.value = null;
|
||
userInfo.value = null;
|
||
currentUser.value = null;
|
||
navigateTo("/login");
|
||
};
|
||
provide("currentUser", currentUser);
|
||
provide("logout", logout);
|
||
return (_ctx, _push, _parent, _attrs) => {
|
||
const _component_NuxtLayout = __nuxt_component_0;
|
||
const _component_NuxtPage = __nuxt_component_1$1;
|
||
_push(ssrRenderComponent(VApp, _attrs, {
|
||
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
||
if (_push2) {
|
||
_push2(ssrRenderComponent(_component_NuxtLayout, null, {
|
||
default: withCtx((_2, _push3, _parent3, _scopeId2) => {
|
||
if (_push3) {
|
||
_push3(ssrRenderComponent(_component_NuxtPage, null, null, _parent3, _scopeId2));
|
||
} else {
|
||
return [
|
||
createVNode(_component_NuxtPage)
|
||
];
|
||
}
|
||
}),
|
||
_: 1
|
||
}, _parent2, _scopeId));
|
||
_push2(ssrRenderComponent(UpgradeToPro, null, null, _parent2, _scopeId));
|
||
} else {
|
||
return [
|
||
createVNode(_component_NuxtLayout, null, {
|
||
default: withCtx(() => [
|
||
createVNode(_component_NuxtPage)
|
||
]),
|
||
_: 1
|
||
}),
|
||
createVNode(UpgradeToPro)
|
||
];
|
||
}
|
||
}),
|
||
_: 1
|
||
}, _parent));
|
||
};
|
||
}
|
||
});
|
||
const _sfc_setup$3 = _sfc_main$3.setup;
|
||
_sfc_main$3.setup = (props, ctx) => {
|
||
const ssrContext = useSSRContext();
|
||
(ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("app.vue");
|
||
return _sfc_setup$3 ? _sfc_setup$3(props, ctx) : void 0;
|
||
};
|
||
const _sfc_main$2 = /* @__PURE__ */ defineComponent$1({
|
||
__name: "ErrorHeader",
|
||
__ssrInlineRender: true,
|
||
props: {
|
||
statusCode: {},
|
||
title: {},
|
||
description: {}
|
||
},
|
||
setup(__props) {
|
||
const props = __props;
|
||
return (_ctx, _push, _parent, _attrs) => {
|
||
_push(`<div${ssrRenderAttrs(mergeProps({ class: "text-center" }, _attrs))} data-v-9f58dd66>`);
|
||
if (props.statusCode) {
|
||
_push(`<h1 class="header-title font-weight-medium mb-2" data-v-9f58dd66>${ssrInterpolate(props.statusCode)}</h1>`);
|
||
} else {
|
||
_push(`<!---->`);
|
||
}
|
||
if (props.title) {
|
||
_push(`<h4 class="text-h4 font-weight-medium mb-2" data-v-9f58dd66>${ssrInterpolate(props.title)}</h4>`);
|
||
} else {
|
||
_push(`<!---->`);
|
||
}
|
||
if (props.description) {
|
||
_push(`<p class="text-body-1 mb-6" data-v-9f58dd66>${ssrInterpolate(props.description)}</p>`);
|
||
} else {
|
||
_push(`<!---->`);
|
||
}
|
||
_push(`</div>`);
|
||
};
|
||
}
|
||
});
|
||
const _sfc_setup$2 = _sfc_main$2.setup;
|
||
_sfc_main$2.setup = (props, ctx) => {
|
||
const ssrContext = useSSRContext();
|
||
(ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("components/ErrorHeader.vue");
|
||
return _sfc_setup$2 ? _sfc_setup$2(props, ctx) : void 0;
|
||
};
|
||
const __nuxt_component_1 = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-9f58dd66"]]);
|
||
const misc404 = "" + __buildAssetsURL("404.CFRyiToj.png");
|
||
const _sfc_main$1 = /* @__PURE__ */ defineComponent$1({
|
||
...{
|
||
inheritAttrs: false
|
||
},
|
||
__name: "error",
|
||
__ssrInlineRender: true,
|
||
props: {
|
||
error: {}
|
||
},
|
||
setup(__props) {
|
||
const props = __props;
|
||
const isDev = false;
|
||
const errToShow = computed(() => {
|
||
var _a, _b;
|
||
const is404 = ((_a = props.error) == null ? void 0 : _a.statusCode) === 404 || ((_b = props.error.message) == null ? void 0 : _b.includes("404"));
|
||
if (is404) {
|
||
return {
|
||
title: "Page Not Found",
|
||
description: "We couldn't find the page you are looking for."
|
||
};
|
||
}
|
||
return {
|
||
title: "Oops! Something went wrong.",
|
||
description: "We are working on it and we'll get it fixed as soon as we can"
|
||
};
|
||
});
|
||
const handleError = () => clearError({ redirect: "/" });
|
||
return (_ctx, _push, _parent, _attrs) => {
|
||
const _component_NuxtLayout = __nuxt_component_0;
|
||
const _component_ErrorHeader = __nuxt_component_1;
|
||
_push(ssrRenderComponent(_component_NuxtLayout, mergeProps({ name: "blank" }, _attrs), {
|
||
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
||
if (_push2) {
|
||
_push2(`<div class="misc-wrapper"${_scopeId}>`);
|
||
_push2(ssrRenderComponent(_component_ErrorHeader, {
|
||
"status-code": props.error.statusCode,
|
||
title: unref(errToShow).title,
|
||
description: unref(errToShow).description
|
||
}, null, _parent2, _scopeId));
|
||
if (unref(isDev)) {
|
||
_push2(`<div style="${ssrRenderStyle({ "max-inline-size": "80dvw", "overflow-x": "scroll" })}"${_scopeId}>${__props.error.stack ?? ""}</div>`);
|
||
} else {
|
||
_push2(`<!---->`);
|
||
}
|
||
_push2(ssrRenderComponent(VBtn, {
|
||
class: "mb-6",
|
||
onClick: handleError
|
||
}, {
|
||
default: withCtx((_2, _push3, _parent3, _scopeId2) => {
|
||
if (_push3) {
|
||
_push3(` Back to Home `);
|
||
} else {
|
||
return [
|
||
createTextVNode(" Back to Home ")
|
||
];
|
||
}
|
||
}),
|
||
_: 1
|
||
}, _parent2, _scopeId));
|
||
_push2(`<div class="misc-avatar w-100 text-center"${_scopeId}>`);
|
||
_push2(ssrRenderComponent(VImg, {
|
||
src: unref(misc404),
|
||
alt: "Page Not Found",
|
||
"max-width": 500,
|
||
class: "mx-auto"
|
||
}, null, _parent2, _scopeId));
|
||
_push2(`</div></div>`);
|
||
} else {
|
||
return [
|
||
createVNode("div", { class: "misc-wrapper" }, [
|
||
createVNode(_component_ErrorHeader, {
|
||
"status-code": props.error.statusCode,
|
||
title: unref(errToShow).title,
|
||
description: unref(errToShow).description
|
||
}, null, 8, ["status-code", "title", "description"]),
|
||
unref(isDev) ? (openBlock(), createBlock("div", {
|
||
key: 0,
|
||
style: { "max-inline-size": "80dvw", "overflow-x": "scroll" },
|
||
innerHTML: __props.error.stack
|
||
}, null, 8, ["innerHTML"])) : createCommentVNode("", true),
|
||
createVNode(VBtn, {
|
||
class: "mb-6",
|
||
onClick: handleError
|
||
}, {
|
||
default: withCtx(() => [
|
||
createTextVNode(" Back to Home ")
|
||
]),
|
||
_: 1
|
||
}),
|
||
createVNode("div", { class: "misc-avatar w-100 text-center" }, [
|
||
createVNode(VImg, {
|
||
src: unref(misc404),
|
||
alt: "Page Not Found",
|
||
"max-width": 500,
|
||
class: "mx-auto"
|
||
}, null, 8, ["src"])
|
||
])
|
||
])
|
||
];
|
||
}
|
||
}),
|
||
_: 1
|
||
}, _parent));
|
||
};
|
||
}
|
||
});
|
||
const _sfc_setup$1 = _sfc_main$1.setup;
|
||
_sfc_main$1.setup = (props, ctx) => {
|
||
const ssrContext = useSSRContext();
|
||
(ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("error.vue");
|
||
return _sfc_setup$1 ? _sfc_setup$1(props, ctx) : void 0;
|
||
};
|
||
const _sfc_main = {
|
||
__name: "nuxt-root",
|
||
__ssrInlineRender: true,
|
||
setup(__props) {
|
||
const IslandRenderer = () => null;
|
||
const nuxtApp = useNuxtApp();
|
||
nuxtApp.deferHydration();
|
||
nuxtApp.ssrContext.url;
|
||
const SingleRenderer = false;
|
||
provide(PageRouteSymbol, useRoute$1());
|
||
nuxtApp.hooks.callHookWith((hooks) => hooks.map((hook) => hook()), "vue:setup");
|
||
const error = useError();
|
||
const abortRender = error.value && !nuxtApp.ssrContext.error;
|
||
onErrorCaptured((err, target, info) => {
|
||
nuxtApp.hooks.callHook("vue:error", err, target, info).catch((hookError) => console.error("[nuxt] Error in `vue:error` hook", hookError));
|
||
{
|
||
const p = nuxtApp.runWithContext(() => showError(err));
|
||
onServerPrefetch(() => p);
|
||
return false;
|
||
}
|
||
});
|
||
const islandContext = nuxtApp.ssrContext.islandContext;
|
||
return (_ctx, _push, _parent, _attrs) => {
|
||
ssrRenderSuspense(_push, {
|
||
default: () => {
|
||
if (unref(abortRender)) {
|
||
_push(`<div></div>`);
|
||
} else if (unref(error)) {
|
||
_push(ssrRenderComponent(unref(_sfc_main$1), { error: unref(error) }, null, _parent));
|
||
} else if (unref(islandContext)) {
|
||
_push(ssrRenderComponent(unref(IslandRenderer), { context: unref(islandContext) }, null, _parent));
|
||
} else if (unref(SingleRenderer)) {
|
||
ssrRenderVNode(_push, createVNode(resolveDynamicComponent(unref(SingleRenderer)), null, null), _parent);
|
||
} else {
|
||
_push(ssrRenderComponent(unref(_sfc_main$3), null, null, _parent));
|
||
}
|
||
},
|
||
_: 1
|
||
});
|
||
};
|
||
}
|
||
};
|
||
const _sfc_setup = _sfc_main.setup;
|
||
_sfc_main.setup = (props, ctx) => {
|
||
const ssrContext = useSSRContext();
|
||
(ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("node_modules/nuxt/dist/app/components/nuxt-root.vue");
|
||
return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
|
||
};
|
||
let entry;
|
||
{
|
||
entry = async function createNuxtAppServer(ssrContext) {
|
||
const vueApp = createApp(_sfc_main);
|
||
const nuxt = createNuxtApp({ vueApp, ssrContext });
|
||
try {
|
||
await applyPlugins(nuxt, plugins);
|
||
await nuxt.hooks.callHook("app:created", vueApp);
|
||
} catch (error) {
|
||
await nuxt.hooks.callHook("app:error", error);
|
||
nuxt.payload.error = nuxt.payload.error || createError(error);
|
||
}
|
||
if (ssrContext == null ? void 0 : ssrContext._renderResponse) {
|
||
throw new Error("skipping render");
|
||
}
|
||
return vueApp;
|
||
};
|
||
}
|
||
const entry$1 = (ssrContext) => entry(ssrContext);
|
||
|
||
export { useLoader as $, matchesSelector as A, VCard as B, VCardText as C, VBtn as D, useRtl as E, provideTheme as F, provideDefaults as G, createRange as H, IconValue as I, makeVariantProps as J, makeThemeProps as K, makeTagProps as L, makeSizeProps as M, makeRoundedProps as N, makeElevationProps as O, makeDensityProps as P, makeBorderProps as Q, keyValues as R, defineFunctionalComponent as S, consoleError as T, deepEqual as U, VDialogTransition as V, getObjectValueByPath as W, isEmpty as X, makeLoaderProps as Y, makeDisplayProps as Z, _export_sfc as _, useRender as a, navigateTo as a$, useBackgroundColor as a0, LoaderSlot as a1, EventProp as a2, getPropertyFromItem as a3, useRoute$1 as a4, getUid as a5, VImg as a6, VCardItem as a7, VCardTitle as a8, VCardSubtitle as a9, MaybeTransition as aA, useScopeId as aB, isObject as aC, createSimpleFunctional as aD, useLocation as aE, usePosition as aF, makePositionProps as aG, makeLocationProps as aH, useRouter$1 as aI, useCookie as aJ, filterInputAttrs as aK, getCurrentInstanceName as aL, consoleWarn as aM, only as aN, nullifyTransforms as aO, pick as aP, Intersect as aQ, callEvent as aR, breakpoints as aS, defineComponent as aT, deprecate as aU, focusChild as aV, makeVOverlayProps as aW, VOverlay as aX, useNuxtApp as aY, resolveRouteObject as aZ, useRuntimeConfig as a_, VCardActions as aa, useTheme as ab, VProgressCircular as ac, makeGroupProps as ad, useGroup as ae, Ripple as af, useBorder as ag, useVariant as ah, useDensity as ai, useElevation as aj, useRounded as ak, useSize as al, useGroupItem as am, useLink as an, genOverlays as ao, makeRouterProps as ap, makeGroupItemProps as aq, useGoTo as ar, focusableChildren as as, useTextColor as at, makeVBtnProps as au, animate as av, standardEasing as aw, keys as ax, useLazy as ay, makeLazyProps as az, useDisplay as b, nuxtLinkDefaults as b0, defineNuxtRouteMiddleware as b1, pickWithRest as b2, clamp as c, debounce as d, entry$1 as default, getCurrentInstance as e, useDimension as f, genericComponent as g, useToggleScope as h, isOn as i, convertToUnit as j, makeDimensionProps as k, useLocale as l, makeComponentProps as m, useProxiedModel as n, forwardRefs as o, propsFactory as p, makeTransitionProps as q, omit as r, VIcon as s, VMenu as t, useResizeObserver as u, VAvatar as v, wrapInArray as w, ensureValidVNode as x, VDefaultsProvider as y, checkPrintable as z };
|