maz-ui 3.50.1 → 4.0.0-alpha.2

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

@@ -0,0 +1,19 @@
+import { Component, ComponentPublicInstance, FunctionalComponent, SVGAttributes } from 'vue';
+export type ModelValueSimple = string | number | null | undefined | boolean;
+export type MazGalleryImage = {
+    thumbnail?: string;
+    src: string;
+    alt?: string;
+} | string;
+export type Color = 'primary' | 'secondary' | 'info' | 'success' | 'warning' | 'danger' | 'white' | 'black' | 'transparent' | 'theme';
+export type Size = 'mini' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type Position = 'top' | 'top right' | 'top left' | 'bottom' | 'bottom right' | 'bottom left' | 'left' | 'right';
+export interface Source {
+    srcset?: string;
+    media?: string;
+}
+export interface DataImage {
+    sources?: Source[];
+}
+export type MazImage = DataImage | string;
+export type Icon = FunctionalComponent<SVGAttributes> | ComponentPublicInstance | Component;

package/dist/types/composables/index.d.ts

@@ -0,0 +1,18 @@
+export * from './useAos';
+export * from './useBreakpoints';
+export * from './useDialog';
+export * from './useFormField';
+export * from './useFormValidator';
+export * from './useFormValidator/types';
+export * from './useIdleTimeout';
+export * from './useInstanceUniqId';
+export * from './useLanguageDisplayNames';
+export * from './useReadingTime';
+export * from './useStringMatching';
+export * from './useSwipe';
+export * from './useThemeHandler';
+export * from './useTimer';
+export * from './useToast';
+export * from './useUserVisibilty';
+export * from './useWait';
+export * from './useWindowSize';

package/dist/types/composables/useAos.d.ts

@@ -0,0 +1,2 @@
+import { AosHandler } from '../plugins/aos';
+export declare function useAos(): AosHandler;

package/dist/types/composables/useBreakpoints.d.ts

@@ -0,0 +1,38 @@
+import { UseWindowSizeOptions } from './useWindowSize';
+export interface UseBreakpointsOptions extends UseWindowSizeOptions {
+    initialWidth?: number;
+    initialHeight?: number;
+    /**
+     * Listen to window `orientationchange` event
+     *
+     * @default true
+     */
+    listenOrientation?: boolean;
+    /**
+     * Whether the scrollbar should be included in the width and height
+     * @default true
+     */
+    includeScrollbar?: boolean;
+    /**
+     * List of breakpoints in format `{ [key: string]: string }`  (e.g. `{ 'sm': '640px', 'md': '768px' }`)
+     */
+    breakpoints: Record<string, string> | Record<string, number>;
+    /**
+     * Is the breakpoint when the screen is considered not medium (tablet - e.g. `md`)
+     * @default 'md'
+     */
+    mediumBreakPoint?: string;
+    /**
+     * Is the breakpoint when the screen is considered not medium (laptop - e.g. `lg`)
+     * @default 'lg'
+     */
+    largeBreakPoint?: string;
+}
+export declare function useBreakpoints({ initialWidth, initialHeight, includeScrollbar, internalWindow, listenOrientation, breakpoints, mediumBreakPoint, largeBreakPoint, }: UseBreakpointsOptions): {
+    width: import('vue').Ref<number, number>;
+    numericBreakpoints: Record<string, number>;
+    isSmallScreen: import('vue').ComputedRef<boolean>;
+    isLargeScreen: import('vue').ComputedRef<boolean>;
+    isMediumScreen: import('vue').ComputedRef<boolean>;
+    breakpoints: Record<string, string> | Record<string, number>;
+};

package/dist/types/composables/useDialog.d.ts

@@ -0,0 +1,2 @@
+import { DialogHandler } from '../plugins/dialog/DialogHandler';
+export declare function useDialog(): DialogHandler;

package/dist/types/composables/useFormField.d.ts

@@ -0,0 +1,56 @@
+import { BaseFormPayload, ExtractModelKey, FormFieldOptions, FormSchema, ValidationIssues } from './useFormValidator/types';
+import { ComputedRef, WritableComputedRef } from 'vue';
+import { getValidationEvents } from './useFormValidator/utils';
+interface UseFormFieldReturn<FieldType> {
+    /**
+     * Indicates if the field has an error
+     */
+    hasError: ComputedRef<boolean>;
+    /**
+     * Errors of the field
+     */
+    errors: ComputedRef<ValidationIssues>;
+    /**
+     * Error message of the field
+     * It's the first error of the field
+     */
+    errorMessage: ComputedRef<string | undefined>;
+    /**
+     * Indicates if the field is valid
+     */
+    isValid: ComputedRef<boolean>;
+    /**
+     * Indicates if the field has been modified
+     */
+    isDirty: ComputedRef<boolean>;
+    /**
+     * Indicates if the field has been blurred
+     */
+    isBlurred: ComputedRef<boolean>;
+    /**
+     * Indicates if the field has been validated
+     */
+    isValidated: ComputedRef<boolean>;
+    /**
+     * Indicates if the field is validating
+     */
+    isValidating: ComputedRef<boolean>;
+    /**
+     * Validation mode of the field
+     */
+    mode: ComputedRef<FormFieldOptions<FieldType>['mode']>;
+    /**
+     * Value of the field
+     */
+    value: WritableComputedRef<FieldType>;
+    /**
+     * Validation events of the field
+     */
+    validationEvents: ComputedRef<ReturnType<typeof getValidationEvents>>;
+    /**
+     * Function to handle the blur event of the field
+     */
+    onBlur: () => void;
+}
+export declare function useFormField<FieldType extends Model[ExtractModelKey<FormSchema<Model>>], Model extends BaseFormPayload = BaseFormPayload>(name: ExtractModelKey<FormSchema<Model>>, options?: FormFieldOptions<FieldType>): UseFormFieldReturn<FieldType>;
+export {};

