@ulu/frontend-vue 0.6.23 → 0.6.25

package/dist/plugins/index.d.ts

@@ -1,6 +1,7 @@
 export { default as corePlugin } from './core/index.js';
 export { default as breakpointsPlugin } from './breakpoints/index.js';
-export { default as popoversPlugin, useTooltip, useTooltipFollow } from './popovers/index.js';
+export { default as popoversPlugin, useTooltip, useTooltipFollow, UluPopover, UluPopoverBase, UluTooltipDisplay, UluTooltipPopover } from './popovers/index.js';
 export { default as modalsPlugin, useModals } from './modals/index.js';
 export { default as toastPlugin, useToast, UluToast, UluToastDisplay } from './toast/index.js';
+export { default as tourPlugin, useTour, UluTourDisplay, UluTourPager, UluTourContent } from './tour/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/plugins/popovers/UluPopover.vue.d.ts

@@ -4,28 +4,47 @@ type __VLS_WithTemplateSlots<T, S> = T & (new () => {
     $slots: S;
 });
 declare const __VLS_component: import('vue').DefineComponent<{}, {
-    $emit: (event: "toggle", ...args: any[]) => void;
+    /**
+     * The reactive internal open/closed state of the popover
+     */
+    isOpen: import('vue').WritableComputedRef<boolean, boolean>;
+    /**
+     * Method to toggle the popover open/closed
+     */
+    toggle: () => void;
+    /**
+     * Method to force the popover closed
+     */
+    close: () => void;
+    /**
+     * Method to explicitly set the open state
+     * @param {Boolean} toOpen - The desired state
+     */
+    changeTo: (toOpen: any) => void;
+    $emit: (event: "toggle" | "update:modelValue", ...args: any[]) => void;
+    clickOutsideCloses: boolean;
     config: Record<string, any>;
     disabled: boolean;
     noPadding: boolean;
     startOpen: boolean;
     activeClass: string;
     classes: Record<string, any>;
-    clickOutsideCloses: boolean;
-    directFocus: Function;
+    directFocus?: Function | undefined;
+    modelValue?: boolean | undefined;
     triggerText?: string | undefined;
     triggerAlt?: string | undefined;
     tooltip?: string | undefined;
     size?: string | undefined;
     $props: {
+        readonly clickOutsideCloses?: boolean | undefined;
         readonly config?: Record<string, any> | undefined;
         readonly disabled?: boolean | undefined;
         readonly noPadding?: boolean | undefined;
         readonly startOpen?: boolean | undefined;
         readonly activeClass?: string | undefined;
         readonly classes?: Record<string, any> | undefined;
-        readonly clickOutsideCloses?: boolean | undefined;
         readonly directFocus?: Function | undefined;
+        readonly modelValue?: boolean | undefined;
         readonly triggerText?: string | undefined;
         readonly triggerAlt?: string | undefined;
         readonly tooltip?: string | undefined;
@@ -33,8 +52,101 @@ declare const __VLS_component: import('vue').DefineComponent<{}, {
     };
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     trigger: HTMLButtonElement;
-    content: HTMLSpanElement;
-    contentArrow: HTMLSpanElement;
+    popoverBase: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            contentEl: HTMLSpanElement;
+            contentArrow: HTMLSpanElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: HTMLSpanElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
+            close: () => void;
+            update: Function;
+            content: import('vue').Ref<null, null>;
+            $emit: (event: "close" | "update:isOpen", ...args: any[]) => void;
+            isOpen: boolean;
+            clickOutsideCloses: boolean;
+            escapeCloses: boolean;
+            directFocus: Function;
+            trigger: Record<string, any>;
+            config: Record<string, any>;
+            modifiers?: string | Record<string, any> | unknown[] | undefined;
+            $props: {
+                readonly isOpen?: boolean | undefined;
+                readonly clickOutsideCloses?: boolean | undefined;
+                readonly escapeCloses?: boolean | undefined;
+                readonly directFocus?: Function | undefined;
+                readonly trigger?: Record<string, any> | undefined;
+                readonly config?: Record<string, any> | undefined;
+                readonly modifiers?: string | Record<string, any> | unknown[] | undefined;
+            };
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<{}> & Readonly<{}>, "$props" | "$emit" | "isOpen" | "clickOutsideCloses" | "escapeCloses" | "directFocus" | "trigger" | "config" | "modifiers" | "content" | "close" | "update"> & import('vue').ShallowUnwrapRef<{
+        close: () => void;
+        update: Function;
+        content: import('vue').Ref<null, null>;
+        $emit: (event: "close" | "update:isOpen", ...args: any[]) => void;
+        isOpen: boolean;
+        clickOutsideCloses: boolean;
+        escapeCloses: boolean;
+        directFocus: Function;
+        trigger: Record<string, any>;
+        config: Record<string, any>;
+        modifiers?: string | Record<string, any> | unknown[] | undefined;
+        $props: {
+            readonly isOpen?: boolean | undefined;
+            readonly clickOutsideCloses?: boolean | undefined;
+            readonly escapeCloses?: boolean | undefined;
+            readonly directFocus?: Function | undefined;
+            readonly trigger?: Record<string, any> | undefined;
+            readonly config?: Record<string, any> | undefined;
+            readonly modifiers?: string | Record<string, any> | unknown[] | undefined;
+        };
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {
+                isOpen: boolean;
+                close: () => void;
+            }): any;
+            footer?(_: {
+                isOpen: boolean;
+                close: () => void;
+            }): any;
+        };
+    }) | null;
 }, any>;
 type __VLS_TemplateResult = {
     attrs: Partial<{}>;
@@ -54,8 +166,79 @@ type __VLS_TemplateResult = {
     };
     refs: {
         trigger: HTMLButtonElement;
-        content: HTMLSpanElement;
-        contentArrow: HTMLSpanElement;
+        popoverBase: ({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{}> & Omit<{} & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>;
+            $attrs: Data;
+            $refs: Data & {
+                contentEl: HTMLSpanElement;
+                contentArrow: HTMLSpanElement;
+            };
+            $slots: Readonly<InternalSlots>;
+            $root: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, ComponentProvideOptions>, {}, {}, "", {}, any> | null;
+            $parent: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, ComponentProvideOptions>, {}, {}, "", {}, any> | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: HTMLSpanElement;
+            $options: ComponentOptionsBase<ToResolvedProps<{}, {}>, {
+                close: () => void;
+                update: Function;
+                content: Ref<null, null>;
+                $emit: (event: "close" | "update:isOpen", ...args: any[]) => void;
+                isOpen: boolean;
+                clickOutsideCloses: boolean;
+                escapeCloses: boolean;
+                directFocus: Function;
+                trigger: Record<string, any>;
+                config: Record<string, any>;
+                modifiers?: string | Record<string, any> | unknown[] | undefined;
+                $props: {
+                    readonly isOpen?: boolean | undefined;
+                    readonly clickOutsideCloses?: boolean | undefined;
+                    readonly escapeCloses?: boolean | undefined;
+                    readonly directFocus?: Function | undefined;
+                    readonly trigger?: Record<string, any> | undefined;
+                    readonly config?: Record<string, any> | undefined;
+                    readonly modifiers?: string | Record<string, any> | unknown[] | undefined;
+                };
+            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & MergedComponentOptionsOverride;
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R, args_2: OnCleanup) => any : (args_0: any, args_1: any, args_2: OnCleanup) => any, options?: WatchOptions<boolean> | undefined): WatchStopHandle;
+        } & Readonly<{}> & Omit<Readonly<{}> & Readonly<{}>, "$props" | "$emit" | "isOpen" | "clickOutsideCloses" | "escapeCloses" | "directFocus" | "trigger" | "config" | "modifiers" | "content" | "close" | "update"> & ShallowUnwrapRef<{
+            close: () => void;
+            update: Function;
+            content: Ref<null, null>;
+            $emit: (event: "close" | "update:isOpen", ...args: any[]) => void;
+            isOpen: boolean;
+            clickOutsideCloses: boolean;
+            escapeCloses: boolean;
+            directFocus: Function;
+            trigger: Record<string, any>;
+            config: Record<string, any>;
+            modifiers?: string | Record<string, any> | unknown[] | undefined;
+            $props: {
+                readonly isOpen?: boolean | undefined;
+                readonly clickOutsideCloses?: boolean | undefined;
+                readonly escapeCloses?: boolean | undefined;
+                readonly directFocus?: Function | undefined;
+                readonly trigger?: Record<string, any> | undefined;
+                readonly config?: Record<string, any> | undefined;
+                readonly modifiers?: string | Record<string, any> | unknown[] | undefined;
+            };
+        }> & ExtractComputedReturns<{}> & ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {
+                    isOpen: boolean;
+                    close: () => void;
+                }): any;
+                footer?(_: {
+                    isOpen: boolean;
+                    close: () => void;
+                }): any;
+            };
+        }) | null;
     };
     rootEl: any;
 };

