maz-ui 3.50.1 → 4.0.0-alpha.2

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

@@ -0,0 +1,32 @@
+export interface UseWindowSizeOptions {
+    /**
+     * The window object to use
+     * @default window - in browser, undefined in SSR
+     */
+    internalWindow?: Window | undefined;
+    /**
+     * Initial width of the window (useful in SSR)
+     * @default Number.POSITIVE_INFINITY
+     */
+    initialWidth?: number;
+    /**
+     * Initial height of the window (useful in SSR)
+     * @default Number.POSITIVE_INFINITY
+     */
+    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;
+}
+export declare function useWindowSize(options?: UseWindowSizeOptions): {
+    width: import('vue').Ref<number, number>;
+    height: import('vue').Ref<number, number>;
+};

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

@@ -0,0 +1,10 @@
+declare const plugin: {
+    install(app: import('vue').App<any>): void;
+};
+export * from './vClickOutside';
+export * from './vClosable';
+export * from './vFullscreenImg';
+export * from './vLazyImg';
+export * from './vTooltip';
+export * from './vZoomImg';
+export { plugin as installDirectives };

package/dist/types/directives/vClickOutside.d.ts

@@ -0,0 +1,15 @@
+import { DirectiveBinding } from 'vue';
+type vClickOutsideBindingValue = (...args: any[]) => any;
+type vClickOutsideDirectiveBinding = DirectiveBinding<vClickOutsideBindingValue>;
+declare function onMounted(el: HTMLElement, binding: vClickOutsideDirectiveBinding): Promise<void>;
+declare function onUnmounted(el: HTMLElement): void;
+declare function onUpdated(el: HTMLElement, binding: vClickOutsideDirectiveBinding): void;
+declare const directive: {
+    mounted: typeof onMounted;
+    updated: typeof onUpdated;
+    unmounted: typeof onUnmounted;
+};
+declare const plugin: {
+    install: (app: import('vue').App<any>) => void;
+};
+export { directive as vClickOutside, vClickOutsideBindingValue, plugin as vClickOutsideInstall };

package/dist/types/directives/vClosable.d.ts

@@ -0,0 +1,18 @@
+import { DirectiveBinding } from 'vue';
+type vClosableBindingValueHandler = (event: Event) => any;
+interface vClosableBindingValueObject {
+    handler: vClosableBindingValueHandler;
+    exclude?: string[];
+}
+type vClosableBindingValue = vClosableBindingValueObject | vClosableBindingValueHandler;
+type vClosableBinding = DirectiveBinding<vClosableBindingValue>;
+declare function unbind(element: HTMLElement, binding: vClosableBinding): void;
+declare function bind(element: HTMLElement, binding: vClosableBinding): void;
+declare const directive: {
+    mounted: typeof bind;
+    unmounted: typeof unbind;
+};
+declare const plugin: {
+    install: (app: import('vue').App<any>) => void;
+};
+export { directive as vClosable, vClosableBindingValue, plugin as vClosableInstall };

package/dist/types/directives/vFullscreenImg/MazFullscreenImg.vue.d.ts

