@ulu/frontend-vue 0.6.23 → 0.6.24

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

@@ -0,0 +1,146 @@
+import { ref as B, computed as m, watch as x, nextTick as g, onUnmounted as L, createElementBlock as u, openBlock as d, withKeys as M, unref as l, normalizeStyle as y, normalizeClass as T, createElementVNode as j, createCommentVNode as v, renderSlot as O } from "vue";
+import { useUluFloating as A } from "../../composables/useUluFloating.js";
+import { useModifiers as H } from "../../composables/useModifiers.js";
+import { wasClickOutside as U } from "@ulu/utils/browser/dom.js";
+const $ = ["data-placement"], z = { class: "popover__inner" }, K = {
+  key: 0,
+  class: "popover__footer"
+}, G = {
+  __name: "UluPopoverBase",
+  props: {
+    /**
+     * Controls the open/active state of the popover
+     */
+    isOpen: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Close popover when click is outside
+     */
+    clickOutsideCloses: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * Close popover when escape key is pressed
+     */
+    escapeCloses: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * Direct focus when open/closing popover
+     */
+    directFocus: {
+      type: Function,
+      default: ({ isOpen: s, trigger: r, content: c }) => {
+        s && c ? c.focus({ preventScroll: !0 }) : !s && r && r instanceof HTMLElement && r.focus({ preventScroll: !0 });
+      }
+    },
+    /**
+     * The target element for the popover to float alongside
+     */
+    trigger: {
+      type: Object,
+      default: null
+    },
+    /**
+     * Floating UI configuration
+     */
+    config: {
+      type: Object,
+      default: () => ({})
+    },
+    /**
+     * Modifiers (to add any modifier classes based on base class [ie. 'large'])
+     */
+    modifiers: [String, Array, Object]
+  },
+  emits: ["close"],
+  setup(s, { expose: r, emit: c }) {
+    const k = c, e = s, o = B(null), { resolvedModifiers: C } = H({ props: e, baseClass: "popover" }), f = m(() => e.config || {}), { floatingStyles: _, placement: w, arrowStyles: E, update: p, isFixedStrategy: F, contentArrow: S } = A(
+      m(() => e.trigger),
+      o,
+      f
+    ), i = () => {
+      k("close");
+    }, h = (t) => {
+      e.isOpen && e.escapeCloses && (t.preventDefault(), i());
+    };
+    let n = null;
+    const a = () => {
+      n && (document.removeEventListener("click", n), n = null);
+    }, b = () => {
+      a(), e.clickOutsideCloses && (n = (t) => {
+        if (!(!e.isOpen || !o.value) && document.body.contains(t.target) && !o.value.contains(t.target) && U(o.value, t)) {
+          if (e.trigger instanceof HTMLElement && e.trigger.contains(t.target))
+            return;
+          i();
+        }
+      }, setTimeout(() => {
+        n && document.addEventListener("click", n);
+      }, 0));
+    };
+    return x(() => e.isOpen, (t) => {
+      t ? (p(), b(), e.directFocus && g(() => {
+        e.directFocus({ isOpen: !0, trigger: e.trigger, content: o.value });
+      })) : (a(), e.directFocus && g(() => {
+        e.directFocus({ isOpen: !1, trigger: e.trigger, content: o.value });
+      }));
+    }, { immediate: !0 }), L(() => {
+      a();
+    }), r({
+      /**
+       * Emits the close event
+       */
+      close: i,
+      /**
+       * Manually trigger a floating UI position update
+       */
+      update: p,
+      /**
+       * The internal root popover element reference
+       */
+      content: o
+    }), (t, N) => (d(), u("span", {
+      class: T(["popover", [
+        {
+          "popover--fixed": l(F),
+          "is-active": s.isOpen
+        },
+        l(C)
+      ]]),
+      ref_key: "contentEl",
+      ref: o,
+      style: y(l(_)),
+      "data-placement": l(w),
+      onKeydown: M(h, ["esc"]),
+      tabindex: "-1"
+    }, [
+      j("span", z, [
+        O(t.$slots, "default", {
+          isOpen: s.isOpen,
+          close: i
+        })
+      ]),
+      t.$slots.footer ? (d(), u("span", K, [
+        O(t.$slots, "footer", {
+          isOpen: s.isOpen,
+          close: i
+        })
+      ])) : v("", !0),
+      f.value.arrow ? (d(), u("span", {
+        key: 1,
+        class: "popover__arrow",
+        ref_key: "contentArrow",
+        ref: S,
+        style: y(l(E)),
+        "data-ulu-popover-arrow": ""
+      }, null, 4)) : v("", !0)
+    ], 46, $));
+  }
+};
+export {
+  G as default
+};

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

