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

package/dist/components/MazReadingProgressBar.vue.d.ts

@@ -0,0 +1,55 @@
+import { HTMLAttributes } from 'vue';
+import { MazColor } from './types';
+export interface MazReadingProgressBarProps {
+    /**
+     * Height of the progress bar
+     * @default 4px
+     */
+    height?: string;
+    /**
+     * Color of the progress bar
+     * @default primary
+     */
+    color?: MazColor;
+    /**
+     * Selector of the element to teleport the progress bar
+     * @default body
+     */
+    teleportSelector?: string;
+    /**
+     * Selector of the element to get the height
+     * @default body
+     */
+    contentSelector?: string;
+    /**
+     * Offset of the progress bar
+     * @default 0
+     */
+    offset?: number;
+    /**
+     * Class of the progress bar
+     * @default undefined
+     */
+    barClass?: HTMLAttributes['class'];
+    /**
+     * Instead of using the height of the content with a selector, you can set a scroll distance
+     * @default undefined
+     */
+    distance?: number;
+}
+declare const _default: import('vue').DefineComponent<MazReadingProgressBarProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    begin: () => any;
+    complete: () => any;
+}, string, import('vue').PublicProps, Readonly<MazReadingProgressBarProps> & Readonly<{
+    onBegin?: (() => any) | undefined;
+    onComplete?: (() => any) | undefined;
+}>, {
+    height: string;
+    color: MazColor;
+    offset: number;
+    teleportSelector: string;
+    distance: number;
+    contentSelector: string;
+    barClass: HTMLAttributes["class"];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/MazSelect.vue.d.ts

@@ -0,0 +1,209 @@
+import { MazUiTranslationsNestedSchema } from '@maz-ui/translations';
+import { HTMLAttributes } from 'vue';
+import { MazInputValue } from './MazInput.vue';
+import { MazPopoverProps } from './MazPopover.vue';
+import { MazColor, MazSize } from './types';
+export interface MazSelectNormalizedOption {
+    [key: string]: MazInputValue;
+}
+export interface MazSelectOptionWithOptGroup {
+    label: string;
+    options: (MazSelectNormalizedOption | string | number | boolean)[];
+}
+export type MazSelectOption = MazSelectNormalizedOption | string | number | boolean | MazSelectOptionWithOptGroup;
+export interface MazSelectProps<Value extends MazInputValue, Option extends MazSelectOption, Multiple extends boolean> {
+    /**
+     * Style attribut of the component root element
+     * @type {HTMLAttributes['style']}
+     */
+    style?: HTMLAttributes['style'];
+    /**
+     * Class attribut of the component root element
+     * @type {HTMLAttributes['class']}
+     */
+    class?: HTMLAttributes['class'];
+    /** The id of the select */
+    id?: string;
+    /**
+     * The label of the select
+     */
+    label?: string;
+    /**
+     * The placeholder of the select
+     */
+    placeholder?: string;
+    /**
+     * The value of the select
+     * @type {Value | Value[]}
+     */
+    modelValue?: Multiple extends true ? Value[] : Value;
+    /**
+     * The options of the select
+     * @type {Option[]}
+     */
+    options: Option[];
+    /**
+     * The key of the option value
+     * @default 'value'
+     */
+    optionValueKey?: string;
+    /**
+     * The key of the option label
+     * @default 'label'
+     */
+    optionLabelKey?: string;
+    /**
+     * The key of the option input value
+     * @default 'label'
+     */
+    optionInputValueKey?: string;
+    /**
+     * The position of the list (auto by default - will switch between bottom-start and top-start)
+     * @type {MazPopoverProps['position']}
+     * @default 'auto'
+     */
+    listPosition?: MazPopoverProps['position'];
+    /**
+     * The prefer position of the list
+     * @type {MazPopoverProps['preferPosition']}
+     * @default 'bottom-start'
+     */
+    preferPosition?: MazPopoverProps['preferPosition'];
+    /**
+     * The fallback position of the list
+     * @type {MazPopoverProps['fallbackPosition']}
+     * @default 'top-start'
+     */
+    fallbackPosition?: MazPopoverProps['fallbackPosition'];
+    /** The height of the option list item */
+    itemHeight?: number;
+    /**
+     * The max height of the option list
+     * @default 240
+     */
+    maxListHeight?: number;
+    /** The max width of the option list */
+    maxListWidth?: number;
+    /** The min height of the option list */
+    minListHeight?: number;
+    /** The min width of the option list */
+    minListWidth?: number;
+    /**
+     * The size of the select
+     * @default 'md'
+     */
+    size?: MazSize;
+    /**
+     * The color of the select
+     * @default 'primary'
+     */
+    color?: MazColor;
+    /** Display search input in option list */
+    search?: boolean;
+    /**
+     * Replace the default search function to provide a custom search function
+     * @default undefined
+     */
+    searchFunction?: (query: string, options: Option[]) => Option[] | undefined;
+    /**
+     * The threshold for the search input where 1 is a perfect match and 0 is a match with any character
+     * @default 0.75
+     */
+    searchThreshold?: number;
+    /** Enable the multiple selection */
+    multiple?: Multiple;
+    /** Make the input required in the form */
+    required?: boolean;
+    /** Disable the component */
+    disabled?: boolean;
+    /** The input will be displayed in full width */
+    block?: boolean;
+    /**
+     * The autocomplete attribute of the input
+     * @default 'off'
+     */
+    autocomplete?: string;
+    /**
+     * The translations of the component
+     * @type {Partial<MazUiTranslationsNestedSchema['select']>}
+     * @default {
+     *   searchPlaceholder: 'Search in options',
+     * }
+     */
+    translations?: Partial<MazUiTranslationsNestedSchema['select']>;
+    /**
+     * The function to format the input value
+     * @type {(value: Multiple extends true ? Value[] : Value) => string}
+     * @default undefined
+     */
+    formatInputValue?: (value: Multiple extends true ? Value[] : Value) => string;
+    /**
+     * The transition name of the panel list options
+     * @type {MazPopoverProps['transition']}
+     * @default 'scale-fade'
+     */
+    transition?: MazPopoverProps['transition'];
+}
+declare const _default: <Option extends MazSelectOption, Value extends MazInputValue, Multiple extends boolean>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onBlur?: ((value: Event) => any) | undefined;
+        readonly onChange?: ((value: Event) => any) | undefined;
+        readonly onClose?: (() => any) | undefined;
+        readonly onFocus?: ((value?: Event | undefined) => any) | undefined;
+        readonly onInput?: ((value: Event) => any) | undefined;
+        readonly onOpen?: (() => any) | undefined;
+        readonly "onUpdate:model-value"?: ((value: Multiple extends true ? Value[] : Value) => any) | undefined;
+        readonly "onUpdate:open"?: ((value: boolean) => any) | undefined;
+        readonly "onSelected-option"?: ((value: Option) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onFocus" | "onBlur" | "onChange" | "onInput" | "onClose" | "onOpen" | "onUpdate:model-value" | "onUpdate:open" | "onSelected-option"> & ({
+        open?: boolean;
+    } & MazSelectProps<Value, Option, Multiple> & {
+        multiple?: boolean;
+    }) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        /**
+         * Open the select
+         * @description This is used to open the list options
+         */
+        open: () => void;
+        /**
+         * Close the select
+         * @description This is used to close the list options
+         */
+        close: () => void;
+    }>): void;
+    attrs: any;
+    slots: {
+        'left-icon'?(_: {
+            isOpen: boolean;
+            close: () => void;
+            open: () => void;
+            toggle: () => void;
+        }): any;
+        'right-icon'?(_: {
+            isOpen: boolean;
+            close: () => void;
+            open: () => void;
+            toggle: () => void;
+        }): any;
+        'no-results'?(_: {}): any;
+        optgroup?(_: {
+            label: string | number | true;
+        }): any;
+        default?(_: {
+            option: Option;
+            isSelected: boolean;
+            isOpen: boolean;
+            close: () => void;
+            open: () => void;
+            toggle: () => void;
+        }): any;
+    };
+    emit: (((evt: "blur", value: Event) => void) & ((evt: "change", value: Event) => void) & ((evt: "close") => void) & ((evt: "focus", value?: Event | undefined) => void) & ((evt: "input", value: Event) => void) & ((evt: "open") => void) & ((evt: "update:model-value", value: Multiple extends true ? Value[] : Value) => void) & ((evt: "selected-option", value: Option) => void)) & ((evt: "update:open", value: boolean) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/MazSelectCountry.vue.d.ts

@@ -0,0 +1,171 @@
+import { MazUiTranslationsNestedSchema } from '@maz-ui/translations';
+import { HTMLAttributes } from 'vue';
+import { CodesType, DisplayNameCode, DisplayNamesOptions } from '../composables/useDisplayNames';
+import { MazPopoverProps } from './MazPopover.vue';
+import { MazSelectProps } from './MazSelect.vue';
+import { MazColor, MazSize } from './types';
+export interface MazSelectCountryProps<Option extends {
+    name: string;
+    code: DisplayNameCode | string;
+} = {
+    name: string;
+    code: string;
+}> extends Omit<MazSelectProps<Option['code'], Option, false>, 'options' | 'multiple'> {
+    /**
+     * Style attribut of the component root element
+     * @type {HTMLAttributes['style']}
+     */
+    style?: HTMLAttributes['style'];
+    /**
+     * Class attribut of the component root element
+     * @type {HTMLAttributes['class']}
+     */
+    class?: HTMLAttributes['class'];
+    /**
+     * Id of the component
+     */
+    id?: string;
+    /**
+     * Color of the component
+     * @type {MazColor}
+     * @default primary
+     */
+    color?: MazColor;
+    /**
+     * Size of the component
+     * @type {MazSize}
+     * @default md
+     */
+    size?: MazSize;
+    /**
+     * Preferred countries to display
+     * @type {Option['code'][]}
+     */
+    preferredCodes?: Option['code'][];
+    /**
+     * Ignored countries to display
+     * @type {Option['code'][]}
+     */
+    ignoredCodes?: Option['code'][];
+    /**
+     * Only countries to display
+     * @type {Option['code'][]}
+     */
+    onlyCodes?: Option['code'][];
+    /**
+     * Position of the list
+     * @type {MazPopoverProps['position']}
+     * @default 'auto'
+     */
+    listPosition?: MazPopoverProps['position'];
+    /**
+     * Hide flags
+     */
+    hideFlags?: boolean;
+    /**
+     * Display search input in options list
+     * @type {boolean}
+     * @default true
+     */
+    search?: boolean;
+    /**
+     * Show code on list
+     * @default false
+     */
+    showCodeInList?: boolean;
+    /**
+     * Locale
+     * @type {string}
+     * @default locale defined within the maz-ui plugin or browser locale or en-US
+     */
+    locale?: string;
+    /**
+     * Success state
+     */
+    success?: boolean;
+    /**
+     * Error state
+     */
+    error?: boolean;
+    /**
+     * Warning state
+     */
+    warning?: boolean;
+    /**
+     *
+     */
+    displayCode?: boolean;
+    /**
+     * Search threshold
+     */
+    searchThreshold?: number;
+    /**
+     * Translations
+     * @type {Partial<MazUiTranslationsNestedSchema['selectCountry']>}
+     * @default MazUiTranslationsNestedSchema['selectCountry']
+     */
+    translations?: Partial<MazUiTranslationsNestedSchema['selectCountry']>;
+    /**
+     * Hint message displayed
+     */
+    hint?: string;
+    /**
+     * Options
+     * @type {Option[]}
+     */
+    options?: Option[];
+    /**
+     * Display name type
+     * @type {Intl.DisplayNamesOptions}
+     * @default { type: 'region', languageDisplay: 'standard', fallback: 'code', style: 'long' }
+     */
+    displayNamesOptions?: DisplayNamesOptions;
+    /**
+     * Codes type
+     * @type {CodesType}
+     * @default defined by displayNamesOptions.type (if 'region', 'country' is used, otherwise 'iso')
+     * @values 'iso' | 'bcp' | 'country' | 'all'
+     */
+    codesType?: CodesType;
+    /**
+     * Open the select
+     * @type {boolean}
+     * @default false
+     */
+    open?: boolean;
+}
+declare const _default: <Option extends {
+    name: string;
+    code: DisplayNameCode | string;
+}>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:model-value"?: ((value?: Option["code"] | undefined) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:model-value"> & MazSelectCountryProps<Option> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        'selector-flag'?(_: {
+            countryCode: Option["code"] | undefined;
+        }): any;
+        'no-results'?(_: {}): any;
+        'country-list-flag'?(_: {
+            option: Option;
+            isSelected: boolean;
+        }): any;
+        'country-list-code'?(_: {
+            option: Option;
+            isSelected: boolean;
+        }): any;
+        'country-list-name'?(_: {
+            option: Option;
+            isSelected: boolean;
+        }): any;
+    };
+    emit: (evt: "update:model-value", value?: Option["code"] | undefined) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/MazSlider/utils.d.ts

