eco-vue-js 0.3.67

package/dist/components/Modal/WModalStepper.vue.js

@@ -0,0 +1,121 @@
+import { defineComponent, useSlots, ref, computed, watch, openBlock, createBlock, withCtx, renderSlot, createTextVNode, toDisplayString, createElementVNode, normalizeStyle, unref, createVNode } from 'vue';
+import _sfc_main$1 from './WModalWrapper.vue.js';
+import _sfc_main$2 from '../Button/WButton.vue.js';
+import { SemanticType } from '../../utils/SemanticType.js';
+import _sfc_main$3 from '../Tabs/WTabs.vue.js';
+import { Notify } from '../../utils/Notify.js';
+
+const _hoisted_1 = { class: "bg-gray-200 dark:bg-gray-700 h-1 w-full" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "WModalStepper",
+  props: {
+    names: {},
+    loading: { type: Boolean }
+  },
+  emits: ["close:modal", "submit", "next", "previous", "update:current", "update:has-changes"],
+  setup(__props, { expose: __expose, emit }) {
+    const slots = useSlots();
+    const tabs = ref();
+    const defaultSlots = computed(() => slots.default?.().filter((item) => typeof item.type !== "symbol") ?? []);
+    const current = ref(0);
+    const previous = () => {
+      emit("previous", current.value);
+      tabs.value?.previous();
+    };
+    const next = () => {
+      emit("next", current.value);
+      const errorMessage = tabs.value?.validate(current.value);
+      if (errorMessage) {
+        Notify.warn({ title: "Form contains invalid values", caption: errorMessage.length < 200 ? errorMessage : void 0 });
+        return;
+      }
+      tabs.value?.next();
+    };
+    watch(current, (value) => {
+      emit("update:current", value);
+    }, { immediate: true });
+    __expose({
+      next,
+      previous
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$1, { maximized: "" }, {
+        title: withCtx(() => [
+          renderSlot(_ctx.$slots, "title", {}, () => [
+            createTextVNode(toDisplayString(_ctx.names?.[current.value]), 1)
+          ])
+        ]),
+        subtitle: withCtx(() => [
+          createElementVNode("div", _hoisted_1, [
+            createElementVNode("div", {
+              class: "bg-primary-default dark:bg-primary-dark h-full transition-[width]",
+              style: normalizeStyle({
+                width: 100 * (current.value + 1) / defaultSlots.value.length + "%"
+              })
+            }, null, 4)
+          ])
+        ]),
+        actions: withCtx(() => [
+          current.value === 0 ? (openBlock(), createBlock(_sfc_main$2, {
+            key: 0,
+            disabled: _ctx.loading,
+            "semantic-type": unref(SemanticType).SECONDARY,
+            class: "w-full",
+            onClick: _cache[2] || (_cache[2] = ($event) => _ctx.$emit("close:modal"))
+          }, {
+            default: withCtx(() => [
+              createTextVNode(" Close ")
+            ]),
+            _: 1
+          }, 8, ["disabled", "semantic-type"])) : (openBlock(), createBlock(_sfc_main$2, {
+            key: 1,
+            disabled: _ctx.loading,
+            "semantic-type": unref(SemanticType).SECONDARY,
+            class: "w-full",
+            onClick: previous
+          }, {
+            default: withCtx(() => [
+              createTextVNode(" Back ")
+            ]),
+            _: 1
+          }, 8, ["disabled", "semantic-type"])),
+          current.value === defaultSlots.value.length - 1 ? (openBlock(), createBlock(_sfc_main$2, {
+            key: 2,
+            "semantic-type": unref(SemanticType).PRIMARY,
+            loading: _ctx.loading,
+            class: "w-full",
+            onClick: _cache[3] || (_cache[3] = ($event) => _ctx.$emit("submit"))
+          }, {
+            default: withCtx(() => [
+              createTextVNode(" Submit ")
+            ]),
+            _: 1
+          }, 8, ["semantic-type", "loading"])) : (openBlock(), createBlock(_sfc_main$2, {
+            key: 3,
+            "semantic-type": unref(SemanticType).PRIMARY,
+            loading: _ctx.loading,
+            class: "w-full",
+            onClick: next
+          }, {
+            default: withCtx(() => [
+              createTextVNode(" Next ")
+            ]),
+            _: 1
+          }, 8, ["semantic-type", "loading"]))
+        ]),
+        default: withCtx(() => [
+          createVNode(_sfc_main$3, {
+            ref_key: "tabs",
+            ref: tabs,
+            slots: defaultSlots.value,
+            "onUpdate:current": _cache[0] || (_cache[0] = ($event) => current.value = $event),
+            "onUpdate:hasChanges": _cache[1] || (_cache[1] = ($event) => _ctx.$emit("update:has-changes", $event))
+          }, null, 8, ["slots"])
+        ]),
+        _: 3
+      });
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/Modal/WModalStepper.vue2.js

@@ -0,0 +1,5 @@
+import _sfc_main from './WModalStepper.vue.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/Modal/WModalWrapper.vue.d.ts

@@ -0,0 +1,21 @@
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+    maximized: {
+        type: import("vue").PropType<boolean>;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    maximized: {
+        type: import("vue").PropType<boolean>;
+    };
+}>>, {}, {}>, {
+    title?(_: {}): any;
+    subtitle?(_: {}): any;
+    default?(_: {}): any;
+    actions?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=WModalWrapper.vue.d.ts.map

package/dist/components/Modal/WModalWrapper.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WModalWrapper.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/Modal/WModalWrapper.vue.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAmIA,wBAA8G;AAI9G,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAAE,QAAO;QAClD,MAAM,EAAE,CAAC,CAAC;KACT,CAAA;CAAE,CAAC"}

package/dist/components/Modal/WModalWrapper.vue.js

@@ -0,0 +1,39 @@
+import { defineComponent, openBlock, createElementBlock, normalizeClass, createElementVNode, renderSlot } from 'vue';
+
+const _hoisted_1 = { class: "sticky top-0 z-[1] bg-default dark:bg-default-dark" };
+const _hoisted_2 = { class: "text-accent font-semibold text-center p-[var(--modal-wrapper-padding,2rem)] flex justify-center items-center text-2xl sm-not:text-xl text-balance" };
+const _hoisted_3 = { class: "sm:px-[var(--modal-wrapper-padding,2rem)]" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "WModalWrapper",
+  props: {
+    maximized: { type: Boolean }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["bg-default dark:bg-default-dark overflow-y-auto overflow-x-hidden overscroll-contain w-[var(--modal-wrapper-width,35rem)] max-w-[calc(100%-var(--modal-wrapper-padding,2rem)*2)] max-h-[calc(100%-var(--modal-wrapper-padding,2rem)*2)] shadow-md rounded-3xl", {
+          "sm-not:max-w-full sm-not:h-full sm-not:rounded-none sm-not:max-h-full": _ctx.maximized
+        }])
+      }, [
+        createElementVNode("div", _hoisted_1, [
+          createElementVNode("div", _hoisted_2, [
+            renderSlot(_ctx.$slots, "title")
+          ]),
+          renderSlot(_ctx.$slots, "subtitle")
+        ]),
+        createElementVNode("div", _hoisted_3, [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        createElementVNode("div", {
+          class: normalizeClass(["sticky bottom-0 flex justify-center p-[var(--modal-wrapper-padding,2rem)] gap-[var(--modal-wrapper-padding,2rem)] w-full bg-default dark:bg-default-dark", {
+            "sm-not:flex-col": !_ctx.maximized
+          }])
+        }, [
+          renderSlot(_ctx.$slots, "actions")
+        ], 2)
+      ], 2);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/Modal/WModalWrapper.vue2.js

@@ -0,0 +1,5 @@
+import _sfc_main from './WModalWrapper.vue.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/Modal/components/ModalCloseButton.vue.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (value: MouseEvent) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>> & {
+    onClick?: ((value: MouseEvent) => any) | undefined;
+}, {}, {}>;
+export default _default;
+//# sourceMappingURL=ModalCloseButton.vue.d.ts.map

package/dist/components/Modal/components/ModalCloseButton.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModalCloseButton.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/Modal/components/ModalCloseButton.vue.ts"],"names":[],"mappings":";;;;;AAyEA,wBAAkD"}

package/dist/components/Modal/components/ModalCloseButton.vue.js

@@ -0,0 +1,23 @@
+import { defineComponent, ref, onMounted, openBlock, createElementBlock } from 'vue';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ModalCloseButton",
+  emits: ["click"],
+  setup(__props) {
+    const closeButton = ref();
+    onMounted(() => {
+      closeButton.value?.focus();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("button", {
+        ref_key: "closeButton",
+        ref: closeButton,
+        class: "cursor-pointer absolute top-0 left-0 h-full w-full -z-10 outline-none",
+        title: "Click outside to close modal",
+        onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("click", $event))
+      }, null, 512);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/Modal/components/ModalCloseButton.vue2.js

@@ -0,0 +1,5 @@
+import _sfc_main from './ModalCloseButton.vue.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/Modal/modals/Confirm/ConfirmModal.vue.d.ts

@@ -0,0 +1,76 @@
+import { SemanticType } from '../../../../utils/SemanticType';
+declare const _default: import("vue").DefineComponent<{
+    title: {
+        type: import("vue").PropType<string>;
+        required: true;
+    };
+    description: {
+        type: import("vue").PropType<string>;
+        required: true;
+    };
+    acceptText: {
+        type: import("vue").PropType<string>;
+    };
+    acceptSemanticType: {
+        type: import("vue").PropType<SemanticType>;
+    };
+    intermediateText: {
+        type: import("vue").PropType<string>;
+    };
+    intermediateSemanticType: {
+        type: import("vue").PropType<SemanticType>;
+    };
+    cancelText: {
+        type: import("vue").PropType<string>;
+    };
+    onAccept: {
+        type: import("vue").PropType<() => void | Promise<void>>;
+        required: true;
+    };
+    onIntermediate: {
+        type: import("vue").PropType<() => void | Promise<void>>;
+    };
+    onCancel: {
+        type: import("vue").PropType<() => void>;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "close:modal": () => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    title: {
+        type: import("vue").PropType<string>;
+        required: true;
+    };
+    description: {
+        type: import("vue").PropType<string>;
+        required: true;
+    };
+    acceptText: {
+        type: import("vue").PropType<string>;
+    };
+    acceptSemanticType: {
+        type: import("vue").PropType<SemanticType>;
+    };
+    intermediateText: {
+        type: import("vue").PropType<string>;
+    };
+    intermediateSemanticType: {
+        type: import("vue").PropType<SemanticType>;
+    };
+    cancelText: {
+        type: import("vue").PropType<string>;
+    };
+    onAccept: {
+        type: import("vue").PropType<() => void | Promise<void>>;
+        required: true;
+    };
+    onIntermediate: {
+        type: import("vue").PropType<() => void | Promise<void>>;
+    };
+    onCancel: {
+        type: import("vue").PropType<() => void>;
+    };
+}>> & {
+    "onClose:modal"?: (() => any) | undefined;
+}, {}, {}>;
+export default _default;
+//# sourceMappingURL=ConfirmModal.vue.d.ts.map

package/dist/components/Modal/modals/Confirm/ConfirmModal.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfirmModal.vue.d.ts","sourceRoot":"","sources":["../../../../../../src/components/Modal/modals/Confirm/ConfirmModal.vue.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,YAAY,EAAC,MAAM,sBAAsB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6NjD,wBAAkD"}

package/dist/components/Modal/modals/Confirm/ConfirmModal.vue.js

@@ -0,0 +1,5 @@
+import _sfc_main from './ConfirmModal.vue2.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/Modal/modals/Confirm/ConfirmModal.vue2.js

@@ -0,0 +1,112 @@
+import { defineComponent, ref, openBlock, createBlock, withCtx, createTextVNode, toDisplayString, createVNode, unref, withModifiers, createCommentVNode, createElementVNode } from 'vue';
+import _sfc_main$1 from '../../WModalWrapper.vue.js';
+import _sfc_main$2 from '../../../Button/WButton.vue.js';
+import { SemanticType } from '../../../../utils/SemanticType.js';
+
+const _hoisted_1 = { class: "text-base text-accent font-normal text-center min-h-[1.25rem] mb-8 sm-not:-px--inner-margin text-balance" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ConfirmModal",
+  props: {
+    title: {},
+    description: {},
+    acceptText: {},
+    acceptSemanticType: {},
+    intermediateText: {},
+    intermediateSemanticType: {},
+    cancelText: {},
+    onAccept: { type: Function },
+    onIntermediate: { type: Function },
+    onCancel: { type: Function }
+  },
+  emits: ["close:modal"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const loadingAccept = ref(false);
+    const loadingIntermediate = ref(false);
+    const intermediate = () => {
+      if (loadingIntermediate.value || loadingAccept.value)
+        return;
+      const promise = props.onIntermediate?.();
+      if (promise) {
+        loadingIntermediate.value = true;
+        promise.then(() => {
+          emit("close:modal");
+        }).finally(() => {
+          loadingIntermediate.value = false;
+        });
+      } else {
+        emit("close:modal");
+      }
+    };
+    const accept = () => {
+      if (loadingIntermediate.value || loadingAccept.value)
+        return;
+      const promise = props.onAccept();
+      if (promise) {
+        loadingAccept.value = true;
+        promise.then(() => {
+          emit("close:modal");
+        }).finally(() => {
+          loadingAccept.value = false;
+        });
+      } else {
+        emit("close:modal");
+      }
+    };
+    const cancel = () => {
+      props.onCancel?.();
+      emit("close:modal");
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$1, { class: "[--modal-wrapper-width:40rem]" }, {
+        title: withCtx(() => [
+          createTextVNode(toDisplayString(_ctx.title), 1)
+        ]),
+        actions: withCtx(() => [
+          createVNode(_sfc_main$2, {
+            "semantic-type": unref(SemanticType).SECONDARY,
+            disabled: loadingAccept.value,
+            class: "w-full",
+            onClick: withModifiers(cancel, ["stop", "prevent"])
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(_ctx.cancelText || "Cancel"), 1)
+            ]),
+            _: 1
+          }, 8, ["semantic-type", "disabled", "onClick"]),
+          _ctx.intermediateText ? (openBlock(), createBlock(_sfc_main$2, {
+            key: 0,
+            "semantic-type": _ctx.intermediateSemanticType ?? unref(SemanticType).SECONDARY,
+            loading: loadingIntermediate.value,
+            disabled: loadingAccept.value,
+            class: "w-full",
+            onClick: withModifiers(intermediate, ["stop", "prevent"])
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(_ctx.intermediateText), 1)
+            ]),
+            _: 1
+          }, 8, ["semantic-type", "loading", "disabled", "onClick"])) : createCommentVNode("", true),
+          createVNode(_sfc_main$2, {
+            "semantic-type": _ctx.acceptSemanticType ?? unref(SemanticType).PRIMARY,
+            loading: loadingAccept.value,
+            disabled: loadingIntermediate.value,
+            class: "w-full",
+            onClick: withModifiers(accept, ["stop", "prevent"])
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(_ctx.acceptText || "Accept"), 1)
+            ]),
+            _: 1
+          }, 8, ["semantic-type", "loading", "disabled", "onClick"])
+        ]),
+        default: withCtx(() => [
+          createElementVNode("div", _hoisted_1, toDisplayString(_ctx.description), 1)
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/Modal/modals/Confirm/types.d.ts

@@ -0,0 +1,14 @@
+import type { SemanticType } from '../../../../utils/SemanticType';
+export type ConfirmModalProps = {
+    title: string;
+    description: string;
+    acceptText?: string;
+    acceptSemanticType?: SemanticType;
+    intermediateText?: string;
+    intermediateSemanticType?: SemanticType;
+    cancelText?: string;
+    onAccept: () => void | Promise<void>;
+    onIntermediate?: () => void | Promise<void>;
+    onCancel?: () => void;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/components/Modal/modals/Confirm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/components/Modal/modals/Confirm/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,sBAAsB,CAAA;AAEtD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,kBAAkB,CAAC,EAAE,YAAY,CAAA;IACjC,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,wBAAwB,CAAC,EAAE,YAAY,CAAA;IACvC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACpC,cAAc,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC3C,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;CACtB,CAAA"}

package/dist/components/Nav/WNavBar.vue.d.ts

@@ -0,0 +1,14 @@
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:isOpen": (value: boolean) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>> & {
+    "onUpdate:isOpen"?: ((value: boolean) => any) | undefined;
+}, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=WNavBar.vue.d.ts.map

package/dist/components/Nav/WNavBar.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WNavBar.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/Nav/WNavBar.vue.ts"],"names":[],"mappings":";;;;;;;AAsKA,wBAA8G;AAe9G,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAAE,QAAO;QAClD,MAAM,EAAE,CAAC,CAAC;KACT,CAAA;CAAE,CAAC"}

package/dist/components/Nav/WNavBar.vue.js

@@ -0,0 +1,69 @@
+import { defineComponent, ref, openBlock, createElementBlock, Fragment, createVNode, Transition, withCtx, withModifiers, createCommentVNode, createElementVNode, normalizeClass, renderSlot, unref } from 'vue';
+import IconMenu from '../../assets/icons/sax/IconMenu.svg.js';
+import { isClientSide } from '../../utils/utils.js';
+
+const _hoisted_1 = ["onClick"];
+const _hoisted_2 = /* @__PURE__ */ createElementVNode("div", { class: "h-[calc(100%+1px)]" }, null, -1);
+const _hoisted_3 = [
+  _hoisted_2
+];
+const _hoisted_4 = { class: "overflow-hidden mt-[3.75rem] bg-default dark:bg-default-dark" };
+const _hoisted_5 = ["onClick"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "WNavBar",
+  emits: ["update:isOpen"],
+  setup(__props, { emit }) {
+    const getHasBackdrop = () => {
+      return isClientSide && window.innerWidth < 1280;
+    };
+    const hasBackdrop = ref(getHasBackdrop());
+    const isOpen = ref(false);
+    const toggle = () => {
+      hasBackdrop.value = getHasBackdrop();
+      isOpen.value = !isOpen.value;
+      emit("update:isOpen", isOpen.value);
+    };
+    const close = () => {
+      isOpen.value = false;
+      emit("update:isOpen", false);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        createVNode(Transition, {
+          "enter-active-class": "transition-opacity",
+          "leave-active-class": "transition-opacity",
+          "enter-from-class": "opacity-0",
+          "leave-to-class": "opacity-0"
+        }, {
+          default: withCtx(() => [
+            isOpen.value && hasBackdrop.value ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              title: "Click to close",
+              class: "fixed top-0 left-0 h-full w-full backdrop-blur bg-primary-light/40 dark:bg-primary-darkest/40 z-30 overflow-y-auto overflow-x-hidden no-scrollbar overscroll-contain print:hidden",
+              onClick: withModifiers(close, ["stop", "prevent"])
+            }, _hoisted_3, 8, _hoisted_1)) : createCommentVNode("", true)
+          ]),
+          _: 1
+        }),
+        createElementVNode("div", {
+          class: normalizeClass(["fixed z-30 top-0 left-0 h-full grid overflow-hidden transition-[grid-template-columns] duration-200 shadow-md xl:shadow-none xl:grid-cols-[1fr] xl-not:bg-default xl-not:dark:bg-default-dark print:hidden", {
+            "xl-not:grid-cols-[0fr]": !isOpen.value,
+            "grid-cols-[1fr]": isOpen.value
+          }])
+        }, [
+          createElementVNode("div", _hoisted_4, [
+            renderSlot(_ctx.$slots, "default")
+          ])
+        ], 2),
+        createElementVNode("div", {
+          class: normalizeClass(["fixed top-0 left-0 xl:hidden flex square-[3.75rem] items-center justify-center cursor-pointer w-ripple z-30 print:hidden", { "text-primary-default": isOpen.value }]),
+          onClick: withModifiers(toggle, ["stop"])
+        }, [
+          createVNode(unref(IconMenu))
+        ], 10, _hoisted_5)
+      ], 64);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/Nav/WNavBar.vue2.js

@@ -0,0 +1,5 @@
+import _sfc_main from './WNavBar.vue.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/Nav/WNavItem.vue.d.ts

@@ -0,0 +1,69 @@
+import { type RouteLocationRaw } from 'vue-router';
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+    icon: {
+        type: import("vue").PropType<SVGComponent>;
+    };
+    to: {
+        type: import("vue").PropType<RouteLocationRaw>;
+        required: true;
+    };
+    title: {
+        type: import("vue").PropType<string>;
+        required: true;
+    };
+    count: {
+        type: import("vue").PropType<number>;
+    };
+    counter: {
+        type: import("vue").PropType<number>;
+    };
+    noQuery: {
+        type: import("vue").PropType<boolean>;
+    };
+    skeleton: {
+        type: import("vue").PropType<boolean>;
+    };
+    hasActive: {
+        type: import("vue").PropType<boolean>;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:isActive": (value: Record<string, boolean>) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    icon: {
+        type: import("vue").PropType<SVGComponent>;
+    };
+    to: {
+        type: import("vue").PropType<RouteLocationRaw>;
+        required: true;
+    };
+    title: {
+        type: import("vue").PropType<string>;
+        required: true;
+    };
+    count: {
+        type: import("vue").PropType<number>;
+    };
+    counter: {
+        type: import("vue").PropType<number>;
+    };
+    noQuery: {
+        type: import("vue").PropType<boolean>;
+    };
+    skeleton: {
+        type: import("vue").PropType<boolean>;
+    };
+    hasActive: {
+        type: import("vue").PropType<boolean>;
+    };
+}>> & {
+    "onUpdate:isActive"?: ((value: Record<string, boolean>) => any) | undefined;
+}, {}, {}>, {
+    icon?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=WNavItem.vue.d.ts.map

package/dist/components/Nav/WNavItem.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WNavItem.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/Nav/WNavItem.vue.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkC,KAAK,gBAAgB,EAAC,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0NjF,wBAA8G;AAiB9G,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAAE,QAAO;QAClD,MAAM,EAAE,CAAC,CAAC;KACT,CAAA;CAAE,CAAC"}