@@ -5,9 +5,6 @@ declare const _default: import('vue').DefineComponent<{}, {
         readonly trigger?: Record<string, any> | undefined;
         readonly config?: Record<string, any> | undefined;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
-    content: HTMLSpanElement;
-    contentArrow: HTMLSpanElement;
-}, HTMLSpanElement>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLSpanElement>;
 export default _default;
 //# sourceMappingURL=UluTooltipPopover.vue.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"UluTooltipPopover.vue.d.ts","sourceRoot":"","sources":["../../../lib/plugins/popovers/UluTooltipPopover.vue"],"names":[],"mappings":"AA+BA;"}
+{"version":3,"file":"UluTooltipPopover.vue.d.ts","sourceRoot":"","sources":["../../../lib/plugins/popovers/UluTooltipPopover.vue"],"names":[],"mappings":"AAiBA;"}

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

@@ -1,10 +1,7 @@
-import { ref as _, computed as f, toRef as v, createElementBlock as t, openBlock as o, normalizeStyle as a, unref as n, normalizeClass as y, createCommentVNode as d, createBlock as g, resolveDynamicComponent as k, normalizeProps as T, mergeProps as w, Fragment as x, createTextVNode as P, toDisplayString as S } from "vue";
-import { useUluFloating as h } from "../../composables/useUluFloating.js";
-import { TOOLTIP_ID as C } from "./index.js";
-const O = ["id", "data-placement"], z = ["innerHTML"], B = {
-  key: 1,
-  class: "popover__inner"
-}, j = {
+import { computed as a, createBlock as r, openBlock as o, unref as i, normalizeClass as s, withCtx as p, createElementBlock as t, Fragment as l, resolveDynamicComponent as m, normalizeProps as u, mergeProps as g, createTextVNode as f, toDisplayString as v } from "vue";
+import { TOOLTIP_ID as _ } from "./index.js";
+import d from "./UluPopoverBase.vue.js";
+const k = ["innerHTML"], O = {
   __name: "UluTooltipPopover",
   props: {
     config: Object,
@@ -13,46 +10,28 @@ const O = ["id", "data-placement"], z = ["innerHTML"], B = {
       default: null
     }
   },
-  setup(s) {
-    const r = s, l = _(null), e = f(() => r.config), {
-      floatingStyles: c,
-      placement: p,
-      arrowStyles: i,
-      contentArrow: m,
-      isFixedStrategy: u
-    } = h(v(r, "trigger"), l, e);
-    return (D, F) => (o(), t("span", {
-      class: y(["popover popover--tooltip is-active", [
-        {
-          "popover--fixed": n(u)
-        },
-        e.value.class
-      ]]),
-      ref_key: "content",
-      ref: l,
-      id: n(C),
-      "data-placement": n(p),
-      style: a(n(c))
-    }, [
-      e.value.isHtml ? (o(), t("span", {
-        key: 0,
-        class: "popover__inner",
-        innerHTML: e.value.content
-      }, null, 8, z)) : (o(), t("span", B, [
-        e.value.component ? (o(), g(k(e.value.component), T(w({ key: 0 }, e.value.componentProps)), null, 16)) : (o(), t(x, { key: 1 }, [
-          P(S(e.value.content), 1)
+  setup(n) {
+    const c = n, e = a(() => c.config);
+    return (y, T) => (o(), r(d, {
+      class: s(["popover--tooltip is-active", e.value.class]),
+      id: i(_),
+      trigger: n.trigger,
+      config: e.value
+    }, {
+      default: p(() => [
+        e.value.isHtml ? (o(), t("span", {
+          key: 0,
+          innerHTML: e.value.content
+        }, null, 8, k)) : (o(), t(l, { key: 1 }, [
+          e.value.component ? (o(), r(m(e.value.component), u(g({ key: 0 }, e.value.componentProps)), null, 16)) : (o(), t(l, { key: 1 }, [
+            f(v(e.value.content), 1)
+          ], 64))
         ], 64))
-      ])),
-      e.value.arrow ? (o(), t("span", {
-        key: 2,
-        class: "popover__arrow",
-        ref_key: "contentArrow",
-        ref: m,
-        style: a(n(i))
-      }, null, 4)) : d("", !0)
-    ], 14, O));
+      ]),
+      _: 1
+    }, 8, ["id", "trigger", "config", "class"]));
   }
 };
 export {
-  j as default
+  O as default
 };

package/dist/plugins/popovers/index.d.ts

@@ -20,4 +20,8 @@ export const TOOLTIP_ID: "ulu-global-tooltip";
 export { useTooltip };
 export { default as useTooltipFollow } from './useTooltipFollow.js';
 export function resolveTooltipConfig(rawConfig: any, tooltipDefaults: object): object | null;
+export { default as UluPopover } from './UluPopover.vue';
+export { default as UluPopoverBase } from './UluPopoverBase.vue';
+export { default as UluTooltipDisplay } from './UluTooltipDisplay.vue';
+export { default as UluTooltipPopover } from './UluTooltipPopover.vue';
 //# sourceMappingURL=index.d.ts.map

package/dist/plugins/popovers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/plugins/popovers/index.js"],"names":[],"mappings":"AAoDA;;;;GAIG;AACH,qCAHW,MAAM,gBACN,MAAM,QAgJhB;AA9LD;;GAEG;AACH,kCAAmC,mBAAmB,CAAC;AAEvD;;GAEG;AACH,gCAAiC,iBAAiB,CAAC;AAEnD;;GAEG;AACH,yBAA0B,oBAAoB,CAAC;;;AAcxC,gDAJI,GAAC,mBACD,MAAM,GACJ,MAAM,GAAC,IAAI,CAgBvB;2BA3C0B,iBAAiB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/plugins/popovers/index.js"],"names":[],"mappings":"AAqDA;;;;GAIG;AACH,qCAHW,MAAM,gBACN,MAAM,QAqJhB;AAnMD;;GAEG;AACH,kCAAmC,mBAAmB,CAAC;AAEvD;;GAEG;AACH,gCAAiC,iBAAiB,CAAC;AAEnD;;GAEG;AACH,yBAA0B,oBAAoB,CAAC;;;AAcxC,gDAJI,GAAC,mBACD,MAAM,GACJ,MAAM,GAAC,IAAI,CAgBvB;;;;;2BA3C0B,iBAAiB"}

package/dist/plugins/popovers/index.js

@@ -1,81 +1,86 @@
-import { reactive as L, markRaw as y } from "vue";
-import A from "./UluTooltipDisplay.vue.js";
-import _ from "./UluPopover.vue.js";
-import g from "./defaults.js";
-const P = "uluPopoverOptions", O = "uluTooltipState", D = "ulu-global-tooltip", T = (s, u) => {
+import { reactive as _, markRaw as y } from "vue";
+import L from "./UluTooltipDisplay.vue.js";
+import P from "./UluPopover.vue.js";
+import D from "./UluPopoverBase.vue.js";
+import E from "./defaults.js";
+const O = "uluPopoverOptions", U = "uluTooltipState", A = "ulu-global-tooltip", T = (s, f) => {
   if (s === !1 || s === null) return null;
   let i = s;
-  return (typeof i != "object" || Array.isArray(i)) && (i = { content: i }), i.component && (i.component = y(i.component)), { ...u, ...i };
+  return (typeof i != "object" || Array.isArray(i)) && (i = { content: i }), i.component && (i.component = y(i.component)), { ...f, ...i };
 };
-function K(s, u = {}) {
+function M(s, f = {}) {
   const i = {
-    plugin: { ...g.plugin, ...u.plugin || {} },
-    popover: { ...g.popover, ...u.popover || {} },
-    tooltip: { ...g.tooltip, ...u.tooltip || {} }
+    plugin: { ...E.plugin, ...f.plugin || {} },
+    popover: { ...E.popover, ...f.popover || {} },
+    tooltip: { ...E.tooltip, ...f.tooltip || {} }
   };
-  s.provide(P, i);
-  const o = L({
+  s.provide(O, i);
+  const o = _({
     visible: !1,
     trigger: null,
     config: {}
-  }), h = (e, r) => {
-    if (e && !r.teleportTo) {
-      const t = e.closest("dialog");
-      t && (r.teleportTo = t);
+  }), h = (e, n) => {
+    const t = e instanceof Element;
+    if (t && !n.teleportTo) {
+      const r = e.closest("dialog");
+      r && (n.teleportTo = r);
     }
-    o.trigger && o.trigger !== e && o.trigger?.removeAttribute && o.trigger.removeAttribute("aria-describedby"), e?.setAttribute && e.setAttribute("aria-describedby", D), o.trigger = e, o.config = r, o.visible = !0;
-  }, f = () => {
-    o.trigger?.removeAttribute && o.trigger.removeAttribute("aria-describedby"), o.visible = !1;
+    o.trigger && o.trigger !== e && o.trigger instanceof Element && o.trigger.removeAttribute("aria-describedby"), t && e.setAttribute("aria-describedby", A), o.trigger = e, o.config = n, o.visible = !0;
+  }, u = () => {
+    o.trigger instanceof Element && o.trigger.removeAttribute("aria-describedby"), o.visible = !1;
   };
-  s.provide(O, {
+  s.provide(U, {
     state: o,
     show: h,
-    hide: f
-  }), s.component("UluTooltipDisplay", A), s.component("UluPopover", _);
-  const v = /* @__PURE__ */ new WeakMap(), b = i.popover, w = i.tooltip, E = { ...b, ...w };
+    hide: u
+  }), s.component("UluTooltipDisplay", L), s.component("UluPopover", P), s.component("UluPopoverBase", D);
+  const v = /* @__PURE__ */ new WeakMap(), b = i.popover, w = i.tooltip, g = { ...b, ...w };
   s.directive(i.plugin.directiveName, {
-    mounted(e, r) {
-      const t = T(r.value, E);
+    mounted(e, n) {
+      const t = T(n.value, g);
       if (!t) return;
-      let n = null;
-      const c = () => {
-        n || (n = setTimeout(() => {
+      let r = null;
+      const l = () => {
+        r || (r = setTimeout(() => {
           h(e, t);
         }, t.delay));
       }, d = () => {
-        clearTimeout(n), n = null, f();
+        clearTimeout(r), r = null, u();
       }, { showEvents: p, hideEvents: m } = t;
-      p.forEach((a) => e.addEventListener(a, c)), m.forEach((a) => e.addEventListener(a, d)), v.set(e, { show: c, hide: d, showEvents: p, hideEvents: m });
+      p.forEach((c) => e.addEventListener(c, l)), m.forEach((c) => e.addEventListener(c, d)), v.set(e, { show: l, hide: d, showEvents: p, hideEvents: m });
     },
-    updated(e, r) {
+    updated(e, n) {
       const t = v.get(e);
-      t && (t.showEvents.forEach((l) => e.removeEventListener(l, t.show)), t.hideEvents.forEach((l) => e.removeEventListener(l, t.hide)));
-      const n = T(r.value, E);
-      if (!n) {
-        o.trigger === e && f();
+      t && (t.showEvents.forEach((a) => e.removeEventListener(a, t.show)), t.hideEvents.forEach((a) => e.removeEventListener(a, t.hide)));
+      const r = T(n.value, g);
+      if (!r) {
+        o.trigger === e && u();
         return;
       }
-      let c = null;
+      let l = null;
       const d = () => {
-        c || (c = setTimeout(() => {
-          h(e, n);
-        }, n.delay));
+        l || (l = setTimeout(() => {
+          h(e, r);
+        }, r.delay));
       }, p = () => {
-        clearTimeout(c), c = null, f();
-      }, { showEvents: m, hideEvents: a } = n;
-      m.forEach((l) => e.addEventListener(l, d)), a.forEach((l) => e.addEventListener(l, p)), v.set(e, { show: d, hide: p, showEvents: m, hideEvents: a }), o.visible && o.trigger === e && h(e, n);
+        clearTimeout(l), l = null, u();
+      }, { showEvents: m, hideEvents: c } = r;
+      m.forEach((a) => e.addEventListener(a, d)), c.forEach((a) => e.addEventListener(a, p)), v.set(e, { show: d, hide: p, showEvents: m, hideEvents: c }), o.visible && o.trigger === e && h(e, r);
     },
     beforeUnmount(e) {
-      o.visible && o.trigger === e && f();
-      const r = v.get(e);
-      r && (r.showEvents.forEach((t) => e.removeEventListener(t, r.show)), r.hideEvents.forEach((t) => e.removeEventListener(t, r.hide)), v.delete(e));
+      o.visible && o.trigger === e && u();
+      const n = v.get(e);
+      n && (n.showEvents.forEach((t) => e.removeEventListener(t, n.show)), n.hideEvents.forEach((t) => e.removeEventListener(t, n.hide)), v.delete(e));
     }
   });
 }
 export {
-  P as POPOVER_OPTIONS_KEY,
-  D as TOOLTIP_ID,
-  O as TOOLTIP_STATE_KEY,
-  K as default,
+  O as POPOVER_OPTIONS_KEY,
+  A as TOOLTIP_ID,
+  U as TOOLTIP_STATE_KEY,
+  P as UluPopover,
+  D as UluPopoverBase,
+  L as UluTooltipDisplay,
+  M as default,
   T as resolveTooltipConfig
 };

package/dist/plugins/tour/UluTourContent.vue.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    step: Record<string, any>;
+    isModal: boolean;
+    $props: {
+        readonly step?: Record<string, any> | undefined;
+        readonly isModal?: boolean | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=UluTourContent.vue.d.ts.map

package/dist/plugins/tour/UluTourContent.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluTourContent.vue.d.ts","sourceRoot":"","sources":["../../../lib/plugins/tour/UluTourContent.vue"],"names":[],"mappings":"AAgBA;"}

package/dist/plugins/tour/UluTourContent.vue.js

@@ -0,0 +1,39 @@
+import { createElementBlock as o, openBlock as t, createBlock as s, createCommentVNode as n, createVNode as c, resolveDynamicComponent as l, normalizeClass as r, withCtx as i, createTextVNode as m, toDisplayString as a } from "vue";
+import d from "../../components/elements/UluRule.vue.js";
+const u = { class: "tour-content crop-margins" }, p = { key: 1 }, C = {
+  __name: "UluTourContent",
+  props: {
+    /**
+     * The tour step configuration object
+     */
+    step: {
+      type: Object,
+      required: !0
+    },
+    /**
+     * Adjusts the typography to match a modal context rather than a popover context
+     */
+    isModal: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  setup(e) {
+    return (f, h) => (t(), o("div", u, [
+      e.step?.title ? (t(), s(l(e.isModal ? "h2" : "strong"), {
+        key: 0,
+        class: r([e.isModal ? "h3" : "h4", "display-block no-margin"])
+      }, {
+        default: i(() => [
+          m(a(e.step.title), 1)
+        ]),
+        _: 1
+      }, 8, ["class"])) : n("", !0),
+      c(d),
+      e.step?.content ? (t(), o("p", p, a(e.step.content), 1)) : n("", !0)
+    ]));
+  }
+};
+export {
+  C as default
+};

package/dist/plugins/tour/UluTourDisplay.vue.d.ts

@@ -0,0 +1,100 @@
+import { nextTick } from 'vue';
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    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", ...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 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", ...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>;
+export default _default;
+//# sourceMappingURL=UluTourDisplay.vue.d.ts.map

package/dist/plugins/tour/UluTourDisplay.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluTourDisplay.vue.d.ts","sourceRoot":"","sources":["../../../lib/plugins/tour/UluTourDisplay.vue"],"names":[],"mappings":"AA+DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAkhBs4S,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA1Vn7S,KAAK"}