@@ -0,0 +1,15 @@
+interface IPosObject {
+    x: number;
+    y: number;
+}
+export declare function getOffset(elem: HTMLDivElement): IPosObject;
+/**
+ * Get the position of the mouse/finger in the element
+ * @param e Trigger event
+ * @param elem Container element
+ * @param isReverse From the right/bottom
+ */
+export declare function getPos(e: MouseEvent | TouchEvent, elem: HTMLDivElement, isReverse?: boolean): IPosObject;
+export declare function isBetween(value: number, prev: number, next: number, direction: string): boolean;
+export declare function getOpacityCoeff(index: number, middle: number, length: number): number;
+export {};

package/dist/components/MazSlider.vue.d.ts

@@ -0,0 +1,31 @@
+import { MazColor } from './types';
+export interface MazSliderProps {
+    /** Array of cursors values */
+    modelValue: number | number[] | undefined | null;
+    /** array of cursors label */
+    labels?: string[];
+    /** min value of sliders */
+    min?: number;
+    /** max value of sliders */
+    max?: number;
+    /** step value for slider increments */
+    step?: number;
+    /** height size of slider bar */
+    size?: string;
+    /** remove div in different colors */
+    divider?: boolean;
+    /** become a logarithmic slider (exponential) */
+    log?: boolean;
+    /** main slider color */
+    color?: MazColor;
+    /** disables cursor animation when active */
+    cursorAnim?: boolean;
+}
+declare const _default: import('vue').DefineComponent<MazSliderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:model-value": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<MazSliderProps> & Readonly<{
+    "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    MazSlider: HTMLDivElement;
+}, any>;
+export default _default;