package/dist/types/composables/useFormValidator/config.d.ts

@@ -0,0 +1,7 @@
+import { StrictOptions } from './types';
+export declare const CONFIG: {
+    mode: StrictOptions['mode'];
+    scrollToErrorSelector: string;
+    debounceTime: number;
+    throttleTime: number;
+};

package/dist/types/composables/useFormValidator/types.d.ts

@@ -0,0 +1,110 @@
+import { useFormField } from '../useFormField';
+import { useFormValidator } from '.';
+import { InferMaybeRef } from '../../ts-helpers/InferMaybeRef';
+import { BaseIssue, BaseSchema, BaseSchemaAsync, InferIssue, InferOutput, objectAsync, ObjectEntries, ObjectEntriesAsync } from 'valibot';
+import { ComponentInternalInstance, InjectionKey, MaybeRef, Ref } from 'vue';
+import { getValidateFunction } from './utils';
+export type ValidationSync = BaseSchema<unknown, unknown, BaseIssue<unknown>>;
+export type ValidationAsync = ValidationSync | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>;
+export type Validation = ValidationAsync;
+export type ValidationIssues = InferIssue<Validation>[];
+export type ExtractModelKey<T> = Extract<keyof T, string>;
+export type FormSchema<Model> = {
+    [K in Extract<keyof Model, string> as Model[K] extends Required<Model>[K] ? K : never]: Validation;
+} & {
+    [K in Extract<keyof Model, string> as Model[K] extends Required<Model>[K] ? never : K]?: Validation;
+};
+export type CustomInstance<Model extends BaseFormPayload> = ComponentInternalInstance & {
+    formContexts?: Map<string | symbol | InjectionKey<FormContext<Model>>, FormContext<Model>>;
+};
+export interface FormValidatorOptions<Model extends BaseFormPayload = BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>> {
+    /**
+     * Validation mode
+     * - lazy: validate on input value change
+     * - aggressive: validate all fields immediately on form creation and on input value change
+     * - blur: validate on blur
+     * - eager: validate on blur at first (only if the field is not empty) and then on input value change
+     * - progressive: field becomes valid after the first validation and then validate on input value change. If invalid validate on blur.
+     * @default 'lazy'
+     */
+    mode?: 'eager' | 'lazy' | 'aggressive' | 'blur' | 'progressive';
+    /**
+     * Fields to validate with throttling
+     * Useful for fields that require a network request to avoid spamming the server
+     * @example { name: 1000 } or { name: true } for the default throttle time (1000ms)
+     */
+    throttledFields?: Partial<Record<ModelKey, number | true>> | null;
+    /**
+     * Fields to validate with debouncing
+     * Useful to wait for the user to finish typing before validating
+     * Useful for fields that require a network request to avoid spamming the server
+     * @example { name: 300 } or { name: true } for the default debounce time (300ms)
+     */
+    debouncedFields?: Partial<Record<ModelKey, number | true>> | null;
+    /**
+     * Scroll to the first error found
+     * @default '.has-field-error'
+     */
+    scrollToError?: string | false;
+    /**
+     * Identifier to use for the form
+     * Useful to have multiple forms on the same page
+     * @default `main-form-validator`
+     */
+    identifier?: string | symbol;
+}
+export type StrictOptions<Model extends BaseFormPayload = BaseFormPayload> = Required<FormValidatorOptions<Model>>;
+export interface FormContext<Model extends BaseFormPayload = BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>> {
+    fieldsStates: Ref<FieldsStates<Model>>;
+    options: StrictOptions;
+    internalSchema: Ref<FormSchema<Model>>;
+    payload: Ref<Model>;
+    errorMessages: Ref<Record<ModelKey, string | undefined>>;
+    isSubmitted: Ref<boolean>;
+}
+export interface FieldState<Model extends BaseFormPayload, FieldType = Model[ExtractModelKey<FormSchema<Model>>]> {
+    blurred: boolean;
+    dirty: boolean;
+    error: boolean;
+    errors: ValidationIssues;
+    valid: boolean;
+    initialValue?: Readonly<FieldType>;
+    validating: boolean;
+    validated: boolean;
+    validateFunction: ReturnType<typeof getValidateFunction<Model>>;
+    mode?: StrictOptions['mode'];
+}
+export type FieldsStates<Model extends BaseFormPayload = BaseFormPayload> = Record<ExtractModelKey<Model>, FieldState<Model>>;
+export type BaseFormPayload = Record<string, any>;
+export interface FormFieldOptions<FieldType> {
+    /**
+     * Default value of the field
+     * @default undefined
+     */
+    defaultValue?: FieldType;
+    /**
+     * Validation mode
+     * To override the form validation mode
+     */
+    mode?: StrictOptions['mode'];
+    /**
+     * Reference to the component or HTML element to associate and trigger validation events
+     * Necessary for 'eager', 'progressive' and 'blur' validation modes
+     */
+    ref?: string;
+    /**
+     * Identifier for the form
+     * Useful when you have multiple forms on the same component
+     * Should be the same as the one used in `useFormValidator`
+     */
+    formIdentifier?: string | symbol;
+}
+export type UseFormValidator<Model extends BaseFormPayload = BaseFormPayload> = typeof useFormValidator<Model>;
+export interface UseFormValidatorParams<Model extends BaseFormPayload> {
+    schema: MaybeRef<FormSchema<Model>>;
+    defaultValues?: MaybeRef<Partial<Model> | undefined>;
+    model?: Ref<Partial<Model> | undefined>;
+    options?: FormValidatorOptions<Model>;
+}
+export type UseFormField<FieldType extends Model[ExtractModelKey<FormSchema<Model>>], Model extends BaseFormPayload = BaseFormPayload> = typeof useFormField<FieldType, Model>;
+export type InferFormValidatorSchema<T extends ObjectEntries | ObjectEntriesAsync | Ref<ObjectEntries> | Ref<ObjectEntriesAsync>> = InferOutput<ReturnType<typeof objectAsync<InferMaybeRef<T>>>>;

