eco-vue-js 0.3.67

package/dist/components/Tabs/WTabsColumns.vue.js

@@ -0,0 +1,33 @@
+import { defineComponent, unref, openBlock, createBlock, createElementBlock, normalizeStyle, Fragment, renderList, resolveDynamicComponent } from 'vue';
+import { getIsMobile } from '../../utils/mobile.js';
+import _sfc_main$1 from './WTabs.vue.js';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "WTabsColumns",
+  props: {
+    names: {}
+  },
+  setup(__props) {
+    const isMobile = getIsMobile();
+    return (_ctx, _cache) => {
+      return unref(isMobile) ? (openBlock(), createBlock(_sfc_main$1, {
+        key: 0,
+        names: _ctx.names,
+        slots: _ctx.$slots.default?.()
+      }, null, 8, ["names", "slots"])) : (openBlock(), createElementBlock("div", {
+        key: 1,
+        class: "grid grid-cols-[repeat(var(--w-columns-length),calc(50%-((var(--w-columns-length)-1)*var(--modal-wrapper-padding,2rem)/2)))] gap-[var(--modal-wrapper-padding,2rem)]",
+        style: normalizeStyle({ "--w-columns-length": _ctx.$slots.default?.().length })
+      }, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.$slots.default?.(), (slot, index) => {
+          return openBlock(), createBlock(resolveDynamicComponent(slot), {
+            key: index,
+            title: _ctx.names[index]
+          }, null, 8, ["title"]);
+        }), 128))
+      ], 4));
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/Tabs/WTabsColumns.vue2.js

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

package/dist/components/Tabs/components/TabItem.vue.d.ts

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

package/dist/components/Tabs/components/TabItem.vue.d.ts.map

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

package/dist/components/Tabs/components/TabItem.vue.js

