@vc-shell/framework 1.1.0 → 1.1.2

package/dist/assets/ui-app-D31Pr1WY.js

@@ -0,0 +1,1993 @@
+import { ref, computed, provide, inject, getCurrentInstance, watchEffect, reactive, readonly, defineComponent, createElementBlock, openBlock, normalizeClass, createElementVNode, renderSlot, withModifiers, createBlock, createCommentVNode, unref, toDisplayString, watch, withCtx, createVNode, h, Teleport, Fragment, resolveDynamicComponent, Transition, renderList, withDirectives, mergeProps, resolveComponent, onMounted, createSlots, createTextVNode, vShow, onUnmounted, normalizeStyle } from 'vue';
+import './ui-indicators-mIQeEqha.js';
+import { _ as _sfc_main$j, A as _sfc_main$k, j as _sfc_main$m, p as _sfc_main$n, f as _sfc_main$p, h as _sfc_main$q, e as _sfc_main$r, y as _sfc_main$s, o as _sfc_main$t, d as _sfc_main$u } from './ui-media-WWYrwmZw.js';
+import { b as _sfc_main$o } from './ui-controls-nmDJYLmC.js';
+import { a as VcContainer } from './ui-layout-v2XBQky3.js';
+import './ui-helpers-CF-EUlOg.js';
+import { i as i18n, c as usePermissions, n as notification, d as useBladeNavigation, b as usePopup, C as ChangePassword, e as useUser, f as useAppSwitcher, V as VcPopupContainer } from './ui-navigation-BtHa6ovW.js';
+import { o as useAppBarWidget, f as useLanguages, u as useNotifications, p as provideAppBarWidget } from './core-composables-DYxpIWyY.js';
+import 'vee-validate';
+import { i as _sfc_main$l } from './ui-content-B7SxH8y9.js';
+import './ui-form-Cs5ooOo7.js';
+import { C as omit, D as snakeCase, j as isEqual, u as useI18n, E as capitalize, v as vOnClickOutside } from './ui-form-fields-DFQi31jT.js';
+import { u as useMenuExpanded } from './shared-composables-v9NkNuAe.js';
+import './core-plugins-wv2bDZ0l.js';
+import { useRoute, useRouter } from 'vue-router';
+import { N as NotificationDropdown, U as UserDropdownButton } from './shared-components-CfAt2hC6.js';
+import './shared-modules-CDP-H5ZB.js';
+import { M as MenuServiceKey, l as DashboardServiceKey, S as SettingsMenuServiceKey, u as useAppBarMobileButtons, D as DynamicModulesKey, p as provideAppBarMobileButtonsService, o as provideGlobalSearch } from './ui-data-Ci3b1ye0.js';
+import './ui-media-advanced-T8ibi153.js';
+import { x as useArrayFind, y as createUnrefFn, z as useColorMode, A as useCycleList, B as watchOnce } from './vueuse-CTQm4Zh0.js';
+
+const preregisteredMenuItems = ref([]);
+function addMenuItem(item) {
+  preregisteredMenuItems.value.push(item);
+}
+const DEFAULT_PRIORITY = Infinity;
+const DEFAULT_GROUP_PRIORITY = Infinity;
+const menuItems = ref([]);
+const rawMenu = ref([]);
+function createMenuService() {
+  const { t } = i18n.global;
+  function addMenuItem2(item) {
+    rawMenu.value.push(item);
+    constructMenu();
+  }
+  function removeMenuItem(item) {
+    const index = menuItems.value.indexOf(item);
+    if (index !== -1) {
+      menuItems.value.splice(index, 1);
+    }
+  }
+  const upsert = createUnrefFn(
+    (array, element) => {
+      const index = array.findIndex((_element) => isEqual(omit(_element, "title"), omit(element, "title")));
+      if (index > -1) {
+        array[index] = { ...element };
+      } else {
+        array.push({ ...element });
+      }
+    }
+  );
+  function sortByPriority(a, b) {
+    const getPriority = (item) => item.priority ?? DEFAULT_PRIORITY;
+    return getPriority(a) - getPriority(b);
+  }
+  function sortByGroupPriority(a, b) {
+    const getGroupPriority = (item) => item.inGroupPriority ?? item.priority ?? DEFAULT_GROUP_PRIORITY;
+    return getGroupPriority(a) - getGroupPriority(b);
+  }
+  function createItemId(title) {
+    const titleValue = typeof title === "string" ? t(title) : title.value;
+    return snakeCase(titleValue);
+  }
+  function createLocalizedTitle(title) {
+    return computed(() => t(title));
+  }
+  function processGroupItem(item, constructedMenu) {
+    if (!item.group && !item.groupConfig) return;
+    let groupId;
+    let groupTitle;
+    let groupIcon;
+    let groupPriority;
+    let groupPermissions;
+    if (item.groupConfig) {
+      groupId = item.groupConfig.id;
+      groupTitle = item.groupConfig.title || groupId;
+      groupIcon = item.groupConfig.icon;
+      groupPriority = item.groupConfig.priority;
+      groupPermissions = item.groupConfig.permissions;
+    } else {
+      groupId = "group_" + createItemId(item.group);
+      groupTitle = item.group;
+      groupIcon = item.groupIcon;
+      groupPriority = item.priority;
+    }
+    const existingGroup = useArrayFind(constructedMenu, (m) => m.groupId === groupId);
+    const groupItem = {
+      ...omit(item, ["group", "groupIcon", "groupPriority", "groupConfig"]),
+      title: createLocalizedTitle(item.title)
+    };
+    if (existingGroup.value && existingGroup.value.children) {
+      upsert(existingGroup.value.children, groupItem);
+      if (item.groupConfig) {
+        if (item.groupConfig.title) {
+          existingGroup.value.title = createLocalizedTitle(item.groupConfig.title);
+        }
+        if (item.groupConfig.icon !== void 0) {
+          existingGroup.value.groupIcon = item.groupConfig.icon;
+        }
+        if (item.groupConfig.priority !== void 0) {
+          existingGroup.value.priority = item.groupConfig.priority;
+        }
+        if (item.groupConfig.permissions !== void 0) {
+          existingGroup.value.permissions = item.groupConfig.permissions;
+        }
+      }
+    } else {
+      const group = {
+        groupId,
+        groupIcon: groupIcon ?? "",
+        title: createLocalizedTitle(groupTitle),
+        children: [groupItem],
+        priority: groupPriority ?? item.priority ?? DEFAULT_PRIORITY,
+        permissions: groupPermissions
+      };
+      upsert(constructedMenu.value, group);
+    }
+  }
+  function processStandaloneItem(item, constructedMenu) {
+    if (item.title) {
+      const standaloneItem = {
+        ...item,
+        title: createLocalizedTitle(item.title)
+      };
+      upsert(constructedMenu.value, standaloneItem);
+    }
+  }
+  function finalizeMenuItems(items) {
+    return items.map(
+      (item) => ({
+        ...item,
+        title: createLocalizedTitle(item.title),
+        id: item.id || createItemId(item.title),
+        children: item.children?.sort(sortByGroupPriority)
+      })
+    ).sort(sortByPriority);
+  }
+  function constructMenu() {
+    const constructedMenu = ref([]);
+    rawMenu.value.forEach((item) => {
+      if (item.group || item.groupConfig) {
+        processGroupItem(item, constructedMenu);
+      } else {
+        processStandaloneItem(item, constructedMenu);
+      }
+    });
+    menuItems.value = finalizeMenuItems(constructedMenu.value);
+  }
+  preregisteredMenuItems.value.forEach((item) => {
+    try {
+      addMenuItem2(item);
+    } catch (e) {
+      console.warn(`Failed to register preregistered menu item ${item.id || item.title}:`, e);
+    }
+  });
+  return {
+    addMenuItem: addMenuItem2,
+    menuItems,
+    removeMenuItem
+  };
+}
+
+function provideMenuService() {
+  const service = createMenuService();
+  provide(MenuServiceKey, service);
+  return service;
+}
+function useMenuService() {
+  const service = inject(MenuServiceKey);
+  if (!service) {
+    console.error("Menu service not found in current context. Injection chain:", getCurrentInstance());
+    throw new Error("MenuService not provided");
+  }
+  return service;
+}
+
+const registeredThemes = ref([
+  // "auto"
+]);
+const useTheme = () => {
+  function register(customNames) {
+    (typeof customNames === "string" ? [customNames] : customNames).forEach((name) => {
+      if (!registeredThemes.value.includes(name)) {
+        registeredThemes.value.push(name);
+      }
+    });
+  }
+  function unregister(customNames) {
+    (typeof customNames === "string" ? [customNames] : customNames).forEach((name) => {
+      const index = registeredThemes.value.indexOf(name);
+      if (index >= 0) {
+        registeredThemes.value.splice(index, 1);
+      }
+    });
+  }
+  function setTheme(theme) {
+    state.value = theme;
+  }
+  const mode = useColorMode({
+    emitAuto: true,
+    initialValue: "light",
+    modes: {
+      ...registeredThemes.value.reduce(
+        (acc, name) => {
+          acc[name] = name;
+          return acc;
+        },
+        {}
+      )
+    }
+  });
+  const { state, next } = useCycleList(registeredThemes.value, { initialValue: mode });
+  watchEffect(() => mode.value = state.value);
+  return {
+    themes: computed(() => registeredThemes.value),
+    current: state,
+    next,
+    register,
+    unregister,
+    setTheme
+  };
+};
+
+const preregisteredWidgets = [];
+function registerDashboardWidget(widget) {
+  const existingWidget = preregisteredWidgets.find((w) => w.id === widget.id);
+  if (!existingWidget) {
+    preregisteredWidgets.push(widget);
+  }
+}
+const createState = () => ({
+  widgets: reactive(/* @__PURE__ */ new Map()),
+  layout: reactive(/* @__PURE__ */ new Map())
+});
+function createDashboardService() {
+  const state = createState();
+  const { hasAccess } = usePermissions();
+  const registerWidget = (widget) => {
+    if (state.widgets.has(widget.id)) {
+      throw new Error(`Widget with id ${widget.id} already registered`);
+    }
+    state.widgets.set(widget.id, widget);
+    if (!widget.position) {
+      const lastWidget = Array.from(state.layout.values()).reduce((max, pos) => {
+        return pos.y > max ? pos.y : max;
+      }, 0);
+      state.layout.set(widget.id, {
+        x: 0,
+        y: lastWidget + 1
+      });
+    } else {
+      state.layout.set(widget.id, widget.position);
+    }
+  };
+  const getWidgets = () => {
+    return Array.from(state.widgets.values()).filter((widget) => {
+      if (!widget.permissions || widget.permissions.length === 0) {
+        return true;
+      }
+      return hasAccess(widget.permissions);
+    });
+  };
+  const updateWidgetPosition = (widgetId, position) => {
+    if (!state.widgets.has(widgetId)) {
+      throw new Error(`Widget with id ${widgetId} not found`);
+    }
+    state.layout.set(widgetId, position);
+  };
+  const getLayout = () => {
+    return state.layout;
+  };
+  preregisteredWidgets.forEach((widget) => {
+    try {
+      registerWidget(widget);
+    } catch (e) {
+      console.warn(`Failed to register preregistered widget ${widget.id}:`, e);
+    }
+  });
+  return {
+    registerWidget,
+    getWidgets,
+    updateWidgetPosition,
+    getLayout
+  };
+}
+
+function provideDashboardService() {
+  const service = createDashboardService();
+  provide(DashboardServiceKey, service);
+  return service;
+}
+function useDashboard() {
+  const service = inject(DashboardServiceKey);
+  if (!service) {
+    throw new Error("DashboardService not provided");
+  }
+  return service;
+}
+
+const preregisteredSettingsMenuItems = [];
+const settingsMenuItems = ref(/* @__PURE__ */ new Map());
+function addSettingsMenuItem(item) {
+  const id = item.id || crypto.randomUUID();
+  preregisteredSettingsMenuItems.push({
+    id,
+    order: item.order ?? preregisteredSettingsMenuItems.length,
+    component: item.component,
+    props: item.props
+  });
+}
+function createSettingsMenuService() {
+  const register = (options) => {
+    const id = options.id || crypto.randomUUID();
+    settingsMenuItems.value.set(id, {
+      id,
+      order: options.order ?? settingsMenuItems.value.size,
+      component: options.component,
+      props: options.props
+    });
+    return id;
+  };
+  const unregister = (id) => {
+    settingsMenuItems.value.delete(id);
+  };
+  const items = computed(() => {
+    return Array.from(settingsMenuItems.value.values()).sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  });
+  preregisteredSettingsMenuItems.forEach((item) => {
+    try {
+      register(item);
+    } catch (e) {
+      console.warn(`Failed to register pre-added settings menu item ${item.id}:`, e);
+    }
+  });
+  return {
+    register,
+    unregister,
+    items
+  };
+}
+
+function provideSettingsMenu() {
+  const settingsMenuService = createSettingsMenuService();
+  provide(SettingsMenuServiceKey, settingsMenuService);
+  return settingsMenuService;
+}
+function useSettingsMenu() {
+  const settingsMenuService = inject(SettingsMenuServiceKey);
+  if (!settingsMenuService) {
+    throw new Error("Settings menu service not found");
+  }
+  return settingsMenuService;
+}
+
+const AppMenuStateKey = Symbol("AppMenuState");
+let _instance = null;
+const useAppMenuState = () => {
+  if (_instance) {
+    return _instance;
+  }
+  const injected = inject(AppMenuStateKey, null);
+  if (injected) {
+    return injected;
+  }
+  const { isExpanded, toggleExpanded, isHoverExpanded, toggleHoverExpanded: toggleHoverExpandedFn } = useMenuExpanded();
+  const stateData = reactive({
+    isSidebarExpanded: isExpanded,
+    isMenuOpen: false,
+    activeButtonId: null
+  });
+  const state = computed(() => readonly(stateData));
+  const toggleSidebar = () => {
+    toggleExpanded();
+    stateData.isSidebarExpanded = isExpanded.value;
+  };
+  const toggleHoverExpanded = (shouldExpand) => {
+    toggleHoverExpandedFn(shouldExpand);
+  };
+  const toggleMenu = () => {
+    stateData.isMenuOpen = !stateData.isMenuOpen;
+    if (!stateData.isMenuOpen) {
+      stateData.activeButtonId = null;
+    }
+  };
+  const setActiveButton = (buttonId) => {
+    stateData.activeButtonId = buttonId;
+  };
+  const isButtonActive = computed(() => (buttonId) => stateData.activeButtonId === buttonId);
+  const closeAll = () => {
+    stateData.isMenuOpen = false;
+    stateData.activeButtonId = null;
+  };
+  const instance = {
+    state,
+    isButtonActive,
+    toggleSidebar,
+    toggleMenu,
+    setActiveButton,
+    toggleHoverExpanded,
+    isHoverExpanded,
+    closeAll
+  };
+  _instance = instance;
+  provide(AppMenuStateKey, instance);
+  return instance;
+};
+
+function useToggleableContent(itemsGetter, activeIdRef) {
+  const currentItem = computed(() => {
+    if (!activeIdRef.value || !Array.isArray(itemsGetter.value)) {
+      return null;
+    }
+    return itemsGetter.value.find((item) => item.id === activeIdRef.value) || null;
+  });
+  const isAnyItemVisible = computed(() => activeIdRef.value !== null);
+  const toggleItem = (id) => {
+    if (activeIdRef.value === id) {
+      activeIdRef.value = null;
+    } else {
+      activeIdRef.value = id;
+    }
+  };
+  const closeItem = () => {
+    activeIdRef.value = null;
+  };
+  const showItem = (id) => {
+    activeIdRef.value = id;
+  };
+  const hideAllItems = () => {
+    activeIdRef.value = null;
+  };
+  return {
+    showItem,
+    hideAllItems,
+    toggleItem,
+    currentItem,
+    isAnyItemVisible,
+    closeItem
+  };
+}
+
+const activeWidgetId = ref(null);
+function useAppBarWidgets() {
+  const { items } = useAppBarWidget();
+  const {
+    showItem: showWidget,
+    hideAllItems: hideAllWidgets,
+    toggleItem: toggleWidget,
+    currentItem: currentWidget,
+    isAnyItemVisible: isAnyWidgetVisible
+  } = useToggleableContent(items, activeWidgetId);
+  return {
+    showWidget,
+    hideAllWidgets,
+    toggleWidget,
+    currentWidget,
+    isAnyWidgetVisible
+  };
+}
+
+const _hoisted_1$f = { class: "vc-menu-item__content" };
+const _hoisted_2$a = { class: "vc-menu-item__title" };
+const _sfc_main$i = /* @__PURE__ */ defineComponent({
+  __name: "settings-menu-item",
+  props: {
+    title: {},
+    icon: {},
+    image: {},
+    emptyIcon: {},
+    isActive: { type: Boolean },
+    disabled: { type: Boolean },
+    isVisible: { type: Boolean, default: true },
+    triggerAction: { default: "click" }
+  },
+  emits: ["trigger:click", "trigger:hover"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const handleTriggerClick = () => {
+      if (props.disabled || props.triggerAction === "none") return;
+      emit("trigger:click");
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["vc-menu-item", {
+          "vc-menu-item--active": _ctx.isActive,
+          "vc-menu-item--clickable": !_ctx.disabled,
+          "vc-menu-item--invisible": !_ctx.isVisible
+        }])
+      }, [
+        createElementVNode("div", {
+          class: "vc-menu-item__trigger",
+          onClick: withModifiers(handleTriggerClick, ["stop"])
+        }, [
+          renderSlot(_ctx.$slots, "trigger", {}, () => [
+            createElementVNode("div", _hoisted_1$f, [
+              renderSlot(_ctx.$slots, "icon", {}, () => [
+                _ctx.icon ? (openBlock(), createBlock(unref(_sfc_main$j), {
+                  key: 0,
+                  icon: _ctx.icon,
+                  size: "l",
+                  class: "vc-menu-item__icon"
+                }, null, 8, ["icon"])) : _ctx.image ? (openBlock(), createBlock(unref(_sfc_main$k), {
+                  key: 1,
+                  src: _ctx.image,
+                  class: "vc-menu-item__image",
+                  "empty-icon": _ctx.emptyIcon
+                }, null, 8, ["src", "empty-icon"])) : createCommentVNode("", true)
+              ]),
+              renderSlot(_ctx.$slots, "title", {}, () => [
+                createElementVNode("p", _hoisted_2$a, toDisplayString(_ctx.title), 1)
+              ]),
+              renderSlot(_ctx.$slots, "additional")
+            ])
+          ])
+        ]),
+        renderSlot(_ctx.$slots, "content")
+      ], 2);
+    };
+  }
+});
+
+const _hoisted_1$e = { class: "vc-language-selector__trigger" };
+const _hoisted_2$9 = { class: "vc-language-selector__title" };
+const _hoisted_3$6 = ["onClick"];
+const _hoisted_4$6 = { class: "vc-language-selector__item-title" };
+const _sfc_main$h = /* @__PURE__ */ defineComponent({
+  __name: "language-selector",
+  setup(__props) {
+    const { availableLocales, getLocaleMessage, locale } = useI18n({ useScope: "global" });
+    const { setLocale, getFlag } = useLanguages();
+    const opened = ref(false);
+    const currLocaleFlag = ref();
+    const languageItems = availableLocales.map((locale2) => ({
+      lang: locale2,
+      title: getLocaleMessage(locale2).language_name,
+      clickHandler(lang) {
+        setLocale(lang);
+      },
+      flag: ""
+    })).filter((item) => item.title);
+    const handleLanguageSelect = (lang) => {
+      if (Object.prototype.hasOwnProperty.call(lang, "clickHandler")) {
+        lang.clickHandler(lang.lang);
+      }
+      opened.value = false;
+    };
+    watch(
+      [() => languageItems, () => locale.value],
+      async ([newValLangItem]) => {
+        for (const lang of newValLangItem) {
+          lang.flag = await getFlag(lang.lang);
+          if (lang.lang === locale.value) {
+            currLocaleFlag.value = lang.flag;
+          }
+        }
+      },
+      { immediate: true }
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$i), {
+        "onTrigger:click": _cache[0] || (_cache[0] = ($event) => opened.value = !opened.value)
+      }, {
+        trigger: withCtx(() => [
+          createElementVNode("div", _hoisted_1$e, [
+            createVNode(unref(_sfc_main$k), {
+              src: currLocaleFlag.value,
+              "empty-icon": "material-language",
+              class: "vc-language-selector__flag"
+            }, null, 8, ["src"]),
+            createElementVNode("span", _hoisted_2$9, toDisplayString(_ctx.$t("COMPONENTS.LANGUAGE_SELECTOR.TITLE")), 1)
+          ])
+        ]),
+        content: withCtx(() => [
+          createVNode(unref(_sfc_main$l), {
+            opened: opened.value,
+            items: unref(languageItems),
+            "is-item-active": (lang) => lang.lang === _ctx.$i18n.locale,
+            onItemClick: handleLanguageSelect
+          }, {
+            item: withCtx(({ item: lang, click }) => [
+              createElementVNode("div", {
+                class: normalizeClass(["vc-language-selector__item", { "vc-language-selector__item--active": lang.lang === _ctx.$i18n.locale }]),
+                onClick: click
+              }, [
+                createVNode(unref(_sfc_main$k), {
+                  src: lang.flag,
+                  class: "vc-language-selector__flag"
+                }, null, 8, ["src"]),
+                createElementVNode("span", _hoisted_4$6, toDisplayString(lang.title), 1)
+              ], 10, _hoisted_3$6)
+            ]),
+            _: 1
+          }, 8, ["opened", "items", "is-item-active"])
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+
+const LanguageSelector = _sfc_main$h;
+
+const _hoisted_1$d = { class: "sidebar__content" };
+const _sfc_main$g = /* @__PURE__ */ defineComponent({
+  ...{
+    inheritAttrs: false
+  },
+  __name: "sidebar",
+  props: {
+    position: { default: "right" },
+    render: { default: "always" },
+    isExpanded: { type: Boolean },
+    title: {},
+    closeCross: { type: Boolean, default: true }
+  },
+  emits: ["close"],
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    const props = __props;
+    const header = h("div", { class: "sidebar__header" }, [
+      props.title ? h("h3", { class: "sidebar__title" }, props.title) : null,
+      props.closeCross ? h(_sfc_main$j, { icon: _sfc_main$m, size: "xs", onClick: () => emit("close"), class: "sidebar__close-icon" }) : null
+    ]);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Teleport, {
+        to: "body",
+        disabled: _ctx.$isDesktop.value
+      }, [
+        _ctx.isExpanded ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+          _ctx.isExpanded ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            class: "sidebar__overlay",
+            onClick: _cache[0] || (_cache[0] = withModifiers(($event) => _ctx.$emit("close"), ["stop"]))
+          })) : createCommentVNode("", true),
+          _ctx.isExpanded ? (openBlock(), createElementBlock("div", {
+            key: 1,
+            class: normalizeClass([
+              "sidebar__dropdown",
+              {
+                "sidebar__dropdown--mobile": _ctx.$isMobile.value && _ctx.render === "mobile",
+                "sidebar__dropdown--desktop": _ctx.$isDesktop.value && _ctx.render === "desktop",
+                "sidebar__dropdown--always": _ctx.render === "always",
+                "sidebar__dropdown--left": _ctx.position === "left",
+                "sidebar__dropdown--right": _ctx.position === "right",
+                "sidebar__dropdown--title": _ctx.title
+              }
+            ])
+          }, [
+            renderSlot(_ctx.$slots, "header", { header: unref(header) }, () => [
+              (openBlock(), createBlock(resolveDynamicComponent(unref(header))))
+            ]),
+            createElementVNode("div", _hoisted_1$d, [
+              renderSlot(_ctx.$slots, "content")
+            ])
+          ], 2)) : createCommentVNode("", true)
+        ], 64)) : renderSlot(_ctx.$slots, "content", { key: 1 })
+      ], 8, ["disabled"]);
+    };
+  }
+});
+
+const _hoisted_1$c = { class: "vc-theme-selector__trigger" };
+const _hoisted_2$8 = { class: "vc-theme-selector__title" };
+const _hoisted_3$5 = ["onClick"];
+const _hoisted_4$5 = { class: "vc-theme-selector__item-title" };
+const _sfc_main$f = /* @__PURE__ */ defineComponent({
+  __name: "theme-selector",
+  setup(__props) {
+    const { current, themes, setTheme } = useTheme();
+    const opened = ref(false);
+    const handleThemeSelect = (theme) => {
+      setTheme(theme);
+      opened.value = false;
+    };
+    watch(
+      () => current.value,
+      (newVal) => {
+        notification(capitalize(newVal));
+      },
+      { deep: true }
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$i), {
+        "onTrigger:click": _cache[0] || (_cache[0] = ($event) => opened.value = !opened.value)
+      }, {
+        trigger: withCtx(() => [
+          createElementVNode("div", _hoisted_1$c, [
+            createVNode(unref(_sfc_main$j), {
+              icon: "material-palette",
+              class: "vc-theme-selector__icon"
+            }),
+            createElementVNode("span", _hoisted_2$8, toDisplayString(_ctx.$t("COMPONENTS.THEME_SELECTOR.THEME_SELECTOR")), 1)
+          ])
+        ]),
+        content: withCtx(() => [
+          createVNode(unref(_sfc_main$l), {
+            opened: opened.value,
+            items: unref(themes),
+            "is-item-active": (theme) => theme === unref(current),
+            onItemClick: handleThemeSelect
+          }, {
+            item: withCtx(({ item: theme, click }) => [
+              createElementVNode("div", {
+                class: normalizeClass(["vc-theme-selector__item", { "vc-theme-selector__item--active": theme === unref(current) }]),
+                onClick: click
+              }, [
+                createElementVNode("span", _hoisted_4$5, toDisplayString(capitalize(theme)), 1)
+              ], 10, _hoisted_3$5)
+            ]),
+            _: 1
+          }, 8, ["opened", "items", "is-item-active"])
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+
+const _hoisted_1$b = { class: "app-bar-header__logo-container" };
+const _hoisted_2$7 = { class: "app-bar-header__logo" };
+const _hoisted_3$4 = ["src"];
+const _hoisted_4$4 = {
+  key: 0,
+  class: "app-bar-header__menu-button-accent"
+};
+const _hoisted_5$2 = {
+  key: 0,
+  class: "app-bar-header__blade-title"
+};
+const _hoisted_6$2 = {
+  key: 0,
+  class: "app-bar-header__actions"
+};
+const _hoisted_7$1 = { class: "app-bar-header__menu-button-wrap" };
+const _hoisted_8 = {
+  key: 0,
+  class: "app-bar-header__menu-button-accent"
+};
+const _sfc_main$e = /* @__PURE__ */ defineComponent({
+  __name: "AppBarHeader",
+  props: {
+    logo: {},
+    expanded: {}
+  },
+  emits: ["logo:click", "toggle-menu"],
+  setup(__props) {
+    const { notifications } = useNotifications();
+    const { blades, currentBladeNavigationData } = useBladeNavigation();
+    const viewTitle = ref("");
+    const currentBladeId = ref(0);
+    watchEffect(
+      () => {
+        const currentTitle = currentBladeNavigationData.value?.instance?.title;
+        const lastBladeTitle = blades.value[blades.value.length - 1]?.props?.navigation?.instance?.title;
+        currentBladeId.value = blades.value[blades.value.length - 1]?.props?.navigation?.idx || 0;
+        viewTitle.value = currentTitle ?? lastBladeTitle ?? "";
+      },
+      { flush: "post" }
+    );
+    const hasUnread = computed(() => {
+      return notifications.value.some((item) => item.isNew);
+    });
+    return (_ctx, _cache) => {
+      return _ctx.$isMobile.value && unref(blades).length <= 1 || _ctx.$isDesktop.value ? (openBlock(), createElementBlock("div", {
+        key: 0,
+        class: normalizeClass(["app-bar-header", {
+          "app-bar-header--collapsed": !_ctx.expanded && !_ctx.$isMobile.value,
+          "app-bar-header--mobile": _ctx.$isMobile.value
+        }])
+      }, [
+        createElementVNode("div", _hoisted_1$b, [
+          createElementVNode("div", _hoisted_2$7, [
+            createElementVNode("img", {
+              class: normalizeClass(["app-bar-header__logo-image", { "app-bar-header__logo-image--mobile": _ctx.$isMobile.value }]),
+              alt: "logo",
+              src: _ctx.logo,
+              onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$isMobile.value ? _ctx.$emit("toggle-menu") : _ctx.$emit("logo:click"))
+            }, null, 10, _hoisted_3$4),
+            hasUnread.value && !_ctx.expanded ? (openBlock(), createElementBlock("div", _hoisted_4$4)) : createCommentVNode("", true)
+          ]),
+          _ctx.$isMobile.value && unref(blades).length === 1 ? (openBlock(), createElementBlock("p", _hoisted_5$2, toDisplayString(viewTitle.value), 1)) : createCommentVNode("", true)
+        ]),
+        _ctx.$isMobile.value ? (openBlock(), createElementBlock("div", _hoisted_6$2, [
+          _ctx.$isMobile.value ? renderSlot(_ctx.$slots, "actions", { key: 0 }) : createCommentVNode("", true)
+        ])) : createCommentVNode("", true),
+        createVNode(Transition, {
+          name: "burger-fade",
+          mode: "out-in"
+        }, {
+          default: withCtx(() => [
+            _ctx.expanded && _ctx.$isDesktop.value ? (openBlock(), createElementBlock("button", {
+              key: 0,
+              ref: "menuButtonRef",
+              class: "app-bar-header__menu-button",
+              onClick: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("toggle-menu"))
+            }, [
+              createElementVNode("div", _hoisted_7$1, [
+                createVNode(unref(_sfc_main$j), {
+                  icon: unref(_sfc_main$n),
+                  size: "xs"
+                }, null, 8, ["icon"]),
+                hasUnread.value ? (openBlock(), createElementBlock("div", _hoisted_8)) : createCommentVNode("", true)
+              ])
+            ], 512)) : createCommentVNode("", true)
+          ]),
+          _: 1
+        })
+      ], 2)) : createCommentVNode("", true);
+    };
+  }
+});
+
+const _hoisted_1$a = { class: "app-bar-overlay__content app-bar-overlay__dropdowns" };
+const _sfc_main$d = /* @__PURE__ */ defineComponent({
+  __name: "AppBarOverlay",
+  props: {
+    isSidebarMode: { type: Boolean },
+    expanded: {}
+  },
+  emits: ["close"],
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Teleport, { to: "body" }, [
+        createElementVNode("div", {
+          class: normalizeClass(["app-bar-overlay", {
+            "app-bar-overlay--mobile": _ctx.$isMobile.value,
+            "app-bar-overlay--desktop": _ctx.$isDesktop.value,
+            "app-bar-overlay--sidebar": _ctx.isSidebarMode,
+            "app-bar-overlay--standalone-mobile": _ctx.$isMobile.value && !_ctx.isSidebarMode,
+            "app-bar-overlay--collapsed": !_ctx.expanded && !_ctx.$isMobile.value
+          }])
+        }, [
+          createElementVNode("div", _hoisted_1$a, [
+            renderSlot(_ctx.$slots, "default")
+          ])
+        ], 2)
+      ]);
+    };
+  }
+});
+
+const activeActionId = ref(null);
+function useAppBarMobileActions() {
+  const { getButtons } = useAppBarMobileButtons();
+  const {
+    showItem: showAction,
+    hideAllItems: hideAllActions,
+    toggleItem: toggleAction,
+    currentItem: currentAction,
+    isAnyItemVisible: isAnyActionVisible,
+    closeItem: closeAction
+  } = useToggleableContent(getButtons, activeActionId);
+  watch(
+    () => getButtons.value,
+    (newButtons) => {
+      if (activeActionId.value) {
+        const buttonStillExists = newButtons.some((button) => button.id === activeActionId.value);
+        if (!buttonStillExists) {
+          const activeButton = currentAction.value;
+          if (activeButton?.onClose) {
+            activeButton.onClose();
+          }
+          hideAllActions();
+        }
+      }
+    },
+    { deep: true }
+  );
+  return {
+    showAction,
+    hideAllActions,
+    toggleAction,
+    currentAction,
+    isAnyActionVisible,
+    closeAction
+  };
+}
+
+const _hoisted_1$9 = {
+  key: 0,
+  class: "app-bar-mobile-actions"
+};
+const _sfc_main$c = /* @__PURE__ */ defineComponent({
+  __name: "AppBarMobileActions",
+  props: {
+    isSidebarMode: { type: Boolean },
+    expanded: {}
+  },
+  setup(__props) {
+    const { getButtons } = useAppBarMobileButtons();
+    const { currentAction, toggleAction, hideAllActions, isAnyActionVisible } = useAppBarMobileActions();
+    const route = useRoute();
+    const handleButtonClick = (button) => {
+      if (currentAction.value?.id === button.id) {
+        button.onClose?.();
+        hideAllActions();
+        return;
+      }
+      if (currentAction.value) {
+        currentAction.value.onClose?.();
+      }
+      toggleAction(button.id);
+      if (!button.component && button.onClick) {
+        button.onClick();
+      }
+    };
+    const handleClose = (button) => {
+      button.onClose?.();
+      hideAllActions();
+    };
+    watch(route, () => {
+      hideAllActions();
+    });
+    return (_ctx, _cache) => {
+      return _ctx.$isMobile.value ? (openBlock(), createElementBlock("div", _hoisted_1$9, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(unref(getButtons), (button) => {
+          return openBlock(), createElementBlock("div", {
+            key: button.id
+          }, [
+            (button.isVisible !== void 0 ? button.isVisible : true) ? (openBlock(), createBlock(unref(_sfc_main$o), {
+              key: 0,
+              text: "",
+              class: normalizeClass(["app-bar-mobile-actions__button", { "app-bar-mobile-actions__button--active": button.id === unref(currentAction)?.id }]),
+              icon: button.icon,
+              "icon-size": "l",
+              onClick: ($event) => handleButtonClick(button)
+            }, null, 8, ["class", "icon", "onClick"])) : createCommentVNode("", true)
+          ]);
+        }), 128)),
+        createVNode(Transition, { name: "overlay" }, {
+          default: withCtx(() => [
+            unref(isAnyActionVisible) && unref(currentAction)?.component ? (openBlock(), createBlock(_sfc_main$d, {
+              key: 0,
+              "is-sidebar-mode": _ctx.isSidebarMode,
+              expanded: _ctx.expanded
+            }, {
+              default: withCtx(() => [
+                withDirectives((openBlock(), createBlock(resolveDynamicComponent(unref(currentAction)?.component), mergeProps(unref(currentAction)?.props || {}, { onClose: handleClose }), null, 16)), [
+                  [unref(vOnClickOutside), [handleClose, { ignore: [".app-bar-mobile-actions__button"] }]]
+                ])
+              ]),
+              _: 1
+            }, 8, ["is-sidebar-mode", "expanded"])) : createCommentVNode("", true)
+          ]),
+          _: 1
+        })
+      ])) : createCommentVNode("", true);
+    };
+  }
+});
+
+const _hoisted_1$8 = { class: "menu-sidebar__widgets" };
+const _hoisted_2$6 = {
+  key: 0,
+  class: "menu-sidebar__close-button"
+};
+const _hoisted_3$3 = { class: "menu-sidebar__content" };
+const _hoisted_4$3 = {
+  key: 0,
+  class: "menu-sidebar__content-main"
+};
+const _hoisted_5$1 = { class: "menu-sidebar__navmenu" };
+const _hoisted_6$1 = { class: "menu-sidebar__user" };
+const _sfc_main$b = /* @__PURE__ */ defineComponent({
+  __name: "MenuSidebar",
+  props: {
+    isOpened: { type: Boolean },
+    expanded: {}
+  },
+  emits: ["update:isOpened"],
+  setup(__props) {
+    return (_ctx, _cache) => {
+      const _component_VcButton = resolveComponent("VcButton");
+      return openBlock(), createBlock(unref(_sfc_main$g), {
+        "is-expanded": _ctx.$isMobile.value ? _ctx.isOpened : false,
+        position: "left",
+        render: "mobile",
+        onClose: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("update:isOpened", false))
+      }, {
+        header: withCtx(() => _cache[2] || (_cache[2] = [
+          createElementVNode("span", null, null, -1)
+        ])),
+        content: withCtx(() => [
+          createElementVNode("div", {
+            class: normalizeClass(["menu-sidebar__wrapper", {
+              "menu-sidebar__wrapper--expanded": _ctx.$isDesktop.value && _ctx.expanded,
+              "menu-sidebar__wrapper--collapsed": _ctx.$isDesktop.value && !_ctx.expanded
+            }])
+          }, [
+            createElementVNode("div", {
+              class: normalizeClass(["menu-sidebar__header", {
+                "menu-sidebar__header--mobile": _ctx.$isMobile.value
+              }])
+            }, [
+              createElementVNode("div", _hoisted_1$8, [
+                renderSlot(_ctx.$slots, "widgets")
+              ]),
+              _cache[3] || (_cache[3] = createElementVNode("div", { class: "menu-sidebar__spacer" }, null, -1)),
+              _ctx.$isDesktop.value ? (openBlock(), createElementBlock("div", _hoisted_2$6, [
+                createVNode(_component_VcButton, {
+                  "icon-class": "menu-sidebar__close-button-icon",
+                  icon: unref(_sfc_main$m),
+                  "icon-size": "xs",
+                  text: "",
+                  onClick: _cache[0] || (_cache[0] = withModifiers(($event) => _ctx.$emit("update:isOpened", false), ["stop"]))
+                }, null, 8, ["icon"])
+              ])) : createCommentVNode("", true)
+            ], 2),
+            createElementVNode("div", _hoisted_3$3, [
+              _ctx.$slots["widgets-active-content"] ? (openBlock(), createElementBlock("div", _hoisted_4$3, [
+                renderSlot(_ctx.$slots, "widgets-active-content")
+              ])) : createCommentVNode("", true),
+              _ctx.$isMobile.value ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+                createElementVNode("div", _hoisted_5$1, [
+                  renderSlot(_ctx.$slots, "navmenu")
+                ]),
+                createElementVNode("div", _hoisted_6$1, [
+                  renderSlot(_ctx.$slots, "user-dropdown")
+                ])
+              ], 64)) : renderSlot(_ctx.$slots, "app-switcher", { key: 2 })
+            ])
+          ], 2)
+        ]),
+        _: 3
+      }, 8, ["is-expanded"]);
+    };
+  }
+});
+
+const _hoisted_1$7 = { class: "app-bar-content__main" };
+const _hoisted_2$5 = { class: "app-bar-content__footer" };
+const _sfc_main$a = /* @__PURE__ */ defineComponent({
+  __name: "AppBarContent",
+  props: {
+    expanded: {}
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["app-bar-content", { "app-bar-content--collapsed": !_ctx.expanded }])
+      }, [
+        createElementVNode("div", _hoisted_1$7, [
+          renderSlot(_ctx.$slots, "navmenu")
+        ]),
+        createElementVNode("div", _hoisted_2$5, [
+          renderSlot(_ctx.$slots, "user-dropdown")
+        ])
+      ], 2);
+    };
+  }
+});
+
+const _hoisted_1$6 = {
+  class: /* @__PURE__ */ normalizeClass(["app-bar-button__button-container"])
+};
+const _hoisted_2$4 = { class: "app-bar-button__button-wrap" };
+const _sfc_main$9 = /* @__PURE__ */ defineComponent({
+  __name: "AppBarWidgetItem",
+  props: {
+    title: {},
+    icon: {},
+    beforeOpen: { type: Function },
+    isOpened: { type: Boolean },
+    widgetId: {}
+  },
+  emits: ["toggle"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { toggleWidget, currentWidget } = useAppBarWidgets();
+    const referenceButton = ref(null);
+    const isActive = computed(() => props.widgetId ? currentWidget.value?.id === props.widgetId : false);
+    function toggleContent() {
+      if (props.beforeOpen && typeof props.beforeOpen === "function" && props.beforeOpen() === false) {
+        return;
+      }
+      if (props.widgetId) {
+        toggleWidget(props.widgetId);
+        emit("toggle", isActive.value);
+      }
+    }
+    onMounted(() => {
+      if (props.isOpened && props.widgetId) {
+        toggleWidget(props.widgetId);
+      }
+    });
+    return (_ctx, _cache) => {
+      const _component_VcIcon = resolveComponent("VcIcon");
+      const _component_VcTooltip = resolveComponent("VcTooltip");
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["app-bar-button", { "app-bar-button--mobile": _ctx.$isMobile.value }])
+      }, [
+        createVNode(_component_VcTooltip, {
+          placement: "bottom",
+          offset: { crossAxis: 0, mainAxis: -10 },
+          delay: 1e3,
+          class: "tw-w-full"
+        }, createSlots({
+          default: withCtx(() => [
+            createElementVNode("button", {
+              ref_key: "referenceButton",
+              ref: referenceButton,
+              class: "app-bar-button__button",
+              onClick: withModifiers(toggleContent, ["stop"])
+            }, [
+              createElementVNode("div", _hoisted_1$6, [
+                renderSlot(_ctx.$slots, "trigger", {
+                  isActive: isActive.value,
+                  toggle: toggleContent
+                }, () => [
+                  createElementVNode("div", _hoisted_2$4, [
+                    createVNode(_component_VcIcon, {
+                      icon: _ctx.icon,
+                      size: "xl",
+                      class: normalizeClass(["app-bar-button__icon", { "app-bar-button__icon--active": isActive.value }])
+                    }, null, 8, ["icon", "class"])
+                  ])
+                ])
+              ])
+            ], 512)
+          ]),
+          _: 2
+        }, [
+          !isActive.value && !!_ctx.title ? {
+            name: "tooltip",
+            fn: withCtx(() => [
+              createTextVNode(toDisplayString(_ctx.title), 1)
+            ]),
+            key: "0"
+          } : void 0
+        ]), 1024)
+      ], 2);
+    };
+  }
+});
+
+const _hoisted_1$5 = { class: "vc-app-toolbar-menu" };
+const _hoisted_2$3 = { class: "vc-app-toolbar-menu__button" };
+const _hoisted_3$2 = {
+  key: 1,
+  class: "vc-app-toolbar-menu__accent"
+};
+const _hoisted_4$2 = {
+  key: 1,
+  class: "vc-app-toolbar-menu__accent"
+};
+const _sfc_main$8 = /* @__PURE__ */ defineComponent({
+  __name: "AppBarWidgetsMenu",
+  setup(__props) {
+    const { items } = useAppBarWidget();
+    function isBadgeActive(item) {
+      if (item.badge === void 0) {
+        return false;
+      }
+      if (typeof item.badge === "function") {
+        return item.badge();
+      }
+      return !!item.badge;
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$5, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(unref(items), (item) => {
+          return openBlock(), createElementBlock("div", {
+            key: item.id,
+            class: "vc-app-toolbar-menu__item"
+          }, [
+            item.component ? (openBlock(), createBlock(_sfc_main$9, {
+              key: 0,
+              "is-opened": isBadgeActive(item),
+              "widget-id": item.id,
+              onToggle: ($event) => item.onClick && item.onClick()
+            }, {
+              trigger: withCtx(({ isActive }) => [
+                createElementVNode("div", _hoisted_2$3, [
+                  createElementVNode("div", {
+                    class: normalizeClass(["vc-app-toolbar-menu__button-icon", {
+                      "vc-app-toolbar-menu__button-icon--active": isActive
+                    }])
+                  }, [
+                    item.icon ? (openBlock(), createBlock(unref(_sfc_main$j), {
+                      key: 0,
+                      icon: item.icon,
+                      size: "l"
+                    }, null, 8, ["icon"])) : createCommentVNode("", true),
+                    isBadgeActive(item) ? (openBlock(), createElementBlock("div", _hoisted_3$2)) : createCommentVNode("", true)
+                  ], 2)
+                ])
+              ]),
+              _: 2
+            }, 1032, ["is-opened", "widget-id", "onToggle"])) : item.onClick ? (openBlock(), createBlock(_sfc_main$9, {
+              key: 1,
+              onToggle: item.onClick
+            }, {
+              trigger: withCtx(({ isActive }) => [
+                createElementVNode("div", {
+                  class: normalizeClass(["vc-app-toolbar-menu__button-icon", {
+                    "vc-app-toolbar-menu__button-icon--active": isActive
+                  }])
+                }, [
+                  item.icon ? (openBlock(), createBlock(unref(_sfc_main$j), {
+                    key: 0,
+                    icon: item.icon,
+                    size: "l"
+                  }, null, 8, ["icon"])) : createCommentVNode("", true),
+                  isBadgeActive(item) ? (openBlock(), createElementBlock("div", _hoisted_4$2)) : createCommentVNode("", true)
+                ], 2)
+              ]),
+              _: 2
+            }, 1032, ["onToggle"])) : createCommentVNode("", true)
+          ]);
+        }), 128))
+      ]);
+    };
+  }
+});
+
+const _hoisted_1$4 = { class: "vc-app-bar__collapse-button-wrap" };
+const _sfc_main$7 = /* @__PURE__ */ defineComponent({
+  __name: "vc-app-bar",
+  props: {
+    logo: {},
+    title: {},
+    disableMenu: { type: Boolean }
+  },
+  emits: ["logo:click", "backlink:click"],
+  setup(__props) {
+    const {
+      state,
+      toggleSidebar,
+      toggleMenu: toggleMenuState,
+      closeAll,
+      toggleHoverExpanded,
+      isHoverExpanded
+    } = useAppMenuState();
+    const { currentWidget, hideAllWidgets, isAnyWidgetVisible } = useAppBarWidgets();
+    const isMobile = inject("isMobile", ref(false));
+    const isDesktop = inject("isDesktop", ref(true));
+    const collapseButtonHover = ref(false);
+    provide("appMenuState", { closeAll });
+    const toggleMenu = () => {
+      toggleMenuState();
+      if (!state.value.isMenuOpen) {
+        hideAllWidgets();
+      }
+    };
+    const handleMenuClose = (value) => {
+      if (!value) {
+        closeAll();
+        hideAllWidgets();
+      }
+    };
+    const handleHoverExpand = (shouldExpand) => {
+      toggleHoverExpanded(shouldExpand);
+    };
+    const appBarClasses = computed(() => {
+      return {
+        "vc-app-bar--mobile": isMobile.value,
+        "vc-app-bar--desktop": isDesktop.value,
+        "vc-app-bar--collapsed": !state.value.isSidebarExpanded && isDesktop.value,
+        "vc-app-bar--hover-expanded": isDesktop.value && isHoverExpanded.value,
+        "vc-app-bar--hover-collapsed": isDesktop.value && !state.value.isSidebarExpanded && !isHoverExpanded.value
+      };
+    });
+    const wrapClasses = computed(() => {
+      return {
+        "vc-app-bar__wrap--mobile-expanded": isMobile.value && state.value.isSidebarExpanded,
+        "vc-app-bar__wrap--desktop-collapsed": isDesktop.value && !state.value.isSidebarExpanded,
+        "vc-app-bar__wrap--desktop-expanded": isDesktop.value && state.value.isSidebarExpanded,
+        "vc-app-bar__wrap--hover-expanded": isDesktop.value && isHoverExpanded.value && !state.value.isSidebarExpanded,
+        "vc-app-bar__wrap--hover-collapsed": isDesktop.value && !isHoverExpanded.value && !state.value.isSidebarExpanded
+      };
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        _ctx.$isDesktop.value ? (openBlock(), createElementBlock("div", {
+          key: 0,
+          class: normalizeClass(["vc-app-bar--padding", {
+            "vc-app-bar--padding-expanded": unref(state).isSidebarExpanded
+          }])
+        }, null, 2)) : createCommentVNode("", true),
+        createElementVNode("div", {
+          class: normalizeClass(["vc-app-bar", appBarClasses.value]),
+          onMouseenter: _cache[4] || (_cache[4] = ($event) => _ctx.$isDesktop.value && !unref(state).isSidebarExpanded && handleHoverExpand(true)),
+          onMouseleave: _cache[5] || (_cache[5] = ($event) => _ctx.$isDesktop.value && !unref(state).isSidebarExpanded && handleHoverExpand(false))
+        }, [
+          createElementVNode("div", {
+            class: normalizeClass(["vc-app-bar__wrap", wrapClasses.value])
+          }, [
+            !_ctx.$isMobile.value ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: "vc-app-bar__collapse-button",
+              onClick: _cache[0] || (_cache[0] = //@ts-ignore
+              (...args) => unref(toggleSidebar) && unref(toggleSidebar)(...args))
+            }, [
+              createElementVNode("div", _hoisted_1$4, [
+                createVNode(Transition, { name: "rotate" }, {
+                  default: withCtx(() => [
+                    withDirectives(createVNode(unref(_sfc_main$j), {
+                      class: normalizeClass(["vc-app-bar__collapse-button-icon", { "rotate-180": !unref(state).isSidebarExpanded }]),
+                      icon: unref(_sfc_main$p),
+                      size: "xs"
+                    }, null, 8, ["icon", "class"]), [
+                      [vShow, true]
+                    ])
+                  ]),
+                  _: 1
+                })
+              ])
+            ])) : createCommentVNode("", true),
+            createElementVNode("div", {
+              class: normalizeClass(["vc-app-bar__wrapper", {
+                "vc-app-bar__wrapper--mobile": _ctx.$isMobile.value,
+                "vc-app-bar__wrapper--hover-collapsed": _ctx.$isDesktop.value && !unref(isHoverExpanded) && !unref(state).isSidebarExpanded
+              }]),
+              onMouseenter: _cache[2] || (_cache[2] = ($event) => collapseButtonHover.value = true),
+              onMouseleave: _cache[3] || (_cache[3] = ($event) => collapseButtonHover.value = false)
+            }, [
+              createVNode(_sfc_main$e, {
+                logo: _ctx.logo,
+                expanded: unref(state).isSidebarExpanded || unref(isHoverExpanded),
+                class: normalizeClass(["vc-app-bar__header", {
+                  "vc-app-bar__header--hover-expanded": _ctx.$isDesktop.value && unref(isHoverExpanded) && !unref(state).isSidebarExpanded,
+                  "vc-app-bar__header--collapsed": _ctx.$isDesktop.value && !unref(state).isSidebarExpanded && !unref(isHoverExpanded)
+                }]),
+                "onLogo:click": _cache[1] || (_cache[1] = ($event) => _ctx.$emit("logo:click")),
+                onToggleMenu: toggleMenu
+              }, {
+                actions: withCtx(() => [
+                  createVNode(_sfc_main$c, {
+                    "is-sidebar-mode": unref(state).isMenuOpen,
+                    expanded: unref(state).isSidebarExpanded
+                  }, null, 8, ["is-sidebar-mode", "expanded"])
+                ]),
+                _: 1
+              }, 8, ["logo", "expanded", "class"]),
+              unref(state).isMenuOpen ? (openBlock(), createBlock(_sfc_main$b, {
+                key: 0,
+                "is-opened": unref(state).isMenuOpen,
+                expanded: unref(state).isSidebarExpanded,
+                "onUpdate:isOpened": handleMenuClose
+              }, {
+                navmenu: withCtx(() => [
+                  renderSlot(_ctx.$slots, "navmenu")
+                ]),
+                "user-dropdown": withCtx(() => [
+                  renderSlot(_ctx.$slots, "user-dropdown")
+                ]),
+                "app-switcher": withCtx(() => [
+                  renderSlot(_ctx.$slots, "app-switcher")
+                ]),
+                widgets: withCtx(() => [
+                  createVNode(_sfc_main$8)
+                ]),
+                "widgets-active-content": withCtx(() => [
+                  unref(isAnyWidgetVisible) ? (openBlock(), createElementBlock("div", {
+                    key: 0,
+                    class: normalizeClass(["vc-app-bar__menu-dropdowns", { "vc-app-bar__menu-dropdowns--mobile": _ctx.$isMobile.value }])
+                  }, [
+                    (openBlock(), createBlock(resolveDynamicComponent(unref(currentWidget)?.component), mergeProps(unref(currentWidget)?.props || {}, { onClose: unref(hideAllWidgets) }), null, 16, ["onClose"]))
+                  ], 2)) : createCommentVNode("", true)
+                ]),
+                _: 3
+              }, 8, ["is-opened", "expanded"])) : createCommentVNode("", true),
+              _ctx.$isDesktop.value ? (openBlock(), createBlock(_sfc_main$a, {
+                key: 1,
+                expanded: unref(state).isSidebarExpanded
+              }, {
+                navmenu: withCtx(() => [
+                  renderSlot(_ctx.$slots, "navmenu")
+                ]),
+                "user-dropdown": withCtx(() => [
+                  renderSlot(_ctx.$slots, "user-dropdown")
+                ]),
+                _: 3
+              }, 8, ["expanded"])) : createCommentVNode("", true)
+            ], 34)
+          ], 2)
+        ], 34)
+      ], 64);
+    };
+  }
+});
+
+const _hoisted_1$3 = {
+  key: 0,
+  class: "vc-app-menu-link__icon"
+};
+const _hoisted_2$2 = {
+  key: 1,
+  class: "vc-app-menu-link__icon-letters"
+};
+const _hoisted_3$1 = { class: "vc-app-menu-link__title" };
+const _hoisted_4$1 = { class: "vc-app-menu-link__title-truncate" };
+const _hoisted_5 = {
+  key: 0,
+  class: "vc-app-menu-link__title-icon"
+};
+const _hoisted_6 = ["data-test-id", "onClick"];
+const _hoisted_7 = {
+  key: 1,
+  class: "vc-app-menu-link__icon-letters"
+};
+const _sfc_main$6 = /* @__PURE__ */ defineComponent({
+  __name: "vc-app-menu-link",
+  props: {
+    children: {},
+    sticky: { type: Boolean, default: true },
+    icon: {},
+    title: {},
+    url: {},
+    expand: { type: Boolean },
+    id: {}
+  },
+  emits: ["onClick"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const isOpened = ref(false);
+    const route = useRoute();
+    const params = Object.fromEntries(Object.entries(route.params).filter(([key]) => key !== "pathMatch"));
+    const isMenuItemActive = computed(() => isActive(props.url ?? "") && !props.children?.length);
+    watch(
+      () => route.path,
+      () => {
+        if (props.children && props.children.length && props.children.find((x) => x?.url === route?.path)) {
+          isOpened.value = true;
+        }
+      },
+      { immediate: true }
+    );
+    function onMenuItemClick() {
+      if (!props.children?.length) {
+        emit("onClick");
+      } else {
+        isOpened.value = !isOpened.value;
+      }
+    }
+    const isActive = (url) => {
+      if (url) {
+        let path = route.path;
+        if (Object.values(params).length) {
+          path = path.replace(Object.values(params)[0], "");
+        }
+        const active = path.endsWith(url);
+        if (active && props.children?.length) {
+          isOpened.value = true;
+        }
+        return active;
+      } else {
+        return false;
+      }
+    };
+    const twoLettersTitle = (title) => {
+      return unref(title)?.split(" ").slice(0, 2).map((word) => word[0]).join("");
+    };
+    onMounted(() => {
+      const storedState = localStorage.getItem(`vc_menu_${props.id}_isOpened`);
+      if (storedState) {
+        isOpened.value = JSON.parse(storedState);
+      }
+    });
+    watch(isOpened, (newValue) => {
+      localStorage.setItem(`vc_menu_${props.id}_isOpened`, JSON.stringify(newValue));
+    });
+    return (_ctx, _cache) => {
+      const _component_VcTooltip = resolveComponent("VcTooltip");
+      const _component_router_link = resolveComponent("router-link");
+      return openBlock(), createElementBlock(Fragment, null, [
+        createElementVNode("div", {
+          class: "vc-app-menu-link",
+          onClick: onMenuItemClick
+        }, [
+          createVNode(_component_VcTooltip, null, createSlots({
+            default: withCtx(() => [
+              createElementVNode("div", {
+                class: normalizeClass(["vc-app-menu-link__item", [
+                  {
+                    "vc-app-menu-link__item_active": isMenuItemActive.value,
+                    "vc-app-menu-link__item_no-hover": !_ctx.children?.length,
+                    "vc-app-menu-link__item_child-opened": _ctx.expand && isOpened.value,
+                    "vc-app-menu-link__item_collapsed": !_ctx.expand
+                  }
+                ]])
+              }, [
+                _ctx.icon ? (openBlock(), createElementBlock("div", _hoisted_1$3, [
+                  createVNode(unref(_sfc_main$j), {
+                    class: "vc-app-menu-link__icon-content",
+                    icon: _ctx.icon,
+                    size: "m"
+                  }, null, 8, ["icon"])
+                ])) : createCommentVNode("", true),
+                !_ctx.expand && !_ctx.icon ? (openBlock(), createElementBlock("div", _hoisted_2$2, toDisplayString(twoLettersTitle(_ctx.title)), 1)) : createCommentVNode("", true),
+                createVNode(Transition, { name: "opacity" }, {
+                  default: withCtx(() => [
+                    withDirectives(createElementVNode("div", _hoisted_3$1, [
+                      createElementVNode("div", _hoisted_4$1, toDisplayString(_ctx.title), 1),
+                      !!_ctx.children?.length && _ctx.expand || false ? (openBlock(), createElementBlock("div", _hoisted_5, [
+                        createVNode(unref(_sfc_main$j), {
+                          class: "vc-app-menu-item__title-icon",
+                          icon: isOpened.value ? _sfc_main$q : _sfc_main$r,
+                          size: "m"
+                        }, null, 8, ["icon"])
+                      ])) : createCommentVNode("", true)
+                    ], 512), [
+                      [vShow, _ctx.expand]
+                    ])
+                  ]),
+                  _: 1
+                })
+              ], 2)
+            ]),
+            _: 2
+          }, [
+            !_ctx.expand ? {
+              name: "tooltip",
+              fn: withCtx(() => [
+                createTextVNode(toDisplayString(_ctx.title), 1)
+              ]),
+              key: "0"
+            } : void 0
+          ]), 1024)
+        ]),
+        withDirectives(createElementVNode("div", {
+          class: normalizeClass(["vc-app-menu-link__child", {
+            "vc-app-menu-link__child-collapsed": !_ctx.expand
+          }])
+        }, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.children, (nested, i) => {
+            return openBlock(), createBlock(_component_VcTooltip, { key: i }, createSlots({
+              default: withCtx(() => [
+                _ctx.$hasAccess(nested.permissions) && nested.url ? (openBlock(), createBlock(_component_router_link, {
+                  key: 0,
+                  to: nested.url,
+                  custom: ""
+                }, {
+                  default: withCtx(() => [
+                    createElementVNode("div", {
+                      class: "vc-app-menu-link__child-item-link",
+                      "data-test-id": nested.routeId,
+                      onClick: ($event) => _ctx.$emit("onClick", nested)
+                    }, [
+                      (openBlock(), createElementBlock("div", {
+                        key: i,
+                        class: normalizeClass([
+                          {
+                            "vc-app-menu-link__child-item_active": isActive(nested.url ?? ""),
+                            "vc-app-menu-link__child-item_collapsed": !_ctx.expand,
+                            "vc-app-menu-link__child-item_expanded": _ctx.expand
+                          },
+                          "vc-app-menu-link__child-item"
+                        ])
+                      }, [
+                        nested.icon ? (openBlock(), createElementBlock("div", {
+                          key: 0,
+                          class: normalizeClass(["vc-app-menu-link__icon vc-app-menu-link__icon--child", {
+                            "vc-app-menu-link__icon-collapsed": !_ctx.expand
+                          }])
+                        }, [
+                          createVNode(unref(_sfc_main$j), {
+                            class: "vc-app-menu-link__icon-content",
+                            icon: nested.icon,
+                            size: "m"
+                          }, null, 8, ["icon"])
+                        ], 2)) : createCommentVNode("", true),
+                        !_ctx.expand && !nested.icon ? (openBlock(), createElementBlock("div", _hoisted_7, toDisplayString(twoLettersTitle(nested.title)), 1)) : createCommentVNode("", true),
+                        createVNode(Transition, { name: "opacity" }, {
+                          default: withCtx(() => [
+                            withDirectives(createElementVNode("p", {
+                              class: normalizeClass(["vc-app-menu-link__child-item-title", {
+                                "vc-app-menu-link__child-item-title--no-icon": !nested.icon
+                              }])
+                            }, toDisplayString(nested.title), 3), [
+                              [vShow, _ctx.expand]
+                            ])
+                          ]),
+                          _: 2
+                        }, 1024)
+                      ], 2))
+                    ], 8, _hoisted_6)
+                  ]),
+                  _: 2
+                }, 1032, ["to"])) : createCommentVNode("", true)
+              ]),
+              _: 2
+            }, [
+              !_ctx.expand ? {
+                name: "tooltip",
+                fn: withCtx(() => [
+                  createTextVNode(toDisplayString(nested.title), 1)
+                ]),
+                key: "0"
+              } : void 0
+            ]), 1024);
+          }), 128))
+        ], 2), [
+          [vShow, isOpened.value]
+        ])
+      ], 64);
+    };
+  }
+});
+
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+  __name: "vc-app-menu-item",
+  props: {
+    sticky: { type: Boolean, default: true },
+    isVisible: { type: Boolean },
+    url: {},
+    icon: {},
+    title: {},
+    children: { default: () => [] },
+    expand: { type: Boolean },
+    id: {}
+  },
+  emits: ["click"],
+  setup(__props) {
+    return (_ctx, _cache) => {
+      const _component_router_link = resolveComponent("router-link");
+      return openBlock(), createElementBlock("div", null, [
+        _ctx.url ? (openBlock(), createBlock(_component_router_link, {
+          key: 0,
+          to: _ctx.url,
+          custom: ""
+        }, {
+          default: withCtx(() => [
+            _ctx.isVisible ? (openBlock(), createBlock(_sfc_main$6, {
+              key: 0,
+              id: _ctx.id,
+              sticky: _ctx.sticky,
+              icon: _ctx.icon ?? "",
+              title: _ctx.title ?? "",
+              url: _ctx.url,
+              expand: _ctx.expand,
+              onOnClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("click"))
+            }, null, 8, ["id", "sticky", "icon", "title", "url", "expand"])) : createCommentVNode("", true)
+          ]),
+          _: 1
+        }, 8, ["to"])) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+          _ctx.isVisible ? (openBlock(), createBlock(_sfc_main$6, {
+            key: 0,
+            id: _ctx.id,
+            children: _ctx.children,
+            sticky: _ctx.sticky,
+            icon: _ctx.icon ?? "",
+            title: _ctx.title ?? "",
+            expand: _ctx.expand,
+            onOnClick: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("click", $event))
+          }, null, 8, ["id", "children", "sticky", "icon", "title", "expand"])) : createCommentVNode("", true)
+        ], 64))
+      ]);
+    };
+  }
+});
+
+const _hoisted_1$2 = { class: "vc-app-menu__menu-items" };
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  __name: "vc-app-menu",
+  props: {
+    version: { default: "" }
+  },
+  emits: ["item:click", "version:click"],
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    const isMobile = inject("isMobile");
+    const { menuItems } = useMenuService();
+    const { isExpanded, isHoverExpanded } = useMenuExpanded();
+    const { closeAll } = useAppMenuState();
+    const handleMenuItemClick = (item, nestedItem) => {
+      if (isMobile.value) {
+        closeAll();
+      }
+      emit("item:click", nestedItem ? nestedItem : item);
+    };
+    const isMenuVisible = computed(() => {
+      return !!menuItems.value.length;
+    });
+    return (_ctx, _cache) => {
+      return isMenuVisible.value ? (openBlock(), createElementBlock("div", {
+        key: 0,
+        class: normalizeClass(["vc-app-menu", {
+          "vc-app-menu--mobile": _ctx.$isMobile.value,
+          "vc-app-menu--collapsed": _ctx.$isDesktop.value && !unref(isExpanded),
+          "vc-app-menu--hover-expanded": unref(isHoverExpanded)
+        }])
+      }, [
+        createElementVNode("div", {
+          class: normalizeClass(["vc-app-menu__inner", {
+            "vc-app-menu__inner--desktop": _ctx.$isDesktop.value,
+            "vc-app-menu__inner--collapsed": _ctx.$isDesktop.value && !unref(isExpanded),
+            "vc-app-menu__inner--hover-expanded": unref(isHoverExpanded)
+          }])
+        }, [
+          createVNode(unref(VcContainer), {
+            "no-padding": true,
+            class: "vc-app-menu__container"
+          }, {
+            default: withCtx(() => [
+              createElementVNode("div", _hoisted_1$2, [
+                (openBlock(true), createElementBlock(Fragment, null, renderList(unref(menuItems), (item) => {
+                  return openBlock(), createBlock(_sfc_main$5, {
+                    id: item.id,
+                    key: item?.id,
+                    "data-test-id": item?.routeId,
+                    "is-visible": _ctx.$hasAccess(item.permissions) && (item.children?.some((child) => _ctx.$hasAccess(child.permissions)) ?? true),
+                    url: item.url,
+                    icon: item.groupIcon || item.icon,
+                    title: item.title,
+                    children: item.children,
+                    expand: _ctx.$isDesktop.value ? unref(isExpanded) || unref(isHoverExpanded) : true,
+                    onClick: ($event) => handleMenuItemClick(item, $event)
+                  }, null, 8, ["id", "data-test-id", "is-visible", "url", "icon", "title", "children", "expand", "onClick"]);
+                }), 128))
+              ])
+            ]),
+            _: 1
+          })
+        ], 2)
+      ], 2)) : createCommentVNode("", true);
+    };
+  }
+});
+
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  __name: "change-password-button",
+  setup(__props) {
+    const { open } = usePopup({ component: ChangePassword });
+    const handleClick = () => {
+      open();
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$i), {
+        icon: unref(_sfc_main$s),
+        title: _ctx.$t("SHELL.ACCOUNT.CHANGE_PASSWORD"),
+        "onTrigger:click": handleClick
+      }, null, 8, ["icon", "title"]);
+    };
+  }
+});
+
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "logout-button",
+  setup(__props) {
+    const { signOut } = useUser();
+    const router = useRouter();
+    const { closeBlade } = useBladeNavigation();
+    const handleLogout = async () => {
+      const isPrevented = await closeBlade(0);
+      if (!isPrevented) {
+        await signOut();
+        router.push({ name: "Login" });
+      }
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$i), {
+        icon: unref(_sfc_main$t),
+        title: _ctx.$t("SHELL.ACCOUNT.LOGOUT"),
+        "onTrigger:click": handleLogout
+      }, null, 8, ["icon", "title"]);
+    };
+  }
+});
+
+const _hoisted_1$1 = { class: "vc-app__main-content" };
+const _hoisted_2$1 = {
+  key: 0,
+  class: "vc-app__workspace"
+};
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  ...{
+    inheritAttrs: false
+  },
+  __name: "vc-app",
+  props: {
+    isReady: { type: Boolean },
+    logo: {},
+    version: {},
+    title: {},
+    avatar: {},
+    name: {},
+    disableMenu: { type: Boolean },
+    role: {}
+  },
+  emits: ["logo-click"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    console.debug("vc-app: Init vc-app");
+    const internalRoutes = inject("bladeRoutes");
+    const dynamicModules = inject(DynamicModulesKey, void 0);
+    const isAppReady = ref(props.isReady);
+    const router = useRouter();
+    const { openBlade, closeBlade, resolveBladeByName, blades, goToRoot } = useBladeNavigation();
+    const { appsList, switchApp, getApps } = useAppSwitcher();
+    const { loadFromHistory, notifications, markAllAsRead } = useNotifications();
+    const route = useRoute();
+    const { isAuthenticated } = useUser();
+    const routes = router.getRoutes();
+    const { register: registerMenuItem } = provideSettingsMenu();
+    const { register: registerAppBarWidget } = provideAppBarWidget();
+    const hasUnreadNotifications = computed(() => {
+      return notifications.value.some((item) => item.isNew);
+    });
+    const { t } = useI18n({ useScope: "global" });
+    const { register: registerMobileButton } = provideAppBarMobileButtonsService();
+    registerMenuItem({
+      id: "language-selector",
+      component: LanguageSelector,
+      order: 20
+    });
+    registerMenuItem({
+      id: "theme-selector",
+      component: _sfc_main$f,
+      order: 10
+    });
+    registerMenuItem({
+      id: "change-password",
+      component: _sfc_main$3,
+      order: 30
+    });
+    registerMenuItem({
+      id: "logout",
+      component: _sfc_main$2,
+      order: 100
+    });
+    registerAppBarWidget({
+      id: "notification-dropdown",
+      component: NotificationDropdown,
+      icon: _sfc_main$u,
+      order: 10,
+      badge: () => hasUnreadNotifications.value
+    });
+    registerMobileButton({
+      id: "notification-dropdown",
+      component: NotificationDropdown,
+      icon: _sfc_main$u,
+      order: 10
+    });
+    const onMenuItemClick = function(item) {
+      console.debug(`vc-app#onMenuItemClick() called.`);
+      if (item.routeId) {
+        openBlade(
+          {
+            blade: resolveBladeByName(item.routeId)
+          },
+          true
+        );
+      } else if (!item.routeId && item.url) {
+        const menuRoute = routes.find((r) => {
+          return "/" + r.path.split("/").filter((part) => part !== "")[1] === item.url || r.path === item.url;
+        });
+        if (typeof menuRoute === "undefined") {
+          openRoot();
+        } else {
+          router.push({ name: menuRoute?.name, params: route.params });
+        }
+      }
+    };
+    const openRoot = async () => {
+      const isPrevented = await closeBlade(1);
+      if (!isPrevented) {
+        router.push(goToRoot());
+      }
+    };
+    watchOnce(
+      () => props.isReady,
+      async (newVal) => {
+        isAppReady.value = newVal;
+        if (isAuthenticated.value && newVal) {
+          await loadFromHistory();
+          await getApps();
+        }
+      }
+    );
+    watch(isAuthenticated, (newVal) => {
+      isAppReady.value = newVal;
+    });
+    provide("internalRoutes", internalRoutes);
+    provide(DynamicModulesKey, dynamicModules);
+    provideDashboardService();
+    provideMenuService();
+    provideGlobalSearch();
+    onUnmounted(() => {
+      isAppReady.value = false;
+    });
+    return (_ctx, _cache) => {
+      const _component_VcLoading = resolveComponent("VcLoading");
+      const _component_VcAppSwitcher = resolveComponent("VcAppSwitcher");
+      const _component_VcBladeNavigation = resolveComponent("VcBladeNavigation");
+      return !isAppReady.value ? (openBlock(), createBlock(_component_VcLoading, {
+        key: 0,
+        active: "",
+        class: "vc-app__loader"
+      })) : (openBlock(), createElementBlock("div", {
+        key: 1,
+        class: normalizeClass(["vc-app", {
+          "vc-app_mobile": _ctx.$isMobile.value
+        }])
+      }, [
+        createElementVNode("div", _hoisted_1$1, [
+          createVNode(_sfc_main$7, {
+            class: "vc-app__app-bar",
+            logo: _ctx.logo,
+            title: _ctx.title,
+            "disable-menu": _ctx.disableMenu,
+            "onBacklink:click": _cache[1] || (_cache[1] = ($event) => unref(closeBlade)(unref(blades).length - 1)),
+            "onLogo:click": openRoot
+          }, {
+            "app-switcher": withCtx(() => [
+              renderSlot(_ctx.$slots, "app-switcher", {}, () => [
+                createVNode(_component_VcAppSwitcher, {
+                  "apps-list": unref(appsList),
+                  onOnClick: _cache[0] || (_cache[0] = ($event) => unref(switchApp)($event))
+                }, null, 8, ["apps-list"])
+              ])
+            ]),
+            navmenu: withCtx(() => [
+              !_ctx.disableMenu ? (openBlock(), createBlock(_sfc_main$4, {
+                key: 0,
+                ref: "menu",
+                class: "vc-app__app-menu",
+                version: _ctx.version,
+                "onItem:click": onMenuItemClick
+              }, null, 8, ["version"])) : createCommentVNode("", true)
+            ]),
+            "user-dropdown": withCtx(() => [
+              createVNode(unref(UserDropdownButton), {
+                "avatar-url": _ctx.avatar,
+                name: _ctx.name,
+                role: _ctx.role
+              }, null, 8, ["avatar-url", "name", "role"])
+            ]),
+            _: 3
+          }, 8, ["logo", "title", "disable-menu"]),
+          unref(isAuthenticated) ? (openBlock(), createElementBlock("div", _hoisted_2$1, [
+            createVNode(_component_VcBladeNavigation)
+          ])) : createCommentVNode("", true),
+          createVNode(unref(VcPopupContainer))
+        ])
+      ], 2));
+    };
+  }
+});
+
+const _hoisted_1 = { class: "vc-login-form__box" };
+const _hoisted_2 = { class: "vc-login-form__header" };
+const _hoisted_3 = { class: "vc-login-form__content" };
+const _hoisted_4 = { class: "vc-login-form__version" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "vc-login-form",
+  props: {
+    logo: {},
+    background: {},
+    title: { default: "Login" }
+  },
+  setup(__props) {
+    const props = __props;
+    const router = useRouter();
+    const backgroundImageHandler = computed(() => {
+      if (props.background) {
+        return `background: url(${CSS.escape(props.background)}) center / cover no-repeat`;
+      }
+      return void 0;
+    });
+    const logoImageHandler = computed(() => {
+      if (props.logo) {
+        return `background: url(${CSS.escape(props.logo)}) center / contain no-repeat`;
+      }
+      return void 0;
+    });
+    const version = router.currentRoute.value.meta?.appVersion;
+    console.debug("Init vc-login-form");
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: "vc-login-form__container",
+        style: normalizeStyle(backgroundImageHandler.value)
+      }, [
+        createElementVNode("div", {
+          class: "vc-login-form__logo",
+          style: normalizeStyle(logoImageHandler.value)
+        }, null, 4),
+        createElementVNode("div", _hoisted_1, [
+          createElementVNode("div", _hoisted_2, toDisplayString(_ctx.title), 1),
+          createElementVNode("div", _hoisted_3, [
+            renderSlot(_ctx.$slots, "default")
+          ])
+        ]),
+        createElementVNode("div", _hoisted_4, toDisplayString(unref(version)), 1)
+      ], 4);
+    };
+  }
+});
+
+export { LanguageSelector as L, _sfc_main$1 as _, _sfc_main as a, _sfc_main$g as b, addMenuItem as c, _sfc_main$i as d, _sfc_main$f as e, createMenuService as f, createSettingsMenuService as g, useMenuService as h, provideDashboardService as i, useDashboard as j, provideSettingsMenu as k, useSettingsMenu as l, addSettingsMenuItem as m, provideMenuService as p, registerDashboardWidget as r, useTheme as u };