package/dist/types/composables/useFormValidator/utils.d.ts

@@ -0,0 +1,116 @@
+import { InjectionKey } from 'vue';
+import { BaseFormPayload, CustomInstance, ExtractModelKey, FieldsStates, FieldState, FormContext, FormFieldOptions, FormSchema, StrictOptions, ValidationIssues } from './types';
+export declare function fieldHasValidation<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>>>(field: ModelKey, schema: FormSchema<Model>): boolean;
+export declare function scrollToError(selector?: string): void;
+export declare function getErrorMessages<Model extends BaseFormPayload = BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>(errors: Record<ModelKey, ValidationIssues>, fieldsStates: FieldsStates<Model>): Record<ModelKey, string | undefined>;
+export declare function isEmptyValue(value: unknown): value is "" | null | undefined;
+export declare function getValidateFunction<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ name, hasValidation, debouncedFields, throttledFields, }: {
+    name: ModelKey;
+    hasValidation: boolean;
+    debouncedFields?: StrictOptions<Model>['debouncedFields'];
+    throttledFields?: StrictOptions<Model>['throttledFields'];
+}): ((args_0: {
+    name: ExtractModelKey<FormSchema<Model>>;
+    fieldState: FieldState<Model, Model[Extract<keyof { [K in Extract<keyof Model, string> as Model[K] extends Required<Model>[K] ? K : never]: import('./types').ValidationAsync; }, string> | Extract<keyof { [K_1 in Extract<keyof Model, string> as Model[K_1] extends Required<Model>[K_1] ? never : K_1]?: import('./types').ValidationAsync | undefined; }, string>]>;
+    schema: FormSchema<Model>;
+    payload: Model;
+    setError?: boolean;
+    setErrorIfInvalidAndNotEmpty?: boolean;
+}) => Promise<void>) | undefined;
+export declare function getFieldState<Model extends BaseFormPayload = BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ name, schema, initialValue, fieldState, options, }: {
+    name: ModelKey;
+    schema?: FormSchema<Model>;
+    initialValue?: Model[ModelKey];
+    fieldState: FieldState<Model>;
+    options?: Pick<StrictOptions<Model>, 'debouncedFields' | 'throttledFields' | 'mode'>;
+}): FieldState<Model>;
+export declare function getFieldsStates<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ schema, payload, options, }: {
+    schema: FormSchema<Model>;
+    payload: Partial<Model>;
+    options: StrictOptions<Model>;
+}): FieldsStates<Model>;
+export declare function updateFieldsStates<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ fieldsStates, payload, schema, options, updateMode, }: {
+    fieldsStates: FieldsStates<Model>;
+    payload: Model;
+    schema: FormSchema<Model>;
+    options: StrictOptions<Model>;
+    updateMode?: boolean;
+}): void;
+export declare function updateFieldState<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ name, fieldState, payload, schema, options, updateMode, }: {
+    name: ModelKey;
+    fieldState: FieldState<Model>;
+    payload: Model;
+    schema: FormSchema<Model>;
+    options: FormFieldOptions<Model[ModelKey]> & StrictOptions<Model>;
+    updateMode?: boolean;
+}): FieldState<Model>;
+export declare function getFieldsErrors<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>(fieldsStates: FieldsStates<Model>): Record<ModelKey, ValidationIssues>;
+export declare function findInteractiveElements(el: HTMLElement): (HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement)[];
+export declare function addEventToInteractiveElements({ interactiveElements, onBlur, mode, }: {
+    interactiveElements: HTMLElement[];
+    onBlur: () => void;
+    mode: StrictOptions['mode'];
+}): void;
+export declare function removeEventFromInteractiveElements({ interactiveElements, onBlur, }: {
+    interactiveElements: HTMLElement[];
+    onBlur: () => void;
+}): void;
+export declare function getFieldValidationResult<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>(name: ModelKey, schema: FormSchema<Model>, value: Model[ModelKey]): Promise<{
+    result: import('valibot').SafeParseResult<FormSchema<Model>[ModelKey]>;
+    isValid: boolean;
+}>;
+export declare function setFieldValidationState<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ name, fieldState, schema, payload, setError, setErrorIfInvalidAndNotEmpty, }: {
+    name: ModelKey;
+    fieldState: FieldState<Model>;
+    schema: FormSchema<Model>;
+    payload: Model;
+    setError?: boolean;
+    setErrorIfInvalidAndNotEmpty?: boolean;
+}): Promise<void>;
+export declare function validateField<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ name, fieldState, payload, schema, }: {
+    name: ModelKey;
+    fieldState: FieldState<Model>;
+    payload: Model;
+    schema: FormSchema<Model>;
+}): Promise<void> | undefined;
+export declare function validateForm<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ fieldsStates, payload, showErrors, schema, }: {
+    fieldsStates: FieldsStates<Model>;
+    showErrors?: boolean;
+    payload: Model;
+    schema: FormSchema<Model>;
+}): Promise<void[]>;
+export declare function canExecuteValidation<Model extends BaseFormPayload>({ eventName, fieldState, isSubmitted, }: {
+    eventName: 'blur' | 'input';
+    fieldState: FieldState<Model>;
+    isSubmitted: boolean;
+}): boolean;
+export declare function handleFieldBlur<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ name, force, payload, fieldState, schema, isSubmitted, }: {
+    name: ModelKey;
+    payload: Model;
+    fieldState: FieldState<Model>;
+    schema: FormSchema<Model>;
+    isSubmitted: boolean;
+    force?: boolean;
+}): Promise<void> | undefined;
+export declare function handleFieldInput<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ name, payload, fieldState, schema, isSubmitted, forceValidation, }: {
+    name: ModelKey;
+    payload: Model;
+    fieldState: FieldState<Model>;
+    schema: FormSchema<Model>;
+    isSubmitted: boolean;
+    forceValidation?: boolean;
+}): Promise<void> | undefined;
+export declare function getInstance<Model extends BaseFormPayload>(composableName: string): CustomInstance<Model>;
+export declare function getContext<Model extends BaseFormPayload>(identifier: string | symbol | InjectionKey<FormContext<Model>>, composableName: string): FormContext<Model, Extract<keyof { [K in Extract<keyof Model, string> as Model[K] extends Required<Model>[K] ? K : never]: import('./types').ValidationAsync; }, string> | Extract<keyof { [K_1 in Extract<keyof Model, string> as Model[K_1] extends Required<Model>[K_1] ? never : K_1]?: import('./types').ValidationAsync | undefined; }, string>>;
+export declare function getValidationEvents<Model extends BaseFormPayload>({ ref, fieldState, onBlur, }: {
+    ref?: string;
+    fieldState: FieldState<Model>;
+    onBlur: () => void;
+}): {
+    onBlur: () => void;
+} | undefined;
+type Valibot = typeof import('valibot');
+export declare function getValibotValidationMethod<MethodName extends keyof Valibot>(methodName: MethodName): Promise<Valibot[MethodName]>;
+export declare function getValidationSchema<Model extends BaseFormPayload>(formSchema: FormSchema<Model>): Promise<import('valibot').ObjectSchemaAsync<FormSchema<Model>, undefined>>;
+export declare function hasModeIncludes(modes: StrictOptions['mode'][], value?: StrictOptions['mode']): value is StrictOptions['mode'];
+export {};