package/dist/plugins/popovers/UluPopover.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UluPopover.vue.d.ts","sourceRoot":"","sources":["../../../lib/plugins/popovers/UluPopover.vue"],"names":[],"mappings":"AAuDA;wBAwfqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAZjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QASG"}
+{"version":3,"file":"UluPopover.vue.d.ts","sourceRoot":"","sources":["../../../lib/plugins/popovers/UluPopover.vue"],"names":[],"mappings":"AA8CA;wBAmaqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAbjC;IAhLI;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAoLy8c,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QATnkd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAS68c,GAAG"}

package/dist/plugins/popovers/UluPopover.vue.js

@@ -1,184 +1,147 @@
-import { computed as V, ref as v, resolveDirective as D, createElementBlock as d, openBlock as u, Fragment as K, withDirectives as L, createElementVNode as x, unref as t, normalizeClass as F, renderSlot as m, createTextVNode as R, toDisplayString as U, withKeys as q, normalizeStyle as T, createCommentVNode as h, nextTick as H } from "vue";
-import { useRequiredInject as Y } from "../../composables/useRequiredInject.js";
-import { POPOVER_OPTIONS_KEY as G } from "./index.js";
-import J from "./defaults.js";
-import { newId as A } from "../../utils/dom.js";
-import { useUluFloating as M } from "../../composables/useUluFloating.js";
-const Q = ["id", "disabled", "aria-expanded", "aria-controls", "aria-label"], W = ["aria-labelledby", "id", "data-placement"], X = { class: "popover__inner" }, Z = {
-  key: 0,
-  class: "popover__footer"
-}, ie = {
+import { computed as O, ref as r, resolveDirective as I, createElementBlock as b, openBlock as y, Fragment as T, withDirectives as j, createVNode as z, unref as a, normalizeClass as C, renderSlot as d, createTextVNode as h, toDisplayString as w, createSlots as D, withCtx as k } from "vue";
+import { useRequiredInject as E } from "../../composables/useRequiredInject.js";
+import { POPOVER_OPTIONS_KEY as N } from "./index.js";
+import A from "./defaults.js";
+import { newId as B } from "../../utils/dom.js";
+import R from "./UluPopoverBase.vue.js";
+const q = ["id", "disabled", "aria-expanded", "aria-controls", "aria-label"], M = {
   __name: "UluPopover",
   props: {
     /**
-     * Text for popover button
+     * V-model state to control the popover externally
      */
+    modelValue: {
+      type: Boolean,
+      default: void 0
+    },
     triggerText: String,
-    /**
-     * Add optional aria-label to button for icons/etc
-     */
     triggerAlt: String,
-    /**
-     * Disable trigger button
-     */
     disabled: Boolean,
-    /**
-     * Tooltip text for trigger button
-     */
     tooltip: String,
-    /**
-     * Popover size (ie large, etc)
-     */
     size: String,
-    /**
-     * No padding on popover content
-     */
     noPadding: Boolean,
-    /**
-     * Floating UI config (merged with defaults for popover)
-     * - See useUluFloating() composable for config API
-     */
     config: {
       type: Object,
       default: () => ({})
     },
-    /**
-     * Mount this component already open state
-     */
     startOpen: Boolean,
-    /**
-     * Active class for trigger button
-     */
     activeClass: {
       type: String,
       default: "is-active"
     },
-    /**
-     * Add custom classes to specific elements
-     * { trigger, content }
-     */
     classes: {
       type: Object,
       default: () => ({})
     },
-    /**
-     * Close popover when click is outside
-     */
     clickOutsideCloses: {
       type: Boolean,
       default: !0
     },
     /**
-     * Direct focus when open/closing popover
+     * Direct focus when open/closing popover.
+     * Overrides UluPopoverBase's default focus management.
      */
-    directFocus: {
-      type: Function,
-      default: ({ isOpen: e, content: g }) => {
-        e && g.focus({ preventScroll: !0 });
-      }
-    }
+    directFocus: Function
   },
-  emits: ["toggle"],
-  setup(e, { emit: g }) {
-    const y = g, i = e, O = A(), b = A(), k = Y(G), B = k ? k.popover : J.popover, S = V(() => ({ ...B, ...i.config })), o = v(i.startOpen || !1), p = v(null), r = v(null), {
-      floatingStyles: E,
-      placement: P,
-      update: $,
-      arrowStyles: z,
-      contentArrow: j,
-      isFixedStrategy: I
-    } = M(p, r, S), w = () => {
-      a(!o.value);
-    }, a = (l) => {
-      o.value = l;
-      const n = {
-        trigger: t(p),
-        content: t(r),
-        isOpen: t(o)
-      }, c = { isOpen: n.isOpen };
-      H(() => {
-        o.value ? ($(), window.setTimeout(() => {
-          N(), i.directFocus(n), y("toggle", c);
-        }, 0)) : (C(), i.directFocus(n), y("toggle", c));
-      });
-    };
-    let s;
-    const N = () => {
-      i.clickOutsideCloses && (s && C(), s = (l) => {
-        r.value && !r.value.contains(l.target) && a(!1);
-      }, document.addEventListener("click", s));
-    }, C = () => {
-      s && (document.removeEventListener("click", s), s = null);
-    }, f = () => a(!1);
-    return (l, n) => {
-      const c = D("ulu-tooltip");
-      return u(), d(K, null, [
-        L((u(), d("button", {
+  emits: ["toggle", "update:modelValue"],
+  setup(e, { expose: S, emit: V }) {
+    const c = V, l = e, u = B(), g = B(), f = E(N), $ = f ? f.popover : A.popover, F = O(() => ({ ...$, ...l.config })), m = r(l.startOpen || !1), p = r(null), P = r(null), o = O({
+      get() {
+        return l.modelValue !== void 0 ? l.modelValue : m.value;
+      },
+      set(t) {
+        l.modelValue !== void 0 ? c("update:modelValue", t) : m.value = t;
+      }
+    }), n = () => {
+      i(!o.value);
+    }, i = (t) => {
+      o.value = t, c("toggle", { isOpen: t });
+    }, s = () => i(!1);
+    return S({
+      /**
+       * The reactive internal open/closed state of the popover
+       */
+      isOpen: o,
+      /**
+       * Method to toggle the popover open/closed
+       */
+      toggle: n,
+      /**
+       * Method to force the popover closed
+       */
+      close: s,
+      /**
+       * Method to explicitly set the open state
+       * @param {Boolean} toOpen - The desired state
+       */
+      changeTo: i
+    }), (t, v) => {
+      const x = I("ulu-tooltip");
+      return y(), b(T, null, [
+        j((y(), b("button", {
           type: "button",
           ref_key: "trigger",
           ref: p,
-          onClick: w,
-          id: t(b),
+          onClick: n,
+          id: a(g),
           disabled: e.disabled,
-          class: F([
+          class: C([
             { [e.activeClass]: o.value },
             e.classes.trigger
           ]),
           "aria-expanded": o.value ? "true" : "false",
-          "aria-controls": t(O),
+          "aria-controls": a(u),
           "aria-label": e.triggerAlt
         }, [
-          m(l.$slots, "trigger", {
+          d(t.$slots, "trigger", {
             isOpen: o.value,
-            close: f
+            close: s
           }, () => [
-            R(U(e.triggerText), 1)
+            h(w(e.triggerText), 1)
           ])
-        ], 10, Q)), [
-          [c, e.tooltip ? e.tooltip : null]
+        ], 10, q)), [
+          [x, e.tooltip ? e.tooltip : null]
         ]),
-        x("span", {
-          class: F(["popover", [
+        z(R, {
+          ref_key: "popoverBase",
+          ref: P,
+          trigger: p.value,
+          config: F.value,
+          isOpen: o.value,
+          clickOutsideCloses: e.clickOutsideCloses,
+          directFocus: e.directFocus,
+          class: C([
             e.size ? `popover--${e.size}` : "",
             {
-              "popover--no-padding": e.noPadding,
-              "popover--fixed": t(I),
-              "is-active": o.value
+              "popover--no-padding": e.noPadding
             },
             e.classes.content
-          ]]),
-          ref_key: "content",
-          ref: r,
-          "aria-labelledby": t(b),
-          id: t(O),
-          style: T(t(E)),
-          "data-placement": t(P),
-          onKeydown: n[0] || (n[0] = q((_) => a(!1), ["esc"])),
-          tabindex: "-1"
-        }, [
-          x("span", X, [
-            m(l.$slots, "default", {
+          ]),
+          "aria-labelledby": a(g),
+          id: a(u),
+          onClose: v[0] || (v[0] = (K) => i(!1))
+        }, D({
+          default: k(() => [
+            d(t.$slots, "default", {
               isOpen: o.value,
-              toggle: w,
-              close: f
+              toggle: n,
+              close: s
             })
           ]),
-          l.$slots.footer ? (u(), d("span", Z, [
-            m(l.$slots, "footer", { close: f })
-          ])) : h("", !0),
-          S.value.arrow ? (u(), d("span", {
-            key: 1,
-            class: "popover__arrow",
-            ref_key: "contentArrow",
-            ref: j,
-            style: T(t(z)),
-            "data-ulu-popover-arrow": ""
-          }, null, 4)) : h("", !0)
-        ], 46, W)
+          _: 2
+        }, [
+          t.$slots.footer ? {
+            name: "footer",
+            fn: k(() => [
+              d(t.$slots, "footer", { close: s })
+            ]),
+            key: "0"
+          } : void 0
+        ]), 1032, ["trigger", "config", "isOpen", "clickOutsideCloses", "directFocus", "class", "aria-labelledby", "id"])
       ], 64);
     };
   }
 };
 export {
-  ie as default
+  M as default
 };

package/dist/plugins/popovers/UluPopoverBase.vue.d.ts

@@ -0,0 +1,58 @@
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    /**
+     * Emits the close event
+     */
+    close: () => void;
+    /**
+     * Manually trigger a floating UI position update
+     */
+    update: Function;
+    /**
+     * The internal root popover element reference
+     */
+    content: import('vue').Ref<null, null>;
+    $emit: (event: "close" | "update:isOpen", ...args: any[]) => void;
+    isOpen: boolean;
+    clickOutsideCloses: boolean;
+    escapeCloses: boolean;
+    directFocus: Function;
+    trigger: Record<string, any>;
+    config: Record<string, any>;
+    modifiers?: string | Record<string, any> | unknown[] | undefined;
+    $props: {
+        readonly isOpen?: boolean | undefined;
+        readonly clickOutsideCloses?: boolean | undefined;
+        readonly escapeCloses?: boolean | undefined;
+        readonly directFocus?: Function | undefined;
+        readonly trigger?: Record<string, any> | undefined;
+        readonly config?: Record<string, any> | undefined;
+        readonly modifiers?: string | Record<string, any> | unknown[] | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    contentEl: HTMLSpanElement;
+    contentArrow: HTMLSpanElement;
+}, HTMLSpanElement>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            isOpen: boolean;
+            close: () => void;
+        }): any;
+        footer?(_: {
+            isOpen: boolean;
+            close: () => void;
+        }): any;
+    };
+    refs: {
+        contentEl: HTMLSpanElement;
+        contentArrow: HTMLSpanElement;
+    };
+    rootEl: HTMLSpanElement;
+};
+//# sourceMappingURL=UluPopoverBase.vue.d.ts.map

package/dist/plugins/popovers/UluPopoverBase.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluPopoverBase.vue.d.ts","sourceRoot":"","sources":["../../../lib/plugins/popovers/UluPopoverBase.vue"],"names":[],"mappings":"AA+BA;wBAoeqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAdjC;IAzHI;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;oBA0HJ"}