@@ -0,0 +1,42 @@
+import { defineComponent, ref, watch, toRef, nextTick, withDirectives, openBlock, createElementBlock, renderSlot, vShow } from 'vue';
+import { useTabItemActiveListener } from '../use/useTabItemActiveListener.js';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "TabItem",
+  props: {
+    isActive: { type: Boolean }
+  },
+  emits: ["update:height"],
+  setup(__props, { expose: __expose, emit }) {
+    const props = __props;
+    const { callListeners } = useTabItemActiveListener();
+    const element = ref();
+    const emitHeight = () => {
+      if (!element.value)
+        return;
+      emit("update:height", element.value.offsetHeight);
+    };
+    watch(toRef(props, "isActive"), async (value) => {
+      if (value)
+        await nextTick();
+      emitHeight();
+      if (value)
+        callListeners();
+    }, { immediate: true });
+    __expose({
+      emitHeight
+    });
+    return (_ctx, _cache) => {
+      return withDirectives((openBlock(), createElementBlock("div", {
+        ref_key: "element",
+        ref: element
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ], 512)), [
+        [vShow, _ctx.isActive]
+      ]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/Tabs/components/TabItem.vue2.js

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

package/dist/components/Tabs/models/injection.d.ts

@@ -0,0 +1,4 @@
+import type { InjectionKey } from 'vue';
+export declare const wTabItemListener: InjectionKey<((value: () => void) => void) | undefined>;
+export declare const wTabItemUnlistener: InjectionKey<((value: () => void) => void) | undefined>;
+//# sourceMappingURL=injection.d.ts.map

package/dist/components/Tabs/models/injection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injection.d.ts","sourceRoot":"","sources":["../../../../../src/components/Tabs/models/injection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,KAAK,CAAA;AAErC,eAAO,MAAM,gBAAgB,wBAAuD,MAAM,IAAI,KAAK,IAAI,cAAc,CAAA;AAErH,eAAO,MAAM,kBAAkB,wBAAyD,MAAM,IAAI,KAAK,IAAI,cAAc,CAAA"}

package/dist/components/Tabs/models/injection.js

@@ -0,0 +1,4 @@
+const wTabItemListener = Symbol("wTabItemListener");
+const wTabItemUnlistener = Symbol("wTabItemUnlistener");
+
+export { wTabItemListener, wTabItemUnlistener };

package/dist/components/Tabs/use/useTabActiveListener.d.ts

@@ -0,0 +1,2 @@
+export declare const useTabActiveListener: (listener: () => void) => void;
+//# sourceMappingURL=useTabActiveListener.d.ts.map

package/dist/components/Tabs/use/useTabActiveListener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTabActiveListener.d.ts","sourceRoot":"","sources":["../../../../../src/components/Tabs/use/useTabActiveListener.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,oBAAoB,aAAc,MAAM,IAAI,SAWxD,CAAA"}

package/dist/components/Tabs/use/useTabActiveListener.js

@@ -0,0 +1,15 @@
+import { inject, onMounted, onBeforeUnmount } from 'vue';
+import { wTabItemListener, wTabItemUnlistener } from '../models/injection.js';
+
+const useTabActiveListener = (listener) => {
+  const tabItemListenerInjected = inject(wTabItemListener, null);
+  const tabItemUnlistenerInjected = inject(wTabItemUnlistener, null);
+  onMounted(() => {
+    tabItemListenerInjected?.(listener);
+  });
+  onBeforeUnmount(() => {
+    tabItemUnlistenerInjected?.(listener);
+  });
+};
+
+export { useTabActiveListener };

package/dist/components/Tabs/use/useTabItemActiveListener.d.ts

@@ -0,0 +1,4 @@
+export declare const useTabItemActiveListener: () => {
+    callListeners: () => void;
+};
+//# sourceMappingURL=useTabItemActiveListener.d.ts.map

package/dist/components/Tabs/use/useTabItemActiveListener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTabItemActiveListener.d.ts","sourceRoot":"","sources":["../../../../../src/components/Tabs/use/useTabItemActiveListener.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,wBAAwB;;CA8BpC,CAAA"}

package/dist/components/Tabs/use/useTabItemActiveListener.js

@@ -0,0 +1,28 @@
+import { ref, provide, onUnmounted } from 'vue';
+import { wTabItemListener, wTabItemUnlistener } from '../models/injection.js';
+
+const useTabItemActiveListener = () => {
+  const listeners = ref([]);
+  const addListener = (value) => {
+    listeners.value.push(value);
+  };
+  provide(wTabItemListener, addListener);
+  const titleMapUnlistener = (value) => {
+    const index = listeners.value.indexOf(value);
+    if (index === -1)
+      return;
+    listeners.value.splice(index, 1);
+  };
+  provide(wTabItemUnlistener, titleMapUnlistener);
+  const callListeners = () => {
+    listeners.value.forEach((cb) => cb());
+  };
+  onUnmounted(() => {
+    listeners.value = [];
+  });
+  return {
+    callListeners
+  };
+};
+
+export { useTabItemActiveListener };

package/dist/components/Toggle/WToggle.vue.d.ts

@@ -0,0 +1,69 @@
+declare const _default: <Value extends boolean | null = boolean>(__VLS_props: {
+    modelValue: Value;
+    title?: string | undefined;
+    small?: boolean | undefined;
+    disabled?: boolean | undefined;
+    loading?: boolean | undefined;
+    readonly?: boolean | undefined;
+    rightLabel?: boolean | undefined;
+    noMargin?: boolean | undefined;
+    description?: string | undefined;
+    intermediate?: boolean | undefined;
+} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, __VLS_ctx?: Pick<{
+    props: {
+        modelValue: Value;
+        title?: string | undefined;
+        small?: boolean | undefined;
+        disabled?: boolean | undefined;
+        loading?: boolean | undefined;
+        readonly?: boolean | undefined;
+        rightLabel?: boolean | undefined;
+        noMargin?: boolean | undefined;
+        description?: string | undefined;
+        intermediate?: boolean | undefined;
+    };
+    expose(exposed: {}): void;
+    attrs: any;
+    slots: {};
+    emit: (e: 'update:modelValue', value: Value) => void;
+}, "attrs" | "slots" | "emit"> | undefined, __VLS_setup?: {
+    props: {
+        modelValue: Value;
+        title?: string | undefined;
+        small?: boolean | undefined;
+        disabled?: boolean | undefined;
+        loading?: boolean | undefined;
+        readonly?: boolean | undefined;
+        rightLabel?: boolean | undefined;
+        noMargin?: boolean | undefined;
+        description?: string | undefined;
+        intermediate?: boolean | undefined;
+    };
+    expose(exposed: {}): void;
+    attrs: any;
+    slots: {};
+    emit: (e: 'update:modelValue', value: Value) => void;
+}) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            modelValue: Value;
+            title?: string | undefined;
+            small?: boolean | undefined;
+            disabled?: boolean | undefined;
+            loading?: boolean | undefined;
+            readonly?: boolean | undefined;
+            rightLabel?: boolean | undefined;
+            noMargin?: boolean | undefined;
+            description?: string | undefined;
+            intermediate?: boolean | undefined;
+        };
+        expose(exposed: {}): void;
+        attrs: any;
+        slots: {};
+        emit: (e: 'update:modelValue', value: Value) => void;
+    } | undefined;
+};
+export default _default;
+//# sourceMappingURL=WToggle.vue.d.ts.map

