@ulu/frontend-vue 0.2.0-beta.2 → 0.2.0-beta.4

package/dist/plugins/breakpoints/index.js

@@ -0,0 +1,34 @@
+import { ref as b, computed as o } from "vue";
+import { useBreakpointManager as f } from "../../composables/useBreakpointManager.js";
+const d = {
+  /**
+   * Breakpoint for mobile down/max
+   */
+  breakpointMobile: "small",
+  /**
+   * Options to pass to useBreakpointManager()
+   */
+  managerOptions: {}
+};
+function k(e, r) {
+  const n = b(!1), a = Object.assign({}, d, r), { breakpointMobile: s } = a, { onReady: t } = a.managerOptions, l = {
+    onReady(i) {
+      i.at(s).max({
+        on() {
+          n.value = !0;
+        },
+        off() {
+          n.value = !1;
+        }
+      }), t && t(i);
+    }
+  }, u = Object.assign({}, a.managerOptions, l), {
+    breakpointManager: p,
+    breakpointActive: c,
+    breakpointDirection: v
+  } = f(u);
+  e.provide("uluBreakpointActive", o(() => c.value)), e.provide("uluBreakpointDirection", o(() => v.value)), e.provide("uluBreakpointManager", o(() => p.value)), e.provide("uluIsMobile", o(() => n.value));
+}
+export {
+  k as default
+};

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/plugins/core/index.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;GAUG;AACH,qCAPW,MAAM,iBAEd;IAA+B,iBAAiB;IAClB,aAAa;IACX,gBAAgB;IAClB,WAAW;CAC3C,QA0DA;AAtED,gCAA0D"}

package/dist/plugins/core/index.js

@@ -0,0 +1,71 @@
+import { reactive as c } from "vue";
+const o = {
+  fontAwesomeStatic: !1,
+  iconComponent: null,
+  iconPropResolver: (a) => ({ icon: a }),
+  iconsByType: {
+    danger: "fas fa-triangle-exclamation",
+    warning: "fas fa-circle-exclamation",
+    info: "fas fa-circle-info",
+    success: "fas fa-circle-check",
+    externalLink: "fas fa-arrow-up-right-from-square",
+    close: "fas fa-xmark",
+    remove: "fas fa-xmark",
+    expand: "fas fa-plus",
+    collapse: "fas fa-minus",
+    resizeHorizontal: "fas fa-grip-lines-vertical",
+    resizeVertical: "fas fa-grip-lines",
+    resizeBoth: "fas fa-grip",
+    ellipsis: "fas fa-ellipsis",
+    pathSeparator: "fas fa-chevron-right",
+    image: "fas fa-image",
+    file: "fas fa-file",
+    previous: "fas fa-chevron-left",
+    next: "fas fa-chevron-right",
+    dropdownExpand: "fas fa-caret-down"
+  }
+};
+function p(a, f = {}) {
+  const t = c({ ...o }), { iconsByType: i, ...r } = f || {};
+  r && Object.assign(t, r);
+  const s = {
+    // Methods to interact with settings
+    getSettings() {
+      return t;
+    },
+    getDefaultSettings() {
+      return { ...o };
+    },
+    updateSettings(e) {
+      return Object.assign(t, e);
+    },
+    getSetting(e) {
+      if (!t.hasOwnProperty(e)) {
+        console.warn(`Attempted to access non-existent setting: ${e}`);
+        return;
+      }
+      return t[e];
+    },
+    updateSetting(e, n) {
+      if (typeof e != "string")
+        throw new Error("Expected key to be string");
+      t[e] = n;
+    },
+    getIcon(e) {
+      const n = t.iconsByType;
+      if (!n[e])
+        throw new Error(`Icon type "${e}" not found!`);
+      return n[e];
+    },
+    setIcon(e, n) {
+      t.iconsByType[e] = n;
+    }
+  };
+  if (i)
+    for (const [e, n] of Object.entries(i))
+      s.setIcon(e, n);
+  a.provide("uluCore", s), a.config.globalProperties.$uluCore = s;
+}
+export {
+  p as default
+};

