eco-vue-js 0.9.3 → 0.9.5

package/dist/components/Form/WForm.vue.d.ts

@@ -11,6 +11,8 @@ declare const __VLS_component: import('vue').DefineComponent<{
     title?: string;
 }, {
     isValid: import('vue').ComputedRef<boolean>;
+    hasChanges: import('vue').ComputedRef<boolean>;
+    hasValue: import('vue').ComputedRef<boolean | null>;
     validate: (silent?: boolean, path?: import('./use/useFormValidateMap').ValidatePath) => string | undefined;
     invalidate: (payload: {
         [x: string]: string | string[] | undefined;
@@ -20,12 +22,14 @@ declare const __VLS_component: import('vue').DefineComponent<{
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     "update:has-changes": (value: boolean) => any;
     "update:is-valid": (value: boolean | undefined) => any;
+    "update:has-value": (value: boolean | null) => any;
 }, string, import('vue').PublicProps, Readonly<{
     name?: string;
     title?: string;
 }> & Readonly<{
     "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
     "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
+    "onUpdate:has-value"?: ((value: boolean | null) => any) | undefined;
 }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/components/Form/WForm.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WForm.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Form/WForm.vue"],"names":[],"mappings":"AAuJA,iBAAS,cAAc;;yBA0BM,GAAG;;;WASlB,OAAO,IAA6B;EAEjD;AAYD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;WArHZ,MAAM;YACL,MAAM;;;;;;;;;;;;;WADP,MAAM;YACL,MAAM;;;;kFA+Hd,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":"WForm.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Form/WForm.vue"],"names":[],"mappings":"AA0KA,iBAAS,cAAc;;yBA0BM,GAAG;;;WASlB,OAAO,IAA6B;EAEjD;AAaD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;WAhIZ,MAAM;YACL,MAAM;;;;;;;;;;;;;;;;WADP,MAAM;YACL,MAAM;;;;;kFA2Id,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/Form/WForm.vue.js

@@ -2,6 +2,7 @@ import { defineComponent, toRef, provide, inject, watch, onBeforeUnmount, openBl
 import { wFormUnlistener } from './models/injection.js';
 import { useFormErrorMessageMap } from './use/useFormErrorMessageMap.js';
 import { useFormHasChangesMap } from './use/useFormHasChangesMap.js';
+import { useFormHasValueMap } from './use/useFormHasValueMap.js';
 import { useFormInitModelMap } from './use/useFormInitModelMap.js';
 import { useFormInvalidateMap } from './use/useFormInvalidateMap.js';
 import { useFormTitleMap } from './use/useFormTitleMap.js';
@@ -13,7 +14,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     name: {},
     title: {}
   },
-  emits: ["update:is-valid", "update:has-changes"],
+  emits: ["update:is-valid", "update:has-changes", "update:has-value"],
   setup(__props, { expose: __expose, emit: __emit }) {
     const props = __props;
     const emit = __emit;
@@ -21,6 +22,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const { titleGetter, titleMapUnlistener } = useFormTitleMap(name, toRef(props, "title"));
     const { errorMessageMapUnlistener, isValid, errorMessage, errorMessageMap } = useFormErrorMessageMap(name, titleGetter);
     const { hasChangesMapUnlistener, hasChanges } = useFormHasChangesMap(name);
+    const { hasValueMapUnlistener, hasValue } = useFormHasValueMap(name);
     const { validateMapUnlistener, validate } = useFormValidateMap(name, titleGetter, (value) => emit("update:is-valid", value));
     const { invalidateMapUnlistener, invalidate } = useFormInvalidateMap(name);
     const { initModelMapUnlistener, initModel } = useFormInitModelMap(name);
@@ -28,6 +30,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       titleMapUnlistener(key);
       errorMessageMapUnlistener(key);
       hasChangesMapUnlistener(key);
+      hasValueMapUnlistener(key);
       validateMapUnlistener(key);
       invalidateMapUnlistener(key);
       initModelMapUnlistener(key);
@@ -36,6 +39,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const unlistenerInjected = inject(wFormUnlistener, void 0);
     watch(errorMessageMap, () => emit("update:is-valid", isValid.value));
     watch(hasChanges, (value) => emit("update:has-changes", value));
+    watch(hasValue, (value) => emit("update:has-value", value));
     onBeforeUnmount(() => {
       if (props.name) {
         unlistenerInjected?.(props.name);
@@ -44,6 +48,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     });
     __expose({
       isValid,
+      hasChanges,
+      hasValue,
       validate,
       invalidate,
       initModel,

package/dist/components/Form/WFormValidator.vue.d.ts

@@ -24,6 +24,7 @@ declare const __VLS_component: import('vue').DefineComponent<{
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     "update:has-changes": (value: boolean) => any;
     "update:is-valid": (value: boolean) => any;
+    "update:has-value": (value: boolean | null) => any;
 }, string, import('vue').PublicProps, Readonly<{
     name?: string;
     title?: string;
@@ -34,6 +35,7 @@ declare const __VLS_component: import('vue').DefineComponent<{
 }> & Readonly<{
     "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
     "onUpdate:is-valid"?: ((value: boolean) => any) | undefined;
+    "onUpdate:has-value"?: ((value: boolean | null) => any) | undefined;
 }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/components/Form/WFormValidator.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WFormValidator.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Form/WFormValidator.vue"],"names":[],"mappings":"AAsjBA,iBAAS,cAAc;;iBAXZ,MAAM,IAAI;;iBAAV,MAAM,IAAI;;;;;WA0GP,OAAO,IAA6B;EAEjD;AAmBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;WAnYZ,MAAM;YACL,MAAM;eACH,UAAU,GAAG,UAAU,EAAE;sBAClB,MAAM;sBACN,MAAM;gBACZ,OAAO;;;wBA8OC,MAAM;qBAjEN,IAAI;;;;;WAlLjB,MAAM;YACL,MAAM;eACH,UAAU,GAAG,UAAU,EAAE;sBAClB,MAAM;sBACN,MAAM;gBACZ,OAAO;;;;kFAyYnB,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":"WFormValidator.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Form/WFormValidator.vue"],"names":[],"mappings":"AA2lBA,iBAAS,cAAc;;iBAZZ,MAAM,IAAI;;iBAAV,MAAM,IAAI;;;;;WA2GP,OAAO,IAA6B;EAEjD;AAoBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;WAvZZ,MAAM;YACL,MAAM;eACH,UAAU,GAAG,UAAU,EAAE;sBAClB,MAAM;sBACN,MAAM;gBACZ,OAAO;;;wBAgQC,MAAM;qBAzEN,IAAI;;;;;;WA5LjB,MAAM;YACL,MAAM;eACH,UAAU,GAAG,UAAU,EAAE;sBAClB,MAAM;sBACN,MAAM;gBACZ,OAAO;;;;;kFA8ZnB,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/Form/WFormValidator.vue.js

@@ -9,7 +9,7 @@ import '../../utils/supportsPassive.js';
 import '../Dropdown/utils/DropdownStyle.js';
 import 'vue-router';
 import '../../utils/Modal.js';
-import { wFormTitleUpdater, wFormErrorMessageUpdater, wFormHasChangesUpdater, wFormValidateUpdater, wFormInvalidateUpdater, wFormInitModelUpdater, wFormUnlistener } from './models/injection.js';
+import { wFormTitleUpdater, wFormErrorMessageUpdater, wFormHasChangesUpdater, wFormHasValueUpdater, wFormValidateUpdater, wFormInvalidateUpdater, wFormInitModelUpdater, wFormUnlistener } from './models/injection.js';
 import { scrollToValidator } from './models/utils.js';
 import { validateRequired } from '../../utils/validate.js';
 import '../Input/WInputSuggest.vue.js';
@@ -27,13 +27,14 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     requiredSymbols: {},
     noChanges: { type: Boolean }
   },
-  emits: ["update:has-changes", "update:is-valid"],
+  emits: ["update:has-changes", "update:has-value", "update:is-valid"],
   setup(__props, { expose: __expose, emit: __emit }) {
     const props = __props;
     const emit = __emit;
     const titleUpdater = inject(wFormTitleUpdater, void 0);
     const errorMessageUpdater = inject(wFormErrorMessageUpdater, void 0);
     const hasChangesUpdater = inject(wFormHasChangesUpdater, void 0);
+    const hasValueUpdater = inject(wFormHasValueUpdater, void 0);
     const validateUpdater = inject(wFormValidateUpdater, void 0);
     const invalidateUpdater = inject(wFormInvalidateUpdater, void 0);
     const initModelUpdater = inject(wFormInitModelUpdater, void 0);
@@ -59,12 +60,17 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const errorMessage = ref(null);
     const hasChanges = ref(false);
     const hasBeenValidated = ref(false);
+    const hasValue = computed(() => {
+      if (!required.value) return null;
+      if (Array.isArray(modelValue.value)) return modelValue.value.length !== 0;
+      return modelValue.value !== void 0 && modelValue.value !== null && modelValue.value !== "";
+    });
     const requiredSymbols = computed(() => props.requiredSymbols?.split("") ?? []);
     const _updateHasChanges = (value) => {
       if (initModelValue.value === void 0) {
         hasChanges.value = value !== void 0 && value !== "";
       } else {
-        if (value instanceof Array && initModelValue.value instanceof Array) {
+        if (Array.isArray(value) && Array.isArray(initModelValue.value)) {
           const oldValue = initModelValue.value;
           const newValue = value;
           hasChanges.value = newValue.length !== oldValue.length || newValue.some((item) => !oldValue.includes(item));
@@ -176,6 +182,12 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       }
       emit("update:has-changes", value);
     });
+    watch(hasValue, (value) => {
+      if (props.name) {
+        hasValueUpdater?.(props.name, value);
+      }
+      emit("update:has-value", value);
+    }, { immediate: true });
     watch(title, (value) => {
       if (props.name) {
         titleUpdater?.(props.name, value);

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

@@ -2,6 +2,7 @@ import { InjectionKey } from 'vue';
 export declare const wFormTitleUpdater: InjectionKey<(key: string, value: string | undefined) => void>;
 export declare const wFormErrorMessageUpdater: InjectionKey<(key: string, value: string | undefined) => void>;
 export declare const wFormHasChangesUpdater: InjectionKey<(key: string, value: boolean) => void>;
+export declare const wFormHasValueUpdater: InjectionKey<(key: string, value: boolean | null) => void>;
 export declare const wFormValidateUpdater: InjectionKey<(key: string, value: () => string | undefined) => void>;
 export declare const wFormInvalidateUpdater: InjectionKey<(key: string, value: (messages: Record<string, string | string[] | undefined>) => void) => void>;
 export declare const wFormInitModelUpdater: InjectionKey<(key: string, value: () => void) => void>;

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

@@ -1 +1 @@
-{"version":3,"file":"injection.d.ts","sourceRoot":"","sources":["../../../../src/components/Form/models/injection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,KAAK,CAAA;AAErC,eAAO,MAAM,iBAAiB,EAAkC,YAAY,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC,CAAA;AAE9H,eAAO,MAAM,wBAAwB,EAAyC,YAAY,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC,CAAA;AAE5I,eAAO,MAAM,sBAAsB,EAAuC,YAAY,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC,CAAA;AAE7H,eAAO,MAAM,oBAAoB,EAAqC,YAAY,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC,CAAA;AAE1I,eAAO,MAAM,sBAAsB,EAAqC,YAAY,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,KAAK,IAAI,KAAK,IAAI,CAAC,CAAA;AAErL,eAAO,MAAM,qBAAqB,EAAsC,YAAY,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC,CAAA;AAE9H,eAAO,MAAM,eAAe,EAAgC,YAAY,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC,CAAA"}
+{"version":3,"file":"injection.d.ts","sourceRoot":"","sources":["../../../../src/components/Form/models/injection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,KAAK,CAAA;AAErC,eAAO,MAAM,iBAAiB,EAAkC,YAAY,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC,CAAA;AAE9H,eAAO,MAAM,wBAAwB,EAAyC,YAAY,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC,CAAA;AAE5I,eAAO,MAAM,sBAAsB,EAAuC,YAAY,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC,CAAA;AAE7H,eAAO,MAAM,oBAAoB,EAAqC,YAAY,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,KAAK,IAAI,CAAC,CAAA;AAEhI,eAAO,MAAM,oBAAoB,EAAqC,YAAY,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC,CAAA;AAE1I,eAAO,MAAM,sBAAsB,EAAqC,YAAY,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,KAAK,IAAI,KAAK,IAAI,CAAC,CAAA;AAErL,eAAO,MAAM,qBAAqB,EAAsC,YAAY,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC,CAAA;AAE9H,eAAO,MAAM,eAAe,EAAgC,YAAY,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC,CAAA"}

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

@@ -1,9 +1,10 @@
 const wFormTitleUpdater = Symbol("wFormTitleUpdater");
 const wFormErrorMessageUpdater = Symbol("wFormErrorMessageUpdater");
 const wFormHasChangesUpdater = Symbol("wFormHasChangesUpdater");
+const wFormHasValueUpdater = Symbol("wFormHasValueUpdater");
 const wFormValidateUpdater = Symbol("wFormValidateUpdater");
 const wFormInvalidateUpdater = Symbol("wFormValidateUpdater");
 const wFormInitModelUpdater = Symbol("wFormInitModelUpdater");
 const wFormUnlistener = Symbol("wFormUnlistener");
 
-export { wFormErrorMessageUpdater, wFormHasChangesUpdater, wFormInitModelUpdater, wFormInvalidateUpdater, wFormTitleUpdater, wFormUnlistener, wFormValidateUpdater };
+export { wFormErrorMessageUpdater, wFormHasChangesUpdater, wFormHasValueUpdater, wFormInitModelUpdater, wFormInvalidateUpdater, wFormTitleUpdater, wFormUnlistener, wFormValidateUpdater };

package/dist/components/Form/use/useFormHasValueMap.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+export declare const useFormHasValueMap: (name: Ref<string | undefined>) => {
+    hasValueMapUnlistener: (key: string) => void;
+    hasValue: import('vue').ComputedRef<boolean | null>;
+};
+//# sourceMappingURL=useFormHasValueMap.d.ts.map

package/dist/components/Form/use/useFormHasValueMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormHasValueMap.d.ts","sourceRoot":"","sources":["../../../../src/components/Form/use/useFormHasValueMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,GAAG,EAAwC,MAAM,KAAK,CAAA;AAInE,eAAO,MAAM,kBAAkB,SAAU,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC;iCAe1B,MAAM;;CAkB3C,CAAA"}

package/dist/components/Form/use/useFormHasValueMap.js

@@ -0,0 +1,31 @@
+import { ref, computed, provide, inject, watch } from 'vue';
+import { wFormHasValueUpdater } from '../models/injection.js';
+
+const useFormHasValueMap = (name) => {
+  const hasValueMap = ref({});
+  const hasValue = computed(() => {
+    const items = Object.values(hasValueMap.value);
+    if (items.length === 0) return null;
+    return items.length !== 0 && items.every((value) => value);
+  });
+  const hasValueMapUpdater = (key, value) => {
+    if (value === null) hasValueMapUnlistener(key);
+    else hasValueMap.value[key] = value;
+  };
+  const hasValueMapUnlistener = (key) => {
+    if (key in hasValueMap.value) delete hasValueMap.value[key];
+  };
+  provide(wFormHasValueUpdater, hasValueMapUpdater);
+  const hasValueUpdaterInjected = inject(wFormHasValueUpdater, void 0);
+  watch(hasValue, (value) => {
+    if (name.value) {
+      hasValueUpdaterInjected?.(name.value, value);
+    }
+  }, { immediate: true });
+  return {
+    hasValueMapUnlistener,
+    hasValue
+  };
+};
+
+export { useFormHasValueMap };

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

@@ -237,6 +237,7 @@ declare function __VLS_template(): {
                             readonly title?: string | undefined;
                             readonly "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
                             readonly "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
+                            readonly "onUpdate:has-value"?: ((value: boolean | null) => any) | undefined;
                         } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
                         $attrs: {
                             [x: string]: unknown;
@@ -250,7 +251,7 @@ declare function __VLS_template(): {
                         $root: import('vue').ComponentPublicInstance | null;
                         $parent: import('vue').ComponentPublicInstance | null;
                         $host: Element | null;
-                        $emit: ((event: "update:has-changes", value: boolean) => void) & ((event: "update:is-valid", value: boolean | undefined) => void);
+                        $emit: ((event: "update:has-changes", value: boolean) => void) & ((event: "update:is-valid", value: boolean | undefined) => void) & ((event: "update:has-value", value: boolean | null) => void);
                         $el: any;
                         $options: import('vue').ComponentOptionsBase<Readonly<{
                             name?: string;
@@ -258,8 +259,11 @@ declare function __VLS_template(): {
                         }> & Readonly<{
                             "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
                             "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
+                            "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;
@@ -269,6 +273,7 @@ declare function __VLS_template(): {
                         }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
                             "update:has-changes": (value: boolean) => any;
                             "update:is-valid": (value: boolean | undefined) => any;
+                            "update:has-value": (value: boolean | null) => any;
                         }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                             beforeCreate?: (() => void) | (() => void)[];
                             created?: (() => void) | (() => void)[];
@@ -295,8 +300,11 @@ declare function __VLS_template(): {
                     }> & Readonly<{
                         "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
                         "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
-                    }>, "errorMessage" | "isValid" | "validate" | "invalidate" | "initModel"> & import('vue').ShallowUnwrapRef<{
+                        "onUpdate:has-value"?: ((value: boolean | null) => any) | undefined;
+                    }>, "errorMessage" | "hasChanges" | "isValid" | "hasValue" | "validate" | "invalidate" | "initModel"> & 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;
@@ -653,6 +661,7 @@ declare const __VLS_component: import('vue').DefineComponent<{
                         readonly title?: string | undefined;
                         readonly "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
                         readonly "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
+                        readonly "onUpdate:has-value"?: ((value: boolean | null) => any) | undefined;
                     } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
                     $attrs: {
                         [x: string]: unknown;
@@ -666,7 +675,7 @@ declare const __VLS_component: import('vue').DefineComponent<{
                     $root: import('vue').ComponentPublicInstance | null;
                     $parent: import('vue').ComponentPublicInstance | null;
                     $host: Element | null;
-                    $emit: ((event: "update:has-changes", value: boolean) => void) & ((event: "update:is-valid", value: boolean | undefined) => void);
+                    $emit: ((event: "update:has-changes", value: boolean) => void) & ((event: "update:is-valid", value: boolean | undefined) => void) & ((event: "update:has-value", value: boolean | null) => void);
                     $el: any;
                     $options: import('vue').ComponentOptionsBase<Readonly<{
                         name?: string;
@@ -674,8 +683,11 @@ declare const __VLS_component: import('vue').DefineComponent<{
                     }> & Readonly<{
                         "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
                         "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
+                        "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;
@@ -685,6 +697,7 @@ declare const __VLS_component: import('vue').DefineComponent<{
                     }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
                         "update:has-changes": (value: boolean) => any;
                         "update:is-valid": (value: boolean | undefined) => any;
+                        "update:has-value": (value: boolean | null) => any;
                     }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                         beforeCreate?: (() => void) | (() => void)[];
                         created?: (() => void) | (() => void)[];
@@ -711,8 +724,11 @@ declare const __VLS_component: import('vue').DefineComponent<{
                 }> & Readonly<{
                     "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
                     "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
-                }>, "errorMessage" | "isValid" | "validate" | "invalidate" | "initModel"> & import('vue').ShallowUnwrapRef<{
+                    "onUpdate:has-value"?: ((value: boolean | null) => any) | undefined;
+                }>, "errorMessage" | "hasChanges" | "isValid" | "hasValue" | "validate" | "invalidate" | "initModel"> & 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;

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

@@ -1 +1 @@
-{"version":3,"file":"WModalStepper.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Modal/WModalStepper.vue"],"names":[],"mappings":"AAyKA,iBAAS,cAAc;;uBA4PI,GAAG;yBACA,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAkEqxS,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;WAxD95S,OAAO,IAA6B;EAEjD;AAsBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;cA7UT,OAAO;eACN,OAAO;mBACH,OAAO;;gBAqBP,IAAI;oBAJA,IAAI;;;;;;cAnBb,OAAO;eACN,OAAO;mBACH,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDA0W8xS,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;OAlB16S,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":"WModalStepper.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Modal/WModalStepper.vue"],"names":[],"mappings":"AAyKA,iBAAS,cAAc;;uBA4PI,GAAG;yBACA,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAkEqxS,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;WAxD95S,OAAO,IAA6B;EAEjD;AAsBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;cA7UT,OAAO;eACN,OAAO;mBACH,OAAO;;gBAqBP,IAAI;oBAJA,IAAI;;;;;;cAnBb,OAAO;eACN,OAAO;mBACH,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDA0W8xS,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;OAlB16S,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/WTabs.vue.d.ts

@@ -1,5 +1,5 @@
 import { TabsProps } from './types';
-import { CSSProperties, nextTick } from 'vue';
+import { CSSProperties } from 'vue';
 import { default as WForm } from '../Form/WForm.vue';
 declare const _default: import('vue').DefineComponent<TabsProps, {
     updateCurrent: (value: string) => void;
@@ -108,7 +108,7 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
             errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
         };
         $forceUpdate: () => void;
-        $nextTick: typeof nextTick;
+        $nextTick: typeof import('vue').nextTick;
         $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
     } & Readonly<{}> & Omit<Readonly<{
         active: boolean;
@@ -189,7 +189,7 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
             errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
         };
         $forceUpdate: () => void;
-        $nextTick: typeof nextTick;
+        $nextTick: typeof import('vue').nextTick;
         $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
     } & Readonly<{}> & Omit<Readonly<{
         active: boolean;
@@ -212,6 +212,7 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
             readonly title?: string | undefined;
             readonly "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
             readonly "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
+            readonly "onUpdate:has-value"?: ((value: boolean | null) => any) | undefined;
         } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
         $attrs: {
             [x: string]: unknown;
@@ -225,7 +226,7 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
         $root: import('vue').ComponentPublicInstance | null;
         $parent: import('vue').ComponentPublicInstance | null;
         $host: Element | null;
-        $emit: ((event: "update:has-changes", value: boolean) => void) & ((event: "update:is-valid", value: boolean | undefined) => void);
+        $emit: ((event: "update:has-changes", value: boolean) => void) & ((event: "update:is-valid", value: boolean | undefined) => void) & ((event: "update:has-value", value: boolean | null) => void);
         $el: any;
         $options: import('vue').ComponentOptionsBase<Readonly<{
             name?: string;
@@ -233,8 +234,11 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
         }> & Readonly<{
             "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
             "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
+            "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;
@@ -244,6 +248,7 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
         }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
             "update:has-changes": (value: boolean) => any;
             "update:is-valid": (value: boolean | undefined) => any;
+            "update:has-value": (value: boolean | null) => any;
         }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
             beforeCreate?: (() => void) | (() => void)[];
             created?: (() => void) | (() => void)[];
@@ -262,7 +267,7 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
             errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
         };
         $forceUpdate: () => void;
-        $nextTick: typeof nextTick;
+        $nextTick: typeof import('vue').nextTick;
         $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
     } & Readonly<{}> & Omit<Readonly<{
         name?: string;
@@ -270,8 +275,11 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
     }> & Readonly<{
         "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
         "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
-    }>, "errorMessage" | "isValid" | "validate" | "invalidate" | "initModel"> & import('vue').ShallowUnwrapRef<{
+        "onUpdate:has-value"?: ((value: boolean | null) => any) | undefined;
+    }>, "errorMessage" | "hasChanges" | "isValid" | "hasValue" | "validate" | "invalidate" | "initModel"> & 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;

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":"AAiSA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,SAAS,CAAA;AAEtC,OAAO,EAAC,KAAK,aAAa,EAAgD,QAAQ,EAAyE,MAAM,KAAK,CAAA;AAEtK,OAAO,KAAK,MAAM,6BAA6B,CAAA;;2BAsEjB,MAAM;yBAMR,MAAM;gBAcjB,IAAI;oBAIA,IAAI;sBAUA,MAAM,6GAAqE,UAAU,CAAC,iBAAiB,CAAC,OAAO,KAAK,CAAC,CAAC,UAAU,CAAC,CAAC;wBAIhI,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA0PhI,GAAG,8CACO,GAAG,yBAE9B,GAAG,6DAEW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCALA,GAAG,8CACO,GAAG,yBAE9B,GAAG,6DAEW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCALA,GAAG,8CACO,GAAG,yBAE9B,GAAG,6DAEW,GAAG;;;;;;;;;;;;;;;;;;;;;AA4J9B,wBAeG"}
+{"version":3,"file":"WTabs.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Tabs/WTabs.vue"],"names":[],"mappings":"AA+TA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,SAAS,CAAA;AAEtC,OAAO,EAAC,KAAK,aAAa,EAA6G,MAAM,KAAK,CAAA;AAElJ,OAAO,KAAK,MAAM,6BAA6B,CAAA;;2BAsEjB,MAAM;yBAMR,MAAM;gBAcjB,IAAI;oBAIA,IAAI;sBAUA,MAAM,6GAAqE,UAAU,CAAC,iBAAiB,CAAC,OAAO,KAAK,CAAC,CAAC,UAAU,CAAC,CAAC;wBAIhI,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAsP9I,GAAR,8CAA8C,GAAG,yBAAyB,GAAG,6DACvE,GAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCADA,GAAR,8CAA8C,GAAG,yBAAyB,GAAG,6DACvE,GAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCADA,GAAR,8CAA8C,GAAG,yBAAyB,GAAG,6DACvE,GAAE;;;;;;;;;;;;;;;;;;;;;;;;AA6LhB,wBAeG"}

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

@@ -1,6 +1,6 @@
-import { defineComponent, useSlots, useTemplateRef, computed, ref, reactive, inject, watch, onMounted, onUnmounted, openBlock, createElementBlock, normalizeClass, Fragment, renderList, createBlock, unref, createSlots, withCtx, resolveDynamicComponent, createElementVNode, normalizeStyle, createCommentVNode, createVNode, TransitionGroup, nextTick } from 'vue';
+import { defineComponent, useSlots, useTemplateRef, computed, ref, inject, watch, onMounted, onUnmounted, openBlock, createElementBlock, normalizeClass, Fragment, renderList, createBlock, unref, createSlots, withCtx, resolveDynamicComponent, mergeProps, createElementVNode, normalizeStyle, createCommentVNode, createVNode, TransitionGroup } from 'vue';
 import _sfc_main$3 from '../Form/WForm.vue.js';
-import { throttle, debounce } from '../../utils/utils.js';
+import { debounce, throttle } from '../../utils/utils.js';
 import _sfc_main$2 from './components/TabItem.vue.js';
 import _sfc_main$1 from './components/TabTitleButton.vue.js';
 import { wTabItemListener, wTabItemUnlistener } from './models/injection.js';
@@ -30,9 +30,15 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         else return [];
       });
     };
-    const defaultSlots = computed(() => {
+    const isTabItem = (slot) => {
+      return slot.type instanceof Object && "__name" in slot.type && slot.type.__name === "WTabsItem";
+    };
+    const defaultSlotsAll = computed(() => {
       return unwrapSlots(defaultSlotsRaw.value);
     });
+    const defaultSlots = computed(() => {
+      return defaultSlotsAll.value.filter(isTabItem);
+    });
     const defaultSlotsKeys = computed(() => defaultSlots.value.map((item) => item.props?.name));
     const current = ref(defaultSlotsKeys.value[props.initTab ?? 0]);
     const currentIndex = computed(() => defaultSlotsKeys.value.indexOf(current.value));
@@ -42,15 +48,10 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const minHeight = ref(0);
     const tabItemRef = useTemplateRef("tabItem");
     const formRef = useTemplateRef("form");
-    const isValidMap = reactive({});
-    const hasChangesMap = reactive({});
-    const hasChanges = computed(() => Object.values(hasChangesMap).includes(true));
-    const updateIsValidMap = (key, value) => {
-      isValidMap[key] = value;
-      nextTick().then(() => {
-        if (value === false && isValidMap[current.value] !== false) switchTab(key);
-      });
-    };
+    const currentIsValud = computed(() => formRef.value?.[defaultSlotsKeys.value.indexOf(current.value)]?.isValid);
+    const switchOnInvalid = debounce((key) => {
+      if (currentIsValud.value !== false) switchTab(key);
+    }, 50);
     const switchTab = throttle((key) => {
       if (current.value === key) return;
       updateCurrent(key);
@@ -109,9 +110,6 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     watch(currentIndex, (value) => {
       emit("update:current-index", value);
     }, { immediate: true });
-    watch(hasChanges, (value) => {
-      emit("update:has-changes", value);
-    }, { immediate: true });
     watch(defaultSlotsKeys, (newValue, oldValue) => {
       const newIndex = newValue.findIndex((item) => !oldValue.includes(item));
       if (props.switchToNew && newIndex !== -1) {
@@ -151,53 +149,74 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         !_ctx.noHeader ? (openBlock(), createElementBlock("div", {
           key: 0,
           ref: "buttonContainer",
-          class: normalizeClass(["no-scrollbar relative flex snap-x snap-mandatory snap-always overflow-x-auto overscroll-x-contain", {
-            "flex-col": _ctx.side
+          class: normalizeClass(["no-scrollbar relative snap-x snap-mandatory snap-always overflow-x-auto overscroll-x-contain", {
+            "grid grid-cols-[1fr,auto]": _ctx.side,
+            "flex": !_ctx.side
           }])
         }, [
-          (openBlock(true), createElementBlock(Fragment, null, renderList(defaultSlots.value, (slot, index) => {
-            return openBlock(), createBlock(_sfc_main$1, {
-              key: slot.props?.name,
-              ref_for: true,
-              ref: "button",
-              active: current.value === slot.props?.name,
-              index,
-              title: slot.props?.title,
-              icon: slot.props?.icon,
-              "has-changes": hasChangesMap[slot.props?.name] === true,
-              "has-error": isValidMap[slot.props?.name] === false,
-              side: _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(() => [
-                  (openBlock(), createBlock(resolveDynamicComponent(slot.children?.title)))
-                ]),
-                key: "0"
-              } : void 0,
-              slot.children?.suffix ? {
-                name: "suffix",
-                fn: withCtx(() => [
-                  (openBlock(), createBlock(resolveDynamicComponent(slot.children?.suffix)))
-                ]),
-                key: "1"
-              } : void 0,
-              slot.children?.right ? {
-                name: "right",
-                fn: withCtx(() => [
-                  (openBlock(), createBlock(resolveDynamicComponent(slot.children?.right)))
-                ]),
-                key: "2"
-              } : void 0
-            ]), 1032, ["active", "index", "title", "icon", "has-changes", "has-error", "side", "onClick"]);
+          (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(formRef)?.[defaultSlots.value.indexOf(slot)]?.hasChanges === true,
+                "has-error": unref(formRef)?.[defaultSlots.value.indexOf(slot)]?.isValid === false,
+                side: _ctx.side,
+                class: normalizeClass({
+                  "col-span-2 grid grid-cols-subgrid": _ctx.side,
+                  "grid-cols-[1fr,auto]": !_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(() => [
+                    (openBlock(), createBlock(resolveDynamicComponent(slot.children?.title), mergeProps({ ref_for: true }, {
+                      hasError: unref(formRef)?.[defaultSlots.value.indexOf(slot)]?.isValid === false,
+                      hasChanges: unref(formRef)?.[defaultSlots.value.indexOf(slot)]?.hasChanges === true,
+                      hasValue: unref(formRef)?.[defaultSlots.value.indexOf(slot)]?.hasValue === true
+                    }), null, 16))
+                  ]),
+                  key: "0"
+                } : void 0,
+                slot.children?.suffix ? {
+                  name: "suffix",
+                  fn: withCtx(() => [
+                    (openBlock(), createBlock(resolveDynamicComponent(slot.children?.suffix), mergeProps({ ref_for: true }, {
+                      hasError: unref(formRef)?.[defaultSlots.value.indexOf(slot)]?.isValid === false,
+                      hasChanges: unref(formRef)?.[defaultSlots.value.indexOf(slot)]?.hasChanges === true,
+                      hasValue: unref(formRef)?.[defaultSlots.value.indexOf(slot)]?.hasValue === true
+                    }), null, 16))
+                  ]),
+                  key: "1"
+                } : void 0,
+                slot.children?.right ? {
+                  name: "right",
+                  fn: withCtx(() => [
+                    (openBlock(), createBlock(resolveDynamicComponent(slot.children?.right), mergeProps({ ref_for: true }, {
+                      hasError: unref(formRef)?.[defaultSlots.value.indexOf(slot)]?.isValid === false,
+                      hasChanges: unref(formRef)?.[defaultSlots.value.indexOf(slot)]?.hasChanges === true,
+                      hasValue: unref(formRef)?.[defaultSlots.value.indexOf(slot)]?.hasValue === true
+                    }), null, 16))
+                  ]),
+                  key: "2"
+                } : void 0
+              ]), 1032, ["active", "index", "title", "icon", "has-changes", "has-error", "side", "class", "onClick"])) : (openBlock(), createBlock(resolveDynamicComponent(slot), { key: 1 }))
+            ], 64);
           }), 128)),
           createElementVNode("div", {
             class: normalizeClass(["absolute 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,
+              "bg-primary-default dark:bg-primary-dark": currentIsValud.value !== false,
+              "bg-negative dark:bg-negative-dark": currentIsValud.value === false,
               "transition-[left,width,background-color]": !_ctx.side && indicatorStyle.value !== void 0,
               "transition-[top,height,background-color]": _ctx.side && indicatorStyle.value !== void 0
             }]),
@@ -232,14 +251,13 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                       ref: "form",
                       name: slot.props?.name,
                       title: slot.props?.title,
-                      "onUpdate:isValid": ($event) => updateIsValidMap(slot.props?.name, $event),
-                      "onUpdate:hasChanges": ($event) => hasChangesMap[slot.props?.name] = $event
+                      "onUpdate:isValid": ($event) => $event === false && unref(switchOnInvalid)(slot.props?.name)
                     }, {
                       default: withCtx(() => [
                         (openBlock(), createBlock(resolveDynamicComponent(slot)))
                       ]),
                       _: 2
-                    }, 1032, ["name", "title", "onUpdate:isValid", "onUpdate:hasChanges"])
+                    }, 1032, ["name", "title", "onUpdate:isValid"])
                   ]),
                   _: 2
                 }, 1032, ["active", "removable", "onUpdate:active"]);

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

@@ -1,14 +1,15 @@
+import { TabsItemScopedProps } from './types';
 declare function __VLS_template(): {
     slots: Readonly<{
         default?: () => void;
-        title?: () => void;
-        suffix?: () => void;
-        right?: () => void;
+        title?: (props: TabsItemScopedProps) => void;
+        suffix?: (props: TabsItemScopedProps) => void;
+        right?: (props: TabsItemScopedProps) => void;
     }> & {
         default?: () => void;
-        title?: () => void;
-        suffix?: () => void;
-        right?: () => void;
+        title?: (props: TabsItemScopedProps) => void;
+        suffix?: (props: TabsItemScopedProps) => void;
+        right?: (props: TabsItemScopedProps) => void;
     };
     refs: {};
     attrs: Partial<{}>;
@@ -20,12 +21,14 @@ declare const __VLS_component: import('vue').DefineComponent<{
     icon?: SVGComponent;
     disabled?: boolean;
     removable?: boolean;
+    divided?: boolean;
 }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
     title: string;
     name: string;
     icon?: SVGComponent;
     disabled?: boolean;
     removable?: boolean;
+    divided?: boolean;
 }> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

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":"AA2CA,iBAAS,cAAc;;kBAVX,MAAM,IAAI;gBACZ,MAAM,IAAI;iBACT,MAAM,IAAI;gBACX,MAAM,IAAI;;kBAHR,MAAM,IAAI;gBACZ,MAAM,IAAI;iBACT,MAAM,IAAI;gBACX,MAAM,IAAI;;;WAsCN,OAAO,IAA6B;EAEjD;AAQD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;WA7DZ,MAAM;UACP,MAAM;WACL,YAAY;eACR,OAAO;gBACN,OAAO;;WAJZ,MAAM;UACP,MAAM;WACL,YAAY;eACR,OAAO;gBACN,OAAO;iGA+DnB,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":"AAwBA,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,SAAS,CAAA;AAyBhD,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;WA9DZ,MAAM;UACP,MAAM;WACL,YAAY;eACR,OAAO;gBACN,OAAO;cACT,OAAO;;WALV,MAAM;UACP,MAAM;WACL,YAAY;eACR,OAAO;gBACN,OAAO;cACT,OAAO;iGA+DjB,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/WTabsItem.vue.js

@@ -7,7 +7,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     name: {},
     icon: {},
     disabled: { type: Boolean },
-    removable: { type: Boolean }
+    removable: { type: Boolean },
+    divided: { type: Boolean }
   },
   setup(__props) {
     return (_ctx, _cache) => {

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

@@ -215,6 +215,7 @@ declare function __VLS_template(): {
                     readonly title?: string | undefined;
                     readonly "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
                     readonly "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
+                    readonly "onUpdate:has-value"?: ((value: boolean | null) => any) | undefined;
                 } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
                 $attrs: {
                     [x: string]: unknown;
@@ -228,7 +229,7 @@ declare function __VLS_template(): {
                 $root: import('vue').ComponentPublicInstance | null;
                 $parent: import('vue').ComponentPublicInstance | null;
                 $host: Element | null;
-                $emit: ((event: "update:has-changes", value: boolean) => void) & ((event: "update:is-valid", value: boolean | undefined) => void);
+                $emit: ((event: "update:has-changes", value: boolean) => void) & ((event: "update:is-valid", value: boolean | undefined) => void) & ((event: "update:has-value", value: boolean | null) => void);
                 $el: any;
                 $options: import('vue').ComponentOptionsBase<Readonly<{
                     name?: string;
@@ -236,8 +237,11 @@ declare function __VLS_template(): {
                 }> & Readonly<{
                     "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
                     "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
+                    "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;
@@ -247,6 +251,7 @@ declare function __VLS_template(): {
                 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
                     "update:has-changes": (value: boolean) => any;
                     "update:is-valid": (value: boolean | undefined) => any;
+                    "update:has-value": (value: boolean | null) => any;
                 }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                     beforeCreate?: (() => void) | (() => void)[];
                     created?: (() => void) | (() => void)[];
@@ -273,8 +278,11 @@ declare function __VLS_template(): {
             }> & Readonly<{
                 "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
                 "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
-            }>, "errorMessage" | "isValid" | "validate" | "invalidate" | "initModel"> & import('vue').ShallowUnwrapRef<{
+                "onUpdate:has-value"?: ((value: boolean | null) => any) | undefined;
+            }>, "errorMessage" | "hasChanges" | "isValid" | "hasValue" | "validate" | "invalidate" | "initModel"> & 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;
@@ -545,6 +553,7 @@ declare const __VLS_component: import('vue').DefineComponent<TabsStepperProps, {
                 readonly title?: string | undefined;
                 readonly "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
                 readonly "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
+                readonly "onUpdate:has-value"?: ((value: boolean | null) => any) | undefined;
             } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
             $attrs: {
                 [x: string]: unknown;
@@ -558,7 +567,7 @@ declare const __VLS_component: import('vue').DefineComponent<TabsStepperProps, {
             $root: import('vue').ComponentPublicInstance | null;
             $parent: import('vue').ComponentPublicInstance | null;
             $host: Element | null;
-            $emit: ((event: "update:has-changes", value: boolean) => void) & ((event: "update:is-valid", value: boolean | undefined) => void);
+            $emit: ((event: "update:has-changes", value: boolean) => void) & ((event: "update:is-valid", value: boolean | undefined) => void) & ((event: "update:has-value", value: boolean | null) => void);
             $el: any;
             $options: import('vue').ComponentOptionsBase<Readonly<{
                 name?: string;
@@ -566,8 +575,11 @@ declare const __VLS_component: import('vue').DefineComponent<TabsStepperProps, {
             }> & Readonly<{
                 "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
                 "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
+                "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;
@@ -577,6 +589,7 @@ declare const __VLS_component: import('vue').DefineComponent<TabsStepperProps, {
             }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
                 "update:has-changes": (value: boolean) => any;
                 "update:is-valid": (value: boolean | undefined) => any;
+                "update:has-value": (value: boolean | null) => any;
             }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                 beforeCreate?: (() => void) | (() => void)[];
                 created?: (() => void) | (() => void)[];
@@ -603,8 +616,11 @@ declare const __VLS_component: import('vue').DefineComponent<TabsStepperProps, {
         }> & Readonly<{
             "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
             "onUpdate:is-valid"?: ((value: boolean | undefined) => any) | undefined;
-        }>, "errorMessage" | "isValid" | "validate" | "invalidate" | "initModel"> & import('vue').ShallowUnwrapRef<{
+            "onUpdate:has-value"?: ((value: boolean | null) => any) | undefined;
+        }>, "errorMessage" | "hasChanges" | "isValid" | "hasValue" | "validate" | "invalidate" | "initModel"> & 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;

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

@@ -1 +1 @@
-{"version":3,"file":"WTabsStepper.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Tabs/WTabsStepper.vue"],"names":[],"mappings":"AAgFA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,SAAS,CAAA;AAmF7C,iBAAS,cAAc;;yBA4HO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAoE6xd,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA1Dt6d,OAAO,IAA6B;EAEjD;AAoBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;gBA3MJ,IAAI;oBAJA,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAkPqyd,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAlBl7d,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":"WTabsStepper.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Tabs/WTabsStepper.vue"],"names":[],"mappings":"AAgFA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,SAAS,CAAA;AAmF7C,iBAAS,cAAc;;yBA4HO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAoE6xd,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA1Dt6d,OAAO,IAA6B;EAEjD;AAoBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;gBA3MJ,IAAI;oBAJA,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAkPqyd,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAlBl7d,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.map

@@ -1 +1 @@
-{"version":3,"file":"TabItem.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/Tabs/components/TabItem.vue"],"names":[],"mappings":"AAsGA,iBAAS,cAAc;;yBA+BM,GAAG;;;;;WAUlB,OAAO,IAA6B;EAEjD;AAYD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;YArGX,OAAO;eACJ,OAAO;;sBAaG,IAAI;;;;;YAdjB,OAAO;eACJ,OAAO;;;;;;OAgHlB,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":"AAwGA,iBAAS,cAAc;;yBAuCM,GAAG;;;;;WAUlB,OAAO,IAA6B;EAEjD;AAYD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;YA7GX,OAAO;eACJ,OAAO;;sBAaG,IAAI;;;;;YAdjB,OAAO;eACJ,OAAO;;;;;;OAwHlB,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, watch, nextTick, withDirectives, openBlock, createElementBlock, renderSlot, vShow, createCommentVNode } from 'vue';
+import { defineComponent, useTemplateRef, watch, nextTick, openBlock, createBlock, KeepAlive, withDirectives, createElementBlock, renderSlot, vShow, createCommentVNode } from 'vue';
 import { useTabItemActiveListener } from '../use/useTabItemActiveListener.js';
 
 const _hoisted_1 = {
@@ -31,11 +31,13 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       emitHeight
     });
     return (_ctx, _cache) => {
-      return !_ctx.removable || _ctx.active ? withDirectives((openBlock(), createElementBlock("div", _hoisted_1, [
-        renderSlot(_ctx.$slots, "default")
-      ], 512)), [
-        [vShow, _ctx.active]
-      ]) : createCommentVNode("", true);
+      return openBlock(), createBlock(KeepAlive, null, [
+        !_ctx.removable || _ctx.active ? withDirectives((openBlock(), createElementBlock("div", _hoisted_1, [
+          renderSlot(_ctx.$slots, "default")
+        ], 512)), [
+          [vShow, _ctx.active]
+        ]) : createCommentVNode("", true)
+      ], 1024);
     };
   }
 });

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

@@ -1 +1 @@
-{"version":3,"file":"TabTitleButton.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/Tabs/components/TabTitleButton.vue"],"names":[],"mappings":"AA8IA,OAAO,EAAC,KAAK,aAAa,EAA6C,MAAM,KAAK,CAAA;AA0FlF,iBAAS,cAAc;;uBA4HI,GAAG;wBACD,GAAG;uBACJ,GAAG;;;;;WAUjB,OAAO,IAA6B;EAEjD;AAaD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;YA7OX,OAAO;WACR,MAAM;cACH,OAAO;gBACL,OAAO;WACZ,MAAM;UACP,YAAY,GAAG,SAAS;WACvB,OAAO;;;;;;;cAgP8B,MAAM;;aAAU,MAAM;;;YAtP1D,OAAO;WACR,MAAM;cACH,OAAO;gBACL,OAAO;WACZ,MAAM;UACP,YAAY,GAAG,SAAS;WACvB,OAAO;;;;;cAgP8B,MAAM;;aAAU,MAAM;;;;OAIlE,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":"TabTitleButton.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/Tabs/components/TabTitleButton.vue"],"names":[],"mappings":"AA8IA,OAAO,EAAC,KAAK,aAAa,EAA6C,MAAM,KAAK,CAAA;AA0FlF,iBAAS,cAAc;;uBA2HI,GAAG;wBACD,GAAG;uBACJ,GAAG;;;;;WAUjB,OAAO,IAA6B;EAEjD;AAaD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;YA5OX,OAAO;WACR,MAAM;cACH,OAAO;gBACL,OAAO;WACZ,MAAM;UACP,YAAY,GAAG,SAAS;WACvB,OAAO;;;;;;;cA+O8B,MAAM;;aAAU,MAAM;;;YArP1D,OAAO;WACR,MAAM;cACH,OAAO;gBACL,OAAO;WACZ,MAAM;UACP,YAAY,GAAG,SAAS;WACvB,OAAO;;;;;cA+O8B,MAAM;;aAAU,MAAM;;;;OAIlE,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/TabTitleButton.vue.js

@@ -66,7 +66,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     return (_ctx, _cache) => {
       return openBlock(), createElementBlock("button", {
         ref: "button",
-        class: "text-description grid cursor-pointer select-none snap-center grid-cols-[1fr,auto] font-semibold outline-none transition-colors duration-500",
+        class: "text-description grid cursor-pointer select-none snap-center font-semibold outline-none transition-colors duration-500",
         onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("click", $event))
       }, [
         createElementVNode("div", {
@@ -94,9 +94,9 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                 ]),
                 _: 1
               })) : createCommentVNode("", true),
-              createTextVNode(" " + toDisplayString(_ctx.title) + " ", 1),
-              renderSlot(_ctx.$slots, "suffix")
-            ])
+              createTextVNode(" " + toDisplayString(_ctx.title), 1)
+            ]),
+            renderSlot(_ctx.$slots, "suffix")
           ], 2)),
           createVNode(Transition, {
             "enter-active-class": "transition-opacity",

package/dist/components/Tabs/types.d.ts

@@ -9,4 +9,9 @@ export interface TabsProps {
     switchToNew?: boolean;
 }
 export type TabsStepperProps = Omit<TabsProps, 'switchToNew' | 'noHeader' | 'side'>;
+export type TabsItemScopedProps = {
+    hasError: boolean;
+    hasChanges: boolean;
+    hasValue: boolean;
+};
 //# sourceMappingURL=types.d.ts.map

package/dist/components/Tabs/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/Tabs/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,KAAK,CAAA;AAE9B,MAAM,WAAW,SAAS;IACxB,WAAW,CAAC,EAAE,KAAK,EAAE,CAAA;IACrB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,SAAS,EAAE,aAAa,GAAG,UAAU,GAAG,MAAM,CAAC,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/Tabs/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,KAAK,CAAA;AAE9B,MAAM,WAAW,SAAS;IACxB,WAAW,CAAC,EAAE,KAAK,EAAE,CAAA;IACrB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,SAAS,EAAE,aAAa,GAAG,UAAU,GAAG,MAAM,CAAC,CAAA;AAEnF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,OAAO,CAAA;IACjB,UAAU,EAAE,OAAO,CAAA;IACnB,QAAQ,EAAE,OAAO,CAAA;CAClB,CAAA"}

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "https://github.com/rsmple/eco-vue-js.git"
   },
-  "version": "0.9.3",
+  "version": "0.9.5",
   "scripts": {
     "build": "run-p type-check \"build-only {@}\" --",
     "preview": "vite preview",
@@ -17,13 +17,13 @@
   },
   "dependencies": {
     "@stylistic/eslint-plugin-ts": "2.11.0",
-    "@tanstack/eslint-plugin-query": "5.60.1",
-    "@vue/eslint-config-typescript": "14.1.3",
-    "eslint-import-resolver-typescript": "3.6.3",
+    "@tanstack/eslint-plugin-query": "5.62.1",
+    "@vue/eslint-config-typescript": "14.1.4",
+    "eslint-import-resolver-typescript": "3.7.0",
     "eslint-plugin-import": "2.31.0",
     "eslint-plugin-tailwindcss": "3.17.5",
     "eslint-plugin-unused-imports": "4.1.4",
-    "eslint-plugin-vue": "9.31.0"
+    "eslint-plugin-vue": "9.32.0"
   },
   "peerDependencies": {
     "@tanstack/vue-query": ">=5.59.0",
@@ -33,20 +33,20 @@
   "devDependencies": {
     "@tsconfig/node22": "22.0.0",
     "@types/jsdom": "21.1.7",
-    "@types/node": "22.9.1",
+    "@types/node": "22.10.1",
     "@types/postcss-import": "14.0.3",
-    "@vitejs/plugin-vue": "5.2.0",
-    "@vue/tsconfig": "0.6.0",
+    "@vitejs/plugin-vue": "5.2.1",
+    "@vue/tsconfig": "0.7.0",
     "autoprefixer": "10.4.20",
-    "eslint": "9.15.0",
+    "eslint": "9.16.0",
     "jsdom": "25.0.1",
     "npm-run-all2": "7.0.1",
     "path": "0.12.7",
     "postcss": "8.4.49",
     "postcss-import": "16.1.0",
-    "tailwindcss": "3.4.15",
+    "tailwindcss": "3.4.16",
     "typescript": "5.6.3",
-    "vite": "5.4.11",
+    "vite": "6.0.2",
     "vite-plugin-dts": "4.3.0",
     "vite-svg-loader": "5.1.0",
     "vue-tsc": "2.1.10"