package/dist/components/Toggle/WToggle.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WToggle.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/Toggle/WToggle.vue.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;yBAiOuC,IAAI;WACpC,GAAG;;cALJ,mBAAmB,mBAAiB,IAAI;;;;;;;;;;;;;;yBAIP,IAAI;WACpC,GAAG;;cALJ,mBAAmB,mBAAiB,IAAI;;;;;;;;;;;;;;;;;6BAIP,IAAI;eACpC,GAAG;;kBALJ,mBAAmB,mBAAiB,IAAI;;;AAzN9C,wBAkOkE"}

package/dist/components/Toggle/WToggle.vue.js

@@ -0,0 +1,94 @@
+import { defineComponent, openBlock, createElementBlock, normalizeClass, createElementVNode, toDisplayString, createCommentVNode, createBlock } from 'vue';
+import WSpinner from '../Spinner/WSpinner.vue.js';
+
+const _hoisted_1 = ["disabled"];
+const _hoisted_2 = {
+  key: 0,
+  class: "text-xs font-normal text-description whitespace-pre-wrap break-words"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "WToggle",
+  props: {
+    modelValue: {},
+    title: { default: void 0 },
+    small: { type: Boolean },
+    disabled: { type: Boolean },
+    loading: { type: Boolean },
+    readonly: { type: Boolean },
+    rightLabel: { type: Boolean },
+    noMargin: { type: Boolean },
+    description: { default: void 0 },
+    intermediate: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const updateModelValue = () => {
+      if (props.disabled || props.loading || props.readonly)
+        return;
+      if (props.intermediate) {
+        emit("update:modelValue", props.modelValue === null ? true : props.modelValue === false ? null : false);
+      } else {
+        emit("update:modelValue", !props.modelValue);
+      }
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass({
+          "mt-1 mb-4": !_ctx.noMargin
+        })
+      }, [
+        createElementVNode("button", {
+          class: normalizeClass(["grid gap-4 w-ripple-trigger w-hover-circle-trigger w-hover-circle-opacity-[0.08] select-none items-center w-full text-start focus:outline-none", {
+            "cursor-not-allowed opacity-50": _ctx.disabled,
+            "cursor-progress": _ctx.loading,
+            "cursor-pointer": !_ctx.readonly && !_ctx.loading && !_ctx.disabled,
+            "grid-cols-[1fr,auto]": !_ctx.rightLabel,
+            "grid-cols-[auto,1fr]": _ctx.rightLabel
+          }]),
+          disabled: _ctx.disabled,
+          onClick: updateModelValue
+        }, [
+          _ctx.title ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            class: normalizeClass(["font-semibold text-accent", {
+              "order-1": _ctx.rightLabel,
+              "text-xs": _ctx.small,
+              "text-base": !_ctx.small
+            }])
+          }, toDisplayString(_ctx.title), 3)) : createCommentVNode("", true),
+          createElementVNode("div", {
+            class: normalizeClass(["relative h-4 w-10 max-w-10 min-w-10 my-4 rounded-lg", {
+              "bg-gray-400 dark:bg-gray-700": !_ctx.modelValue || _ctx.loading,
+              "bg-primary-default dark:bg-primary-dark bg-opacity-70 dark:bg-opacity-70": _ctx.modelValue && !_ctx.loading
+            }])
+          }, [
+            createElementVNode("div", {
+              class: normalizeClass(["absolute square-6 -top-1 rounded-full transition-all", {
+                "right-4": _ctx.modelValue === false,
+                "right-2": _ctx.modelValue === null,
+                "right-0": _ctx.modelValue === true,
+                "w-ripple w-hover-circle": !_ctx.disabled && !_ctx.readonly
+              }])
+            }, [
+              createElementVNode("div", {
+                class: normalizeClass(["h-full w-full rounded-full shadow-md z-10 flex items-center justify-center text-description", {
+                  "bg-default dark:bg-gray-100": !_ctx.modelValue || _ctx.loading,
+                  "bg-primary-default dark:bg-primary-dark": _ctx.modelValue && !_ctx.loading
+                }])
+              }, [
+                _ctx.loading ? (openBlock(), createBlock(WSpinner, {
+                  key: 0,
+                  class: "[--spinner-size:1.25rem]"
+                })) : createCommentVNode("", true)
+              ], 2)
+            ], 2)
+          ], 2)
+        ], 10, _hoisted_1),
+        _ctx.description ? (openBlock(), createElementBlock("div", _hoisted_2, toDisplayString(_ctx.description), 1)) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/Toggle/WToggle.vue2.js

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