package/dist/plugins/index.d.ts

@@ -0,0 +1,6 @@
+export { default as corePlugin } from './core/index.js';
+export { default as modalsPlugin } from './modals/index.js';
+export { default as toastPlugin } from './toast/index.js';
+export { default as breakpointsPlugin } from './breakpoints/index.js';
+export { default as popoversPlugin, useTooltip, useTooltipFollow } from './popovers/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/{types/utils → plugins}/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/utils/index.js"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/plugins/index.js"],"names":[],"mappings":""}

package/dist/{types/plugins → plugins}/modals/UluModalsDisplay.vue.d.ts

@@ -1,4 +1,4 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {
+declare const _default: import('vue').DefineComponent<{}, {}, {
     open: boolean;
 }, {
     currentModal(): any;
@@ -6,9 +6,9 @@ declare const _default: import("vue").DefineComponent<{}, {}, {
 }, {
     modalMounted(): void;
     modalUnmounted(): void;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("modal-unmount" | "modal-mount")[], "modal-unmount" | "modal-mount", import("vue").PublicProps, Readonly<{}> & Readonly<{
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("modal-unmount" | "modal-mount")[], "modal-unmount" | "modal-mount", import('vue').PublicProps, Readonly<{}> & Readonly<{
     "onModal-unmount"?: ((...args: any[]) => any) | undefined;
     "onModal-mount"?: ((...args: any[]) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;
 //# sourceMappingURL=UluModalsDisplay.vue.d.ts.map

package/dist/plugins/modals/UluModalsDisplay.vue.d.ts.map

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

package/dist/plugins/modals/UluModalsDisplay.vue.js

@@ -0,0 +1,54 @@
+import { createBlock as d, createCommentVNode as u, openBlock as a, resolveDynamicComponent as l, mergeProps as m } from "vue";
+import s from "../../_virtual/_plugin-vue_export-helper.js";
+const c = {
+  name: "UluModalsDisplay",
+  emits: [
+    "modal-unmount",
+    "modal-mount"
+  ],
+  data() {
+    return {
+      open: !1
+    };
+  },
+  computed: {
+    currentModal() {
+      return this.$uluModalsState.data?.active;
+    },
+    currentProps() {
+      return this.$uluModalsState.data?.activeProps;
+    }
+  },
+  watch: {
+    // Watch for changes in the global state (e.g., when $uluModals.open() is called)
+    currentModal(o) {
+      o ? this.open = !0 : this.open = !1;
+    },
+    // Watch for changes in the local state (e.g., when the modal emits 'update:modelValue')
+    open(o) {
+      !o && this.currentModal && this.$uluModals.close();
+    }
+  },
+  methods: {
+    modalMounted() {
+      this.$emit("modal-mount", { modal: this.currentModal });
+    },
+    modalUnmounted() {
+      this.$nextTick(() => {
+        this.$emit("modal-unmount");
+      });
+    }
+  }
+};
+function i(o, t, p, M, n, e) {
+  return e.currentModal ? (a(), d(l(e.currentModal.component), m({ key: 0 }, e.currentProps, {
+    modelValue: n.open,
+    "onUpdate:modelValue": t[0] || (t[0] = (r) => n.open = r),
+    onVnodeMounted: e.modalMounted,
+    onVnodeUnmounted: e.modalUnmounted
+  }), null, 16, ["modelValue", "onVnodeMounted", "onVnodeUnmounted"])) : u("", !0);
+}
+const V = /* @__PURE__ */ s(c, [["render", i]]);
+export {
+  V as default
+};

package/dist/plugins/modals/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../lib/plugins/modals/api.js"],"names":[],"mappings":";;;;AA6BO;;IAML;;;;OAIG;;IAKH;;;OAGG;oBADS,MAAM;IAUlB;;OAEG;;IAKH;;;OAGG;uBADS,MAAM;EAUlB;AAxDF;;GAEG;AACH;;;EAAyB;AAnBzB,4BAAkB"}

package/dist/plugins/modals/api.js

@@ -0,0 +1,58 @@
+import { ref as l, markRaw as r } from "vue";
+const n = [], c = l({
+  /**
+   * Holds active component options (including component, and options)
+   */
+  active: null,
+  /**
+   * Populated with any props passed to open method, bound to modal component
+   */
+  activeProps: null
+}), a = c.value, d = {
+  data: a,
+  modals: n
+}, m = (s) => ({
+  open(t, e = null) {
+    const o = this.get(t);
+    a.active = r(o), a.activeProps = Object.assign({}, o.props, e);
+  },
+  /**
+   * Close the active modal
+   * @param {String|Node} focusTo The element or selector for an element to programmatically focus after modal close
+   * @see https://www.deque.com/blog/accessible-routing-in-javascript-frameworks/
+   */
+  close() {
+    a.active = null, a.activeProps = null;
+  },
+  /**
+   * Get a modal's config object by name
+   * @return {Object} Modal config object
+   */
+  get(t) {
+    const e = n.find((o) => o.name === t);
+    if (e)
+      return e;
+    throw new Error(`Unable to find modal named: ${t}`);
+  },
+  /**
+   * Add a modal config
+   */
+  add(t) {
+    const e = s(t);
+    n.push(e);
+  },
+  /**
+   * Removes a modal config by name
+   * @return {Object} Modal that was removed
+   */
+  remove(t) {
+    const e = n.findIndex((o) => o.name === t);
+    if (e > -1)
+      return n.splice(e, 1);
+    warn("unable to find modal to remove");
+  }
+});
+export {
+  m as createApi,
+  d as modalsState
+};

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/plugins/modals/index.js"],"names":[],"mappings":"AAsBA;;;;GAIG;AACH,uDAFW,sBAAsB,QA8BhC;;;;;;;;;;;;kBAxCa,eAAe"}

package/dist/plugins/modals/index.js

@@ -0,0 +1,16 @@
+import n from "./UluModalsDisplay.vue.js";
+import e from "../../components/collapsible/UluModal.vue.js";
+import { createApi as d, modalsState as a } from "./api.js";
+const r = {
+  modals: [],
+  modalOptions: {}
+};
+function f(o, i) {
+  const l = Object.assign({}, r, i), s = d((t) => Object.assign({}, l.modalOptions, t));
+  o.component("UluModalsDisplay", n), o.component("UluModal", e), l.modals.forEach((t) => {
+    s.add(t);
+  }), a.options = l, o.config.globalProperties.$uluModals = s, o.provide("uluModals", s), o.config.globalProperties.$uluModalsState = a;
+}
+export {
+  f as default
+};

package/dist/plugins/modals/useModals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useModals.d.ts","sourceRoot":"","sources":["../../../lib/plugins/modals/useModals.js"],"names":[],"mappings":"AASO,6BAHM,MAAM,CASlB"}

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

@@ -0,0 +1,62 @@
+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<{}, {
+    $emit: (event: "toggle", ...args: any[]) => void;
+    config: Record<string, any>;
+    disabled: boolean;
+    noPadding: boolean;
+    startOpen: boolean;
+    activeClass: string;
+    classes: Record<string, any>;
+    clickOutsideCloses: boolean;
+    directFocus: Function;
+    triggerText?: string | undefined;
+    triggerAlt?: string | undefined;
+    tooltip?: string | undefined;
+    size?: string | undefined;
+    $props: {
+        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 triggerText?: string | undefined;
+        readonly triggerAlt?: string | undefined;
+        readonly tooltip?: string | undefined;
+        readonly size?: string | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    trigger: HTMLButtonElement;
+    content: HTMLSpanElement;
+    contentArrow: HTMLSpanElement;
+}, any>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        trigger?(_: {
+            isOpen: boolean;
+            close: () => void;
+        }): any;
+        default?(_: {
+            isOpen: boolean;
+            toggle: () => void;
+            close: () => void;
+        }): any;
+        footer?(_: {
+            close: () => void;
+        }): any;
+    };
+    refs: {
+        trigger: HTMLButtonElement;
+        content: HTMLSpanElement;
+        contentArrow: HTMLSpanElement;
+    };
+    rootEl: any;
+};
+//# sourceMappingURL=UluPopover.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UluPopover.vue.d.ts","sourceRoot":"","sources":["../../../lib/plugins/popovers/UluPopover.vue"],"names":[],"mappings":"AAuDA;wBA4aqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAZjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QASG"}

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

@@ -0,0 +1,146 @@
+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 = {
+  __name: "UluPopover",
+  props: {
+    triggerText: String,
+    triggerAlt: String,
+    disabled: Boolean,
+    tooltip: String,
+    size: String,
+    noPadding: Boolean,
+    config: {
+      type: Object,
+      default: () => ({})
+    },
+    startOpen: Boolean,
+    activeClass: {
+      type: String,
+      default: "is-active"
+    },
+    classes: {
+      type: Object,
+      default: () => ({})
+    },
+    clickOutsideCloses: {
+      type: Boolean,
+      default: !0
+    },
+    directFocus: {
+      type: Function,
+      default: ({ isOpen: e, content: g }) => {
+        e && g.focus({ preventScroll: !0 });
+      }
+    }
+  },
+  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", {
+          type: "button",
+          ref_key: "trigger",
+          ref: p,
+          onClick: w,
+          id: t(b),
+          disabled: e.disabled,
+          class: F([
+            { [e.activeClass]: o.value },
+            e.classes.trigger
+          ]),
+          "aria-expanded": o.value ? "true" : "false",
+          "aria-controls": t(O),
+          "aria-label": e.triggerAlt
+        }, [
+          m(l.$slots, "trigger", {
+            isOpen: o.value,
+            close: f
+          }, () => [
+            R(U(e.triggerText), 1)
+          ])
+        ], 10, Q)), [
+          [c, e.tooltip ? e.tooltip : null]
+        ]),
+        x("span", {
+          class: F(["popover", [
+            e.size ? `popover--${e.size}` : "",
+            {
+              "popover--no-padding": e.noPadding,
+              "popover--fixed": t(I),
+              "is-active": o.value
+            },
+            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", {
+              isOpen: o.value,
+              toggle: w,
+              close: f
+            })
+          ]),
+          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)
+      ], 64);
+    };
+  }
+};
+export {
+  ie as default
+};

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