package/dist/types/composables/useFormValidator.d.ts

@@ -0,0 +1,17 @@
+import { BaseFormPayload, ExtractModelKey, FieldsStates, FormSchema, FormValidatorOptions, UseFormValidatorParams } from './useFormValidator/types';
+import { Ref } from 'vue';
+import { scrollToError } from './useFormValidator/utils';
+export declare function useFormValidator<Model extends BaseFormPayload>({ schema, defaultValues, model, options }: UseFormValidatorParams<Model>): {
+    identifier: string | symbol;
+    isDirty: import('vue').ComputedRef<boolean>;
+    isSubmitting: Ref<boolean, boolean>;
+    isSubmitted: Ref<boolean, boolean>;
+    isValid: import('vue').ComputedRef<boolean>;
+    errors: import('vue').ComputedRef<Record<ExtractModelKey<FormSchema<Model>>, import('./useFormValidator/types').ValidationIssues>>;
+    model: Ref<Model, Model>;
+    fieldsStates: Ref<FieldsStates<Model>, FieldsStates<Model>>;
+    validateForm: (showErrors?: boolean) => Promise<void[]>;
+    scrollToError: typeof scrollToError;
+    handleSubmit: <Func extends (model: Model) => Promise<Awaited<ReturnType<Func>>> | ReturnType<Func>>(successCallback: Func, enableScrollOrSelector?: FormValidatorOptions["scrollToError"]) => (event?: Event) => Promise<ReturnType<Func> | undefined>;
+    errorMessages: import('vue').ComputedRef<Record<ExtractModelKey<FormSchema<Model>>, string | undefined>>;
+};

package/dist/types/composables/useIdleTimeout.d.ts

@@ -0,0 +1,5 @@
+import { IdleTimeout, IdleTimeoutCallback, IdleTimeoutOptions } from '../helpers/idleTimeout';
+export declare function useIdleTimeout({ callback, options, }: {
+    callback: IdleTimeoutCallback;
+    options?: IdleTimeoutOptions;
+}): IdleTimeout;

