eco-vue-js 0.9.7 → 0.9.9

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":"AA0KA,iBAAS,cAAc;;uBA4PI,GAAG;yBACA,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAkEiuS,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4DAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;WAxD12S,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDA0W0uS,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wDAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;OAlBt3S,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/Modal/WModalStepper.vue.js

@@ -92,6 +92,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         default: withCtx(() => [
           createVNode(_sfc_main$4, {
             ref: "tabsStepper",
+            "no-header": "",
             "onUpdate:first": _cache[0] || (_cache[0] = ($event) => first.value = $event),
             "onUpdate:last": _cache[1] || (_cache[1] = ($event) => last.value = $event),
             "onUpdate:currentTitle": _cache[2] || (_cache[2] = ($event) => currentTitle.value = $event),

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

@@ -7,6 +7,7 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
     next: () => void;
     previous: () => void;
     validate: (index: number, silent?: boolean | undefined, path?: import('../Form/use/useFormValidateMap').ValidatePath | undefined) => ReturnType<ComponentInstance<typeof WForm>["validate"]>;
+    validateIfNoError: (index: number, silent?: boolean | undefined, path?: import('../Form/use/useFormValidateMap').ValidatePath | undefined) => ReturnType<ComponentInstance<typeof WForm>["validate"]>;
     invalidate: (index: number, payload: {
         [x: string]: string | string[] | undefined;
     }) => ReturnType<ComponentInstance<typeof WForm>["invalidate"]>;
@@ -33,8 +34,15 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
             readonly index: number;
             readonly hasError: boolean;
             readonly hasChanges: boolean;
+            readonly hasValue: boolean;
             readonly title: string;
             readonly icon: SVGComponent | undefined;
+            readonly first: boolean;
+            readonly last: boolean;
+            readonly disabled?: boolean | undefined;
+            readonly stepper?: boolean | undefined;
+            readonly showHasValue?: boolean | undefined;
+            readonly noIndicator?: boolean | undefined;
             readonly side?: boolean | undefined;
             readonly onClick?: ((value: MouseEvent) => any) | undefined;
             readonly "onUpdate:indicator-style"?: ((value: CSSProperties) => any) | undefined;
@@ -50,7 +58,7 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
         $refs: {
             [x: string]: unknown;
         } & {
-            button: HTMLButtonElement;
+            container: HTMLDivElement;
         };
         $slots: Readonly<{
             [name: string]: import('vue').Slot<any> | undefined;
@@ -69,8 +77,15 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
             index: number;
             hasError: boolean;
             hasChanges: boolean;
+            hasValue: boolean;
             title: string;
             icon: SVGComponent | undefined;
+            first: boolean;
+            last: boolean;
+            disabled?: boolean;
+            stepper?: boolean;
+            showHasValue?: boolean;
+            noIndicator?: boolean;
             side?: boolean;
         }> & Readonly<{
             onClick?: ((value: MouseEvent) => any) | undefined;
@@ -115,8 +130,15 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
         index: number;
         hasError: boolean;
         hasChanges: boolean;
+        hasValue: boolean;
         title: string;
         icon: SVGComponent | undefined;
+        first: boolean;
+        last: boolean;
+        disabled?: boolean;
+        stepper?: boolean;
+        showHasValue?: boolean;
+        noIndicator?: boolean;
         side?: boolean;
     }> & Readonly<{
         onClick?: ((value: MouseEvent) => any) | undefined;
@@ -130,17 +152,32 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
         update: () => void;
     }> & {} & import('vue').ComponentCustomProperties & {} & {
         $slots: {
-            title?(_: {}): any;
-            suffix?(_: {}): any;
-            right?(_: {}): any;
+            title?(_: {
+                hasChanges: boolean;
+                hasError: boolean;
+                hasValue: boolean;
+            }): any;
+            suffix?(_: {
+                hasChanges: boolean;
+                hasError: boolean;
+                hasValue: boolean;
+            }): any;
+            right?(_: {
+                hasChanges: boolean;
+                hasError: boolean;
+                hasValue: boolean;
+            }): any;
         };
     }) | null)[];
     tabItem: (({
         $: import('vue').ComponentInternalInstance;
         $data: {};
         $props: {
+            readonly name: string;
+            readonly title: string;
             readonly active: boolean;
             readonly removable: boolean;
+            readonly "onTab:switch"?: ((value: string) => any) | undefined;
             readonly "onUpdate:height"?: ((value: number) => any) | undefined;
             readonly "onUpdate:active"?: (() => any) | undefined;
         } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
@@ -150,7 +187,93 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
         $refs: {
             [x: string]: unknown;
         } & {
-            element: HTMLDivElement;
+            form: ({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: {
+                    readonly name?: string | undefined;
+                    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;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $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) & ((event: "update:has-value", value: boolean | null) => void);
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<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;
+                }>, {
+                    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>;
+                }, {}, {}, {}, 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)[];
+                    beforeMount?: (() => void) | (() => void)[];
+                    mounted?: (() => void) | (() => void)[];
+                    beforeUpdate?: (() => void) | (() => void)[];
+                    updated?: (() => void) | (() => void)[];
+                    activated?: (() => void) | (() => void)[];
+                    deactivated?: (() => void) | (() => void)[];
+                    beforeDestroy?: (() => void) | (() => void)[];
+                    beforeUnmount?: (() => void) | (() => void)[];
+                    destroyed?: (() => void) | (() => void)[];
+                    unmounted?: (() => void) | (() => void)[];
+                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    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 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;
+                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;
+            }>, "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;
+                }) => void;
+                initModel: () => void;
+                errorMessage: import('vue').ComputedRef<string>;
+            }> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    default?(_: {}): any;
+                };
+            }) | null;
         };
         $slots: Readonly<{
             [name: string]: import('vue').Slot<any> | undefined;
@@ -158,97 +281,32 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
         $root: import('vue').ComponentPublicInstance | null;
         $parent: import('vue').ComponentPublicInstance | null;
         $host: Element | null;
-        $emit: ((event: "update:height", value: number) => void) & ((event: "update:active") => void);
+        $emit: ((event: "tab:switch", value: string) => void) & ((event: "update:height", value: number) => void) & ((event: "update:active") => void);
         $el: any;
         $options: import('vue').ComponentOptionsBase<Readonly<{
+            name: string;
+            title: string;
             active: boolean;
             removable: boolean;
         }> & Readonly<{
+            "onTab:switch"?: ((value: string) => any) | undefined;
             "onUpdate:height"?: ((value: number) => any) | undefined;
             "onUpdate:active"?: (() => any) | undefined;
         }>, {
             emitHeight: () => void;
-        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-            "update:height": (value: number) => any;
-            "update:active": () => any;
-        }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
-            beforeCreate?: (() => void) | (() => void)[];
-            created?: (() => void) | (() => void)[];
-            beforeMount?: (() => void) | (() => void)[];
-            mounted?: (() => void) | (() => void)[];
-            beforeUpdate?: (() => void) | (() => void)[];
-            updated?: (() => void) | (() => void)[];
-            activated?: (() => void) | (() => void)[];
-            deactivated?: (() => void) | (() => void)[];
-            beforeDestroy?: (() => void) | (() => void)[];
-            beforeUnmount?: (() => void) | (() => void)[];
-            destroyed?: (() => void) | (() => void)[];
-            unmounted?: (() => void) | (() => void)[];
-            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
-            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
-            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 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;
-        removable: boolean;
-    }> & Readonly<{
-        "onUpdate:height"?: ((value: number) => any) | undefined;
-        "onUpdate:active"?: (() => any) | undefined;
-    }>, "emitHeight"> & import('vue').ShallowUnwrapRef<{
-        emitHeight: () => void;
-    }> & {} & import('vue').ComponentCustomProperties & {} & {
-        $slots: {
-            default?(_: {}): any;
-        };
-    }) | null)[];
-    form: (({
-        $: import('vue').ComponentInternalInstance;
-        $data: {};
-        $props: {
-            readonly name?: string | undefined;
-            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;
-        };
-        $refs: {
-            [x: string]: unknown;
-        };
-        $slots: Readonly<{
-            [name: string]: import('vue').Slot<any> | undefined;
-        }>;
-        $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) & ((event: "update:has-value", value: boolean | null) => void);
-        $el: any;
-        $options: import('vue').ComponentOptionsBase<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;
-        }>, {
             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;
-            errorMessage: import('vue').ComputedRef<string>;
         }, {}, {}, {}, 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;
+            "tab:switch": (value: string) => any;
+            "update:height": (value: number) => any;
+            "update:active": () => any;
         }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
             beforeCreate?: (() => void) | (() => void)[];
             created?: (() => void) | (() => void)[];
