maz-ui 3.44.4-beta.0 → 3.44.4-beta.2

package/types/components/MazTabsBar.vue.d.ts

@@ -31,27 +31,18 @@ export interface Props {
      */
     autoScroll?: boolean;
 }
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
-    queryParam: string;
-    autoScroll: boolean;
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
-    queryParam: string;
-    autoScroll: boolean;
-}>>>, {
-    queryParam: string;
-    autoScroll: boolean;
-}, {}>, {
+declare function __VLS_template(): {
     item?(_: {
         item: {
             label: string;
             disabled: boolean;
             badge: {
                 content: string | number | boolean;
-                color?: BadgeColor | undefined;
-                pastel?: boolean | undefined;
-                outline?: boolean | undefined;
-                size?: string | undefined;
-                roundedSize?: BadgeRoundedSize | undefined;
+                color?: BadgeColor;
+                pastel?: boolean;
+                outline?: boolean;
+                size?: string;
+                roundedSize?: BadgeRoundedSize;
             } | undefined;
         };
         active: boolean;
@@ -60,7 +51,18 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__
     "badge-content"?(_: {
         content: string | number | boolean;
     }): any;
-}>;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+    queryParam: string;
+    autoScroll: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+    queryParam: string;
+    autoScroll: boolean;
+}>>>, {
+    queryParam: string;
+    autoScroll: boolean;
+}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;
 type __VLS_WithDefaults<P, D> = {
     [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {

package/types/components/MazTabsContent.vue.d.ts

@@ -1,6 +1,8 @@
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>, {
+declare function __VLS_template(): {
     default?(_: {}): any;
-}>;
+};
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {

package/types/components/MazTabsContentItem.vue.d.ts

@@ -1,4 +1,7 @@
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{
     tab: {
         type: NumberConstructor;
         required: true;
@@ -8,9 +11,8 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
         type: NumberConstructor;
         required: true;
     };
-}>>, {}, {}>, {
-    default?(_: {}): any;
-}>;
+}>>, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {

package/types/components/MazTextarea.vue.d.ts

@@ -85,7 +85,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     warning: boolean;
     disabled: boolean;
     color: Color;
-    class: any;
+    class: HTMLAttributes["class"];
     required: boolean;
     readonly: boolean;
     modelValue: string;

package/types/components/MazTransitionExpand.vue.d.ts

@@ -2,15 +2,17 @@ export interface Props {
     /** Duration of the animation in milliseconds */
     animationDuration?: string;
 }
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
     animationDuration: string;
 }>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
     animationDuration: string;
 }>>>, {
     animationDuration: string;
-}, {}>, {
-    default?(_: {}): any;
-}>;
+}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;
 type __VLS_WithDefaults<P, D> = {
     [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {

package/types/modules/composables/use-form-validator/index.d.ts

@@ -1,8 +1,7 @@
 import type { Ref } from 'vue';
-import type { BaseFormPayload, ExtractModelKey, FieldsStates, FormFieldOptions, ObjectValidationSchema, Options } from './types';
 import { scrollToError } from './utils';
-export type UseFormValidator<T extends BaseFormPayload = BaseFormPayload> = typeof useFormValidator<T>;
-export declare function useFormValidator<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<Model> = ExtractModelKey<Model>, Schema extends ObjectValidationSchema = ObjectValidationSchema>({ schema, model, defaultValues, options, }: {
+import type { BaseFormPayload, ExtractModelKey, FieldsStates, FormFieldOptions, ObjectValidationSchema, Options } from './types';
+export declare function useFormValidator<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<Model> = ExtractModelKey<Model>, Schema extends ObjectValidationSchema<Model> = ObjectValidationSchema<Model>>({ schema, model, defaultValues, options, }: {
     schema: Ref<Schema>;
     model?: Ref<Partial<Model>>;
     defaultValues?: Ref<Partial<Model>>;
@@ -12,7 +11,7 @@ export declare function useFormValidator<Model extends BaseFormPayload, ModelKey
     isSubmitting: Ref<boolean>;
     isSubmitted: Ref<boolean>;
     isValid: import("vue").ComputedRef<boolean>;
-    errors: import("vue").ComputedRef<Record<Extract<keyof Model, string>, import("./types").ValidationIssues>>;
+    errors: import("vue").ComputedRef<Record<Extract<keyof Model, string>, import("./types").ValidationIssues<Model>>>;
     model: Ref<Model>;
     context: {
         handleFieldInput: (name: ModelKey, force?: boolean) => void;
@@ -22,7 +21,7 @@ export declare function useFormValidator<Model extends BaseFormPayload, ModelKey
         addFieldValidationWatch: (name: ModelKey) => void;
         validateField: (name: ModelKey) => Promise<void>;
         options: {
-            mode: "eager" | "lazy" | "onBlur" | "onInput" | "aggressive";
+            mode: "eager" | "lazy" | "aggressive" | "onBlur" | "onInput";
             throttledFields: Partial<Record<Extract<keyof Model, string>, number | true>> | null;
             debouncedFields: Partial<Record<Extract<keyof Model, string>, number | true>> | null;
             scrollToErrorSelector: string;
@@ -35,10 +34,9 @@ export declare function useFormValidator<Model extends BaseFormPayload, ModelKey
     scrollToError: typeof scrollToError;
     handleSubmit: (successCallback: (model: Model) => Promise<unknown> | unknown, enableScrollOrSelector?: boolean | string) => (event: Event) => Promise<void>;
 };
-export type UseFormField<T extends BaseFormPayload = BaseFormPayload, Key extends Extract<keyof T, string> = Extract<keyof T, string>> = typeof useFormField<T, Key>;
 export declare function useFormField<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<Model> = ExtractModelKey<Model>, FieldType = Model[ModelKey] | undefined>(name: ModelKey, options?: FormFieldOptions<FieldType>): {
     hasError: import("vue").ComputedRef<boolean>;
-    errors: import("vue").ComputedRef<import("./types").ValidationIssues>;
+    errors: import("vue").ComputedRef<import("./types").ValidationIssues<BaseFormPayload>>;
     errorMessage: import("vue").ComputedRef<string | undefined>;
     isValid: import("vue").ComputedRef<boolean>;
     isDirty: import("vue").ComputedRef<boolean>;

package/types/modules/composables/use-form-validator/types.d.ts

@@ -1,8 +1,11 @@
-import type { BaseIssue, BaseSchema, BaseSchemaAsync, ErrorMessage, InferIssue, ObjectEntries, ObjectEntriesAsync, ObjectSchema, ObjectSchemaAsync } from 'valibot';
+import type { BaseIssue, BaseSchema, BaseSchemaAsync, ErrorMessage, InferIssue, ObjectSchema, ObjectSchemaAsync } from 'valibot';
 import type { ComponentPublicInstance, Ref } from 'vue';
-export type Validation<TInput = unknown, TOutput = unknown, TIssue extends BaseIssue<TInput> = BaseIssue<TInput>> = BaseSchema<TInput, TOutput, TIssue> | BaseSchemaAsync<TInput, TOutput, TIssue>;
-export type ObjectValidationSchema = ObjectSchemaAsync<ObjectEntriesAsync, ErrorMessage<BaseIssue<unknown>> | undefined> | ObjectSchema<ObjectEntries, ErrorMessage<BaseIssue<unknown>> | undefined>;
-export type ValidationIssues = InferIssue<Validation>[];
+import type { useFormField, useFormValidator } from './index';
+export type ValidationAsync<TInput extends BaseFormPayload, TOutput extends BaseFormPayload = TInput, TIssue extends BaseIssue<TInput> = BaseIssue<TInput>> = BaseSchema<TInput, TOutput, TIssue> | BaseSchemaAsync<TInput, TOutput, TIssue>;
+export type ValidationSync<TInput extends BaseFormPayload, TOutput extends BaseFormPayload = TInput, TIssue extends BaseIssue<TInput> = BaseIssue<TInput>> = BaseSchema<TInput, TOutput, TIssue>;
+export type Validation<TInput extends BaseFormPayload> = ValidationSync<TInput> | ValidationAsync<TInput>;
+export type ObjectValidationSchema<Model extends BaseFormPayload = BaseFormPayload, ModelKey extends ExtractModelKey<Model> = ExtractModelKey<Model>> = ObjectSchemaAsync<Record<ModelKey, ValidationAsync<Model>>, ErrorMessage<BaseIssue<unknown>> | undefined> | ObjectSchema<Record<ModelKey, ValidationSync<Model>>, ErrorMessage<BaseIssue<unknown>> | undefined>;
+export type ValidationIssues<TInput extends BaseFormPayload> = InferIssue<Validation<TInput>>[];
 export type ExtractModelKey<T> = Extract<keyof T, string>;
 export interface Options<Model extends BaseFormPayload = BaseFormPayload, ModelKey extends ExtractModelKey<Model> = ExtractModelKey<Model>> {
     /**
@@ -42,24 +45,26 @@ export interface FormContext<Model extends BaseFormPayload = BaseFormPayload, Mo
     validateField: (name: ModelKey) => void;
     fieldsStates: FieldsStates<Model>;
     options: StrictOptions;
-    schema: Ref<ObjectValidationSchema>;
+    schema: Ref<ObjectValidationSchema<Model>>;
     payload: Ref<Model>;
 }
-export interface FieldState<T> {
+export interface FieldState<Model extends BaseFormPayload, FieldType = Model[ExtractModelKey<Model>]> {
     blurred: boolean;
     dirty: boolean;
     error: boolean;
-    errors: ValidationIssues;
+    errors: ValidationIssues<Model>;
     valid: boolean;
-    initialValue: T | undefined;
+    initialValue?: FieldType | Readonly<FieldType>;
     validating: boolean;
     validated: boolean;
     mode: StrictOptions['mode'] | 'none';
 }
-export type FieldsStates<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<Model> = ExtractModelKey<Model>> = Record<ModelKey, FieldState<Model[ModelKey]>>;
-export type BaseFormPayload = Record<string, unknown | undefined>;
+export type FieldsStates<Model extends BaseFormPayload = BaseFormPayload, ModelKey extends ExtractModelKey<Model> = ExtractModelKey<Model>> = Record<ModelKey, FieldState<Model>>;
+export type BaseFormPayload = Record<string, any>;
 export interface FormFieldOptions<T> {
     mode?: StrictOptions['mode'] | 'none';
     defaultValue?: T;
-    componentRef?: Ref<ComponentPublicInstance | undefined>;
+    componentRef?: Ref<ComponentPublicInstance | HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | undefined>;
 }
+export type UseFormValidator<T extends BaseFormPayload = BaseFormPayload> = typeof useFormValidator<T>;
+export type UseFormField<T extends BaseFormPayload = BaseFormPayload> = typeof useFormField<T>;

package/types/modules/composables/use-form-validator/utils.d.ts

@@ -1,35 +1,35 @@
 import type { Ref } from 'vue';
 import type { BaseFormPayload, ExtractModelKey, FieldState, FieldsStates, FormFieldOptions, ObjectValidationSchema, StrictOptions, ValidationIssues } from './types';
 export declare function getValibotValidationMethod(): Promise<typeof import("valibot").safeParseAsync>;
-export declare function fieldHasValidation(field: string, schema: ObjectValidationSchema): boolean;
+export declare function fieldHasValidation<Model extends BaseFormPayload>(field: string, schema: ObjectValidationSchema<Model>): boolean;
 export declare function scrollToError(selector?: string): void;
-export declare function isEmptyValue(value: unknown): boolean;
-export declare function getFieldState<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<Model> = ExtractModelKey<Model>>({ name, schema, initialValue, mode, }: {
+export declare function isEmptyValue(value: unknown): value is "" | null | undefined;
+export declare function getFieldState<Model extends BaseFormPayload = BaseFormPayload, ModelKey extends ExtractModelKey<Model> = ExtractModelKey<Model>>({ name, schema, initialValue, mode, }: {
     name: ModelKey;
-    schema?: ObjectValidationSchema;
-    initialValue: Model[ModelKey];
+    schema?: ObjectValidationSchema<Model>;
+    initialValue?: Model[ModelKey] | Readonly<Model[ModelKey]>;
     mode?: StrictOptions['mode'] | 'none';
-}): FieldState<Model[ModelKey]>;
-export declare function getFieldsStates<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<Model> = ExtractModelKey<Model>>(schema: ObjectValidationSchema, payload: Partial<Model>, mode: StrictOptions['mode']): FieldsStates<Model>;
+}): FieldState<Model>;
+export declare function getFieldsStates<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<Model> = ExtractModelKey<Model>>(schema: ObjectValidationSchema<Model>, payload: Partial<Model>, mode: StrictOptions['mode']): FieldsStates<Model>;
 export declare function mergeFieldState<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<Model> = ExtractModelKey<Model>>({ name, fieldsStates, payload, schema, options, }: {
     name: ModelKey;
     fieldsStates: FieldsStates<Model>;
     payload: Ref<Model>;
-    schema: Ref<ObjectValidationSchema>;
+    schema: Ref<ObjectValidationSchema<Model>>;
     options: FormFieldOptions<Model[ModelKey]>;
 }): FieldsStates<Model>[ModelKey] & {
-    errors: ValidationIssues;
+    errors: ValidationIssues<Model>;
     blurred: boolean;
     dirty: boolean;
     error: boolean;
     valid: boolean;
-    initialValue: unknown;
+    initialValue?: Model[Extract<keyof Model, string>] | Readonly<Model[Extract<keyof Model, string>]> | undefined;
     validating: boolean;
     validated: boolean;
-    mode: "eager" | "lazy" | "onBlur" | "onInput" | "none" | "aggressive";
+    mode: StrictOptions["mode"] | "none";
 };
-export declare function getFieldsErrors<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<Model> = ExtractModelKey<Model>>(fieldsStates: FieldsStates<Model>): Record<ModelKey, ValidationIssues>;
-export declare function findInteractiveElements(el: HTMLElement): HTMLElement[];
+export declare function getFieldsErrors<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<Model> = ExtractModelKey<Model>>(fieldsStates: FieldsStates<Model>): Record<ModelKey, ValidationIssues<Model>>;
+export declare function findInteractiveElements(el: HTMLElement): (HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement)[];
 export declare function addEventToInteractiveElements({ interactiveElements, onBlur, onInput, mode, }: {
     interactiveElements: HTMLElement[];
     onBlur: () => void;

package/types/modules/directives/v-fullscreen-img/MazFullscreenImg.vue.d.ts

@@ -60,8 +60,8 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     };
     offset: number;
     animation: {
-        duration?: number | undefined;
-        easing?: string | undefined;
+        duration?: number;
+        easing?: string;
     };
     openInstanceClass: string;
     zoom: boolean;

package/types/modules/plugins/toaster/MazToast.vue.d.ts

@@ -46,7 +46,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     link: ToasterLink;
     timeout: number | boolean;
     position: ToasterPosition;
-    type: "info" | "success" | "warning" | "danger" | "theme";
+    type: LocalToasterOptions["type"];
     message: string;
     icon: boolean;
     maxToasts: number | boolean;

package/types/tailwindcss/tailwind.config.d.ts

@@ -56,7 +56,7 @@ export declare const baseConfig: {
     };
     plugins: {
         handler: import("tailwindcss/types/config").PluginCreator;
-        config?: Partial<import("tailwindcss/types/config").Config> | undefined;
+        config?: Partial<import("tailwindcss/types/config").Config>;
     }[];
 };
 export declare const tailwindConfig: {
@@ -115,7 +115,7 @@ export declare const tailwindConfig: {
     };
     plugins: {
         handler: import("tailwindcss/types/config").PluginCreator;
-        config?: Partial<import("tailwindcss/types/config").Config> | undefined;
+        config?: Partial<import("tailwindcss/types/config").Config>;
     }[];
 };
 export default baseConfig;

package/components/chunks/MazSpinner-D1paofz3.mjs

@@ -1,37 +0,0 @@
-import { defineComponent as t, openBlock as o, createElementBlock as n, normalizeClass as s, pushScopeId as c, popScopeId as a, createElementVNode as r } from "vue";
-import { _ as i } from "./MazPhoneNumberInput-CYcy4OZW.mjs";
-import '../assets/MazSpinner.css';const p = (e) => (c("data-v-c16a57a3"), e = e(), a(), e), d = ["width", "height"], l = /* @__PURE__ */ p(() => /* @__PURE__ */ r(
-  "path",
-  { d: "M43.935,25.145c0-10.318-8.364-18.683-18.683-18.683c-10.318,0-18.683,8.365-18.683,18.683h4.068c0-8.071,6.543-14.615,14.615-14.615c8.072,0,14.615,6.543,14.615,14.615H43.935z" },
-  null,
-  -1
-  /* HOISTED */
-)), m = [
-  l
-], h = /* @__PURE__ */ t({
-  __name: "MazSpinner",
-  props: {
-    size: { type: String, default: "2em" },
-    color: {
-      type: String,
-      default: "primary"
-    }
-  },
-  setup(e) {
-    return (_, u) => (o(), n("svg", {
-      width: e.size,
-      height: e.size,
-      version: "1.1",
-      xmlns: "http://www.w3.org/2000/svg",
-      x: "0px",
-      y: "0px",
-      viewBox: "0 0 50 50",
-      "xml:space": "preserve",
-      class: s(["m-spinner", `m-spinner--${e.color}`]),
-      style: { "enable-background": "new 0 0 50 50" }
-    }, m, 10, d));
-  }
-}), f = /* @__PURE__ */ i(h, [["__scopeId", "data-v-c16a57a3"]]);
-export {
-  f as default
-};