eco-vue-js 0.9.22 → 0.9.23

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

@@ -1 +1 @@
-{"version":3,"file":"WTabs.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Tabs/WTabs.vue"],"names":[],"mappings":"AAiYA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,SAAS,CAAA;AAEtC,OAAO,EAAC,KAAK,aAAa,EAA6G,MAAM,KAAK,CAAA;AAElJ,OAAO,KAAK,MAAM,6BAA6B,CAAA;;2BA4FjB,MAAM;yBAMR,MAAM;gBAiCjB,IAAI;oBAYA,IAAI;sBAUA,MAAM,6GAAqE,UAAU,CAAC,iBAAiB,CAAC,OAAO,KAAK,CAAC,CAAC,UAAU,CAAC,CAAC;+BAIzH,MAAM,6GAAqE,UAAU,CAAC,iBAAiB,CAAC,OAAO,KAAK,CAAC,CAAC,UAAU,CAAC,CAAC;wBAMzI,MAAM;;UAAuE,UAAU,CAAC,iBAAiB,CAAC,OAAO,KAAK,CAAC,CAAC,YAAY,CAAC,CAAC;uBAIvI,MAAM,KAAsE,UAAU,CAAC,iBAAiB,CAAC,OAAO,KAAK,CAAC,CAAC,WAAW,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAsKzI,GAAG,8CAA8C,GAAG,yBAErD,GAAG,6DACZ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAHO,GAAG,8CAA8C,GAAG,yBAErD,GAAG,6DACZ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAHO,GAAG,8CAA8C,GAAG,yBAErD,GAAG,6DACZ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsQd,wBAkBG"}
+{"version":3,"file":"WTabs.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Tabs/WTabs.vue"],"names":[],"mappings":"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"}

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

@@ -1,4 +1,5 @@
-import { defineComponent, useSlots, useTemplateRef, computed, ref, inject, watch, onMounted, onUnmounted, openBlock, createElementBlock, normalizeClass, Fragment, renderList, createBlock, unref, createSlots, withCtx, resolveDynamicComponent, mergeProps, normalizeStyle, createCommentVNode, createVNode, TransitionGroup } from 'vue';
+import { defineComponent, useSlots, useTemplateRef, computed, ref, inject, watch, onMounted, onUnmounted, openBlock, createBlock, normalizeClass, withCtx, createElementBlock, Fragment, renderList, unref, createSlots, resolveDynamicComponent, mergeProps, normalizeStyle, createCommentVNode, createVNode, TransitionGroup } from 'vue';
+import _sfc_main$1 from '../Form/WForm.vue.js';
 import '../Button/WButtonAction.vue.js';
 import '../Button/WButton.vue.js';
 import { getIsMobile } from '../../utils/mobile.js';
@@ -14,12 +15,13 @@ import '../Input/WInputSuggest.vue.js';
 import '../Input/WInputDate.vue.js';
 import '../Link/WLink.vue.js';
 import '@tanstack/vue-query';
-import _sfc_main$2 from './components/TabItem.vue.js';
-import _sfc_main$1 from './components/TabTitleButton.vue.js';
+import _sfc_main$3 from './components/TabItem.vue.js';
+import _sfc_main$2 from './components/TabTitleButton.vue.js';
 
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "WTabs",
   props: {
+    name: {},
     customSlots: {},
     lessTransitions: { type: Boolean },
     initTab: {},
@@ -38,7 +40,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const props = __props;
     const emit = __emit;
     const slots = useSlots();
-    const containerRef = useTemplateRef("container");
+    const formRef = useTemplateRef("form");
     const buttonContainerRef = useTemplateRef("buttonContainer");
     const defaultSlotsRaw = computed(() => props.customSlots ?? slots.default?.() ?? []);
     const unwrapSlots = (slots2) => {
@@ -57,7 +59,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const defaultSlots = computed(() => {
       return defaultSlotsAll.value.filter(isTabItem);
     });
-    const defaultSlotsKeys = computed(() => defaultSlots.value.map((item) => item.props?.name));
+    const defaultSlotsKeys = computed(() => defaultSlots.value.map((item) => item.props.name));
     const current = ref(props.initTab ?? (props.initTabIndex !== void 0 ? defaultSlotsKeys.value[props.initTabIndex] : defaultSlots.value.find((slot) => !!slot.props?.init)?.props?.name ?? defaultSlotsKeys.value[0]));
     const currentIndex = computed(() => defaultSlotsKeys.value.indexOf(current.value));
     const isDirect = ref(true);
@@ -65,10 +67,10 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const indicatorStyle = ref(void 0);
     const minHeight = ref(0);
     const tabItemRef = useTemplateRef("tabItem");
-    const currentIsValid = computed(() => tabItemRef.value?.[currentIndex.value]?.isValid ?? true);
+    const currentIsValid = computed(() => typeof formRef.value?.errorMessageMap[current.value] !== "string");
     const hasNoValueFirst = computed(() => {
       if (!props.stepper) return 0;
-      const index = tabItemRef.value?.findIndex((item) => item?.hasValue === false) ?? 0;
+      const index = defaultSlotsKeys.value.findIndex((item) => formRef.value?.hasValueMap[item] === false);
       if (index === -1) return defaultSlotsKeys.value.length;
       return index;
     });
@@ -97,7 +99,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         timeout = null;
       }
       timeout = setTimeout(() => {
-        containerRef.value?.scrollTo({ left: document.documentElement.offsetWidth, behavior: "smooth" });
+        formRef.value?.$el?.scrollTo({ left: document.documentElement.offsetWidth, behavior: "smooth" });
         timeout = null;
       }, 300);
     };