@@ -270,22 +328,25 @@ declare const _default: import('vue').DefineComponent<TabsProps, {
         $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;
-        title?: string;
+        name: string;
+        title: string;
+        active: boolean;
+        removable: boolean;
     }> & Readonly<{
-        "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<{
+        "onTab:switch"?: ((value: string) => any) | undefined;
+        "onUpdate:height"?: ((value: number) => any) | undefined;
+        "onUpdate:active"?: (() => any) | undefined;
+    }>, "errorMessage" | "hasChanges" | "isValid" | "hasValue" | "validate" | "invalidate" | "initModel" | "emitHeight"> & import('vue').ShallowUnwrapRef<{
+        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;
-        errorMessage: import('vue').ComputedRef<string>;
     }> & {} & import('vue').ComponentCustomProperties & {} & {
         $slots: {
             default?(_: {}): any;

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":"AAkUA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,SAAS,CAAA;AAEtC,OAAO,EAAC,KAAK,aAAa,EAA6G,MAAM,KAAK,CAAA;AAElJ,OAAO,KAAK,MAAM,6BAA6B,CAAA;;2BAyEjB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAiPlF,GAAG,8CAC7D,GAAG,yBACE,GAAG,6DACE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAH6C,GAAG,8CAC7D,GAAG,yBACE,GAAG,6DACE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAH6C,GAAG,8CAC7D,GAAG,yBACE,GAAG,6DACE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;AAgM/B,wBAeG"}
+{"version":3,"file":"WTabs.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Tabs/WTabs.vue"],"names":[],"mappings":"AAqUA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,SAAS,CAAA;AAEtC,OAAO,EAAC,KAAK,aAAa,EAA6G,MAAM,KAAK,CAAA;AAElJ,OAAO,KAAK,MAAM,6BAA6B,CAAA;;2BAiFjB,MAAM;yBAMR,MAAM;gBAcjB,IAAI;oBAIA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA0O1E,GAAG,8CAA8C,GAAG,yBAA0B,GAAE,6DACnI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CADgD,GAAG,8CAA8C,GAAG,yBAA0B,GAAE,6DACnI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCADgD,GAAG,8CAA8C,GAAG,yBAA0B,GAAE,6DACnI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwJpC,wBAeG"}

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

@@ -1,9 +1,19 @@
-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 { 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 '../Button/WButtonAction.vue.js';
+import '../Button/WButton.vue.js';
 import { debounce, throttle } from '../../utils/utils.js';
+import '../Button/WButtonDropdown.vue.js';
+import '../../utils/supportsPassive.js';
+import '../Dropdown/utils/DropdownStyle.js';
+import 'vue-router';
+import { wTabItemListener, wTabItemUnlistener } from './models/injection.js';
+import '../../utils/Modal.js';
+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 { wTabItemListener, wTabItemUnlistener } from './models/injection.js';
 
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "WTabs",
@@ -15,7 +25,10 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     side: { type: Boolean },
     disableMinHeight: { type: Boolean },
     noHeader: { type: Boolean },
-    switchToNew: { type: Boolean }
+    switchToNew: { type: Boolean },
+    noIndicator: { type: Boolean },
+    stepper: { type: Boolean },
+    showHasValue: { type: Boolean }
   },
   emits: ["update:current", "update:current-index", "update:has-changes", "update:current-title", "update:tabs-length"],
   setup(__props, { expose: __expose, emit: __emit }) {
@@ -48,10 +61,15 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const indicatorStyle = ref(void 0);
     const minHeight = ref(0);
     const tabItemRef = useTemplateRef("tabItem");
-    const formRef = useTemplateRef("form");
-    const currentIsValud = computed(() => formRef.value?.[defaultSlotsKeys.value.indexOf(current.value)]?.isValid);
+    const currentIsValid = computed(() => tabItemRef.value?.[currentIndex.value]?.isValid ?? true);
+    const hasNoValueFirst = computed(() => {
+      if (!props.stepper) return 0;
+      const index = tabItemRef.value?.findIndex((item) => item?.hasValue === false) ?? 0;
+      if (index === -1) return defaultSlotsKeys.value.length;
+      return index;
+    });
     const switchOnInvalid = debounce((key) => {
-      if (currentIsValud.value !== false) switchTab(key);
+      if (currentIsValid.value !== false) switchTab(key);
     }, 50);
     const switchTab = throttle((key) => {
       if (current.value === key) return;
@@ -82,13 +100,17 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       minHeight.value = value;
     };
     const validate = (index, ...args) => {
-      return formRef.value?.[index]?.validate(...args);
+      return tabItemRef.value?.[index]?.validate(...args);
+    };
+    const validateIfNoError = (index, ...args) => {
+      if (tabItemRef.value?.[index]?.errorMessage) return tabItemRef.value?.[index].errorMessage;
+      return tabItemRef.value?.[index]?.validate(...args);
     };
     const invalidate = (index, ...args) => {
-      return formRef.value?.[index]?.invalidate(...args);
+      return tabItemRef.value?.[index]?.invalidate(...args);
     };
     const initModel = (index, ...args) => {
-      return formRef.value?.[index]?.initModel(...args);
+      return tabItemRef.value?.[index]?.initModel(...args);
     };
     const updateIndicator = () => {
       buttonRef.value?.forEach((item) => item?.update());
@@ -97,10 +119,10 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       if (!buttonContainerRef.value) return;
       if (props.side) {
         if (buttonContainerRef.value.scrollHeight <= buttonContainerRef.value.offsetHeight) return;
-        buttonContainerRef.value.scrollTo({ top: ((value.top ?? 0) - buttonContainerRef.value.offsetTop) / 2, behavior: "smooth" });
+        buttonContainerRef.value.scrollTo({ top: value.top - buttonContainerRef.value.offsetHeight / 2, behavior: "smooth" });
       } else {
         if (buttonContainerRef.value.scrollWidth <= buttonContainerRef.value.offsetWidth) return;
-        buttonContainerRef.value.scrollTo({ left: ((value.left ?? 0) - buttonContainerRef.value.offsetLeft) / 2, behavior: "smooth" });
+        buttonContainerRef.value.scrollTo({ left: value.left - buttonContainerRef.value.offsetWidth / 2, behavior: "smooth" });
       }
     };
     const tabItemListenerInjected = inject(wTabItemListener, null);
@@ -137,6 +159,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       next,
       previous,
       validate,
+      validateIfNoError,
       invalidate,
       initModel
     });
@@ -152,7 +175,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
           ref: "buttonContainer",
           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
+            "flex pr-[30%]": !_ctx.side
           }])
         }, [
           (openBlock(true), createElementBlock(Fragment, null, renderList(defaultSlotsAll.value, (slot, index) => {
@@ -167,62 +190,54 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                 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,
+                "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({
-                  "col-span-2 grid grid-cols-subgrid": _ctx.side,
-                  "grid-cols-[1fr,auto]": !_ctx.side
-                }),
+                "no-indicator": _ctx.noIndicator,
                 "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))
+                  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(() => [
-                    (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))
+                  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(() => [
-                    (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))
+                  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", "side", "class", "onClick"])) : (openBlock(), createBlock(resolveDynamicComponent(slot), { key: 1 }))
+              ]), 1032, ["active", "index", "title", "icon", "has-changes", "has-error", "has-value", "first", "last", "disabled", "stepper", "show-has-value", "side", "no-indicator", "onClick"])) : (openBlock(), createBlock(resolveDynamicComponent(slot), { key: 1 }))
             ], 64);
           }), 128)),
