maz-ui 2.3.12 → 3.0.0-beta.13

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

@@ -0,0 +1,47 @@
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    currency: {
+        type: StringConstructor;
+        default: string;
+    };
+    locale: {
+        type: StringConstructor;
+        default: string;
+    };
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+}, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:model-value" | "formatted")[], "update:model-value" | "formatted", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    modelValue?: unknown;
+    currency?: unknown;
+    locale?: unknown;
+    min?: unknown;
+    max?: unknown;
+} & {
+    currency: string;
+    locale: string;
+    min: number;
+    max: number;
+} & {
+    modelValue?: string | number | undefined;
+}> & {
+    "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
+    onFormatted?: ((...args: any[]) => any) | undefined;
+}, {
+    modelValue: string | number;
+    currency: string;
+    locale: string;
+    min: number;
+    max: number;
+}>;
+export default _default;

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

@@ -0,0 +1,69 @@
+import { Prop } from 'vue';
+import { Image } from './types';
+declare const _default: import("vue").DefineComponent<{
+    image: Prop<Image, Image>;
+    noPhoto: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    noLoader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    noObserverOnce: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loadOnce: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    imageHeightFull: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    observerOptions: Prop<{
+        root?: HTMLElement | null | undefined;
+        threshold?: number | undefined;
+        rootMargin?: string | undefined;
+    } | undefined, {
+        root?: HTMLElement | null | undefined;
+        threshold?: number | undefined;
+        rootMargin?: string | undefined;
+    } | undefined>;
+}, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("intersecting" | "loading" | "loaded" | "error")[], "intersecting" | "loading" | "loaded" | "error", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    image?: unknown;
+    noPhoto?: unknown;
+    noLoader?: unknown;
+    noObserverOnce?: unknown;
+    loadOnce?: unknown;
+    imageHeightFull?: unknown;
+    observerOptions?: unknown;
+} & {
+    noPhoto: boolean;
+    noLoader: boolean;
+    noObserverOnce: boolean;
+    loadOnce: boolean;
+    imageHeightFull: boolean;
+} & {
+    observerOptions?: {
+        root?: HTMLElement | null | undefined;
+        threshold?: number | undefined;
+        rootMargin?: string | undefined;
+    } | undefined;
+    image?: Image | undefined;
+}> & {
+    onIntersecting?: ((...args: any[]) => any) | undefined;
+    onLoading?: ((...args: any[]) => any) | undefined;
+    onLoaded?: ((...args: any[]) => any) | undefined;
+    onError?: ((...args: any[]) => any) | undefined;
+}, {
+    noPhoto: boolean;
+    noLoader: boolean;
+    noObserverOnce: boolean;
+    loadOnce: boolean;
+    imageHeightFull: boolean;
+}>;
+export default _default;

package/types/components/MazPhoneNumberInput/constantes/locales.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    countrySelector: {
+        placeholder: string;
+        error: string;
+    };
+    phoneInput: {
+        placeholder: string;
+        example: string;
+    };
+};
+export default _default;

package/types/components/MazPhoneNumberInput/index.vue.d.ts

