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

package/dist/plugins/aos.d.ts

@@ -0,0 +1,81 @@
+import { Plugin } from 'vue';
+import { Router } from 'vue-router';
+export interface AosOptions {
+    animation?: {
+        /**
+         * The delay of the animation
+         * @default 0
+         */
+        delay?: number;
+        /**
+         * The duration of the animation
+         * @default 300
+         */
+        duration?: number;
+        /**
+         * If true, the animation will be triggered only once
+         * @default true
+         */
+        once?: boolean;
+    };
+    /**
+     * The delay before the animation starts
+     * @default 100
+     */
+    delay?: number;
+    /**
+     * The observer options
+     * @default {
+     *   root: undefined,
+     *   rootMargin: '0px',
+     *   threshold: 0.2,
+     * }
+     */
+    observer?: IntersectionObserverInit;
+    /**
+     * The router instance to trigger the animation on route change
+     * @default undefined
+     */
+    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 AosPlugin: Plugin<[AosOptions?]>;
+declare module 'vue' {
+    interface ComponentCustomProperties {
+        /**
+         * Aos handler instance
+         * @description You should install the plugin to use this property
+         * @examl
+         * ```ts
+         * import { AosPlugin } from 'maz-ui/plugins/aos'
+         * import { createApp } from 'vue'
+         *
+         * const app = createApp(App)
+         * app.use(AosPlugin)
+         *
+         * const aos = useAos()
+         * aos.runAnimations()
+         */
+        $mazAos: AosHandler;
+    }
+}
+export declare function getAosInstance(): AosHandler;
+export {};

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

@@ -0,0 +1,16 @@
+import { App } from 'vue';
+import { MazDialogConfirmProps } from '../../components/MazDialogConfirm.vue';
+export type DialogOptions = Partial<Omit<MazDialogConfirmProps, 'modelValue' | 'variant' | 'justify'>> & {
+    onClose?: () => unknown;
+    onAccept?: (response: unknown) => unknown;
+    onReject?: (response: unknown) => unknown;
+};
+export declare class DialogHandler {
+    private readonly app;
+    readonly globalOptions: DialogOptions;
+    constructor(app: App, globalOptions?: DialogOptions);
+    open(options: DialogOptions): {
+        destroy: () => void;
+        close: () => void;
+    };
+}

package/dist/plugins/dialog.d.ts

@@ -0,0 +1,26 @@
+import { Plugin } from 'vue';
+import { DialogOptions, DialogHandler } from './dialog/DialogHandler';
+export declare const DialogPlugin: Plugin<[DialogOptions?]>;
+declare module 'vue' {
+    interface ComponentCustomProperties {
+        /**
+         * Dialog handler instance
+         * @description You should install the plugin to use this property
+         * @examl
+         * ```ts
+         * import { DialogPlugin } from 'maz-ui/plugins/dialog'
+         * import { createApp } from 'vue'
+         *
+         * const app = createApp(App)
+         * app.use(DialogPlugin)
+         *
+         * const dialog = useDialog()
+         * dialog.open({
+         *   title: 'Hello',
+         *   message: 'This is a dialog',
+         * })
+         */
+        $mazDialog: Omit<DialogHandler, 'app'>;
+    }
+}
+export { DialogHandler, type DialogOptions } from './dialog/DialogHandler';

package/dist/plugins/index.d.ts

@@ -0,0 +1,5 @@
+export { AosHandler, type AosOptions, AosPlugin, getAosInstance } from './aos';
+export { type DialogOptions, DialogPlugin } from './dialog';
+export { MazUi, type MazUiOptions } from './maz-ui';
+export { ToastHandler, type ToastOptions, ToastPlugin, type ToastPosition } from './toast';
+export { WaitHandler, waitInstance, WaitPlugin } from './wait';

package/dist/plugins/maz-ui.d.ts

@@ -0,0 +1,43 @@
+import { MazUiThemeOptions } from '@maz-ui/themes/plugin';
+import { MazUiTranslationsOptions } from '@maz-ui/translations';
+import { Plugin } from 'vue';
+export interface MazUiOptions {
+    /**
+     * The theme configurations
+     * Can not be disabled
+     */
+    theme: MazUiThemeOptions;
+    /**
+     * The translations configurations
+     * Can not be disabled
+     */
+    translations?: MazUiTranslationsOptions;
+}
+/**
+ * @example
+ * ```ts
+ * import { MazUi } from 'maz-ui/plugins/maz-ui'
+ * import { mazUi as mazUiPreset } from '@maz-ui/themes/presets/mazUi'
+ * import 'maz-ui/styles'
+ *
+ * app.use(MazUi, {
+ *   theme: {
+ *     preset: mazUiPreset,
+ *     strategy: 'hybrid',
+ *     darkMode: 'class',
+ *   },
+ *   translations: {
+ *     locale: 'en',
+ *     translations: {
+ *       en: {
+ *         ...
+ *       },
+ *       fr: {
+ *         ...
+ *       },
+ *     },
+ *   },
+ * })
+ * ```
+ */
+export declare const MazUi: Plugin<[MazUiOptions]>;

package/dist/plugins/toast/MazToast.vue.d.ts

@@ -0,0 +1,34 @@
+import { ToastOptions } from './types';
+export interface MazToastProps extends ToastOptions {
+    /**
+     * The message of the toast
+     */
+    message?: string;
+    /**
+     * The type of the toast
+     */
+    type?: ToastOptions['type'];
+    /**
+     * The function to destroy the toast
+     */
+    destroy?: () => void;
+}
+declare function closeToast(): void;
+declare const _default: import('vue').DefineComponent<MazToastProps, {
+    /**
+     * Close the toast
+     * @description This is used to close the toast
+     */
+    closeToast: typeof closeToast;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (args_0: Event) => any;
+    close: () => any;
+    open: () => any;
+}, string, import('vue').PublicProps, Readonly<MazToastProps> & Readonly<{
+    onClick?: ((args_0: Event) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    Toast: HTMLDivElement;
+}, any>;
+export default _default;

package/dist/plugins/toast/ToastHandler.d.ts

@@ -0,0 +1,29 @@
+import { App } from 'vue';
+import { ToastOptions } from './types';
+export declare class ToastHandler {
+    private readonly app;
+    private readonly globalOptions?;
+    constructor(app: App, globalOptions?: ToastOptions | undefined);
+    private show;
+    private getLocalOptions;
+    message(message: string, options?: ToastOptions): {
+        destroy: () => void;
+        close: () => any;
+    };
+    success(message: string, options?: Omit<ToastOptions, 'type'>): {
+        destroy: () => void;
+        close: () => any;
+    };
+    error(message: string, options?: Omit<ToastOptions, 'type'>): {
+        destroy: () => void;
+        close: () => any;
+    };
+    info(message: string, options?: Omit<ToastOptions, 'type'>): {
+        destroy: () => void;
+        close: () => any;
+    };
+    warning(message: string, options?: Omit<ToastOptions, 'type'>): {
+        destroy: () => void;
+        close: () => any;
+    };
+}

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

@@ -0,0 +1,104 @@
+import { IconComponent } from '@maz-ui/icons';
+import { RouteLocationRaw } from 'vue-router';
+import { MazBtnProps } from '../../components/MazBtn.vue';
+import { MazColor } from '../../components/types';
+export type ToastPosition = 'top' | 'top-right' | 'top-left' | 'bottom' | 'bottom-right' | 'bottom-left';
+export interface ToastButton extends MazBtnProps {
+    /**
+     * If the toast is closed when the button is clicked
+     * @default false
+     */
+    closeToast?: boolean;
+    /**
+     * The text of the button
+     */
+    text?: string;
+    /**
+     * The target of the button
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#attr-target
+     * @default _self
+     */
+    target?: string;
+    /**
+     * The method to call when the button is clicked
+     */
+    onClick?: () => unknown;
+    /**
+     * The route to navigate to when the button is clicked
+     * (only with `vue-router`)
+     */
+    to?: RouteLocationRaw;
+    /**
+     * The URL to navigate to when the button is clicked
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#attr-href
+     */
+    href?: string;
+    /**
+     * The size of the button
+     * @default 'xs'
+     */
+    size?: MazBtnProps['size'];
+    /**
+     * The color of the button
+     * @default color of the toast
+     */
+    color?: MazBtnProps['color'];
+}
+export interface ToastOptions {
+    /**
+     * If the message is HTML
+     * @default false
+     */
+    html?: boolean;
+    /**
+     * The type of the toast
+     * @default 'info'
+     */
+    type?: MazColor;
+    /**
+     * The maximum number of toasts to display
+     * @default false
+     */
+    maxToasts?: number | boolean;
+    /**
+     * If the toast is queued, it will be displayed in the order of the toasts
+     * @default false
+     */
+    queue?: boolean;
+    /**
+     * The position of the toast on the screen
+     * @default 'bottom-right'
+     */
+    position?: ToastPosition;
+    /**
+     * If the toast is paused on hover, it will be paused when the mouse is over the toast
+     * @default true
+     */
+    pauseOnHover?: boolean;
+    /**
+     * The timeout is in ms, it's the time before the toast is automatically closed
+     * if set to `false`, the toast will not be closed automatically
+     * @default 10000
+     */
+    timeout?: number | boolean;
+    /**
+     * If the toast is persistent, the user should close it manually
+     * @default false
+     */
+    persistent?: boolean;
+    /**
+     * Display an icon in the toast
+     * @default true
+     */
+    icon?: false | IconComponent;
+    /**
+     * The action will be displayed as a button in the toast
+     * @default undefined
+     */
+    button?: ToastButton;
+    /**
+     * The actions will be displayed as a buttons in the toast
+     * @default undefined
+     */
+    buttons?: ToastButton[];
+}

package/dist/plugins/toast.d.ts

@@ -0,0 +1,25 @@
+import { Plugin } from 'vue';
+import { ToastOptions } from './toast/types';
+import { ToastHandler } from './toast/ToastHandler';
+export declare const ToastPlugin: Plugin<[ToastOptions?]>;
+declare module 'vue' {
+    interface ComponentCustomProperties {
+        /**
+         * Toast handler instance
+         * @description You should install the plugin to use this property
+         * @example
+         * ```ts
+         * import { ToastPlugin } from 'maz-ui/plugins/toast'
+         * import { createApp } from 'vue'
+         *
+         * const app = createApp(App)
+         * app.use(ToastPlugin)
+         *
+         * const toast = useToast()
+         * toast.success('Hello, world!')
+         */
+        $mazToast: ToastHandler;
+    }
+}
+export { ToastHandler };
+export type { ToastOptions, ToastPosition } from './toast/types';

package/dist/plugins/wait.d.ts

@@ -0,0 +1,33 @@
+import { Plugin } from 'vue';
+type LoaderId = string | symbol | number;
+export declare class WaitHandler {
+    private _loaders;
+    get loaders(): import('vue').ComputedRef<LoaderId[]>;
+    stop(loaderId?: LoaderId): this;
+    start(loaderId?: LoaderId): this;
+    isLoading(loaderId?: LoaderId): boolean;
+    get anyLoading(): import('vue').ComputedRef<boolean>;
+}
+export declare const waitInstance: WaitHandler;
+export declare const WaitPlugin: Plugin;
+declare module 'vue' {
+    interface ComponentCustomProperties {
+        /**
+         * Wait handler instance
+         * @description You should install the plugin to use this property
+         * @examl
+         * ```ts
+         * import { WaitPlugin } from 'maz-ui/plugins/wait'
+         * import { createApp } from 'vue'
+         *
+         * const app = createApp(App)
+         * app.use(WaitPlugin)
+         *
+         * const wait = useWait()
+         * wait.start()
+         * ```
+         */
+        $mazWait: WaitHandler;
+    }
+}
+export {};

package/dist/resolvers/MazComponentsResolver.d.ts

@@ -0,0 +1,10 @@
+import { ComponentResolver } from 'unplugin-vue-components/types';
+/**
+ * Resolver for Maz-UI (components)
+ *
+ * @author @louismazel
+ * @link https://maz-ui.com
+ */
+export declare function MazComponentsResolver(options?: {
+    devMode?: boolean;
+}): ComponentResolver;

package/dist/resolvers/MazDirectivesResolver.d.ts

@@ -0,0 +1,11 @@
+import { ComponentResolver } from 'unplugin-vue-components/types';
+/**
+ * Resolver for Maz-UI (directives)
+ *
+ * @author @louismazel
+ * @link https://maz-ui.com
+ */
+export declare function MazDirectivesResolver(options?: {
+    devMode?: boolean;
+    prefix?: string;
+}): ComponentResolver;

package/dist/resolvers/MazModulesResolver.d.ts

@@ -0,0 +1,11 @@
+import { ResolverFunction } from 'unplugin-auto-import/types';
+/**
+ * Resolver for Maz-UI (modules)
+ *
+ * @author @louismazel
+ * @link https://maz-ui.com
+ */
+export declare function MazModulesResolver(options?: {
+    devMode?: boolean;
+    prefix?: string;
+}): ResolverFunction;

package/dist/resolvers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './MazComponentsResolver';
+export * from './MazDirectivesResolver';
+export * from './MazModulesResolver';

package/dist/tailwindcss/index.d.ts

@@ -0,0 +1,6 @@
+export * from './tailwind.config';
+export * from './utils/colors';
+export { getNumericScreensFromTailwind, screens } from './variables/breakpoints';
+export * from './variables/colors';
+export * from './variables/design-tokens';
+export { zIndex } from './variables/z-indexes';

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

@@ -0,0 +1,89 @@
+import { Config } from 'tailwindcss';
+import { getNumericScreensFromTailwind } from './variables/breakpoints';
+export { getNumericScreensFromTailwind };
+export declare function defineMazTailwindConfig(config?: Partial<Config> & {
+    content: Config['content'];
+}, { utilities }?: {
+    utilities?: Record<string, any>;
+}): {
+    content: (import('tailwindcss/types/config').ContentConfig | undefined) & import('tailwindcss/types/config').ContentConfig;
+    important?: Partial<import('tailwindcss/types/config').ImportantConfig> | undefined;
+    prefix?: string | undefined;
+    separator?: string | undefined;
+    safelist?: import('tailwindcss/types/config').SafelistConfig[] | undefined;
+    blocklist?: string[] | undefined;
+    presets?: Partial<import('tailwindcss/types/config').Config>[] | undefined;
+    future?: Partial<import('tailwindcss/types/config').FutureConfig> | undefined;
+    experimental?: Partial<import('tailwindcss/types/config').ExperimentalConfig> | undefined;
+    darkMode: Partial<import('tailwindcss/types/config').DarkModeConfig>;
+    theme: Partial<import('tailwindcss/types/config').CustomThemeConfig & {
+        extend: Partial<import('tailwindcss/types/config').CustomThemeConfig>;
+    }> | {
+        extend: {
+            colors: import('tailwindcss/types/config').ResolvableTo<import('tailwindcss/types/config').RecursiveKeyValuePair<string, string>>;
+            screens: {
+                'mob-s': string;
+                'mob-m': string;
+                'mob-l': string;
+                'tab-s': string;
+                'tab-m': string;
+                'tab-l': string;
+                'lap-s': string;
+                'lap-m': string;
+                'lap-l': string;
+                'lap-xl': string;
+                'lap-2xl': string;
+                'lap-3xl': string;
+            };
+            zIndex: {
+                '1': string;
+                '2': string;
+                '3': string;
+                '4': string;
+                '5': string;
+                '15': string;
+                '25': string;
+                '35': string;
+                '45': string;
+                '75': string;
+                '100': string;
+                'default-backdrop': string;
+            };
+            borderRadius: {
+                sm: string;
+                md: string;
+                DEFAULT: string;
+                lg: string;
+                xl: string;
+            };
+            borderColor: {
+                DEFAULT: string;
+            };
+            borderWidth: {
+                DEFAULT: string;
+                0: string;
+                2: string;
+                4: string;
+                8: string;
+            };
+            fontFamily: {
+                sans: string;
+            };
+            transitionDuration: {
+                DEFAULT: string;
+            };
+            transitionTimingFunction: {
+                DEFAULT: string;
+            };
+            boxShadow: {
+                sm: string;
+                DEFAULT: string;
+                md: string;
+                lg: string;
+                xl: string;
+            };
+        };
+    };
+    corePlugins?: Partial<import('tailwindcss/types/config').CorePluginsConfig> | undefined;
+    plugins: Partial<import('tailwindcss/types/config').PluginsConfig>;
+};

package/dist/tailwindcss/utils/colors.d.ts

@@ -0,0 +1,7 @@
+import { ThemeConfig } from 'tailwindcss/types/config';
+export declare function getColors(): ThemeConfig['colors'];
+export declare function createScaleColor(colorName: string): Record<string, string>;
+export declare function createSimpleColor(colorName: string, withForeground?: boolean): string | {
+    DEFAULT: string;
+    foreground: string;
+};

package/dist/tailwindcss/variables/breakpoints.d.ts

@@ -0,0 +1,15 @@
+export declare const screens: {
+    'mob-s': string;
+    'mob-m': string;
+    'mob-l': string;
+    'tab-s': string;
+    'tab-m': string;
+    'tab-l': string;
+    'lap-s': string;
+    'lap-m': string;
+    'lap-l': string;
+    'lap-xl': string;
+    'lap-2xl': string;
+    'lap-3xl': string;
+};
+export declare function getNumericScreensFromTailwind<T extends Record<string, string> | Record<string, number>>(inputScreens: T): Record<keyof T, number>;

package/dist/tailwindcss/variables/colors.d.ts

@@ -0,0 +1,21 @@
+export declare const baseColors: {};
+export declare const scaleColors: {
+    readonly primary: "primary";
+    readonly secondary: "secondary";
+    readonly accent: "accent";
+    readonly destructive: "destructive";
+    readonly success: "success";
+    readonly warning: "warning";
+    readonly contrast: "contrast";
+    readonly info: "info";
+    readonly foreground: "foreground";
+    readonly surface: "background";
+    readonly divider: "border";
+    readonly elevation: "shadow";
+    readonly overlay: "overlay";
+    readonly muted: "muted";
+};
+export declare const noForegroundColors: ["surface", "foreground", "overlay", "divider", "muted", "elevation"];
+export declare const colorScales: readonly ["50", "100", "200", "300", "400", "500", "600", "700", "800", "900"];
+export type ScaleColorName = keyof typeof scaleColors;
+export type ColorScale = typeof colorScales[number];

package/dist/tailwindcss/variables/design-tokens.d.ts

@@ -0,0 +1,35 @@
+export declare const designTokens: {
+    borderRadius: {
+        sm: string;
+        md: string;
+        DEFAULT: string;
+        lg: string;
+        xl: string;
+    };
+    borderColor: {
+        DEFAULT: string;
+    };
+    borderWidth: {
+        DEFAULT: string;
+        0: string;
+        2: string;
+        4: string;
+        8: string;
+    };
+    fontFamily: {
+        sans: string;
+    };
+    transitionDuration: {
+        DEFAULT: string;
+    };
+    transitionTimingFunction: {
+        DEFAULT: string;
+    };
+    boxShadow: {
+        sm: string;
+        DEFAULT: string;
+        md: string;
+        lg: string;
+        xl: string;
+    };
+};

package/dist/tailwindcss/variables/utilities.d.ts

@@ -0,0 +1,17 @@
+export declare const utilities: {
+    '.flex-center': {
+        'align-items': string;
+        'justify-content': string;
+    };
+    '.padded-container-no-p': {
+        width: string;
+        'padding-inline': string;
+    };
+    '.padded-container': {
+        width: string;
+        'padding-inline': string;
+    };
+    '.cap-f::first-letter': {
+        'text-transform': string;
+    };
+};

package/dist/tailwindcss/variables/z-indexes.d.ts

@@ -0,0 +1,14 @@
+export declare const zIndex: {
+    '1': string;
+    '2': string;
+    '3': string;
+    '4': string;
+    '5': string;
+    '15': string;
+    '25': string;
+    '35': string;
+    '45': string;
+    '75': string;
+    '100': string;
+    'default-backdrop': string;
+};