@@ -0,0 +1,47 @@
+export interface MazFullscreenImgProps {
+    src: string;
+    clickedElementBounds?: {
+        top: number;
+        left: number;
+        height: number;
+        width: number;
+    };
+    offset?: number;
+    animation?: {
+        duration?: number;
+        easing?: string;
+    };
+    openInstanceClass?: string;
+    clickedElement: HTMLElement;
+    destroy?: () => void;
+    alt?: string | null;
+    zoom?: boolean;
+}
+declare const _default: import('vue').DefineComponent<MazFullscreenImgProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+    "before-close": (...args: any[]) => void;
+    next: (...args: any[]) => void;
+    previous: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<MazFullscreenImgProps> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+    "onBefore-close"?: ((...args: any[]) => any) | undefined;
+    onNext?: ((...args: any[]) => any) | undefined;
+    onPrevious?: ((...args: any[]) => any) | undefined;
+}>, {
+    destroy: () => void;
+    animation: {
+        duration?: number;
+        easing?: string;
+    };
+    alt: string | null;
+    clickedElementBounds: {
+        top: number;
+        left: number;
+        height: number;
+        width: number;
+    };
+    offset: number;
+    openInstanceClass: string;
+    zoom: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/directives/vFullscreenImg/fullscreen-img.directive.d.ts

@@ -0,0 +1,7 @@
+import { vFullscreenImgBindingValue } from './fullscreen-img.handler';
+declare const directive: {
+    mounted(el: HTMLElement, binding: import('vue').DirectiveBinding<vFullscreenImgBindingValue, string, string>): void;
+    updated(el: HTMLElement, binding: import('vue').DirectiveBinding<vFullscreenImgBindingValue, string, string>): void;
+    unmounted(el: HTMLElement): void;
+};
+export { directive as vFullscreenImg };

package/dist/types/directives/vFullscreenImg/fullscreen-img.handler.d.ts

@@ -0,0 +1,36 @@
+import { DirectiveBinding } from 'vue';
+export interface vFullscreenImgOptions {
+    disabled?: boolean;
+    scaleOnHover?: boolean;
+    blurOnHover?: boolean;
+    zoom?: boolean;
+    offset?: number;
+    animation?: {
+        duration?: number;
+        easing?: string;
+    };
+}
+interface vFullscreenImgBindingOptions extends vFullscreenImgOptions {
+    src: string;
+    alt?: string | null;
+}
+export type vFullscreenImgBindingValue = string | vFullscreenImgBindingOptions | undefined;
+export type vFullscreenImgBinding = DirectiveBinding<vFullscreenImgBindingValue>;
+export declare class FullscreenImgHandler {
+    private options;
+    private defaultOptions;
+    private mouseEnterListener;
+    private mouseLeaveListener;
+    private renderPreviewListener;
+    private buildOptions;
+    get allInstances(): HTMLElement[];
+    private getImgSrc;
+    private getImgAlt;
+    create(el: HTMLElement, binding: vFullscreenImgBinding): void;
+    update(el: HTMLElement, binding: vFullscreenImgBinding): void;
+    remove(el: HTMLElement): void;
+    private renderPreview;
+    private mouseLeave;
+    private mouseEnter;
+}
+export {};

package/dist/types/directives/vFullscreenImg.d.ts

@@ -0,0 +1,6 @@
+declare const plugin: {
+    install(app: import('vue').App<any>): void;
+};
+export { plugin as vFullscreenImgInstall };
+export { vFullscreenImg } from './vFullscreenImg/fullscreen-img.directive';
+export type { vFullscreenImgBindingValue, vFullscreenImgOptions } from './vFullscreenImg/fullscreen-img.handler';

package/dist/types/directives/vLazyImg/lazy-img.directive.d.ts

@@ -0,0 +1,7 @@
+import { vLazyImgBindingValue } from './lazy-img.handler';
+declare const directive: {
+    created(el: HTMLElement, binding: import('vue').DirectiveBinding<vLazyImgBindingValue, string, string>): void;
+    updated(el: HTMLElement, binding: import('vue').DirectiveBinding<vLazyImgBindingValue, string, string>): void;
+    unmounted(el: HTMLElement, binding: import('vue').DirectiveBinding<vLazyImgBindingValue, string, string>): void;
+};
+export { directive as vLazyImg };

package/dist/types/directives/vLazyImg/lazy-img.handler.d.ts

@@ -0,0 +1,39 @@
+import { ClassOptions, vLazyImgBinding, vLazyImgOptions } from './types';
+export * from './types';
+export declare const DEFAULT_OPTIONS: ClassOptions;
+export declare class LazyImg {
+    private observers;
+    private readonly defaultOptions;
+    private options;
+    private onImgLoadedCallback;
+    private onImgErrorCallback;
+    private hasImgLoaded;
+    constructor(opts?: vLazyImgOptions);
+    private loadErrorPhoto;
+    private buildOptions;
+    private removeClass;
+    private addClass;
+    private removeAllStateClasses;
+    private setBaseClass;
+    private imageIsLoading;
+    private imageHasNoPhoto;
+    private imageIsLoaded;
+    private imageHasError;
+    private getSrc;
+    private getImageUrl;
+    private setPictureSourceUrls;
+    private hasBgImgMode;
+    private isPictureElement;
+    private getImgElement;
+    private setDefaultPhoto;
+    private addEventListenerToImg;
+    private loadImage;
+    setImgSrc(el: HTMLElement, src: string): void;
+    private handleIntersectionObserver;
+    private createObserver;
+    private imageHandler;
+    private bindUpdateHandler;
+    add(el: HTMLElement, binding: vLazyImgBinding): Promise<void>;
+    update(el: HTMLElement, binding: vLazyImgBinding): Promise<void>;
+    remove(el: HTMLElement, binding: vLazyImgBinding): void;
+}

package/dist/types/directives/vLazyImg/types.d.ts

@@ -0,0 +1,35 @@
+import { DirectiveBinding, ObjectDirective } from 'vue';
+export interface ClassOptions {
+    baseClass: string;
+    loadingClass: string;
+    loadedClass: string;
+    errorClass: string;
+    noPhotoClass: string;
+    noPhoto: boolean;
+    noUseErrorPhoto: boolean;
+    observerOnce: boolean;
+    loadOnce: boolean;
+    observerOptions: {
+        root?: HTMLElement | null;
+        threshold: number;
+        rootMargin?: string;
+    };
+    /**
+     * @deprecated use `fallbackSrc` instead
+     */
+    errorPhoto?: string;
+    fallbackSrc?: string;
+    onLoading?: (el: Element) => unknown;
+    onLoaded?: (el: Element) => unknown;
+    onError?: (el: Element) => unknown;
+    onIntersecting?: (el: Element) => unknown;
+}
+export type vLazyImgOptions = Partial<ClassOptions>;
+interface vLazyImgBindingOptions extends vLazyImgOptions {
+    src?: string;
+    disabled?: boolean;
+}
+export type vLazyImgBindingValue = string | vLazyImgBindingOptions;
+export type vLazyImgBinding = DirectiveBinding<vLazyImgBindingValue>;
+export type vLazyImgDirective = ObjectDirective<HTMLElement, vLazyImgBinding>;
+export {};

package/dist/types/directives/vLazyImg.d.ts

@@ -0,0 +1,6 @@
+import { vLazyImgBindingValue, vLazyImgOptions } from './vLazyImg/types';
+declare const plugin: {
+    install(app: import('vue').App<any>, opts?: Partial<import('./vLazyImg/types').ClassOptions>): void;
+};
+export { vLazyImg } from './vLazyImg/lazy-img.directive';
+export { vLazyImgBindingValue, plugin as vLazyImgInstall, vLazyImgOptions };

package/dist/types/directives/vTooltip.d.ts

@@ -0,0 +1,42 @@
+import { Color } from '../components/types';
+import { DirectiveBinding } from 'vue';
+type vTooltipColor = Exclude<Color, 'transparent'> | 'default' | 'light' | 'dark';
+interface vTooltipOptions {
+    /**
+     * Position of the tooltip
+     * @default 'top'
+     */
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    /**
+     * Color of the tooltip
+     * @default 'default'
+     */
+    color?: vTooltipColor;
+}
+type vTooltipBindingValue = string | ({
+    /**
+     * Text to display in the tooltip
+     * @default ''
+     */
+    text: string;
+    /**
+     * Open the tooltip
+     * @default false
+     */
+    open?: boolean;
+    /**
+     * Offset of the tooltip
+     * @default '1rem'
+     */
+    offset?: string;
+} & vTooltipOptions);
+export type TooltipBinding = DirectiveBinding<vTooltipBindingValue>;
+declare const directive: {
+    beforeMount(el: HTMLElement, binding: DirectiveBinding<vTooltipBindingValue, string, string>): void;
+    updated(el: HTMLElement, binding: DirectiveBinding<vTooltipBindingValue, string, string>): void;
+    unmounted(el: HTMLElement, binding: DirectiveBinding<vTooltipBindingValue, string, string>): void;
+};
+declare const plugin: {
+    install: (app: import('vue').App<any>, options?: vTooltipOptions) => void;
+};
+export { directive as vTooltip, type vTooltipBindingValue, type vTooltipColor, plugin as vTooltipInstall, type vTooltipOptions, };

package/dist/types/directives/vZoomImg/zoom-img.directive.d.ts

@@ -0,0 +1,6 @@
+import { vZoomImgBindingValue } from './zoom-img.handler';
+export declare const vZoomImg: {
+    created(el: HTMLElement, binding: import('vue').DirectiveBinding<vZoomImgBindingValue, string, string>): void;
+    updated(_el: HTMLElement, binding: import('vue').DirectiveBinding<vZoomImgBindingValue, string, string>): void;
+    unmounted(el: HTMLElement): void;
+};

package/dist/types/directives/vZoomImg/zoom-img.handler.d.ts

@@ -0,0 +1,46 @@
+import { DirectiveBinding } from 'vue';
+export interface vZoomImgOptions {
+    disabled?: boolean;
+    scale?: boolean;
+    blur?: boolean;
+}
+interface vZoomImgBindingOptions extends vZoomImgOptions {
+    src: string;
+    alt?: string;
+}
+export type vZoomImgBindingValue = string | vZoomImgBindingOptions;
+export type vZoomImgBinding = DirectiveBinding<vZoomImgBindingValue>;
+export declare class VueZoomImg {
+    private options;
+    private loader;
+    private wrapper;
+    private img;
+    private keydownHandler;
+    private onImgLoadedCallback;
+    private buttonsAdded;
+    private defaultOptions;
+    private mouseEnterListener;
+    private mouseLeaveListener;
+    private renderPreviewListener;
+    constructor(binding: vZoomImgBinding);
+    private buildOptions;
+    get allInstances(): HTMLElement[];
+    create(el: HTMLElement): void;
+    update(binding: vZoomImgBinding): void;
+    remove(el: HTMLElement): void;
+    private renderPreview;
+    private onImgLoaded;
+    private getLoader;
+    private mouseLeave;
+    private mouseEnter;
+    private keydownLister;
+    private getButton;
+    private closePreview;
+    private getNewInstanceIndex;
+    private nextPreviousImage;
+    private useNextInstance;
+    private addStyle;
+    private keyboardEventHandler;
+    private imgEventHandler;
+}
+export {};

package/dist/types/directives/vZoomImg.d.ts

@@ -0,0 +1,6 @@
+import { vZoomImg } from './vZoomImg/zoom-img.directive';
+declare const plugin: {
+    install(app: import('vue').App<any>): void;
+};
+export { vZoomImg, plugin as vZoomImgInstall };
+export type { vZoomImgBindingValue } from './vZoomImg/zoom-img.handler';

package/dist/types/filters/camelCase.d.ts

@@ -0,0 +1 @@
+export declare function camelCase(str: string): string;

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

@@ -0,0 +1,26 @@
+import { App } from 'vue';
+import { camelCase } from './camelCase';
+import { capitalize } from './capitalize';
+import { currency } from './currency';
+import { date } from './date';
+import { number } from './number';
+import { pascalCase } from './pascalCase';
+declare const filters: {
+    capitalize: typeof capitalize;
+    camelCase: typeof camelCase;
+    currency: typeof currency;
+    date: typeof date;
+    number: typeof number;
+    pascalCase: typeof pascalCase;
+};
+export type Filters = typeof filters;
+declare const installFilters: {
+    install(app: App): void;
+};
+export { installFilters };
+export * from './camelCase';
+export * from './capitalize';
+export * from './currency';
+export * from './date';
+export * from './number';
+export * from './pascalCase';

package/dist/types/filters/pascalCase.d.ts

@@ -0,0 +1 @@
+export declare function pascalCase(str: string): string;

package/dist/types/helpers/countryFlagFromFlagCdn.d.ts

@@ -0,0 +1,7 @@
+import { CountryCode } from 'libphonenumber-js';
+type Ratio = '16x12' | '20x15' | '24x18' | '28x21' | '32x24' | '36x27' | '40x30' | '48x36' | '56x42' | '60x45' | '64x48' | '72x54' | '80x60' | '84x63' | '96x72' | '108x81' | '112x84' | '120x90' | '128x96' | '144x108' | '160x120' | '192x144' | '224x168' | '256x192';
+type Height = 'h20' | 'h24' | 'h40' | 'h60' | 'h80' | 'h120' | 'h240';
+type Width = 'w20' | 'w40' | 'w80' | 'w160' | 'w320' | 'w640' | 'w1280' | 'w2560';
+type Size = Ratio | Height | Width;
+export declare function countryFlagUrlFromFlagCdn(countryIsoCode: CountryCode, size?: Size): string;
+export {};

package/dist/types/helpers/freezeValue.d.ts

@@ -0,0 +1,5 @@
+import { MaybeRef } from 'vue';
+/**
+ * Freeze a value to prevent it from being modified
+ */
+export declare function freezeValue<T>(value: MaybeRef<T>): Readonly<T>;

package/dist/types/helpers/idleTimeout/idle-timeout-handler.d.ts

@@ -0,0 +1,29 @@
+import { IdleTimeoutCallback, IdleTimeoutOptions } from './types';
+export declare class IdleTimeout {
+    private readonly callback;
+    private readonly defaultOptions;
+    private options;
+    private timeoutHandler?;
+    private isIdle;
+    private isDestroy;
+    private startTime;
+    private remainingTime;
+    private lastClientX;
+    private lastClientY;
+    private eventNames;
+    constructor(callback: IdleTimeoutCallback, options?: IdleTimeoutOptions);
+    get element(): Document | HTMLElement;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    reset(): void;
+    destroy(): void;
+    private resetTimeout;
+    private handleEvent;
+    private handleTimeout;
+    get destroyed(): boolean;
+    get timeout(): number;
+    set timeout(value: number);
+    get idle(): boolean;
+    set idle(value: boolean);
+}

package/dist/types/helpers/idleTimeout/types.d.ts

@@ -0,0 +1,29 @@
+import { IdleTimeout } from './idle-timeout-handler';
+export type IdleTimeoutCallback = ({ isIdle, eventType, instance, }: {
+    isIdle: boolean;
+    eventType?: string;
+    instance: IdleTimeout;
+}) => unknown;
+export interface IdleTimeoutStrictOption {
+    /**
+     * HTMLElement to spy / watch
+     * @default undefined
+     */
+    element?: HTMLElement | Document;
+    /**
+     * Timeout duration in ms
+     * @default 60 * 1000 * 5 // 5 min
+     */
+    timeout: number;
+    /**
+     * Watch once
+     * @default false
+     */
+    once: boolean;
+    /**
+     * Watch immediately on load (make it false is useful for SSR context)
+     * @default true
+     */
+    immediate: boolean;
+}
+export type IdleTimeoutOptions = Partial<IdleTimeoutStrictOption>;

package/dist/types/helpers/idleTimeout.d.ts

@@ -0,0 +1,2 @@
+export { IdleTimeout } from './idleTimeout/idle-timeout-handler';
+export type { IdleTimeoutCallback, IdleTimeoutOptions } from './idleTimeout/types';

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

@@ -0,0 +1,21 @@
+export * from './checkAvailability';
+export * from './countryCodeToUnicodeFlag';
+export * from './countryFlagFromFlagCdn';
+export * from './debounce';
+export * from './debounceCallback';
+export * from './debounceId';
+export * from './freezeValue';
+export * from './idleTimeout';
+export * from './injectStrict';
+export * from './isClient';
+export * from './isEqual';
+export * from './isStandaloneMode';
+export * from './mountComponent';
+export * from './normalizeString';
+export * from './scriptLoader';
+export * from './sleep';
+export * from './swipeHandler';
+export * from './throttle';
+export * from './throttleId';
+export * from './truthyFilter';
+export * from './userVisibility';

package/dist/types/helpers/injectStrict.d.ts

@@ -0,0 +1,2 @@
+import { InjectionKey } from 'vue';
+export declare function injectStrict<T>(key: string | InjectionKey<T> | symbol, fallback?: T): NonNullable<T>;

package/dist/types/helpers/isStandaloneMode.d.ts

@@ -0,0 +1 @@
+export declare function isStandaloneMode(): boolean;

package/dist/types/helpers/mountComponent.d.ts

@@ -0,0 +1,14 @@
+import { App, Component, createVNode, VNodeProps } from 'vue';
+export declare function mount<T extends Component, P = Record<string, unknown>>(component: T, options?: {
+    props?: P & VNodeProps;
+    children?: Parameters<typeof createVNode>[2];
+    app?: App;
+    element?: HTMLElement;
+    addDestroyInProps?: boolean;
+}): {
+    vNode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>;
+    destroy: () => void;
+    el: HTMLElement | undefined;
+};

package/dist/types/helpers/userVisibility/user-visibility-handler.d.ts

@@ -0,0 +1,19 @@
+import { UserVisibilyCallback, UserVisibilyOptions } from './types';
+export declare class UserVisibility {
+    private readonly callback;
+    private eventHandlerFunction;
+    private event;
+    private timeoutHandler?;
+    private options;
+    private readonly defaultOptions;
+    private isVisible;
+    constructor(callback: UserVisibilyCallback, options?: UserVisibilyOptions);
+    start(): void;
+    private emitCallback;
+    private eventHandler;
+    private clearTimeout;
+    private initTimeout;
+    private addEventListener;
+    private removeEventListener;
+    destroy(): void;
+}

package/dist/types/helpers/userVisibility.d.ts

@@ -0,0 +1,2 @@
+export type { UserVisibilyCallback, UserVisibilyOptions } from './userVisibility/types';
+export { UserVisibility } from './userVisibility/user-visibility-handler';

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from './composables';
+export * from './directives';
+export * from './filters';
+export * from './helpers';
+export * from './plugins';
+export * from './resolvers';
+export * from './ts-helpers';

package/dist/types/plugins/aos.d.ts

@@ -0,0 +1,36 @@
+import { App } from 'vue';
+import { Router } from 'vue-router';
+export interface AosOptions {
+    animation?: {
+        delay?: number;
+        duration?: number;
+        once?: boolean;
+    };
+    delay?: number;
+    observer?: IntersectionObserverInit;
+    router?: Router;
+}
+interface ClassOptions extends Omit<AosOptions, 'router'> {
+    animation: {
+        delay: number;
+        duration: number;
+        once: boolean;
+    };
+    delay: number;
+    observer: IntersectionObserverInit & {
+        rootMargin: string;
+        threshold: number | number[];
+    };
+}
+export declare class AosHandler {
+    options: ClassOptions;
+    constructor(options?: Omit<AosOptions, 'router'>);
+    private handleIntersect;
+    private handleObserver;
+    runAnimations(): Promise<void> | undefined;
+}
+export declare const plugin: {
+    install: (app: App, options?: AosOptions) => void;
+};
+export declare function getInstance(): AosHandler;
+export {};

package/dist/types/plugins/dialog/DialogHandler.d.ts

@@ -0,0 +1,15 @@
+import { App } from 'vue';
+import { MazDialogPromiseProps } from '../../components/MazDialogPromise.vue';
+export type DialogOptions = Partial<Omit<MazDialogPromiseProps, 'modelValue'>> & {
+    promiseCallback?: () => unknown;
+};
+export declare class DialogHandler {
+    private readonly app;
+    private readonly globalOptions;
+    constructor(app: App, globalOptions?: DialogOptions);
+    open(options: DialogOptions): {
+        promise: Promise<unknown>;
+        destroy: () => void;
+        close: () => void;
+    };
+}

package/dist/types/plugins/dialog.d.ts

@@ -0,0 +1,6 @@
+import { App } from 'vue';
+import { DialogOptions } from './dialog/DialogHandler';
+export declare const installDialog: {
+    install(app: App, options?: DialogOptions): void;
+};
+export { DialogHandler, type DialogOptions } from './dialog/DialogHandler';