-          createElementVNode("div", {
+          !_ctx.noIndicator ? (openBlock(), createElementBlock("div", {
+            key: 0,
             class: normalizeClass(["absolute rounded-sm duration-500", {
-              "bg-primary-default dark:bg-primary-dark": currentIsValud.value !== false,
-              "bg-negative dark:bg-negative-dark": currentIsValud.value === false,
+              "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)
+          }, null, 6)) : createCommentVNode("", true)
         ], 2)) : createCommentVNode("", true),
         defaultSlots.value.some((slot) => slot.children?.default) ? (openBlock(), createElementBlock("div", {
           key: 1,
@@ -241,27 +256,19 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                   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": unref(switchOnInvalid),
                   "onUpdate:height": _cache[1] || (_cache[1] = ($event) => !_ctx.disableMinHeight && updateHeight($event)),
                   "onUpdate:active": ($event) => _ctx.$emit("update:current-title", slot.props?.title)
                 }, {
                   default: withCtx(() => [
-                    createVNode(_sfc_main$3, {
-                      ref_for: true,
-                      ref: "form",
-                      name: slot.props?.name,
-                      title: slot.props?.title,
-                      "onUpdate:isValid": ($event) => $event === false && unref(switchOnInvalid)(slot.props?.name)
-                    }, {
-                      default: withCtx(() => [
-                        (openBlock(), createBlock(resolveDynamicComponent(slot)))
-                      ]),
-                      _: 2
-                    }, 1032, ["name", "title", "onUpdate:isValid"])
+                    (openBlock(), createBlock(resolveDynamicComponent(slot)))
                   ]),
                   _: 2
-                }, 1032, ["active", "removable", "onUpdate:active"]);
+                }, 1032, ["name", "title", "active", "removable", "onTab:switch", "onUpdate:active"]);
               }), 128))
             ]),
             _: 1