eco-vue-js 0.3.67

package/dist/components/Select/components/SelectAsyncPrefixPage.vue.js

@@ -0,0 +1,89 @@
+import { defineComponent, toRef, computed, watch, onBeforeUnmount, openBlock, createElementBlock, Fragment, renderList, unref, normalizeClass, renderSlot, createBlock, resolveDynamicComponent, createSlots, withCtx, createElementVNode, withModifiers, createVNode, createCommentVNode } from 'vue';
+import IconCancel from '../../../assets/icons/default/IconCancel.svg.js';
+
+const _hoisted_1 = ["onClick"];
+const _hoisted_2 = ["onClick"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "SelectAsyncPrefixPage",
+  props: {
+    useQueryFn: {},
+    queryParams: {},
+    disabled: { type: Boolean },
+    loading: { type: Boolean },
+    optionComponent: {},
+    disableClear: { type: Boolean }
+  },
+  emits: ["unselect", "update:pages-count", "update:fetching"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const { data, isFetching } = props.useQueryFn(toRef(props, "queryParams"));
+    const pagesCount = computed(() => data.value?.pages_count);
+    watch(pagesCount, (value) => {
+      if (value === void 0)
+        return;
+      emit("update:pages-count", value);
+    });
+    watch(isFetching, (value) => {
+      emit("update:fetching", value);
+    }, { immediate: true });
+    onBeforeUnmount(() => {
+      emit("update:fetching", false);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(true), createElementBlock(Fragment, null, renderList(unref(data)?.results, (option) => {
+        return openBlock(), createElementBlock("div", {
+          key: option.id,
+          class: normalizeClass(["relative flex overflow-hidden items-center text-description", {
+            "cursor-pointer": !_ctx.disabled,
+            "cursor-not-allowed": _ctx.disabled
+          }])
+        }, [
+          renderSlot(_ctx.$slots, "default", {
+            option,
+            skeleton: !unref(data)
+          }, () => [
+            _ctx.optionComponent ? (openBlock(), createBlock(resolveDynamicComponent(_ctx.optionComponent), {
+              key: 0,
+              option,
+              selected: true,
+              model: true,
+              skeleton: !unref(data)
+            }, createSlots({ _: 2 }, [
+              !_ctx.disableClear && !_ctx.disabled ? {
+                name: "default",
+                fn: withCtx(() => [
+                  createElementVNode("button", {
+                    class: normalizeClass(["relative flex square-5 rounded-full -my-1 -mr-2 ml-1 items-center justify-center outline-none", {
+                      "cursor-progress": _ctx.loading,
+                      "cursor-pointer w-ripple w-ripple-hover": !_ctx.loading
+                    }]),
+                    onMousedown: _cache[0] || (_cache[0] = withModifiers(() => {
+                    }, ["stop", "prevent"])),
+                    onClick: withModifiers(($event) => !_ctx.loading && _ctx.$emit("unselect", option.id), ["stop", "prevent"])
+                  }, [
+                    createVNode(unref(IconCancel), { class: "square-3" })
+                  ], 42, _hoisted_1)
+                ]),
+                key: "0"
+              } : void 0
+            ]), 1032, ["option", "skeleton"])) : createCommentVNode("", true)
+          ]),
+          !_ctx.optionComponent && !_ctx.disableClear && !_ctx.disabled ? (openBlock(), createElementBlock("button", {
+            key: 0,
+            class: normalizeClass(["relative flex square-5 rounded-full items-center justify-center outline-none", {
+              "cursor-progress": _ctx.loading,
+              "cursor-pointer w-ripple w-ripple-hover ": !_ctx.loading
+            }]),
+            onMousedown: _cache[1] || (_cache[1] = withModifiers(() => {
+            }, ["stop", "prevent"])),
+            onClick: withModifiers(($event) => !_ctx.loading && _ctx.$emit("unselect", option.id), ["stop", "prevent"])
+          }, [
+            createVNode(unref(IconCancel), { class: "square-3" })
+          ], 42, _hoisted_2)) : createCommentVNode("", true)
+        ], 2);
+      }), 128);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/Select/components/SelectAsyncPrefixPage.vue2.js

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

package/dist/components/Select/components/SelectOption.vue.d.ts

@@ -0,0 +1,104 @@
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+    isSelected: {
+        type: import("vue").PropType<boolean>;
+        required: true;
+    };
+    isCursor: {
+        type: import("vue").PropType<boolean>;
+    };
+    loading: {
+        type: import("vue").PropType<boolean>;
+    };
+    skeleton: {
+        type: import("vue").PropType<boolean>;
+    };
+    scroll: {
+        type: import("vue").PropType<boolean>;
+    };
+    first: {
+        type: import("vue").PropType<boolean>;
+    };
+    last: {
+        type: import("vue").PropType<boolean>;
+    };
+    previous: {
+        type: import("vue").PropType<number | null>;
+    };
+    next: {
+        type: import("vue").PropType<number | null>;
+    };
+    isNoCursor: {
+        type: import("vue").PropType<boolean>;
+    };
+}, {
+    scrollIntoView: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: () => void;
+    unselect: () => void;
+    "update:is-cursor": (value: {
+        previous: number | null | undefined;
+        next: number | null | undefined;
+    }) => void;
+    "update:cursor": () => void;
+    "update:previous": (value: number | null | undefined) => void;
+    "update:next": (value: number | null | undefined) => void;
+    unmounted: () => void;
+    "update:first": () => void;
+    "update:last": () => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    isSelected: {
+        type: import("vue").PropType<boolean>;
+        required: true;
+    };
+    isCursor: {
+        type: import("vue").PropType<boolean>;
+    };
+    loading: {
+        type: import("vue").PropType<boolean>;
+    };
+    skeleton: {
+        type: import("vue").PropType<boolean>;
+    };
+    scroll: {
+        type: import("vue").PropType<boolean>;
+    };
+    first: {
+        type: import("vue").PropType<boolean>;
+    };
+    last: {
+        type: import("vue").PropType<boolean>;
+    };
+    previous: {
+        type: import("vue").PropType<number | null>;
+    };
+    next: {
+        type: import("vue").PropType<number | null>;
+    };
+    isNoCursor: {
+        type: import("vue").PropType<boolean>;
+    };
+}>> & {
+    onSelect?: (() => any) | undefined;
+    onUnselect?: (() => any) | undefined;
+    "onUpdate:is-cursor"?: ((value: {
+        previous: number | null | undefined;
+        next: number | null | undefined;
+    }) => any) | undefined;
+    "onUpdate:cursor"?: (() => any) | undefined;
+    "onUpdate:previous"?: ((value: number | null | undefined) => any) | undefined;
+    "onUpdate:next"?: ((value: number | null | undefined) => any) | undefined;
+    onUnmounted?: (() => any) | undefined;
+    "onUpdate:first"?: (() => any) | undefined;
+    "onUpdate:last"?: (() => any) | undefined;
+}, {}, {}>, {
+    default: (props: {
+        selected: boolean;
+    }) => void;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=SelectOption.vue.d.ts.map

package/dist/components/Select/components/SelectOption.vue.d.ts.map

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

package/dist/components/Select/components/SelectOption.vue.js

@@ -0,0 +1,112 @@
+import { defineComponent, ref, watch, toRef, onUnmounted, openBlock, createElementBlock, normalizeClass, withModifiers, createElementVNode, renderSlot, createVNode, Transition, withCtx, createBlock, unref, createCommentVNode } from 'vue';
+import IconCheck from '../../../assets/icons/default/IconCheck.svg.js';
+import WSpinner from '../../Spinner/WSpinner.vue.js';
+
+const _hoisted_1 = ["onClick"];
+const _hoisted_2 = { class: "flex items-center max-w-[calc(100%-2.5rem)] flex-1 overflow-hidden" };
+const _hoisted_3 = {
+  key: 0,
+  class: "flex items-center justify-center text-primary-default dark:text-primary-dark w-10 [--spinner-size:1.5rem]"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "SelectOption",
+  props: {
+    isSelected: { type: Boolean },
+    isCursor: { type: Boolean },
+    loading: { type: Boolean },
+    skeleton: { type: Boolean },
+    scroll: { type: Boolean },
+    first: { type: Boolean },
+    last: { type: Boolean },
+    previous: {},
+    next: {},
+    isNoCursor: { type: Boolean }
+  },
+  emits: ["select", "unselect", "update:is-cursor", "update:cursor", "update:previous", "update:next", "unmounted", "update:first", "update:last"],
+  setup(__props, { expose: __expose, emit }) {
+    const props = __props;
+    const element = ref();
+    const toggle = () => {
+      if (props.isSelected)
+        emit("unselect");
+      else
+        emit("select");
+      return false;
+    };
+    const scrollIntoView = () => {
+      element.value?.scrollIntoView({ behavior: "auto", block: "center" });
+    };
+    watch(toRef(props, "isCursor"), (value) => {
+      if (!value)
+        return;
+      emit("update:is-cursor", { previous: props.previous, next: props.next });
+      if (props.scroll)
+        scrollIntoView();
+    }, { immediate: true });
+    watch(toRef(props, "isNoCursor"), (value) => {
+      if (value && props.first && !props.skeleton)
+        emit("update:cursor");
+    }, { immediate: true });
+    watch(toRef(props, "previous"), (value) => {
+      if (props.isCursor && !props.skeleton)
+        emit("update:previous", value);
+    }, { immediate: true });
+    watch(toRef(props, "next"), (value) => {
+      if (props.isCursor && !props.skeleton)
+        emit("update:next", value);
+    }, { immediate: true });
+    watch(toRef(props, "first"), (value) => {
+      if (value)
+        emit("update:first");
+    }, { immediate: true });
+    watch(toRef(props, "last"), (value) => {
+      if (value)
+        emit("update:last");
+    }, { immediate: true });
+    watch(toRef(props, "next"), (value) => {
+      if (props.isCursor && !props.skeleton)
+        emit("update:next", value);
+    }, { immediate: true });
+    onUnmounted(() => {
+      if (props.isCursor)
+        emit("unmounted");
+    });
+    __expose({
+      scrollIntoView
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "element",
+        ref: element,
+        class: normalizeClass(["relative flex w-full select-none cursor-pointer py-2 px-[1.0625rem]", {
+          "bg-primary-light dark:bg-primary-darkest": _ctx.isSelected,
+          "before:opacity-5": _ctx.isCursor && !_ctx.skeleton,
+          "cursor-progress": _ctx.loading || _ctx.skeleton,
+          "w-ripple": !_ctx.loading && !_ctx.skeleton
+        }]),
+        onMousedown: _cache[0] || (_cache[0] = withModifiers(() => {
+        }, ["prevent", "stop"])),
+        onClick: withModifiers(toggle, ["prevent", "stop"])
+      }, [
+        createElementVNode("div", _hoisted_2, [
+          renderSlot(_ctx.$slots, "default", { selected: _ctx.isSelected })
+        ]),
+        createVNode(Transition, {
+          "enter-active-class": "transition-opacity",
+          "leave-active-class": "transition-opacity",
+          "enter-from-class": "opacity-0",
+          "leave-to-class": "opacity-0"
+        }, {
+          default: withCtx(() => [
+            _ctx.isSelected || _ctx.loading ? (openBlock(), createElementBlock("div", _hoisted_3, [
+              _ctx.isSelected && !_ctx.loading ? (openBlock(), createBlock(unref(IconCheck), { key: 0 })) : _ctx.loading ? (openBlock(), createBlock(WSpinner, { key: 1 })) : createCommentVNode("", true)
+            ])) : createCommentVNode("", true)
+          ]),
+          _: 1
+        })
+      ], 42, _hoisted_1);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/Select/components/SelectOption.vue2.js

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

package/dist/components/Skeleton/WSkeleton.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=WSkeleton.vue.d.ts.map

package/dist/components/Skeleton/WSkeleton.vue.d.ts.map

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

package/dist/components/Skeleton/WSkeleton.vue.js

@@ -0,0 +1,14 @@
+import { openBlock, createElementBlock, normalizeStyle } from 'vue';
+import _export_sfc from '../../_virtual/_plugin-vue_export-helper.js';
+
+const _sfc_main = {};
+
+function _sfc_render(_ctx, _cache) {
+  return (openBlock(), createElementBlock("div", {
+    class: "bg-primary-light dark:bg-primary-darkest w-skeleton before:animate-ticker",
+    style: normalizeStyle({'--skeleton-width': (Math.round(Math.random() * 40) + 40) + '%'})
+  }, "   ", 4))
+}
+const WSkeleton = /*#__PURE__*/_export_sfc(_sfc_main, [['render',_sfc_render]]);
+
+export { WSkeleton as default };

package/dist/components/Spinner/WSpinner.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=WSpinner.vue.d.ts.map

package/dist/components/Spinner/WSpinner.vue.d.ts.map

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

package/dist/components/Spinner/WSpinner.vue.js

@@ -0,0 +1,33 @@
+import { openBlock, createElementBlock, createElementVNode } from 'vue';
+import _export_sfc from '../../_virtual/_plugin-vue_export-helper.js';
+
+const _sfc_main = {};
+
+const _hoisted_1 = {
+  class: "animate-spin square-[var(--spinner-size,2rem)]",
+  width: "20",
+  height: "20",
+  viewBox: "25 25 50 50"
+};
+const _hoisted_2 = /*#__PURE__*/createElementVNode("circle", {
+  class: "animate-spinner-dash",
+  cx: "50",
+  cy: "50",
+  r: "20",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-width": "10%",
+  "stroke-miterlimit": "8",
+  "stroke-dasharray": "1, 100",
+  "stroke-dashoffset": "0"
+}, null, -1);
+const _hoisted_3 = [
+  _hoisted_2
+];
+
+function _sfc_render(_ctx, _cache) {
+  return (openBlock(), createElementBlock("svg", _hoisted_1, _hoisted_3))
+}
+const WSpinner = /*#__PURE__*/_export_sfc(_sfc_main, [['render',_sfc_render]]);
+
+export { WSpinner as default };

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

@@ -0,0 +1,39 @@
+import { type VNode } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    names: {
+        type: import("vue").PropType<string[]>;
+    };
+    slots: {
+        type: import("vue").PropType<VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>[]>;
+    };
+    lessTransitions: {
+        type: import("vue").PropType<boolean>;
+    };
+}, {
+    updateIndex: (value: number) => void;
+    next: () => void;
+    previous: () => void;
+    validate: (index: number) => string | undefined;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:current": (value: number) => void;
+    "update:has-changes": (value: boolean) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    names: {
+        type: import("vue").PropType<string[]>;
+    };
+    slots: {
+        type: import("vue").PropType<VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>[]>;
+    };
+    lessTransitions: {
+        type: import("vue").PropType<boolean>;
+    };
+}>> & {
+    "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
+    "onUpdate:current"?: ((value: number) => any) | undefined;
+}, {}, {}>;
+export default _default;
+//# sourceMappingURL=WTabs.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WTabs.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/Tabs/WTabs.vue.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkC,KAAK,KAAK,EAAoD,MAAM,KAAK,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4WlH,wBAAkD"}

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

@@ -0,0 +1,210 @@
+import { defineComponent, useSlots, computed, ref, reactive, inject, watch, onMounted, onUnmounted, openBlock, createElementBlock, Fragment, renderList, normalizeClass, unref, createElementVNode, createTextVNode, toDisplayString, createVNode, Transition, withCtx, createCommentVNode, normalizeStyle, TransitionGroup, createBlock, resolveDynamicComponent, nextTick } from 'vue';
+import _sfc_main$1 from './components/TabItem.vue.js';
+import _sfc_main$2 from '../Form/WForm.vue.js';
+import { throttle, debounce } from '../../utils/utils.js';
+import { wTabItemListener, wTabItemUnlistener } from './models/injection.js';
+
+const _hoisted_1 = { class: "mb-8" };
+const _hoisted_2 = {
+  key: 0,
+  class: "relative flex mb-4 sm-not:-px--inner-margin"
+};
+const _hoisted_3 = ["onClick"];
+const _hoisted_4 = { class: "relative" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "WTabs",
+  props: {
+    names: {},
+    slots: {},
+    lessTransitions: { type: Boolean }
+  },
+  emits: ["update:current", "update:has-changes"],
+  setup(__props, { expose: __expose, emit }) {
+    const props = __props;
+    const slots = useSlots();
+    const defaultSlots = computed(() => (props.slots ?? slots.default?.() ?? []).filter((item) => typeof item.type !== "symbol"));
+    const current = ref(0);
+    const isDirect = ref(true);
+    const button = ref([]);
+    const indicatorStyle = ref(void 0);
+    const minHeight = ref(0);
+    const tabItem = ref([]);
+    const form = ref([]);
+    const isValidMap = reactive({});
+    const hasChangesMap = reactive({});
+    const hasChanges = computed(() => Object.values(hasChangesMap).includes(true));
+    const updateIsValidMap = (index, value) => {
+      if (value !== void 0)
+        isValidMap[index] = value;
+      else
+        delete isValidMap[index];
+      nextTick().then(() => {
+        if (value === false && isValidMap[current.value] !== false)
+          switchTab(index);
+      });
+    };
+    const updateHasChangesMap = (index, value) => {
+      if (value !== void 0)
+        hasChangesMap[index] = value;
+      else
+        delete hasChangesMap[index];
+    };
+    const switchTab = throttle((index) => {
+      if (current.value === index)
+        return;
+      updateIndex(index);
+    }, 200);
+    const updateIndex = (value) => {
+      tabItem.value[current.value]?.emitHeight?.();
+      setIndexDebounced(value);
+    };
+    const setIndexDebounced = debounce((value) => {
+      if (current.value === value || value < 0 || value > defaultSlots.value.length - 1)
+        return;
+      isDirect.value = current.value < value;
+      current.value = value;
+    }, 100);
+    const next = () => {
+      switchTab(current.value + 1);
+    };
+    const previous = () => {
+      switchTab(current.value - 1);
+    };
+    const updateIndicator = () => {
+      if (!props.names)
+        return;
+      const element = button.value[current.value];
+      if (!element || !element.offsetWidth)
+        return;
+      indicatorStyle.value = {
+        width: element.offsetWidth + "px",
+        left: element.offsetLeft + "px"
+      };
+    };
+    const updateHeight = (value) => {
+      if (minHeight.value >= value)
+        return;
+      minHeight.value = value;
+    };
+    const validate = (index) => {
+      return form?.value[index].validate();
+    };
+    const tabItemListenerInjected = inject(wTabItemListener, null);
+    const tabItemUnlistenerInjected = inject(wTabItemUnlistener, null);
+    watch(current, (value) => {
+      emit("update:current", value);
+      updateIndicator();
+    }, { immediate: true });
+    watch(hasChanges, (value) => {
+      emit("update:has-changes", value);
+    }, { immediate: true });
+    onMounted(() => {
+      updateIndicator();
+      tabItemListenerInjected?.(updateIndicator);
+    });
+    onUnmounted(() => {
+      tabItemUnlistenerInjected?.(updateIndicator);
+    });
+    __expose({
+      updateIndex,
+      next,
+      previous,
+      validate
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        _ctx.names ? (openBlock(), createElementBlock("div", _hoisted_2, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(defaultSlots.value, (_, index) => {
+            return openBlock(), createElementBlock("button", {
+              ref_for: true,
+              ref_key: "button",
+              ref: button,
+              key: index,
+              class: normalizeClass(["flex-1 font-semibold flex items-center justify-center h-10 cursor-pointer relative w-ripple w-ripple-hover select-none transition-colors duration-500 outline-none", {
+                "text-description": current.value !== index && isValidMap[index] !== false,
+                "text-primary-default dark:text-primary-dark": current.value === index && isValidMap[index] !== false,
+                "text-negative dark:text-negative-dark": isValidMap[index] === false
+              }]),
+              onClick: ($event) => unref(switchTab)(index)
+            }, [
+              createElementVNode("div", _hoisted_4, [
+                createTextVNode(toDisplayString(_ctx.names[index]) + " ", 1),
+                createVNode(Transition, {
+                  "enter-active-class": "transition-opacity",
+                  "leave-active-class": "transition-opacity",
+                  "enter-from-class": "opacity-0",
+                  "leave-to-class": "opacity-0"
+                }, {
+                  default: withCtx(() => [
+                    hasChangesMap[index] ? (openBlock(), createElementBlock("div", {
+                      key: 0,
+                      class: normalizeClass(["absolute top-0 -right-4 square-2 rounded-full transition-colors duration-500", {
+                        "bg-info dark:bg-info-dark": isValidMap[index] !== false,
+                        "bg-negative dark:bg-negative-dark": isValidMap[index] === false
+                      }])
+                    }, null, 2)) : createCommentVNode("", true)
+                  ]),
+                  _: 2
+                }, 1024)
+              ])
+            ], 10, _hoisted_3);
+          }), 128)),
+          createElementVNode("div", {
+            class: normalizeClass(["absolute bottom-0 h-1 rounded-sm duration-500", {
+              "bg-primary-default dark:bg-primary-dark": isValidMap[current.value] !== false,
+              "bg-negative dark:bg-negative-dark": isValidMap[current.value] === false,
+              "transition-[left,width,background-color]": indicatorStyle.value !== void 0
+            }]),
+            style: normalizeStyle(indicatorStyle.value)
+          }, null, 6)
+        ])) : createCommentVNode("", true),
+        createElementVNode("div", {
+          class: "relative transition-[min-height] h-full duration-300",
+          style: normalizeStyle({ minHeight: minHeight.value ? minHeight.value + "px" : "auto", "--direction-factor": isDirect.value ? "1" : "-1" })
+        }, [
+          createVNode(TransitionGroup, {
+            "enter-active-class": "transition-transform duration-[250ms] w-full",
+            "leave-active-class": "transition-transform duration-[250ms] w-full absolute top-0",
+            "enter-from-class": _ctx.lessTransitions ? "opacity-0" : "translate-x-[calc((100%+var(--inner-margin))*var(--direction-factor))]",
+            "leave-to-class": _ctx.lessTransitions ? "opacity-0" : "translate-x-[calc((100%+var(--inner-margin))*var(--direction-factor)*-1)]"
+          }, {
+            default: withCtx(() => [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(defaultSlots.value, (slot, index) => {
+                return openBlock(), createBlock(_sfc_main$1, {
+                  ref_for: true,
+                  ref_key: "tabItem",
+                  ref: tabItem,
+                  key: index,
+                  "is-active": index === current.value,
+                  class: "width-full",
+                  "onUpdate:height": updateHeight
+                }, {
+                  default: withCtx(() => [
+                    createVNode(_sfc_main$2, {
+                      ref_for: true,
+                      ref_key: "form",
+                      ref: form,
+                      name: index.toString(),
+                      title: _ctx.names?.[index],
+                      "onUpdate:isValid": ($event) => updateIsValidMap(index, $event),
+                      "onUpdate:hasChanges": ($event) => updateHasChangesMap(index, $event)
+                    }, {
+                      default: withCtx(() => [
+                        (openBlock(), createBlock(resolveDynamicComponent(slot)))
+                      ]),
+                      _: 2
+                    }, 1032, ["name", "title", "onUpdate:isValid", "onUpdate:hasChanges"])
+                  ]),
+                  _: 2
+                }, 1032, ["is-active"]);
+              }), 128))
+            ]),
+            _: 1
+          }, 8, ["enter-from-class", "leave-to-class"])
+        ], 4)
+      ]);
+    };
+  }
+});
+
+export { _sfc_main as default };

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

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

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

@@ -0,0 +1,13 @@
+declare const _default: import("vue").DefineComponent<{
+    names: {
+        type: import("vue").PropType<string[]>;
+        required: true;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    names: {
+        type: import("vue").PropType<string[]>;
+        required: true;
+    };
+}>>, {}, {}>;
+export default _default;
+//# sourceMappingURL=WTabsColumns.vue.d.ts.map

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

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