@@ -0,0 +1,195 @@
+import type { CountryCode } from 'libphonenumber-js';
+import { PropType } from 'vue';
+import { Color, Position, Size } from '../types';
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: StringConstructor;
+        validator: (prop: string) => boolean;
+        default: undefined;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultPhoneNumber: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultCountryCode: {
+        type: PropType<CountryCode>;
+        default: undefined;
+        validator: (code: CountryCode) => boolean;
+    };
+    preferredCountries: {
+        type: PropType<CountryCode[]>;
+        default: undefined;
+    };
+    ignoredCountries: {
+        type: PropType<CountryCode[]>;
+        default: undefined;
+    };
+    onlyCountries: {
+        type: PropType<CountryCode[]>;
+        default: undefined;
+    };
+    translations: {
+        type: PropType<{
+            countrySelector: {
+                placeholder: string;
+                error: string;
+            };
+            phoneInput: {
+                placeholder: string;
+                example: string;
+            };
+        }>;
+        default: undefined;
+    };
+    listPosition: {
+        type: PropType<Position>;
+        default: string;
+        validator: (value: Position) => boolean;
+    };
+    color: {
+        type: PropType<Color>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    size: {
+        type: PropType<Size>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    noFlags: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    noExample: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    noSearch: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    noUseBrowserLocale: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    fetchCountry: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    noCountrySelector: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showCodeOnList: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    error: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update" | "update:model-value" | "country-code")[], "update" | "update:model-value" | "country-code", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    modelValue?: unknown;
+    id?: unknown;
+    placeholder?: unknown;
+    defaultPhoneNumber?: unknown;
+    defaultCountryCode?: unknown;
+    preferredCountries?: unknown;
+    ignoredCountries?: unknown;
+    onlyCountries?: unknown;
+    translations?: unknown;
+    listPosition?: unknown;
+    color?: unknown;
+    size?: unknown;
+    noFlags?: unknown;
+    disabled?: unknown;
+    noExample?: unknown;
+    noSearch?: unknown;
+    noUseBrowserLocale?: unknown;
+    fetchCountry?: unknown;
+    noCountrySelector?: unknown;
+    showCodeOnList?: unknown;
+    error?: unknown;
+} & {
+    listPosition: Position;
+    color: Color;
+    size: Size;
+    noFlags: boolean;
+    disabled: boolean;
+    noExample: boolean;
+    noSearch: boolean;
+    noUseBrowserLocale: boolean;
+    fetchCountry: boolean;
+    noCountrySelector: boolean;
+    showCodeOnList: boolean;
+    error: boolean;
+} & {
+    id?: string | undefined;
+    modelValue?: string | undefined;
+    placeholder?: string | undefined;
+    defaultPhoneNumber?: string | undefined;
+    defaultCountryCode?: CountryCode | undefined;
+    preferredCountries?: CountryCode[] | undefined;
+    ignoredCountries?: CountryCode[] | undefined;
+    onlyCountries?: CountryCode[] | undefined;
+    translations?: {
+        countrySelector: {
+            placeholder: string;
+            error: string;
+        };
+        phoneInput: {
+            placeholder: string;
+            example: string;
+        };
+    } | undefined;
+}> & {
+    onUpdate?: ((...args: any[]) => any) | undefined;
+    "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
+    "onCountry-code"?: ((...args: any[]) => any) | undefined;
+}, {
+    id: string;
+    modelValue: string;
+    placeholder: string;
+    defaultPhoneNumber: string;
+    defaultCountryCode: CountryCode;
+    preferredCountries: CountryCode[];
+    ignoredCountries: CountryCode[];
+    onlyCountries: CountryCode[];
+    translations: {
+        countrySelector: {
+            placeholder: string;
+            error: string;
+        };
+        phoneInput: {
+            placeholder: string;
+            example: string;
+        };
+    };
+    listPosition: Position;
+    color: Color;
+    size: Size;
+    noFlags: boolean;
+    disabled: boolean;
+    noExample: boolean;
+    noSearch: boolean;
+    noUseBrowserLocale: boolean;
+    fetchCountry: boolean;
+    noCountrySelector: boolean;
+    showCodeOnList: boolean;
+    error: boolean;
+}>;
+export default _default;

package/types/components/MazPhoneNumberInput/types.d.ts

@@ -0,0 +1,19 @@
+import { CountryCallingCode, CountryCode, NationalNumber, NumberType } from 'libphonenumber-js';
+import locales from './constantes/locales';
+export declare type Result = {
+    isValid: boolean;
+    countryCode?: CountryCode;
+    countryCallingCode?: CountryCallingCode;
+    nationalNumber?: NationalNumber;
+    type?: NumberType;
+    formatInternational?: string;
+    formatNational?: string;
+    uri?: string;
+    e164?: string;
+};
+export declare type Translations = typeof locales;
+export declare type Country = {
+    iso2: CountryCode;
+    dialCode: CountryCallingCode;
+    name: string;
+};

package/types/components/MazPhoneNumberInput/utils/countries-name-list-by-iso-code.d.ts

@@ -0,0 +1,3 @@
+export declare const countriesNameListByIsoCode: {
+    [key: string]: string;
+};

package/types/components/MazPhoneNumberInput/utils/index.d.ts

@@ -0,0 +1,15 @@
+import { CountryCode, Examples } from 'libphonenumber-js';
+import { Country, Result } from '../types';
+export declare function getCountryName(code: CountryCode | string): string | undefined;
+export declare function loadPhoneNumberExamplesFile(): Promise<Examples>;
+export declare function getExamplePhoneNumber(countryCode: CountryCode): import("libphonenumber-js").PhoneNumber | undefined;
+export declare function sanitizePhoneNumber(input?: string): string | undefined;
+export declare function getCountriesList(): Country[] | undefined;
+export declare function browserLocale(): string | undefined;
+export declare function isCountryAvailable(locale: string): boolean;
+export declare const getResultsFromPhoneNumber: (countryCode?: CountryCode | undefined, phoneNumber?: string | undefined) => Result;
+export declare function getAsYouTypeFormat(countryCode: CountryCode, phoneNumber?: string): string | undefined;
+export declare function fetchCountryCode(): Promise<string | undefined>;
+declare type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
+export declare function truthyFilter<T>(value: T): value is Truthy<T>;
+export {};

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

@@ -0,0 +1,110 @@
+import { PropType } from 'vue';
+import { Color, ModelValueSimple, Position, Size } from './types';
+export declare type MazSelectOptions = Record<string, ModelValueSimple>;
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: PropType<ModelValueSimple>;
+        default: undefined;
+    };
+    options: {
+        type: PropType<MazSelectOptions[]>;
+        required: true;
+    };
+    optionValueKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    optionLabelKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    optionInputValueKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    listPosition: {
+        type: PropType<Position>;
+        default: string;
+        validator: (value: Position) => boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    open: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    color: {
+        type: PropType<Color>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    itemHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxListHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxListWidth: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    size: {
+        type: PropType<Size>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+}, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "open" | "update:model-value" | "blur")[], "close" | "open" | "update:model-value" | "blur", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    modelValue?: unknown;
+    options?: unknown;
+    optionValueKey?: unknown;
+    optionLabelKey?: unknown;
+    optionInputValueKey?: unknown;
+    listPosition?: unknown;
+    disabled?: unknown;
+    open?: unknown;
+    color?: unknown;
+    itemHeight?: unknown;
+    maxListHeight?: unknown;
+    maxListWidth?: unknown;
+    size?: unknown;
+} & {
+    open: boolean;
+    options: MazSelectOptions[];
+    optionValueKey: string;
+    optionLabelKey: string;
+    optionInputValueKey: string;
+    listPosition: Position;
+    disabled: boolean;
+    color: Color;
+    itemHeight: number;
+    maxListHeight: number;
+    size: Size;
+} & {
+    modelValue?: ModelValueSimple;
+    maxListWidth?: number | undefined;
+}> & {
+    onClose?: ((...args: any[]) => any) | undefined;
+    onOpen?: ((...args: any[]) => any) | undefined;
+    "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
+    onBlur?: ((...args: any[]) => any) | undefined;
+}, {
+    open: boolean;
+    modelValue: ModelValueSimple;
+    optionValueKey: string;
+    optionLabelKey: string;
+    optionInputValueKey: string;
+    listPosition: Position;
+    disabled: boolean;
+    color: Color;
+    itemHeight: number;
+    maxListHeight: number;
+    maxListWidth: number;
+    size: Size;
+}>;
+export default _default;

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