@@ -108,8 +110,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       current.value = value;
       scrollToTabContent();
     }, 100);
-    const next = () => {
-      const errorMessage = validateIfNoError(currentIndex.value);
+    const next = (update = false) => {
+      const errorMessage = update ? validate(current.value) : validateIfNoError(current.value);
       if (errorMessage) {
         Notify.warn({ title: "Form contains invalid values", caption: errorMessage.length < 200 ? errorMessage : void 0 });
         return;
@@ -119,22 +121,33 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const previous = () => {
       switchTab(defaultSlotsKeys.value[currentIndex.value - 1]);
     };
+    const jump = (name, update = false) => {
+      const valid = defaultSlotsKeys.value.slice(currentIndex.value, defaultSlotsKeys.value.indexOf(name)).every((item) => {
+        const errorMessage = update ? validate(item) : validateIfNoError(item);
+        if (errorMessage) {
+          Notify.warn({ title: "Form contains invalid values", caption: errorMessage.length < 200 ? errorMessage : void 0 });
+          return false;
+        }
+        return true;
+      });
+      if (valid) return switchTab(name);
+    };
     const updateHeight = (value) => {
       if (minHeight.value >= value) return;
       minHeight.value = value;
     };
-    const validate = (index, ...args) => {
-      return tabItemRef.value?.[index]?.validate(...args);
+    const validate = (name, ...args) => {
+      return formRef.value?.validateMap[name]?.(...args);
     };
-    const validateIfNoError = (index, ...args) => {
-      if (tabItemRef.value?.[index]?.errorMessage) return tabItemRef.value?.[index].errorMessage;
-      return tabItemRef.value?.[index]?.validate(...args);
+    const validateIfNoError = (name, ...args) => {
+      if (formRef.value?.errorMessageMap[name]) return formRef.value.errorMessageMap[name];
+      return formRef.value?.validateMap[name]?.(...args);
     };
-    const invalidate = (index, ...args) => {
-      return tabItemRef.value?.[index]?.invalidate(...args);
+    const invalidate = (name, ...args) => {
+      return formRef.value?.invalidateMap[name]?.(...args);
     };
-    const initModel = (index, ...args) => {
-      return tabItemRef.value?.[index]?.initModel(...args);
+    const initModel = (name, ...args) => {
+      return formRef.value?.initModelMap[name]?.(...args);
     };
     const updateIndicator = () => {
       buttonRef.value?.forEach((item) => item?.update());
@@ -194,128 +207,133 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       updateIndex,
       next,
       previous,
+      jump,
       validate,
       validateIfNoError,
       invalidate,
       initModel
     });
     return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        ref: "container",
+      return openBlock(), createBlock(_sfc_main$1, {
+        ref: "form",
+        name: _ctx.name,
         class: normalizeClass(["grid gap-4", {
           "grid grid-cols-1": !_ctx.side,
           "sm-not:grid-cols-[repeat(2,100vw)] sm-not:snap-x sm-not:snap-mandatory sm-not:snap-always sm-not:overflow-x-auto sm-not:overscroll-x-contain grid grid-cols-[auto,1fr] items-start": _ctx.side
         }])
-      }, [
-        !_ctx.noHeader ? (openBlock(), createElementBlock("div", {
-          key: 0,
-          ref: "buttonContainer",
-          class: normalizeClass(["relative", {
-            "sm-not:snap-start grid grid-cols-[1fr,auto]": _ctx.side,
-            "no-scrollbar sm-not:-pl--inner-margin flex snap-x snap-mandatory snap-always overflow-x-auto overscroll-x-contain pr-[50%]": !_ctx.side
-          }])
-        }, [
-          (openBlock(true), createElementBlock(Fragment, null, renderList(defaultSlotsAll.value, (slot, index) => {
-            return openBlock(), createElementBlock(Fragment, {
-              key: slot.props?.name
-            }, [
-              isTabItem(slot) ? (openBlock(), createBlock(_sfc_main$1, {
-                key: 0,
-                ref_for: true,
-                ref: "button",
-                active: current.value === slot.props?.name,
-                index,
-                title: slot.props?.title,
-                icon: slot.props?.icon,
-                "has-changes": unref(tabItemRef)?.[defaultSlots.value.indexOf(slot)]?.hasChanges === true,
-                "has-error": unref(tabItemRef)?.[defaultSlots.value.indexOf(slot)]?.isValid === false,
-                "has-value": unref(tabItemRef)?.[defaultSlots.value.indexOf(slot)]?.hasValue === true,
-                first: defaultSlots.value.indexOf(slot) === 0,
-                last: defaultSlots.value.indexOf(slot) === defaultSlots.value.length - 1,
-                disabled: _ctx.stepper ? defaultSlots.value.indexOf(slot) > hasNoValueFirst.value : false,
-                stepper: _ctx.stepper,
-                "show-has-value": _ctx.showHasValue,
-                side: _ctx.side,
-                class: normalizeClass({
-                  "snap-center": !_ctx.side
-                }),
-                "onUpdate:indicatorStyle": _cache[0] || (_cache[0] = ($event) => indicatorStyle.value = $event),
-                "onUpdate:scrollPosition": updateScrollPosition,
-                onClick: ($event) => unref(switchTab)(slot.props?.name)
-              }, createSlots({ _: 2 }, [
-                slot.children?.title ? {
-                  name: "title",
-                  fn: withCtx((scope) => [
-                    (openBlock(), createBlock(resolveDynamicComponent(slot.children?.title), mergeProps({ ref_for: true }, scope), null, 16))
-                  ]),
-                  key: "0"
-                } : void 0,
-                slot.children?.suffix ? {
-                  name: "suffix",
-                  fn: withCtx((scope) => [
-                    (openBlock(), createBlock(resolveDynamicComponent(slot.children?.suffix), mergeProps({ ref_for: true }, scope), null, 16))
-                  ]),
-                  key: "1"
-                } : void 0,
-                slot.children?.right ? {
-                  name: "right",
-                  fn: withCtx((scope) => [
-                    (openBlock(), createBlock(resolveDynamicComponent(slot.children?.right), mergeProps({ ref_for: true }, scope), null, 16))
-                  ]),
-                  key: "2"
-                } : void 0
-              ]), 1032, ["active", "index", "title", "icon", "has-changes", "has-error", "has-value", "first", "last", "disabled", "stepper", "show-has-value", "side", "class", "onClick"])) : (openBlock(), createBlock(resolveDynamicComponent(slot), { key: 1 }))
-            ], 64);
-          }), 128)),
-          !_ctx.stepper ? (openBlock(), createElementBlock("div", {
+      }, {
+        default: withCtx(() => [
+          !_ctx.noHeader ? (openBlock(), createElementBlock("div", {
             key: 0,
-            class: normalizeClass(["absolute rounded-sm duration-500", {
-              "bg-primary-default dark:bg-primary-dark": currentIsValid.value !== false,
-              "bg-negative dark:bg-negative-dark": currentIsValid.value === false,
-              "transition-[left,width,background-color]": !_ctx.side && indicatorStyle.value !== void 0,
-              "transition-[top,height,background-color]": _ctx.side && indicatorStyle.value !== void 0
-            }]),
-            style: normalizeStyle(indicatorStyle.value)
-          }, null, 6)) : createCommentVNode("", true)
-        ], 2)) : createCommentVNode("", true),
-        defaultSlots.value.some((slot) => slot.children?.default) ? (openBlock(), createElementBlock("div", {
-          key: 1,
-          class: normalizeClass(["relative h-full transition-[min-height] duration-300", {
-            "sm-not:snap-start": _ctx.side
-          }]),
-          style: normalizeStyle({ minHeight: minHeight.value ? minHeight.value + "px" : "auto", "--direction-factor": isDirect.value ? "1" : "-1" })
-        }, [
-          createVNode(TransitionGroup, {
-            "enter-active-class": "transition-[transform,opacity] duration-[250ms] w-full",
-            "leave-active-class": "transition-[transform,opacity] duration-[250ms] w-full absolute top-0",
-            "enter-from-class": _ctx.lessTransitions || _ctx.side ? "opacity-0" : "opacity-0 translate-x-[calc((100%+var(--inner-margin))*var(--direction-factor))]",
-            "leave-to-class": _ctx.lessTransitions || _ctx.side ? "opacity-0" : "opacity-0 translate-x-[calc((100%+var(--inner-margin))*var(--direction-factor)*-1)]"
-          }, {
-            default: withCtx(() => [
-              (openBlock(true), createElementBlock(Fragment, null, renderList(defaultSlots.value, (slot) => {
-                return openBlock(), createBlock(_sfc_main$2, {
+            ref: "buttonContainer",
+            class: normalizeClass(["relative", {
+              "sm-not:snap-start grid grid-cols-[1fr,auto]": _ctx.side,
+              "no-scrollbar sm-not:-pl--inner-margin flex snap-x snap-mandatory snap-always overflow-x-auto overscroll-x-contain pr-[50%]": !_ctx.side
+            }])
+          }, [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(defaultSlotsAll.value, (slot, index) => {
+              return openBlock(), createElementBlock(Fragment, {
+                key: slot.props?.name
+              }, [
+                isTabItem(slot) ? (openBlock(), createBlock(_sfc_main$2, {
+                  key: 0,
                   ref_for: true,
-                  ref: "tabItem",
-                  key: slot.props?.name,
-                  name: slot.props?.name,
-                  title: slot.props?.title,
-                  active: slot.props?.name === current.value,
-                  removable: slot.props?.removable,
-                  "onTab:switch": _cache[1] || (_cache[1] = ($event) => !_ctx.noSwitchOnInvalid && unref(switchOnInvalid)($event)),
-                  "onUpdate:height": _cache[2] || (_cache[2] = ($event) => !_ctx.disableMinHeight && updateHeight($event)),
-                  "onUpdate:active": ($event) => _ctx.$emit("update:current-title", slot.props?.title)
-                }, {
-                  default: withCtx(() => [
-                    (openBlock(), createBlock(resolveDynamicComponent(slot)))
-                  ]),
-                  _: 2
-                }, 1032, ["name", "title", "active", "removable", "onUpdate:active"]);
-              }), 128))
-            ]),
-            _: 1
-          }, 8, ["enter-from-class", "leave-to-class"])
-        ], 6)) : createCommentVNode("", true)
-      ], 2);
+                  ref: "button",
+                  active: current.value === slot.props.name,
+                  index,
+                  title: slot.props.title,
+                  icon: slot.props.icon,
+                  "has-changes": unref(formRef)?.hasChangesMap[slot.props.name] === true,
+                  "has-error": typeof unref(formRef)?.errorMessageMap[slot.props.name] === "string",
+                  "has-value": unref(formRef)?.hasValueMap[slot.props.name] === true,
+                  first: defaultSlots.value.indexOf(slot) === 0,
+                  last: defaultSlots.value.indexOf(slot) === defaultSlots.value.length - 1,
+                  disabled: _ctx.stepper ? defaultSlots.value.indexOf(slot) > hasNoValueFirst.value : false,
+                  stepper: _ctx.stepper,
+                  "show-has-value": _ctx.showHasValue,
+                  side: _ctx.side,
+                  class: normalizeClass({
+                    "snap-center": !_ctx.side
+                  }),
+                  "onUpdate:indicatorStyle": _cache[0] || (_cache[0] = ($event) => indicatorStyle.value = $event),
+                  "onUpdate:scrollPosition": updateScrollPosition,
+                  onClick: ($event) => unref(switchTab)(slot.props?.name)
+                }, createSlots({ _: 2 }, [
+                  slot.children?.title ? {
+                    name: "title",
+                    fn: withCtx((scope) => [
+                      (openBlock(), createBlock(resolveDynamicComponent(slot.children?.title), mergeProps({ ref_for: true }, scope), null, 16))
+                    ]),
+                    key: "0"
+                  } : void 0,
+                  slot.children?.suffix ? {
+                    name: "suffix",
+                    fn: withCtx((scope) => [
+                      (openBlock(), createBlock(resolveDynamicComponent(slot.children?.suffix), mergeProps({ ref_for: true }, scope), null, 16))
+                    ]),
+                    key: "1"
+                  } : void 0,
+                  slot.children?.right ? {
+                    name: "right",
+                    fn: withCtx((scope) => [
+                      (openBlock(), createBlock(resolveDynamicComponent(slot.children?.right), mergeProps({ ref_for: true }, scope), null, 16))
+                    ]),
+                    key: "2"
+                  } : void 0
+                ]), 1032, ["active", "index", "title", "icon", "has-changes", "has-error", "has-value", "first", "last", "disabled", "stepper", "show-has-value", "side", "class", "onClick"])) : (openBlock(), createBlock(resolveDynamicComponent(slot), { key: 1 }))
+              ], 64);
+            }), 128)),
+            !_ctx.stepper ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: normalizeClass(["absolute rounded-sm duration-500", {
+                "bg-primary-default dark:bg-primary-dark": currentIsValid.value !== false,
+                "bg-negative dark:bg-negative-dark": currentIsValid.value === false,
+                "transition-[left,width,background-color]": !_ctx.side && indicatorStyle.value !== void 0,
+                "transition-[top,height,background-color]": _ctx.side && indicatorStyle.value !== void 0
+              }]),
+              style: normalizeStyle(indicatorStyle.value)
+            }, null, 6)) : createCommentVNode("", true)
+          ], 2)) : createCommentVNode("", true),
+          defaultSlots.value.some((slot) => slot.children?.default) ? (openBlock(), createElementBlock("div", {
+            key: 1,
+            class: normalizeClass(["relative h-full transition-[min-height] duration-300", {
+              "sm-not:snap-start": _ctx.side
+            }]),
+            style: normalizeStyle({ minHeight: minHeight.value ? minHeight.value + "px" : "auto", "--direction-factor": isDirect.value ? "1" : "-1" })
+          }, [
+            createVNode(TransitionGroup, {
+              "enter-active-class": "transition-[transform,opacity] duration-[250ms] w-full",
+              "leave-active-class": "transition-[transform,opacity] duration-[250ms] w-full absolute top-0",
+              "enter-from-class": _ctx.lessTransitions || _ctx.side ? "opacity-0" : "opacity-0 translate-x-[calc((100%+var(--inner-margin))*var(--direction-factor))]",
+              "leave-to-class": _ctx.lessTransitions || _ctx.side ? "opacity-0" : "opacity-0 translate-x-[calc((100%+var(--inner-margin))*var(--direction-factor)*-1)]"
+            }, {
+              default: withCtx(() => [
+                (openBlock(true), createElementBlock(Fragment, null, renderList(defaultSlots.value, (slot) => {
+                  return openBlock(), createBlock(_sfc_main$3, {
+                    ref_for: true,
+                    ref: "tabItem",
+                    key: slot.props.name,
+                    name: slot.props.name,
+                    title: slot.props.title,
+                    active: slot.props.name === current.value,
+                    removable: slot.props.removable ?? false,
+                    "onTab:switch": _cache[1] || (_cache[1] = ($event) => !_ctx.noSwitchOnInvalid && unref(switchOnInvalid)($event)),
+                    "onUpdate:height": _cache[2] || (_cache[2] = ($event) => !_ctx.disableMinHeight && updateHeight($event)),
+                    "onUpdate:active": ($event) => _ctx.$emit("update:current-title", slot.props?.title)
+                  }, {
+                    default: withCtx(() => [
+                      (openBlock(), createBlock(resolveDynamicComponent(slot)))
+                    ]),
+                    _: 2
+                  }, 1032, ["name", "title", "active", "removable", "onUpdate:active"]);
+                }), 128))
+              ]),
+              _: 1
+            }, 8, ["enter-from-class", "leave-to-class"])
+          ], 6)) : createCommentVNode("", true)
+        ]),
+        _: 1
+      }, 8, ["name", "class"]);
     };
   }
 });

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