package/dist/components/MazSpinner.vue.d.ts

@@ -0,0 +1,15 @@
+import { MazColor } from './types';
+export interface MazSpinnerProps {
+    /**
+     * The size of the spinner
+     * @default 2em
+     */
+    size?: string;
+    /**
+     * The color of the spinner
+     * @default theme
+     */
+    color?: MazColor;
+}
+declare const _default: import('vue').DefineComponent<MazSpinnerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<MazSpinnerProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, SVGSVGElement>;
+export default _default;

package/dist/components/MazStepper.vue.d.ts

@@ -0,0 +1,60 @@
+import { IconComponent } from '@maz-ui/icons';
+import { MazColor } from './types';
+export interface MazStepperStep {
+    title?: string;
+    subtitle?: string;
+    titleInfo?: string;
+    disabled?: boolean;
+    error?: boolean;
+    success?: boolean;
+    warning?: boolean;
+    icon?: string | IconComponent;
+}
+export interface MazStepperProps {
+    /** The current step */
+    modelValue?: number;
+    /** The steps */
+    steps?: MazStepperStep[];
+    /**
+     * The color of the stepper
+     * @default primary
+     */
+    color?: MazColor;
+    /** Disable the next steps */
+    disabledNextSteps?: boolean;
+    /** Disable the previous steps */
+    disabledPreviousSteps?: boolean;
+    /** Auto validate the steps */
+    autoValidateSteps?: boolean;
+    /** Open all steps */
+    allStepsOpened?: boolean;
+    /** Validate all steps */
+    allStepsValidated?: boolean;
+    /** Allow to close the steps */
+    canCloseSteps?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<`icon-${number}`, (_: {}) => any>> & Partial<Record<`title-${number}`, (_: {}) => any>> & Partial<Record<`subtitle-${number}`, (_: {}) => any>> & Partial<Record<`title-info-${number}`, (_: {}) => any>> & Partial<Record<`content-${number}`, (_: {
+        validated: boolean;
+        error: boolean | undefined;
+        warning: boolean | undefined;
+        nextStep: () => void;
+        previousStep: () => void;
+    }) => any>>;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<MazStepperProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:model-value": (value: number) => any;
+}, string, import('vue').PublicProps, Readonly<MazStepperProps> & Readonly<{
+    "onUpdate:model-value"?: ((value: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MazSwitch.vue.d.ts

@@ -0,0 +1,69 @@
+import { HTMLAttributes } from 'vue';
+import { MazColor } from './types';
+export interface MazSwitchProps {
+    /** Style attribut of the component root element */
+    style?: HTMLAttributes['style'];
+    /** Class attribut of the component root element */
+    class?: HTMLAttributes['class'];
+    /** The model value of the switch */
+    modelValue?: boolean;
+    /** The id of the switch */
+    id?: string;
+    /** If the switch is disabled */
+    disabled?: boolean;
+    /** The name of the switch */
+    name?: string;
+    /** Text label */
+    label?: string;
+    /** The color of the switch */
+    color?: MazColor;
+    /** Whether there is an error with the input. */
+    error?: boolean;
+    /** Whether the input is successful. */
+    success?: boolean;
+    /** Whether there is a warning with the input. */
+    warning?: boolean;
+    /** The hint text to display below the input. */
+    hint?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            value: boolean;
+        }): any;
+    };
+    refs: {
+        inputRef: HTMLInputElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<MazSwitchProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    blur: (value: FocusEvent) => any;
+    change: (value: boolean) => any;
+    focus: (value: FocusEvent) => any;
+    "update:model-value": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<MazSwitchProps> & Readonly<{
+    onBlur?: ((value: FocusEvent) => any) | undefined;
+    onChange?: ((value: boolean) => any) | undefined;
+    onFocus?: ((value: FocusEvent) => any) | undefined;
+    "onUpdate:model-value"?: ((value: boolean) => any) | undefined;
+}>, {
+    name: string;
+    style: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+    class: HTMLAttributes["class"];
+    color: MazColor;
+    disabled: boolean;
+    id: string;
+    modelValue: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    inputRef: HTMLInputElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};