@@ -0,0 +1,3 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UluTooltipDisplay.vue.d.ts.map

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

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

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

@@ -0,0 +1,22 @@
+import { createBlock as o, createCommentVNode as r, unref as e, openBlock as i, Teleport as c, createVNode as n } from "vue";
+import { useRequiredInject as a } from "../../composables/useRequiredInject.js";
+import { TOOLTIP_STATE_KEY as p } from "./index.js";
+import s from "./UluTooltipPopover.vue.js";
+const d = {
+  __name: "UluTooltipDisplay",
+  setup(m) {
+    const t = a(p);
+    return (f, l) => e(t)?.state.visible ? (i(), o(c, {
+      key: 0,
+      to: e(t).state.config.teleportTo || "body"
+    }, [
+      n(s, {
+        trigger: e(t).state.trigger,
+        config: e(t).state.config
+      }, null, 8, ["trigger", "config"])
+    ], 8, ["to"])) : r("", !0);
+  }
+};
+export {
+  d as default
+};

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

@@ -0,0 +1,13 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    trigger: Record<string, any>;
+    config?: Record<string, any> | undefined;
+    $props: {
+        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>;
+export default _default;
+//# sourceMappingURL=UluTooltipPopover.vue.d.ts.map

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

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

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

@@ -0,0 +1,58 @@
+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 = {
+  __name: "UluTooltipPopover",
+  props: {
+    config: Object,
+    trigger: {
+      type: Object,
+      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)
+        ], 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));
+  }
+};
+export {
+  j as default
+};

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

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../../lib/plugins/popovers/defaults.js"],"names":[],"mappings":";gBAGY,MAAM;;;;;;;;;iBA8CN,MAAM"}