@maz-ui/nuxt 4.0.0-beta.0

package/dist/module.mjs

@@ -0,0 +1,348 @@
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { defineNuxtModule, createResolver, addPlugin, addComponent, addImports } from '@nuxt/kit';
+import { defu } from 'defu';
+import { capitalize } from 'maz-ui';
+
+const COMPONENT_NAMES = {
+  MazAccordion: true,
+  MazAnimatedCounter: true,
+  MazAnimatedElement: true,
+  MazAnimatedText: true,
+  MazAvatar: true,
+  MazBackdrop: true,
+  MazBadge: true,
+  MazBottomSheet: true,
+  MazBtn: true,
+  MazCard: true,
+  MazCardSpotlight: true,
+  MazCarousel: true,
+  MazChart: true,
+  MazCheckbox: true,
+  MazChecklist: true,
+  MazCircularProgressBar: true,
+  MazDialog: true,
+  MazDialogPromise: true,
+  MazDrawer: true,
+  MazDropdown: true,
+  MazDropzone: true,
+  MazExpandAnimation: true,
+  MazFullscreenLoader: true,
+  MazGallery: true,
+  MazIcon: true,
+  MazInput: true,
+  MazInputCode: true,
+  MazInputNumber: true,
+  MazInputPhoneNumber: true,
+  MazInputPrice: true,
+  MazInputTags: true,
+  MazLazyImg: true,
+  MazLink: true,
+  MazLoadingBar: true,
+  MazPagination: true,
+  MazDatePicker: true,
+  MazPullToRefresh: true,
+  MazRadio: true,
+  MazRadioButtons: true,
+  MazReadingProgressBar: true,
+  MazSelect: true,
+  MazSelectCountry: true,
+  MazSlider: true,
+  MazSpinner: true,
+  MazStepper: true,
+  MazSwitch: true,
+  MazTable: true,
+  MazTableCell: true,
+  MazTableRow: true,
+  MazTableTitle: true,
+  MazTabs: true,
+  MazTabsBar: true,
+  MazTabsContent: true,
+  MazTabsContentItem: true,
+  MazTextarea: true,
+  MazPopover: true
+};
+const _dirname = dirname(fileURLToPath(import.meta.url));
+const defaults = {
+  general: {
+    autoImportPrefix: "",
+    defaultMazIconPath: "",
+    devtools: true
+  },
+  css: {
+    injectMainCss: true
+  },
+  theme: {
+    preset: "maz-ui",
+    strategy: "hybrid",
+    darkModeStrategy: "class",
+    prefix: "maz",
+    colorMode: "auto"
+  },
+  translations: {
+    locale: "en"
+  },
+  components: {
+    autoImport: true
+  },
+  composables: {
+    useTheme: true,
+    useAos: true,
+    useToast: true,
+    useDialog: true,
+    useWait: true,
+    useIdleTimeout: true,
+    useReadingTime: true,
+    useTranslations: true,
+    useFormField: true,
+    useWindowSize: true,
+    useBreakpoints: true,
+    useUserVisibility: true,
+    useStringMatching: true,
+    useTimer: true,
+    useFormValidator: true,
+    useDisplayNames: true,
+    useFreezeValue: true,
+    useInjectStrict: true,
+    useInstanceUniqId: true,
+    useMountComponent: true,
+    useSwipe: true
+  },
+  directives: {
+    vZoomImg: false,
+    vLazyImg: false,
+    vClickOutside: false,
+    vFullscreenImg: false,
+    vTooltip: false
+  }
+};
+function addComposableImport({
+  name,
+  from,
+  prefix = ""
+}) {
+  addImports({
+    from,
+    name,
+    // typeFrom: `maz-ui/dist/types/composables/${name}.d.ts`,
+    as: `use${capitalize(prefix)}${name.replace("use", "")}`
+  });
+}
+const module = defineNuxtModule({
+  meta: {
+    name: "maz-ui",
+    configKey: "mazUi",
+    compatibility: {
+      nuxt: ">=3.0.0"
+    }
+  },
+  defaults,
+  /* eslint-disable complexity, sonarjs/cognitive-complexity */
+  setup(options, nuxt) {
+    const { resolve } = createResolver(import.meta.url);
+    nuxt.options.build.transpile = ["maz-ui", "@maz-ui/themes", ...nuxt.options.build.transpile];
+    const moduleOptions = defu(nuxt.options.runtimeConfig.public.mazUi, options, defaults);
+    nuxt.options.runtimeConfig.public.mazUi = moduleOptions;
+    if (moduleOptions.css.injectMainCss) {
+      nuxt.options.css = ["maz-ui/dist/css/main.css", ...nuxt.options.css];
+    }
+    addPlugin(resolve(_dirname, "./runtime/plugins/theme"));
+    addPlugin(resolve(_dirname, "./runtime/plugins/translations"));
+    if (moduleOptions.components.autoImport) {
+      for (const name of Object.keys(COMPONENT_NAMES)) {
+        addComponent({
+          name,
+          filePath: `maz-ui/components/${name}`
+        });
+      }
+    }
+    if (moduleOptions.composables.useAos) {
+      addPlugin(resolve(_dirname, "./runtime/plugins/aos"));
+      addComposableImport({
+        name: "useAos",
+        from: resolve(_dirname, "./runtime/composables/useAos"),
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+      const injectAosCSS = typeof moduleOptions.composables.useAos === "object" && typeof moduleOptions.composables.useAos.injectCss === "boolean" ? moduleOptions.composables.useAos.injectCss : true;
+      if (injectAosCSS) {
+        nuxt.options.css = ["maz-ui/aos-styles", ...nuxt.options.css];
+      }
+    }
+    if (moduleOptions.directives.vZoomImg) {
+      addPlugin(resolve(_dirname, "./runtime/plugins/v-zoom-img"));
+    }
+    if (moduleOptions.directives.vLazyImg) {
+      addPlugin(resolve(_dirname, "./runtime/plugins/v-lazy-img"));
+    }
+    if (moduleOptions.directives.vClickOutside) {
+      addPlugin(resolve(_dirname, "./runtime/plugins/v-click-outside"));
+    }
+    if (moduleOptions.directives.vFullscreenImg) {
+      addPlugin(resolve(_dirname, "./runtime/plugins/v-fullscreen-img"));
+    }
+    if (moduleOptions.directives.vTooltip) {
+      addPlugin(resolve(_dirname, "./runtime/plugins/v-tooltip"));
+    }
+    if (moduleOptions.composables.useToast) {
+      addPlugin(resolve(_dirname, "./runtime/plugins/toast"));
+      addComposableImport({
+        name: "useToast",
+        from: resolve(_dirname, "./runtime/composables/useToast"),
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useDialog) {
+      addPlugin(resolve(_dirname, "./runtime/plugins/dialog"));
+      addComposableImport({
+        name: "useDialog",
+        from: resolve(_dirname, "./runtime/composables/useDialog"),
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useWait) {
+      addPlugin(resolve(_dirname, "./runtime/plugins/wait"));
+      addComposableImport({
+        name: "useWait",
+        from: resolve(_dirname, "./runtime/composables/useWait"),
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useIdleTimeout) {
+      addComposableImport({
+        name: "useIdleTimeout",
+        from: "maz-ui/composables/useIdleTimeout",
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useReadingTime) {
+      addComposableImport({
+        name: "useReadingTime",
+        from: "maz-ui/composables/useReadingTime",
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useWindowSize) {
+      addComposableImport({
+        name: "useWindowSize",
+        from: "maz-ui/composables/useWindowSize",
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useBreakpoints) {
+      addImports({
+        from: "maz-ui/composables/useBreakpoints",
+        name: "useBreakpoints",
+        as: "useBreakpoints"
+      });
+    }
+    if (moduleOptions.composables.useUserVisibility) {
+      addComposableImport({
+        name: "useUserVisibility",
+        from: "maz-ui/composables/useUserVisibility",
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useStringMatching) {
+      addComposableImport({
+        name: "useStringMatching",
+        from: "maz-ui/composables/useStringMatching",
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useTimer) {
+      addComposableImport({
+        name: "useTimer",
+        from: "maz-ui/composables/useTimer",
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useFreezeValue) {
+      addComposableImport({
+        name: "useFreezeValue",
+        from: "maz-ui/composables/useFreezeValue",
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useInjectStrict) {
+      addComposableImport({
+        name: "useInjectStrict",
+        from: "maz-ui/composables/useInjectStrict",
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useInstanceUniqId) {
+      addComposableImport({
+        name: "useInstanceUniqId",
+        from: "maz-ui/composables/useInstanceUniqId",
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useMountComponent) {
+      addComposableImport({
+        name: "useMountComponent",
+        from: "maz-ui/composables/useMountComponent",
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useSwipe) {
+      addComposableImport({
+        name: "useSwipe",
+        from: "maz-ui/composables/useSwipe",
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useFormValidator) {
+      addComposableImport({
+        name: "useFormValidator",
+        from: "maz-ui/composables/useFormValidator",
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useFormField) {
+      addComposableImport({
+        name: "useFormField",
+        from: "maz-ui/composables/useFormField",
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useDisplayNames) {
+      addComposableImport({
+        name: "useDisplayNames",
+        from: "maz-ui/composables/useDisplayNames",
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useTheme) {
+      addComposableImport({
+        name: "useTheme",
+        from: "@maz-ui/themes/composables/useTheme",
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.composables.useTranslations) {
+      addComposableImport({
+        name: "useTranslations",
+        from: "@maz-ui/translations",
+        prefix: moduleOptions.general?.autoImportPrefix
+      });
+    }
+    if (moduleOptions.general.defaultMazIconPath) {
+      addPlugin(resolve(_dirname, "./runtime/plugins/maz-icon-path"));
+    }
+    if (moduleOptions.general.devtools) {
+      nuxt.hook("devtools:customTabs", (iframeTabs) => {
+        iframeTabs.push({
+          name: "maz-ui",
+          title: "maz-ui",
+          icon: "https://maz-ui.com/img/icons/android-chrome-512x512.png",
+          view: {
+            type: "iframe",
+            src: "https://maz-ui.com"
+          }
+        });
+      });
+    }
+  }
+});
+
+export { module as default };

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

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

package/dist/runtime/composables/useAos.js

@@ -0,0 +1,5 @@
+import { useNuxtApp } from "nuxt/app";
+export function useAos() {
+  const { $mazAos } = useNuxtApp();
+  return $mazAos;
+}

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

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

package/dist/runtime/composables/useDialog.js

@@ -0,0 +1,5 @@
+import { useNuxtApp } from "nuxt/app";
+export function useDialog() {
+  const { $mazDialog } = useNuxtApp();
+  return $mazDialog;
+}

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

@@ -0,0 +1,2 @@
+import type { ToastHandler } from 'maz-ui/plugins/toast';
+export declare function useToast(): ToastHandler;

package/dist/runtime/composables/useToast.js

@@ -0,0 +1,5 @@
+import { useNuxtApp } from "nuxt/app";
+export function useToast() {
+  const { $mazToast } = useNuxtApp();
+  return $mazToast;
+}

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

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

package/dist/runtime/composables/useWait.js

@@ -0,0 +1,5 @@
+import { useNuxtApp } from "nuxt/app";
+export function useWait() {
+  const { $mazWait } = useNuxtApp();
+  return $mazWait;
+}

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

@@ -0,0 +1,12 @@
+import { AosHandler } from 'maz-ui/plugins/aos';
+declare const _default: import("#app").Plugin<{
+    mazAos: AosHandler;
+}> & import("#app").ObjectPlugin<{
+    mazAos: AosHandler;
+}>;
+export default _default;
+declare module '#app' {
+    interface NuxtApp {
+        $mazAos: AosHandler;
+    }
+}

package/dist/runtime/plugins/aos.js

@@ -0,0 +1,12 @@
+import { AosHandler, AosPlugin } from "maz-ui/plugins/aos";
+import { defineNuxtPlugin, useRouter } from "nuxt/app";
+export default defineNuxtPlugin(({ $config, vueApp }) => {
+  const aosOptions = $config.public.mazUi?.composables?.useAos;
+  const options = typeof aosOptions === "object" ? { ...aosOptions, router: aosOptions.router ? useRouter() : void 0 } : {};
+  vueApp.use(AosPlugin, options);
+  return {
+    provide: {
+      mazAos: new AosHandler(options)
+    }
+  };
+});

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

@@ -0,0 +1,12 @@
+import { DialogHandler } from 'maz-ui/plugins/dialog';
+declare const _default: import("#app").Plugin<{
+    mazDialog: DialogHandler;
+}> & import("#app").ObjectPlugin<{
+    mazDialog: DialogHandler;
+}>;
+export default _default;
+declare module '#app' {
+    interface NuxtApp {
+        $mazDialog: DialogHandler;
+    }
+}

package/dist/runtime/plugins/dialog.js

@@ -0,0 +1,23 @@
+import { DialogHandler } from "maz-ui/plugins/dialog";
+import { defineNuxtPlugin } from "nuxt/app";
+export default defineNuxtPlugin(({ vueApp, $config }) => {
+  const dialogOptions = $config.public.mazUi?.composables?.useDialog;
+  const options = typeof dialogOptions === "object" ? dialogOptions : void 0;
+  const instance = new DialogHandler(vueApp, options);
+  const dialogServer = {
+    open: () => {
+      return {
+        promise: Promise.resolve(),
+        destroy: () => {
+        },
+        close: () => {
+        }
+      };
+    }
+  };
+  return {
+    provide: {
+      mazDialog: import.meta.server ? dialogServer : instance
+    }
+  };
+});

package/dist/runtime/plugins/maz-icon-path.d.ts

@@ -0,0 +1,11 @@
+declare const _default: import("#app").Plugin<{
+    mazIconPath: any;
+}> & import("#app").ObjectPlugin<{
+    mazIconPath: any;
+}>;
+export default _default;
+declare module '#app' {
+    interface NuxtApp {
+        $mazIconPath: string;
+    }
+}

package/dist/runtime/plugins/maz-icon-path.js

@@ -0,0 +1,10 @@
+import { defineNuxtPlugin } from "nuxt/app";
+export default defineNuxtPlugin(({ $config, vueApp }) => {
+  const defaultMazIconPath = $config.public.mazUi?.general?.defaultMazIconPath;
+  vueApp.provide("mazIconPath", defaultMazIconPath);
+  return {
+    provide: {
+      mazIconPath: defaultMazIconPath
+    }
+  };
+});

package/dist/runtime/plugins/theme.d.ts

@@ -0,0 +1,8 @@
+import { type ThemeState } from '@maz-ui/themes';
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;
+declare module '#app' {
+    interface NuxtApp {
+        $mazThemeState: ThemeState;
+    }
+}

package/dist/runtime/plugins/theme.js

@@ -0,0 +1,92 @@
+import {
+  generateFullCSS,
+  mergePresets
+} from "@maz-ui/themes";
+import { MazUiTheme } from "@maz-ui/themes/plugin";
+import { getPreset } from "@maz-ui/themes/utils";
+import { generateCriticalCSS } from "@maz-ui/themes/utils/css-generator";
+import { defineNuxtPlugin, useCookie, useHead, useRequestHeaders } from "nuxt/app";
+function getServerInitialColorMode() {
+  const colorModeCookie = useCookie("maz-color-mode");
+  if (colorModeCookie.value && ["light", "dark", "auto"].includes(colorModeCookie.value)) {
+    return colorModeCookie.value;
+  }
+  if (import.meta.server) {
+    const headers = useRequestHeaders();
+    if (headers["sec-ch-prefers-color-scheme"] === "dark") {
+      return "dark";
+    }
+    const userAgent = headers["user-agent"]?.toLowerCase();
+    if (userAgent?.includes("dark")) {
+      return "dark";
+    }
+  }
+  return "auto";
+}
+function getServerIsDark(colorMode) {
+  return colorMode === "dark";
+}
+export default defineNuxtPlugin(async ({ vueApp, $config }) => {
+  const themeConfig = $config.public.mazUi?.theme;
+  let preset = await getPreset(themeConfig?.preset);
+  if (themeConfig?.overrides) {
+    preset = mergePresets(preset, themeConfig.overrides);
+  }
+  const config = {
+    strategy: "hybrid",
+    darkModeStrategy: "class",
+    prefix: "maz",
+    colorMode: "auto",
+    injectFullCSSOnServer: true,
+    ...themeConfig,
+    preset
+  };
+  const initialColorMode = config.colorMode === "auto" ? getServerInitialColorMode() : config.colorMode ?? "auto";
+  const serverIsDark = getServerIsDark(initialColorMode);
+  const initialIsDark = initialColorMode === "dark" || initialColorMode === "auto" && serverIsDark;
+  const themeState = {
+    currentPreset: config.preset,
+    colorMode: initialColorMode,
+    isDark: initialIsDark,
+    strategy: config.strategy,
+    darkModeStrategy: config.darkModeStrategy
+  };
+  if (import.meta.server) {
+    const cssOptions = {
+      mode: config.colorMode === "auto" ? "both" : config.colorMode,
+      darkSelectorStrategy: config.darkModeStrategy ?? "class",
+      prefix: config.prefix
+    };
+    const criticalCSS = generateCriticalCSS(themeState.currentPreset, cssOptions);
+    useHead({
+      style: [
+        {
+          innerHTML: criticalCSS,
+          id: "maz-theme-critical"
+        }
+      ]
+    });
+    if (config.injectFullCSSOnServer) {
+      const fullCSS = generateFullCSS(themeState.currentPreset, cssOptions);
+      useHead({
+        style: [{ innerHTML: fullCSS, id: "maz-theme-full" }]
+      });
+    }
+    if (initialIsDark && config.darkModeStrategy === "class") {
+      useHead({
+        htmlAttrs: {
+          class: "dark"
+        }
+      });
+    }
+  }
+  MazUiTheme.install(vueApp, {
+    ...config,
+    preset: themeState.currentPreset,
+    colorMode: themeState.colorMode,
+    strategy: themeState.strategy,
+    darkModeStrategy: themeState.darkModeStrategy,
+    injectFullCSS: !config.injectFullCSSOnServer,
+    injectCriticalCSS: false
+  });
+});

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

@@ -0,0 +1,12 @@
+import { ToastHandler } from 'maz-ui/plugins/toast';
+declare const _default: import("#app").Plugin<{
+    mazToast: ToastHandler;
+}> & import("#app").ObjectPlugin<{
+    mazToast: ToastHandler;
+}>;
+export default _default;
+declare module '#app' {
+    interface NuxtApp {
+        $mazToast: ToastHandler;
+    }
+}

package/dist/runtime/plugins/toast.js

@@ -0,0 +1,26 @@
+import { ToastHandler } from "maz-ui/plugins/toast";
+import { defineNuxtPlugin } from "nuxt/app";
+export default defineNuxtPlugin(({ vueApp, $config }) => {
+  const toastOptions = $config.public.mazUi?.composables?.useToast;
+  const options = typeof toastOptions === "object" ? toastOptions : void 0;
+  const instance = new ToastHandler(vueApp, options);
+  const toastServer = {
+    show: (_message) => {
+    },
+    success: (_message) => {
+    },
+    error: (_message) => {
+    },
+    warning: (_message) => {
+    },
+    info: (_message) => {
+    },
+    message: (_message) => {
+    }
+  };
+  return {
+    provide: {
+      mazToast: import.meta.server ? toastServer : instance
+    }
+  };
+});

package/dist/runtime/plugins/translations.d.ts

@@ -0,0 +1,8 @@
+import { type MazTranslationsInstance } from '@maz-ui/translations';
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;
+declare module '#app' {
+    interface NuxtApp {
+        $mazTranslations: MazTranslationsInstance;
+    }
+}

package/dist/runtime/plugins/translations.js

@@ -0,0 +1,6 @@
+import { MazTranslations } from "@maz-ui/translations";
+import { defineNuxtPlugin } from "nuxt/app";
+export default defineNuxtPlugin(async ({ vueApp, $config }) => {
+  const translationsOptions = $config.public.mazUi?.translations;
+  await MazTranslations.install(vueApp, translationsOptions);
+});

package/dist/runtime/plugins/v-click-outside.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/v-click-outside.js

@@ -0,0 +1,5 @@
+import { vClickOutsideInstall } from "maz-ui/directives/vClickOutside";
+import { defineNuxtPlugin } from "nuxt/app";
+export default defineNuxtPlugin(({ vueApp }) => {
+  vueApp.use(vClickOutsideInstall);
+});

package/dist/runtime/plugins/v-fullscreen-img.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/v-fullscreen-img.js

@@ -0,0 +1,5 @@
+import { vFullscreenImgInstall } from "maz-ui/directives/vFullscreenImg";
+import { defineNuxtPlugin } from "nuxt/app";
+export default defineNuxtPlugin(({ vueApp }) => {
+  vueApp.use(vFullscreenImgInstall);
+});

package/dist/runtime/plugins/v-lazy-img.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/v-lazy-img.js

@@ -0,0 +1,7 @@
+import { vLazyImgInstall } from "maz-ui/directives/vLazyImg";
+import { defineNuxtPlugin } from "nuxt/app";
+export default defineNuxtPlugin(({ vueApp, $config }) => {
+  const vLazyImgOptions = $config.public.mazUi?.directives?.vLazyImg;
+  const options = typeof vLazyImgOptions === "object" ? vLazyImgOptions : void 0;
+  vueApp.use(vLazyImgInstall, options);
+});

package/dist/runtime/plugins/v-tooltip.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;