@@ -0,0 +1,25 @@
+import { PropType } from 'vue';
+import { Color } from './types';
+declare const _default: import("vue").DefineComponent<{
+    size: {
+        type: StringConstructor;
+        default: string;
+    };
+    color: {
+        type: PropType<Color>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+}, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    size?: unknown;
+    color?: unknown;
+} & {
+    size: string;
+    color: Color;
+} & {}>, {
+    size: string;
+    color: Color;
+}>;
+export default _default;

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

@@ -0,0 +1,4 @@
+declare const _default: import("vue").DefineComponent<{}, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
+export default _default;

package/types/components/index.d.ts

@@ -0,0 +1,18 @@
+export { default as MazArrowIcon } from './MazArrowIcon.vue';
+export { default as MazAvatar } from './MazAvatar.vue';
+export { default as MazBackDrop } from './MazBackDrop.vue';
+export { default as MazBottomSheet } from './MazBottomSheet.vue';
+export { default as MazBtn } from './MazBtn.vue';
+export { default as MazCheckbox } from './MazCheckbox.vue';
+export { default as MazDialog } from './MazDialog.vue';
+export { default as MazDropzone } from './MazDropzone/index.vue';
+export { default as MazCard } from './MazCard.vue';
+export { default as MazGallery } from './MazGallery.vue';
+export { default as MazIcon } from './MazIcon.vue';
+export { default as MazInput } from './MazInput.vue';
+export { default as MazInputPrice } from './MazInputPrice.vue';
+export { default as MazLazyImg } from './MazLazyImg.vue';
+export { default as MazPhoneNumberInput } from './MazPhoneNumberInput/index.vue';
+export { default as MazSelect } from './MazSelect.vue';
+export { default as MazSpinner } from './MazSpinner.vue';
+export { default as MazTransitionExpand } from './MazTransitionExpand.vue';