@@ -1,6 +1,8 @@
 declare function __VLS_template(): {
-    slots: {
-        default?(_: {}): any;
+    slots: Readonly<{
+        default: () => [];
+    }> & {
+        default: () => [];
     };
     refs: {};
     attrs: Partial<{}>;

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

@@ -1 +1 @@
-{"version":3,"file":"WTabsColumns.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Tabs/WTabsColumns.vue"],"names":[],"mappings":"AAuCA,iBAAS,cAAc;;yBA+CM,GAAG;;;WASlB,OAAO,IAA6B;EAEjD;AASD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe,+QAKnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAKpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}
+{"version":3,"file":"WTabsColumns.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Tabs/WTabsColumns.vue"],"names":[],"mappings":"AA+CA,iBAAS,cAAc;;iBAPZ,MAAM,EAAE;;iBAAR,MAAM,EAAE;;;WA4DL,OAAO,IAA6B;EAEjD;AASD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe,+QAKnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAKpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

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

@@ -1,4 +1,4 @@
-import { TabsItemScopedProps } from './types';
+import { TabsItemProps, TabsItemScopedProps } from './types';
 declare function __VLS_template(): {
     slots: Readonly<{
         default?: () => void;
@@ -15,23 +15,7 @@ declare function __VLS_template(): {
     attrs: Partial<{}>;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<{
-    title: string;
-    name: string;
-    icon?: SVGComponent;
-    disabled?: boolean;
-    removable?: boolean;
-    divided?: boolean;
-    init?: boolean;
-}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
-    title: string;
-    name: string;
-    icon?: SVGComponent;
-    disabled?: boolean;
-    removable?: boolean;
-    divided?: boolean;
-    init?: boolean;
-}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_component: import('vue').DefineComponent<TabsItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TabsItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

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

@@ -1 +1 @@
-{"version":3,"file":"WTabsItem.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Tabs/WTabsItem.vue"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,SAAS,CAAA;AA0BhD,iBAAS,cAAc;;kBAVX,MAAM,IAAI;gBACZ,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI;iBACnC,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI;gBACrC,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI;;kBAHlC,MAAM,IAAI;gBACZ,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI;iBACnC,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI;gBACrC,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI;;;WAsChC,OAAO,IAA6B;EAEjD;AAQD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;WA/DZ,MAAM;UACP,MAAM;WACL,YAAY;eACR,OAAO;gBACN,OAAO;cACT,OAAO;WACV,OAAO;;WANP,MAAM;UACP,MAAM;WACL,YAAY;eACR,OAAO;gBACN,OAAO;cACT,OAAO;WACV,OAAO;iGA+Dd,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAWpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}
+{"version":3,"file":"WTabsItem.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Tabs/WTabsItem.vue"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAC,aAAa,EAAE,mBAAmB,EAAC,MAAM,SAAS,CAAA;AAkB/D,iBAAS,cAAc;;kBAVX,MAAM,IAAI;gBACZ,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI;iBACnC,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI;gBACrC,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI;;kBAHlC,MAAM,IAAI;gBACZ,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI;iBACnC,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI;gBACrC,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI;;;WAsChC,OAAO,IAA6B;EAEjD;AAQD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe,sSAMnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAWpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

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

@@ -39,14 +39,18 @@ declare function __VLS_template(): {
                 "onUpdate:has-value"?: ((value: boolean | null) => any) | undefined;
             }>, {
                 isValid: import('vue').ComputedRef<boolean>;
-                hasChanges: import('vue').ComputedRef<boolean>;
-                hasValue: import('vue').ComputedRef<boolean | null>;
-                validate: (silent?: boolean, path?: import('../../Form/use/useFormValidateMap').ValidatePath) => string | undefined;
-                invalidate: (payload: {
-                    [x: string]: string | string[] | undefined;
-                }) => void;
-                initModel: () => void;
-                errorMessage: import('vue').ComputedRef<string>;
+                hasChanges: import('vue').Ref<boolean, boolean>;
+                hasChangesMap: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+                hasValue: import('vue').Ref<boolean | null, boolean | null>;
+                hasValueMap: import('vue').Ref<Record<string, boolean | null>, Record<string, boolean | null>>;
+                validate: import('vue').Ref<(silent?: boolean, path?: import('../../Form/models/utils').ValidatePath) => string | undefined, (silent?: boolean, path?: import('../../Form/models/utils').ValidatePath) => string | undefined>;
+                validateMap: import('vue').Ref<Record<string, (silent?: boolean, path?: import('../../Form/models/utils').ValidatePath) => string | undefined>, Record<string, (silent?: boolean, path?: import('../../Form/models/utils').ValidatePath) => string | undefined>>;
+                invalidate: import('vue').Ref<(messages: Record<string, string | string[] | undefined>) => void, (messages: Record<string, string | string[] | undefined>) => void>;
+                invalidateMap: import('vue').Ref<Record<string, (messages: Record<string, string | string[] | undefined>) => void>, Record<string, (messages: Record<string, string | string[] | undefined>) => void>>;
+                initModel: import('vue').Ref<() => void, () => void>;
+                initModelMap: import('vue').Ref<Record<string, () => void>, Record<string, () => void>>;
+                errorMessage: import('vue').Ref<string | undefined, string | undefined>;
+                errorMessageMap: import('vue').Ref<Record<string, string | undefined>, Record<string, string | undefined>>;
             }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
                 "update:has-changes": (value: boolean) => any;
                 "update:is-valid": (value: boolean | undefined) => any;
@@ -79,16 +83,20 @@ declare function __VLS_template(): {
             "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
             "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
             "onUpdate:has-value"?: ((value: boolean | null) => any) | undefined;
-        }>, "errorMessage" | "hasChanges" | "isValid" | "hasValue" | "validate" | "invalidate" | "initModel"> & import('vue').ShallowUnwrapRef<{
+        }>, "errorMessage" | "hasChanges" | "hasChangesMap" | "isValid" | "hasValue" | "hasValueMap" | "validate" | "validateMap" | "invalidate" | "invalidateMap" | "initModel" | "initModelMap" | "errorMessageMap"> & import('vue').ShallowUnwrapRef<{
             isValid: import('vue').ComputedRef<boolean>;
-            hasChanges: import('vue').ComputedRef<boolean>;
-            hasValue: import('vue').ComputedRef<boolean | null>;
-            validate: (silent?: boolean, path?: import('../../Form/use/useFormValidateMap').ValidatePath) => string | undefined;
-            invalidate: (payload: {
-                [x: string]: string | string[] | undefined;
-            }) => void;
-            initModel: () => void;
-            errorMessage: import('vue').ComputedRef<string>;
+            hasChanges: import('vue').Ref<boolean, boolean>;
+            hasChangesMap: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+            hasValue: import('vue').Ref<boolean | null, boolean | null>;
+            hasValueMap: import('vue').Ref<Record<string, boolean | null>, Record<string, boolean | null>>;
+            validate: import('vue').Ref<(silent?: boolean, path?: import('../../Form/models/utils').ValidatePath) => string | undefined, (silent?: boolean, path?: import('../../Form/models/utils').ValidatePath) => string | undefined>;
+            validateMap: import('vue').Ref<Record<string, (silent?: boolean, path?: import('../../Form/models/utils').ValidatePath) => string | undefined>, Record<string, (silent?: boolean, path?: import('../../Form/models/utils').ValidatePath) => string | undefined>>;
+            invalidate: import('vue').Ref<(messages: Record<string, string | string[] | undefined>) => void, (messages: Record<string, string | string[] | undefined>) => void>;
+            invalidateMap: import('vue').Ref<Record<string, (messages: Record<string, string | string[] | undefined>) => void>, Record<string, (messages: Record<string, string | string[] | undefined>) => void>>;
+            initModel: import('vue').Ref<() => void, () => void>;
+            initModelMap: import('vue').Ref<Record<string, () => void>, Record<string, () => void>>;
+            errorMessage: import('vue').Ref<string | undefined, string | undefined>;
+            errorMessageMap: import('vue').Ref<Record<string, string | undefined>, Record<string, string | undefined>>;
         }> & {} & import('vue').ComponentCustomProperties & {} & {
             $slots: {
                 default?(_: {}): any;
@@ -105,15 +113,7 @@ declare const __VLS_component: import('vue').DefineComponent<{
     removable: boolean;
 }, {
     emitHeight: () => void;
-    isValid: import('vue').ComputedRef<boolean>;
-    hasChanges: import('vue').ComputedRef<boolean>;
-    hasValue: import('vue').ComputedRef<boolean | null>;
-    errorMessage: import('vue').ComputedRef<string | undefined>;
-    validate: (silent?: boolean, path?: import('../../Form/use/useFormValidateMap').ValidatePath) => string | undefined;
-    invalidate: (payload: {
-        [x: string]: string | string[] | undefined;
-    }) => void;
-    initModel: () => void;
+    name: import('vue').Ref<string, string>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     "tab:switch": (value: string) => any;
     "update:height": (value: number) => any;
@@ -163,14 +163,18 @@ declare const __VLS_component: import('vue').DefineComponent<{
             "onUpdate:has-value"?: ((value: boolean | null) => any) | undefined;
         }>, {
             isValid: import('vue').ComputedRef<boolean>;
-            hasChanges: import('vue').ComputedRef<boolean>;
-            hasValue: import('vue').ComputedRef<boolean | null>;
-            validate: (silent?: boolean, path?: import('../../Form/use/useFormValidateMap').ValidatePath) => string | undefined;
-            invalidate: (payload: {
-                [x: string]: string | string[] | undefined;
-            }) => void;
-            initModel: () => void;
-            errorMessage: import('vue').ComputedRef<string>;
+            hasChanges: import('vue').Ref<boolean, boolean>;
+            hasChangesMap: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+            hasValue: import('vue').Ref<boolean | null, boolean | null>;
+            hasValueMap: import('vue').Ref<Record<string, boolean | null>, Record<string, boolean | null>>;
+            validate: import('vue').Ref<(silent?: boolean, path?: import('../../Form/models/utils').ValidatePath) => string | undefined, (silent?: boolean, path?: import('../../Form/models/utils').ValidatePath) => string | undefined>;
+            validateMap: import('vue').Ref<Record<string, (silent?: boolean, path?: import('../../Form/models/utils').ValidatePath) => string | undefined>, Record<string, (silent?: boolean, path?: import('../../Form/models/utils').ValidatePath) => string | undefined>>;
+            invalidate: import('vue').Ref<(messages: Record<string, string | string[] | undefined>) => void, (messages: Record<string, string | string[] | undefined>) => void>;
+            invalidateMap: import('vue').Ref<Record<string, (messages: Record<string, string | string[] | undefined>) => void>, Record<string, (messages: Record<string, string | string[] | undefined>) => void>>;
+            initModel: import('vue').Ref<() => void, () => void>;
+            initModelMap: import('vue').Ref<Record<string, () => void>, Record<string, () => void>>;
+            errorMessage: import('vue').Ref<string | undefined, string | undefined>;
+            errorMessageMap: import('vue').Ref<Record<string, string | undefined>, Record<string, string | undefined>>;
         }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
             "update:has-changes": (value: boolean) => any;
             "update:is-valid": (value: boolean | undefined) => any;
@@ -203,16 +207,20 @@ declare const __VLS_component: import('vue').DefineComponent<{
         "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
         "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
         "onUpdate:has-value"?: ((value: boolean | null) => any) | undefined;
-    }>, "errorMessage" | "hasChanges" | "isValid" | "hasValue" | "validate" | "invalidate" | "initModel"> & import('vue').ShallowUnwrapRef<{
+    }>, "errorMessage" | "hasChanges" | "hasChangesMap" | "isValid" | "hasValue" | "hasValueMap" | "validate" | "validateMap" | "invalidate" | "invalidateMap" | "initModel" | "initModelMap" | "errorMessageMap"> & import('vue').ShallowUnwrapRef<{
         isValid: import('vue').ComputedRef<boolean>;
-        hasChanges: import('vue').ComputedRef<boolean>;
-        hasValue: import('vue').ComputedRef<boolean | null>;
-        validate: (silent?: boolean, path?: import('../../Form/use/useFormValidateMap').ValidatePath) => string | undefined;
-        invalidate: (payload: {
-            [x: string]: string | string[] | undefined;
-        }) => void;
-        initModel: () => void;
-        errorMessage: import('vue').ComputedRef<string>;
+        hasChanges: import('vue').Ref<boolean, boolean>;
+        hasChangesMap: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+        hasValue: import('vue').Ref<boolean | null, boolean | null>;
+        hasValueMap: import('vue').Ref<Record<string, boolean | null>, Record<string, boolean | null>>;
+        validate: import('vue').Ref<(silent?: boolean, path?: import('../../Form/models/utils').ValidatePath) => string | undefined, (silent?: boolean, path?: import('../../Form/models/utils').ValidatePath) => string | undefined>;
+        validateMap: import('vue').Ref<Record<string, (silent?: boolean, path?: import('../../Form/models/utils').ValidatePath) => string | undefined>, Record<string, (silent?: boolean, path?: import('../../Form/models/utils').ValidatePath) => string | undefined>>;
+        invalidate: import('vue').Ref<(messages: Record<string, string | string[] | undefined>) => void, (messages: Record<string, string | string[] | undefined>) => void>;
+        invalidateMap: import('vue').Ref<Record<string, (messages: Record<string, string | string[] | undefined>) => void>, Record<string, (messages: Record<string, string | string[] | undefined>) => void>>;
+        initModel: import('vue').Ref<() => void, () => void>;
+        initModelMap: import('vue').Ref<Record<string, () => void>, Record<string, () => void>>;
+        errorMessage: import('vue').Ref<string | undefined, string | undefined>;
+        errorMessageMap: import('vue').Ref<Record<string, string | undefined>, Record<string, string | undefined>>;
     }> & {} & import('vue').ComponentCustomProperties & {} & {
         $slots: {
             default?(_: {}): any;

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

@@ -1 +1 @@
-{"version":3,"file":"TabItem.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/Tabs/components/TabItem.vue"],"names":[],"mappings":"AA0EA,OAAO,EAAW,QAAQ,EAAwB,MAAM,KAAK,CAAA;AAiF7D,iBAAS,cAAc;;yBA6DM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCA0DgvjB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;WAhDx3jB,OAAO,IAA6B;EAEjD;AAcD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;UAhKb,MAAM;WACL,MAAM;YACL,OAAO;eACJ,OAAO;;sBAuBG,IAAI;;;;;;;;;;;;;;;UA1BnB,MAAM;WACL,MAAM;YACL,OAAO;eACJ,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA4L4vjB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;OAlBp4jB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAWpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}
+{"version":3,"file":"TabItem.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/Tabs/components/TabItem.vue"],"names":[],"mappings":"AA2DA,OAAO,EAAC,QAAQ,EAA+B,MAAM,KAAK,CAAA;AA4D1D,iBAAS,cAAc;;yBA6DM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCA0D4qmB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAhDpzmB,OAAO,IAA6B;EAEjD;AAcD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;UA3Ib,MAAM;WACL,MAAM;YACL,OAAO;eACJ,OAAO;;sBAcG,IAAI;;;;;;;UAjBnB,MAAM;WACL,MAAM;YACL,OAAO;eACJ,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAuKwrmB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAlBh0mB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAWpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

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

@@ -1,4 +1,4 @@
-import { defineComponent, useTemplateRef, computed, watch, nextTick, withDirectives, openBlock, createBlock, withCtx, renderSlot, vShow, createCommentVNode } from 'vue';
+import { defineComponent, useTemplateRef, watch, nextTick, toRef, withDirectives, openBlock, createBlock, withCtx, renderSlot, vShow, createCommentVNode } from 'vue';
 import _sfc_main$1 from '../../Form/WForm.vue.js';
 import { useTabItemActiveListener } from '../use/useTabItemActiveListener.js';
 
@@ -16,13 +16,6 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const emit = __emit;
     const { callListeners } = useTabItemActiveListener();
     const formRef = useTemplateRef("form");
-    const isValid = computed(() => formRef.value?.isValid ?? true);
-    const hasChanges = computed(() => formRef.value?.hasChanges ?? false);
-    const hasValue = computed(() => formRef.value?.hasValue ?? null);
-    const errorMessage = computed(() => formRef.value?.errorMessage);
-    const validate = (...args) => formRef.value?.validate(...args);
-    const invalidate = (...args) => formRef.value?.invalidate(...args);
-    const initModel = () => formRef.value?.initModel();
     const emitHeight = () => {
       if (!formRef.value) return;
       emit("update:height", formRef.value.$el.offsetHeight);
@@ -35,13 +28,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     }, { immediate: true });
     __expose({
       emitHeight,
-      isValid,
-      hasChanges,
-      hasValue,
-      errorMessage,
-      validate,
-      invalidate,
-      initModel
+      name: toRef(props, "name")
     });
     return (_ctx, _cache) => {
       return !_ctx.removable || _ctx.active ? withDirectives((openBlock(), createBlock(_sfc_main$1, {