package/dist/components/Tooltip/WTooltip.vue.d.ts

@@ -0,0 +1,35 @@
+declare const _default: import("vue").DefineComponent<{
+    text: {
+        type: import("vue").PropType<string>;
+    };
+    noTouch: {
+        type: import("vue").PropType<boolean>;
+    };
+    overflowOnly: {
+        type: import("vue").PropType<boolean>;
+    };
+    light: {
+        type: import("vue").PropType<boolean>;
+    };
+    trigger: {
+        type: import("vue").PropType<Element>;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    text: {
+        type: import("vue").PropType<string>;
+    };
+    noTouch: {
+        type: import("vue").PropType<boolean>;
+    };
+    overflowOnly: {
+        type: import("vue").PropType<boolean>;
+    };
+    light: {
+        type: import("vue").PropType<boolean>;
+    };
+    trigger: {
+        type: import("vue").PropType<Element>;
+    };
+}>>, {}, {}>;
+export default _default;
+//# sourceMappingURL=WTooltip.vue.d.ts.map

package/dist/components/Tooltip/WTooltip.vue.d.ts.map

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

package/dist/components/Tooltip/WTooltip.vue.js

@@ -0,0 +1,67 @@
+import { defineComponent, useSlots, ref, computed, watch, toRef, onBeforeUnmount, unref, openBlock, createElementBlock, createCommentVNode } from 'vue';
+import { getIsTouchDevice } from '../../utils/mobile.js';
+import { Tooltip } from '../../utils/Tooltip.js';
+import { getIncrement } from './models/utils.js';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "WTooltip",
+  props: {
+    text: {},
+    noTouch: { type: Boolean },
+    overflowOnly: { type: Boolean },
+    light: { type: Boolean },
+    trigger: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const slots = useSlots();
+    const isTouchDevice = getIsTouchDevice();
+    const container = ref();
+    const isOpen = ref(false);
+    const parent = computed(() => container.value?.parentElement ?? null);
+    const triggerElement = computed(() => props.trigger ?? parent.value);
+    const open = () => {
+      const slot = slots.default?.()?.[0];
+      if (!parent.value)
+        return;
+      if (!slot && !props.text)
+        return;
+      isOpen.value = true;
+      if (props.overflowOnly) {
+        const rect = parent.value.getBoundingClientRect();
+        if (parent.value.scrollHeight === Math.round(rect.height) && parent.value.scrollWidth === Math.round(rect.width))
+          return;
+      }
+      Tooltip.add({ parent: parent.value, slot, text: props.text, light: props.light, key: getIncrement() });
+    };
+    const close = () => {
+      isOpen.value = false;
+      Tooltip.close();
+    };
+    watch(triggerElement, (newValue, oldValue) => {
+      oldValue?.removeEventListener("mouseenter", open);
+      oldValue?.removeEventListener("mouseleave", close);
+      newValue?.addEventListener("mouseenter", open);
+      newValue?.addEventListener("mouseleave", close);
+    });
+    watch(toRef(props, "text"), () => {
+      if (isOpen.value)
+        open();
+    });
+    onBeforeUnmount(() => {
+      triggerElement.value?.removeEventListener("mouseenter", open);
+      triggerElement.value?.removeEventListener("mouseleave", close);
+      close();
+    });
+    return (_ctx, _cache) => {
+      return !(_ctx.noTouch && unref(isTouchDevice)) ? (openBlock(), createElementBlock("span", {
+        key: 0,
+        ref_key: "container",
+        ref: container,
+        class: "hidden"
+      }, null, 512)) : createCommentVNode("", true);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/Tooltip/WTooltip.vue2.js

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

package/dist/components/Tooltip/WTooltipContainer.vue.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+export default _default;
+//# sourceMappingURL=WTooltipContainer.vue.d.ts.map

package/dist/components/Tooltip/WTooltipContainer.vue.d.ts.map

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

package/dist/components/Tooltip/WTooltipContainer.vue.js

@@ -0,0 +1,152 @@
+import { defineComponent, ref, onBeforeMount, onMounted, onBeforeUnmount, onUnmounted, openBlock, createBlock, Transition, withCtx, unref, createElementVNode, normalizeClass, normalizeStyle, resolveDynamicComponent, createElementBlock, toDisplayString, createCommentVNode } from 'vue';
+import _sfc_main$1 from '../Dropdown/WDropdown.vue.js';
+import { HorizontalAlign } from '../../utils/HorizontalAlign.js';
+import { initTooltip } from '../../utils/Tooltip.js';
+import { isClientSide } from '../../utils/utils.js';
+
+const _hoisted_1 = {
+  key: 1,
+  class: "whitespace-nowrap"
+};
+const MARGIN = 12;
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "WTooltipContainer",
+  setup(__props) {
+    const tooltipMeta = ref(null);
+    const container = ref();
+    const containerWidth = ref(0);
+    let timeout;
+    const setTooltipMeta = (meta) => {
+      clearTimeoutOnClose();
+      if (!meta) {
+        timeout = setTimeout(() => {
+          tooltipMeta.value = null;
+          timeout = void 0;
+        }, 100);
+      } else if (tooltipMeta.value !== meta) {
+        timeout = setTimeout(() => {
+          tooltipMeta.value = meta;
+          updateContainerStyles(container.value);
+        }, 25);
+      }
+    };
+    const close = () => {
+      clearTimeoutOnClose();
+      tooltipMeta.value = null;
+    };
+    const clearTimeoutOnClose = () => {
+      if (!timeout)
+        return;
+      clearTimeout(timeout);
+      timeout = void 0;
+    };
+    const updateContainerStyles = (value) => {
+      if (!value) {
+        containerWidth.value = 0;
+      } else {
+        containerWidth.value = value.getBoundingClientRect().width;
+      }
+    };
+    const getMarginStyles = (left, right) => {
+      if (!isClientSide || !containerWidth.value)
+        return;
+      const l = left ? Number.parseFloat(left.substring(0, left.indexOf("px"))) : void 0;
+      if (l !== void 0) {
+        const containerLeft = l - containerWidth.value / 2 - MARGIN;
+        if (containerLeft < 0)
+          return { marginLeft: 0 - containerLeft + "px", marginRight: containerLeft + "px" };
+        const containerRight = window.innerWidth - l - containerWidth.value / 2 - MARGIN;
+        if (containerRight < 0)
+          return { marginRight: 0 - containerRight + "px", marginLeft: containerRight + "px" };
+        return {};
+      }
+      const r = right ? Number.parseFloat(right.substring(0, right.indexOf("px"))) : void 0;
+      if (r !== void 0) {
+        const containerLeft = window.innerWidth - r - containerWidth.value / 2 - MARGIN;
+        if (containerLeft < 0)
+          return { marginLeft: 0 - containerLeft + "px", marginRight: containerLeft + "px" };
+        const containerRight = r - containerWidth.value / 2 - MARGIN;
+        if (containerRight < 0)
+          return { marginRight: 0 - containerRight + "px", marginLeft: containerRight + "px" };
+        return {};
+      }
+    };
+    const marginStyleCache = ref();
+    const getMarginStylesCached = (left, right) => {
+      const styles = getMarginStyles(left, right);
+      if (!styles)
+        return marginStyleCache.value;
+      marginStyleCache.value = styles;
+      return styles;
+    };
+    onBeforeMount(() => {
+      initTooltip(setTooltipMeta);
+    });
+    onMounted(() => {
+      window.addEventListener("touch", close);
+    });
+    onBeforeUnmount(() => {
+      initTooltip(void 0);
+    });
+    onUnmounted(() => {
+      window.removeEventListener("touch", close);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Transition, {
+        "enter-active-class": "transition-opacity",
+        "leave-active-class": "transition-opacity",
+        "enter-from-class": "opacity-0",
+        "leave-to-class": "opacity-0"
+      }, {
+        default: withCtx(() => [
+          tooltipMeta.value ? (openBlock(), createBlock(_sfc_main$1, {
+            key: 0,
+            "parent-element": tooltipMeta.value.parent,
+            "horizontal-align": unref(HorizontalAlign).CENTER,
+            "max-height": 120,
+            "max-width": 240,
+            "emit-update": "",
+            class: "z-[10000] [--arrow-size:8px] transition-[top,bottom,left,right]",
+            "onUpdate:rect": close
+          }, {
+            default: withCtx(({ left, right, istop }) => [
+              createElementVNode("div", {
+                ref_key: "container",
+                ref: container,
+                class: "flex justify-center items-center flex-col drop-shadow-md dark:drop-shadow-none pointer-events-none"
+              }, [
+                createElementVNode("div", {
+                  class: normalizeClass(["w-[calc(var(--arrow-size)/2)] z-10 pointer-events-auto border-[transparent] border-solid [border-width:var(--arrow-size)]", {
+                    "text-black-default dark:text-gray-800": !tooltipMeta.value.light,
+                    "text-default dark:text-gray-800": tooltipMeta.value.light,
+                    "border-t-current order-2": istop,
+                    "border-b-current": !istop
+                  }]),
+                  onMouseover: _cache[0] || (_cache[0] = ($event) => setTooltipMeta(tooltipMeta.value)),
+                  onMouseleave: _cache[1] || (_cache[1] = ($event) => setTooltipMeta(null))
+                }, null, 34),
+                createElementVNode("div", {
+                  class: normalizeClass(["py-3 px-4 rounded-xl text-xs font-medium text-center transition-[margin] pointer-events-auto", {
+                    "bg-black-default dark:bg-gray-800 text-default": !tooltipMeta.value.light,
+                    "bg-default dark:bg-gray-800 text-accent": tooltipMeta.value.light
+                  }]),
+                  style: normalizeStyle(getMarginStylesCached(left, right)),
+                  onMouseover: _cache[2] || (_cache[2] = ($event) => setTooltipMeta(tooltipMeta.value)),
+                  onMouseleave: _cache[3] || (_cache[3] = ($event) => setTooltipMeta(null))
+                }, [
+                  tooltipMeta.value.slot ? (openBlock(), createBlock(resolveDynamicComponent(tooltipMeta.value.slot), {
+                    key: tooltipMeta.value.key
+                  })) : tooltipMeta.value.text ? (openBlock(), createElementBlock("div", _hoisted_1, toDisplayString(tooltipMeta.value.text), 1)) : createCommentVNode("", true)
+                ], 38)
+              ], 512)
+            ]),
+            _: 1
+          }, 8, ["parent-element", "horizontal-align"])) : createCommentVNode("", true)
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/Tooltip/WTooltipContainer.vue2.js

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

package/dist/components/Tooltip/models/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const getIncrement: () => number;
+//# sourceMappingURL=utils.d.ts.map