package/types/components/types.d.ts

@@ -0,0 +1,50 @@
+import Dropzone, { DropzoneFile, DropzoneOptions } from 'dropzone';
+import { ComponentPublicInstance } from 'vue';
+export declare type ModelValueSimple = string | number | null | undefined | boolean;
+export declare type MazGalleryImage = {
+    slug: string;
+    alt?: string;
+} | string;
+export declare type Color = 'primary' | 'secondary' | 'info' | 'success' | 'warning' | 'danger' | 'white' | 'black' | 'transparent';
+export declare const colors: Color[];
+export declare type Size = 'mini' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export declare type Position = 'top' | 'top right' | 'top left' | 'bottom' | 'bottom right' | 'bottom left';
+export interface Source {
+    srcset?: string;
+    media?: string;
+}
+export interface DataImage {
+    sources?: Source[];
+}
+export declare type Image = DataImage | string;
+export interface MazDropzoneOptions extends DropzoneOptions {
+    dictFilesDescriptions?: string;
+    autoRemoveOnError?: boolean;
+}
+export interface MazDropzoneFile extends DropzoneFile {
+    manuallyAdded?: boolean;
+}
+export interface IMazDropzone extends Dropzone {
+    options: MazDropzoneOptions;
+}
+export interface MazDropzoneInstance extends ComponentPublicInstance {
+    manuallyAddFile: (file: DropzoneFile, fileUrl: string) => void;
+    setOption: (option: string, value: any) => IMazDropzone['options'];
+    processQueue: IMazDropzone['processQueue'];
+    removeFile: IMazDropzone['removeFile'];
+    removeAllFiles: IMazDropzone['removeAllFiles'];
+    destroy: IMazDropzone['destroy'];
+    disable: IMazDropzone['disable'];
+    enable: IMazDropzone['enable'];
+    accept: IMazDropzone['accept'];
+    addFile: IMazDropzone['addFile'];
+    resizeImage: IMazDropzone['resizeImage'];
+    cancelUpload: IMazDropzone['cancelUpload'];
+    getAcceptedFiles: () => MazDropzoneFile[];
+    getRejectedFiles: () => MazDropzoneFile[];
+    getFilesWithStatus: IMazDropzone['getFilesWithStatus'];
+    getQueuedFiles: IMazDropzone['getQueuedFiles'];
+    getUploadingFiles: IMazDropzone['getUploadingFiles'];
+    getAddedFiles: IMazDropzone['getAddedFiles'];
+    getActiveFiles: IMazDropzone['getActiveFiles'];
+}