package/dist/types/composables/useInstanceUniqId.d.ts

@@ -0,0 +1,4 @@
+export declare function useInstanceUniqId({ componentName, providedId, }: {
+    componentName: string;
+    providedId?: string;
+}): import('vue').ComputedRef<string>;

package/dist/types/composables/useLanguageDisplayNames.d.ts

@@ -0,0 +1,18 @@
+import { MaybeRefOrGetter } from 'vue';
+declare const bcp47Codes: readonly ["af-ZA", "sq-AL", "ar-DZ", "ar-BH", "ar-EG", "ar-IQ", "ar-JO", "ar-KW", "ar-LB", "ar-LY", "ar-MA", "ar-OM", "ar-QA", "ar-SA", "ar-SY", "ar-TN", "ar-AE", "ar-YE", "hy-AM", "Cy-az-AZ", "Lt-az-AZ", "eu-ES", "be-BY", "bg-BG", "ca-ES", "zh-CN", "zh-HK", "zh-MO", "zh-SG", "zh-TW", "zh-CHS", "zh-CHT", "hr-HR", "cs-CZ", "da-DK", "div-MV", "nl-BE", "nl-NL", "en-AU", "en-BZ", "en-CA", "en-CB", "en-IE", "en-JM", "en-NZ", "en-PH", "en-ZA", "en-TT", "en-GB", "en-US", "en-ZW", "et-EE", "fo-FO", "fa-IR", "fi-FI", "fr-BE", "fr-CA", "fr-FR", "fr-LU", "fr-MC", "fr-CH", "gl-ES", "ka-GE", "de-AT", "de-DE", "de-LI", "de-LU", "de-CH", "el-GR", "gu-IN", "he-IL", "hi-IN", "hu-HU", "is-IS", "id-ID", "it-IT", "it-CH", "ja-JP", "kn-IN", "kk-KZ", "kok-IN", "ko-KR", "ky-KZ", "lv-LV", "lt-LT", "mk-MK", "ms-BN", "ms-MY", "mr-IN", "mn-MN", "nb-NO", "nn-NO", "pl-PL", "pt-BR", "pt-PT", "pa-IN", "ro-RO", "ru-RU", "sa-IN", "Cy-sr-SP", "Lt-sr-SP", "sk-SK", "sl-SI", "es-AR", "es-BO", "es-CL", "es-CO", "es-CR", "es-DO", "es-EC", "es-SV", "es-GT", "es-HN", "es-MX", "es-NI", "es-PA", "es-PY", "es-PE", "es-PR", "es-ES", "es-UY", "es-VE", "sw-KE", "sv-FI", "sv-SE", "syr-SY", "ta-IN", "tt-RU", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK", "Cy-uz-UZ", "Lt-uz-UZ", "vi-VN"];
+export declare const iso6391Codes: readonly ["aa", "ab", "ae", "af", "ak", "am", "an", "ar", "as", "av", "ay", "az", "ba", "be", "bg", "bh", "bi", "bm", "bn", "bo", "br", "bs", "ca", "ce", "ch", "co", "cr", "cs", "cu", "cv", "cy", "da", "de", "dv", "dz", "ee", "el", "en", "eo", "es", "et", "eu", "fa", "ff", "fi", "fj", "fo", "fr", "fy", "ga", "gd", "gl", "gn", "gu", "gv", "ha", "he", "hi", "ho", "hr", "ht", "hu", "hy", "hz", "ia", "id", "ie", "ig", "ii", "ik", "io", "is", "it", "iu", "ja", "jv", "ka", "kg", "ki", "kj", "kk", "kl", "km", "kn", "ko", "kr", "ks", "ku", "kv", "kw", "ky", "la", "lb", "lg", "li", "ln", "lo", "lt", "lu", "lv", "mg", "mh", "mi", "mk", "ml", "mn", "mr", "ms", "mt", "my", "na", "nb", "nd", "ne", "ng", "nl", "nn", "no", "nr", "nv", "ny", "oc", "oj", "om", "or", "os", "pa", "pi", "pl", "ps", "pt", "qu", "rm", "rn", "ro", "ru", "rw", "sa", "sc", "sd", "se", "sg", "si", "sk", "sl", "sm", "sn", "so", "sq", "sr", "ss", "st", "su", "sv", "sw", "ta", "te", "tg", "th", "ti", "tk", "tl", "tn", "to", "tr", "ts", "tt", "tw", "ty", "ug", "uk", "ur", "uz", "ve", "vi", "vo", "wa", "wo", "xh", "yi", "yo", "za", "zh", "zu"];
+export declare const languageCodes: ("br" | "hr" | "li" | "th" | "tr" | "sm" | "lg" | "to" | "mi" | "mn" | "ms" | "tt" | "el" | "af-ZA" | "sq-AL" | "ar-DZ" | "ar-BH" | "ar-EG" | "ar-IQ" | "ar-JO" | "ar-KW" | "ar-LB" | "ar-LY" | "ar-MA" | "ar-OM" | "ar-QA" | "ar-SA" | "ar-SY" | "ar-TN" | "ar-AE" | "ar-YE" | "hy-AM" | "Cy-az-AZ" | "Lt-az-AZ" | "eu-ES" | "be-BY" | "bg-BG" | "ca-ES" | "zh-CN" | "zh-HK" | "zh-MO" | "zh-SG" | "zh-TW" | "zh-CHS" | "zh-CHT" | "hr-HR" | "cs-CZ" | "da-DK" | "div-MV" | "nl-BE" | "nl-NL" | "en-AU" | "en-BZ" | "en-CA" | "en-CB" | "en-IE" | "en-JM" | "en-NZ" | "en-PH" | "en-ZA" | "en-TT" | "en-GB" | "en-US" | "en-ZW" | "et-EE" | "fo-FO" | "fa-IR" | "fi-FI" | "fr-BE" | "fr-CA" | "fr-FR" | "fr-LU" | "fr-MC" | "fr-CH" | "gl-ES" | "ka-GE" | "de-AT" | "de-DE" | "de-LI" | "de-LU" | "de-CH" | "el-GR" | "gu-IN" | "he-IL" | "hi-IN" | "hu-HU" | "is-IS" | "id-ID" | "it-IT" | "it-CH" | "ja-JP" | "kn-IN" | "kk-KZ" | "kok-IN" | "ko-KR" | "ky-KZ" | "lv-LV" | "lt-LT" | "mk-MK" | "ms-BN" | "ms-MY" | "mr-IN" | "mn-MN" | "nb-NO" | "nn-NO" | "pl-PL" | "pt-BR" | "pt-PT" | "pa-IN" | "ro-RO" | "ru-RU" | "sa-IN" | "Cy-sr-SP" | "Lt-sr-SP" | "sk-SK" | "sl-SI" | "es-AR" | "es-BO" | "es-CL" | "es-CO" | "es-CR" | "es-DO" | "es-EC" | "es-SV" | "es-GT" | "es-HN" | "es-MX" | "es-NI" | "es-PA" | "es-PY" | "es-PE" | "es-PR" | "es-ES" | "es-UY" | "es-VE" | "sw-KE" | "sv-FI" | "sv-SE" | "syr-SY" | "ta-IN" | "tt-RU" | "te-IN" | "th-TH" | "tr-TR" | "uk-UA" | "ur-PK" | "Cy-uz-UZ" | "Lt-uz-UZ" | "vi-VN" | "aa" | "ab" | "ae" | "af" | "ak" | "am" | "an" | "ar" | "as" | "av" | "ay" | "az" | "ba" | "be" | "bg" | "bh" | "bi" | "bm" | "bn" | "bo" | "bs" | "ca" | "ce" | "ch" | "co" | "cr" | "cs" | "cu" | "cv" | "cy" | "da" | "de" | "dv" | "dz" | "ee" | "en" | "eo" | "es" | "et" | "eu" | "fa" | "ff" | "fi" | "fj" | "fo" | "fr" | "fy" | "ga" | "gd" | "gl" | "gn" | "gu" | "gv" | "ha" | "he" | "hi" | "ho" | "ht" | "hu" | "hy" | "hz" | "ia" | "id" | "ie" | "ig" | "ii" | "ik" | "io" | "is" | "it" | "iu" | "ja" | "jv" | "ka" | "kg" | "ki" | "kj" | "kk" | "kl" | "km" | "kn" | "ko" | "kr" | "ks" | "ku" | "kv" | "kw" | "ky" | "la" | "lb" | "ln" | "lo" | "lt" | "lu" | "lv" | "mg" | "mh" | "mk" | "ml" | "mr" | "mt" | "my" | "na" | "nb" | "nd" | "ne" | "ng" | "nl" | "nn" | "no" | "nr" | "nv" | "ny" | "oc" | "oj" | "om" | "or" | "os" | "pa" | "pi" | "pl" | "ps" | "pt" | "qu" | "rm" | "rn" | "ro" | "ru" | "rw" | "sa" | "sc" | "sd" | "se" | "sg" | "si" | "sk" | "sl" | "sn" | "so" | "sq" | "sr" | "ss" | "st" | "su" | "sv" | "sw" | "ta" | "te" | "tg" | "ti" | "tk" | "tl" | "tn" | "ts" | "tw" | "ty" | "ug" | "uk" | "ur" | "uz" | "ve" | "vi" | "vo" | "wa" | "wo" | "xh" | "yi" | "yo" | "za" | "zh" | "zu")[];
+export type IsoCode = (typeof bcp47Codes)[number];
+export type Iso6391Code = (typeof iso6391Codes)[number];
+export type LanguageCode = (typeof languageCodes)[number];
+export declare function useLanguageDisplayNames(mainLocale?: MaybeRefOrGetter<string | LanguageCode>): {
+    getLanguageDisplayName: ({ code, locale }: {
+        code?: MaybeRefOrGetter<string | LanguageCode>;
+        locale?: MaybeRefOrGetter<string | LanguageCode>;
+    }) => import('vue').ComputedRef<string | undefined>;
+    getAllLanguageDisplayNames: (locale?: MaybeRefOrGetter<string | LanguageCode>) => import('vue').ComputedRef<({
+        language: string;
+        code: "br" | "hr" | "li" | "th" | "tr" | "sm" | "lg" | "to" | "mi" | "mn" | "ms" | "tt" | "el" | "af-ZA" | "sq-AL" | "ar-DZ" | "ar-BH" | "ar-EG" | "ar-IQ" | "ar-JO" | "ar-KW" | "ar-LB" | "ar-LY" | "ar-MA" | "ar-OM" | "ar-QA" | "ar-SA" | "ar-SY" | "ar-TN" | "ar-AE" | "ar-YE" | "hy-AM" | "Cy-az-AZ" | "Lt-az-AZ" | "eu-ES" | "be-BY" | "bg-BG" | "ca-ES" | "zh-CN" | "zh-HK" | "zh-MO" | "zh-SG" | "zh-TW" | "zh-CHS" | "zh-CHT" | "hr-HR" | "cs-CZ" | "da-DK" | "div-MV" | "nl-BE" | "nl-NL" | "en-AU" | "en-BZ" | "en-CA" | "en-CB" | "en-IE" | "en-JM" | "en-NZ" | "en-PH" | "en-ZA" | "en-TT" | "en-GB" | "en-US" | "en-ZW" | "et-EE" | "fo-FO" | "fa-IR" | "fi-FI" | "fr-BE" | "fr-CA" | "fr-FR" | "fr-LU" | "fr-MC" | "fr-CH" | "gl-ES" | "ka-GE" | "de-AT" | "de-DE" | "de-LI" | "de-LU" | "de-CH" | "el-GR" | "gu-IN" | "he-IL" | "hi-IN" | "hu-HU" | "is-IS" | "id-ID" | "it-IT" | "it-CH" | "ja-JP" | "kn-IN" | "kk-KZ" | "kok-IN" | "ko-KR" | "ky-KZ" | "lv-LV" | "lt-LT" | "mk-MK" | "ms-BN" | "ms-MY" | "mr-IN" | "mn-MN" | "nb-NO" | "nn-NO" | "pl-PL" | "pt-BR" | "pt-PT" | "pa-IN" | "ro-RO" | "ru-RU" | "sa-IN" | "Cy-sr-SP" | "Lt-sr-SP" | "sk-SK" | "sl-SI" | "es-AR" | "es-BO" | "es-CL" | "es-CO" | "es-CR" | "es-DO" | "es-EC" | "es-SV" | "es-GT" | "es-HN" | "es-MX" | "es-NI" | "es-PA" | "es-PY" | "es-PE" | "es-PR" | "es-ES" | "es-UY" | "es-VE" | "sw-KE" | "sv-FI" | "sv-SE" | "syr-SY" | "ta-IN" | "tt-RU" | "te-IN" | "th-TH" | "tr-TR" | "uk-UA" | "ur-PK" | "Cy-uz-UZ" | "Lt-uz-UZ" | "vi-VN" | "aa" | "ab" | "ae" | "af" | "ak" | "am" | "an" | "ar" | "as" | "av" | "ay" | "az" | "ba" | "be" | "bg" | "bh" | "bi" | "bm" | "bn" | "bo" | "bs" | "ca" | "ce" | "ch" | "co" | "cr" | "cs" | "cu" | "cv" | "cy" | "da" | "de" | "dv" | "dz" | "ee" | "en" | "eo" | "es" | "et" | "eu" | "fa" | "ff" | "fi" | "fj" | "fo" | "fr" | "fy" | "ga" | "gd" | "gl" | "gn" | "gu" | "gv" | "ha" | "he" | "hi" | "ho" | "ht" | "hu" | "hy" | "hz" | "ia" | "id" | "ie" | "ig" | "ii" | "ik" | "io" | "is" | "it" | "iu" | "ja" | "jv" | "ka" | "kg" | "ki" | "kj" | "kk" | "kl" | "km" | "kn" | "ko" | "kr" | "ks" | "ku" | "kv" | "kw" | "ky" | "la" | "lb" | "ln" | "lo" | "lt" | "lu" | "lv" | "mg" | "mh" | "mk" | "ml" | "mr" | "mt" | "my" | "na" | "nb" | "nd" | "ne" | "ng" | "nl" | "nn" | "no" | "nr" | "nv" | "ny" | "oc" | "oj" | "om" | "or" | "os" | "pa" | "pi" | "pl" | "ps" | "pt" | "qu" | "rm" | "rn" | "ro" | "ru" | "rw" | "sa" | "sc" | "sd" | "se" | "sg" | "si" | "sk" | "sl" | "sn" | "so" | "sq" | "sr" | "ss" | "st" | "su" | "sv" | "sw" | "ta" | "te" | "tg" | "ti" | "tk" | "tl" | "tn" | "ts" | "tw" | "ty" | "ug" | "uk" | "ur" | "uz" | "ve" | "vi" | "vo" | "wa" | "wo" | "xh" | "yi" | "yo" | "za" | "zh" | "zu";
+    } | undefined)[]>;
+};
+export {};

package/dist/types/composables/useReadingTime.d.ts

@@ -0,0 +1,25 @@
+import { ComputedRef, Ref } from 'vue';
+export interface ReadingTimeOptions {
+    /** Content to calculate the reading time */
+    content?: string | Ref<string>;
+    /** Selector of the content to calculate the reading time */
+    contentSelector?: string | Ref<string>;
+    /** Ref of the content to calculate the reading time */
+    contentRef?: Ref<HTMLElement | undefined>;
+    /**
+     * Words per minute
+     * @default 150
+     */
+    velocity?: number | Ref<number>;
+}
+export interface ReadingTimeReturn {
+    /** Content to calculate the reading time */
+    content: ComputedRef<string | undefined | null>;
+    /** Number of words in the content */
+    wordCount: ComputedRef<number>;
+    /** Words per minute */
+    velocity: ComputedRef<number>;
+    /** Reading time in minutes */
+    duration: ComputedRef<number>;
+}
+export declare function useReadingTime(options: ReadingTimeOptions): ReadingTimeReturn;

package/dist/types/composables/useStringMatching.d.ts

@@ -0,0 +1,5 @@
+import { Ref } from 'vue';
+export declare function useStringMatching(string1: string | Ref<string>, string2: string | Ref<string>, threshold?: number | Ref<number>): {
+    isMatching: import('vue').ComputedRef<boolean>;
+    score: import('vue').ComputedRef<number>;
+};

package/dist/types/composables/useSwipe.d.ts

@@ -0,0 +1,14 @@
+import { MaybeRef } from 'vue';
+import { SwipeOptions } from '../helpers/swipeHandler';
+export declare function useSwipe(options: Omit<SwipeOptions, 'onValuesChanged' | 'element'> & {
+    element: MaybeRef<HTMLElement> | string | null | undefined;
+}): {
+    xDiff: import('vue').Ref<number | undefined, number | undefined>;
+    yDiff: import('vue').Ref<number | undefined, number | undefined>;
+    xStart: import('vue').Ref<number | undefined, number | undefined>;
+    xEnd: import('vue').Ref<number | undefined, number | undefined>;
+    yStart: import('vue').Ref<number | undefined, number | undefined>;
+    yEnd: import('vue').Ref<number | undefined, number | undefined>;
+    start: () => void;
+    stop: () => void;
+};

package/dist/types/composables/useThemeHandler.d.ts

@@ -0,0 +1,58 @@
+export interface StrictThemeHandlerOptions {
+    /**
+     * Class to be added to the html element when dark theme is set
+     * @default 'dark'
+     */
+    darkClass: string;
+    /**
+     * Class to be added to the html element when light theme is set
+     * @default 'light'
+     */
+    lightClass: string;
+    /**
+     * Key to store the theme in local storage
+     * @default 'theme'
+     */
+    storageThemeKey: string;
+    /**
+     * Value to set the theme to dark
+     * @default 'dark'
+     */
+    storageThemeValueDark: string;
+    /**
+     * Value to set the theme to light
+     * @default 'light'
+     */
+    storageThemeValueLight: string;
+    /**
+     * Value to set the theme to system
+     * @default 'system'
+     */
+    storageThemeValueSystem: string;
+    /**
+     * Watch for changes in the system theme
+     * @default true
+     */
+    watchChanges: boolean;
+    /**
+     * Default theme to set if no theme has been previously set by the user
+     * Useful to force a theme on first visit
+     * The value will not be stored in local storage
+     * @default undefined
+     */
+    defaultTheme?: 'light' | 'dark';
+}
+export type ThemeHandlerOptions = Partial<StrictThemeHandlerOptions>;
+export declare function useThemeHandler(opts?: ThemeHandlerOptions): {
+    autoSetTheme: () => void;
+    toggleTheme: () => void;
+    setSystemTheme: () => void;
+    setDarkTheme: () => void;
+    setLightTheme: () => void;
+    setDefaultTheme: () => void;
+    hasDarkTheme: import('vue').ComputedRef<boolean>;
+    hasLightTheme: import('vue').ComputedRef<boolean>;
+    hasSystemTheme: import('vue').ComputedRef<boolean>;
+    theme: import('vue').Ref<string, string>;
+    selectedTheme: import('vue').Ref<string, string>;
+};

package/dist/types/composables/useTimer.d.ts

@@ -0,0 +1,29 @@
+export interface TimerOptions {
+    /**
+     * The time in milliseconds
+     * @default 1000
+     */
+    timeout?: number;
+    /**
+     * The callback to execute when the timer is finished
+     * @default undefined
+     */
+    callback?: () => unknown;
+    /**
+     * The interval to update the remaining time
+     * @default 200
+     */
+    remainingTimeUpdate?: number;
+    /**
+     * The offset time to execute the callback
+     * @default 0
+     */
+    callbackOffsetTime?: number;
+}
+export declare function useTimer({ timeout, callback, remainingTimeUpdate, callbackOffsetTime }: TimerOptions): {
+    remainingTime: import('vue').Ref<number, number>;
+    start: (timeout?: number) => void;
+    pause: () => void;
+    resume: () => void;
+    stop: () => void;
+};

package/dist/types/composables/useToast.d.ts

@@ -0,0 +1,2 @@
+import { ToasterHandler } from '../plugins/toaster/ToasterHandler';
+export declare function useToast(): ToasterHandler;

package/dist/types/composables/useUserVisibilty.d.ts

@@ -0,0 +1,5 @@
+import { UserVisibility, UserVisibilyCallback, UserVisibilyOptions } from '../helpers/userVisibility';
+export declare function useUserVisibility({ callback, options, }: {
+    callback: UserVisibilyCallback;
+    options?: UserVisibilyOptions;
+}): UserVisibility;

package/dist/types/composables/useWait.d.ts

@@ -0,0 +1,2 @@
+import { WaitHandler } from '../plugins/wait';
+export declare function useWait(): WaitHandler;