package/types/components_tmp/MazCalendar/types.d.ts

@@ -0,0 +1,16 @@
+export interface DaySlot {
+    start: string;
+    end: string;
+    options?: {
+        badge?: number;
+        highlighted?: boolean;
+        warning?: boolean;
+        blocked?: boolean;
+        disabled?: boolean;
+    };
+    extra?: Record<string, any>;
+}
+export interface Day {
+    date: string;
+    slots?: DaySlot[];
+}

package/types/components_tmp/MazChart/includes.d.ts

@@ -0,0 +1,11 @@
+export declare const chartJsEventNames: string[];
+export declare function generateEventObject(type: string, chartRef?: HTMLCanvasElement): {
+    type: string;
+    chartRef: HTMLCanvasElement | undefined;
+    preventDefault(): void;
+    isDefaultPrevented(): boolean;
+    _defaultPrevented: boolean;
+};
+export declare function generateChartJsEventListener(emit: (event: string, ...args: any[]) => void, event: ReturnType<typeof generateEventObject>): {
+    [x: string]: () => boolean;
+};

package/types/components_tmp/MazMap/map-module/create-html-marker.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="google.maps" />
+interface OffsetPosition {
+    x: number;
+    y: number;
+}
+export interface HTMLMarker extends google.maps.OverlayView {
+    remove(): void;
+    getPosition(): google.maps.LatLng | null | undefined;
+    getDraggable(): boolean;
+}
+export declare const createHTMLMarker: (options: {
+    api: typeof google;
+    map: google.maps.Map;
+    templateHtml: string;
+    position: google.maps.LatLng | google.maps.LatLngLiteral;
+    offset?: OffsetPosition;
+}) => HTMLMarker;
+export {};

package/types/components_tmp/MazMap/map-module/map.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="google.maps" />
+import { HTMLMarker } from './create-html-marker';
+import { ScriptOptions } from './script-loader';
+export declare type MapOptions = google.maps.MapOptions;
+export interface MapMarker extends google.maps.MarkerOptions {
+    infoWindow?: google.maps.InfoWindowOptions;
+}
+export interface MarkerInfoWindowOptions extends google.maps.InfoWindowOptions {
+    offset?: {
+        x: number;
+        y: number;
+    };
+}
+export interface MapHTMLMarker {
+    position: google.maps.LatLng | google.maps.LatLngLiteral;
+    templateHtml: string;
+    offset?: {
+        x: number;
+        y: number;
+    };
+    infoWindow?: MarkerInfoWindowOptions;
+}
+export declare class Map {
+    private readonly mapContainerId;
+    private readonly apiKey;
+    private readonly options?;
+    private api;
+    private map;
+    private markers;
+    private htmlMarkers;
+    private mapOptions;
+    constructor(mapContainerId: string, apiKey: string, options?: google.maps.MapOptions | undefined);
+    init(options?: ScriptOptions): Promise<void>;
+    private getInfoWindow;
+    private addInfoWindowContentToMarker;
+    addMarker({ infoWindow, ...arguments_ }: MapMarker): google.maps.Marker;
+    addHTMLMarker({ position, templateHtml, offset, infoWindow, }: MapHTMLMarker): HTMLMarker;
+    get allMarkers(): (google.maps.Marker | HTMLMarker)[];
+    fitOnAllMarkers(): void;
+    removeAllMarkers(): void;
+}
+export * from './script-loader';
+export * from './create-html-marker';