@dialpad/dialtone-vue 3.73.0 → 3.73.2

package/dist/popover-3dbe0634.js

@@ -0,0 +1,975 @@
+import { _ as C, D as w, b as S, W as k, h as L, d as x, g as O, X as F, Y as B, Z as H } from "./index-a257a50a.js";
+import { resolveComponent as d, openBlock as r, createBlock as a, withKeys as p, withModifiers as v, withCtx as u, createVNode as g, createElementBlock as E, normalizeClass as h, renderSlot as y, createCommentVNode as f, mergeProps as A, Teleport as I, createElementVNode as b, resolveDynamicComponent as D, toHandlers as R } from "vue";
+const V = {
+  props: {
+    /**
+     * If true, a hidden close button is included for screen readers
+     * @values true, false
+     */
+    visuallyHiddenClose: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Label for the visually hidden close button
+     * Required if visuallyHiddenClose is set to `true`
+     */
+    visuallyHiddenCloseLabel: {
+      type: String,
+      default: null
+    }
+  },
+  watch: {
+    $props: {
+      immediate: !0,
+      deep: !0,
+      handler() {
+        this.validateVisuallyHiddenCloseProps();
+      }
+    }
+  },
+  computed: {
+    showVisuallyHiddenClose() {
+      return this.visuallyHiddenClose && this.visuallyHiddenCloseLabel != null;
+    }
+  },
+  methods: {
+    validateVisuallyHiddenCloseProps() {
+      this.visuallyHiddenClose && !this.visuallyHiddenCloseLabel && console.error(`If visuallyHiddenClose prop is true, the component includes
+           a visually hidden close button and you must set the visuallyHiddenCloseLabel prop.`);
+    }
+  }
+}, N = {
+  name: "SrOnlyCloseButton",
+  components: {
+    DtIcon: w,
+    DtButton: S
+  },
+  props: {
+    /**
+     * Label for the visually hidden close button
+     * Required if visuallyHiddenClose is set to `true`
+     */
+    visuallyHiddenCloseLabel: {
+      type: String,
+      default: null
+    }
+  },
+  emits: ["close"],
+  methods: {
+    close() {
+      this.$emit("close");
+    }
+  }
+};
+function K(e, t, o, s, i, n) {
+  const c = d("dt-icon"), m = d("dt-button");
+  return r(), a(m, {
+    id: "sr-only-close-button",
+    "data-qa": "dt-sr-only-close-button",
+    class: "d-vi-visible-sr",
+    "aria-label": o.visuallyHiddenCloseLabel,
+    onClick: n.close,
+    onKeydown: p(v(n.close, ["prevent", "stop"]), ["space"])
+  }, {
+    default: u(() => [
+      g(c, { name: "close" })
+    ]),
+    _: 1
+  }, 8, ["aria-label", "onClick", "onKeydown"]);
+}
+const q = /* @__PURE__ */ C(N, [["render", K]]), T = ':not(:disabled):not([aria-disabled="true"]):not([role="presentation"])', W = `${T}:not([tabindex="-1"])`, z = "button,[href],input,select,textarea,details,[tabindex]", M = {
+  methods: {
+    /**
+     * get the first focusable element in your component, includes tabindex="-1".
+     * @param {object} el - optional - ref of dom element to trap focus on.
+     *  will default to the root node of the vue component
+     */
+    async getFirstFocusableElement(e) {
+      await this.$nextTick();
+      const t = this._getFocusableElements(e, !0);
+      return this._getFirstFocusElement(t);
+    },
+    /**
+     * set focus to the first focusable element in your component, includes tabindex="-1".
+     * @param {object} el - optional - ref of dom element to trap focus on.
+     *  will default to the root node of the vue component
+     */
+    async focusFirstElement(e) {
+      const t = await this.getFirstFocusableElement(e);
+      t == null || t.focus({ preventScroll: !0 });
+    },
+    /**
+     * internal use only.
+     *
+     * @param focusableElements - list of focusable elements
+     * @returns {*} - first DOM element that is focusable.
+     * @private
+     */
+    _getFirstFocusElement(e) {
+      if (!e.length)
+        return;
+      let t = e[0];
+      return t.matches('[type="radio"]:not(:checked)') && (t = e.find((o) => o.checked && o.name === t.name) || t), t;
+    },
+    /**
+     * internal use only.
+     *
+     * gets all the focusable elements within the component
+     * and sets the first and last of those elements.
+     *
+     * @param {object} el - the root dom element to find focusable elements in.
+     * @param {bool} includeNegativeTabIndex - will include tabindex="-1" in the list of focusable elements.
+     */
+    _getFocusableElements(e = this.$el, t = !1) {
+      return e ? [...e.querySelectorAll(z)].filter((s) => {
+        const i = window.getComputedStyle(s);
+        return i.getPropertyValue("display") !== "none" && i.getPropertyValue("visibility") !== "hidden" && s.matches(t ? T : W);
+      }) : [];
+    },
+    /**
+     * tabs to the next element contained within your component, does not include tabindex="-1".
+     * @param {object} e - keypress event
+     * @param {object} el - optional - ref of dom element to trap focus on.
+     *  will default to the root node of the vue component
+     */
+    focusTrappedTabPress(e, t) {
+      if (!(e.key === "Tab"))
+        return;
+      const s = this._getFocusableElements(t);
+      if (!s.length) {
+        e.preventDefault();
+        return;
+      }
+      const i = this._getFirstFocusElement(s), n = s[s.length - 1];
+      e.shiftKey ? document.activeElement === i && (n.focus(), e.preventDefault()) : document.activeElement === n && (i.focus(), e.preventDefault());
+    }
+  }
+}, P = {
+  none: void 0,
+  small: "d-p4",
+  medium: "d-p8",
+  large: "d-p16"
+}, j = {
+  none: void 0,
+  small: "d-pl4",
+  medium: "d-pl8",
+  large: "d-pl16"
+}, G = ["dialog", "menu", "listbox", "tree", "grid"], U = ["", "anchor"], Y = ["none", "dialog", "first"], Z = ["parent", "body"], X = [
+  ...k
+], $ = {
+  name: "PopoverHeaderFooter",
+  components: {
+    DtButton: S,
+    DtIcon: w
+  },
+  props: {
+    // eslint-disable-next-line vue/require-default-prop
+    type: {
+      type: String,
+      validator: function(e) {
+        return ["header", "footer"].includes(e);
+      }
+    },
+    /**
+     * Additional class name for the content wrapper element.
+     */
+    contentClass: {
+      type: [String, Array, Object],
+      default: ""
+    },
+    /**
+     * Determines visibility for close button
+     * @values true, false
+     */
+    showCloseButton: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * A set of props to be passed into the popover's header close button.
+     * Requires an 'ariaLabel' property.
+     */
+    closeButtonProps: {
+      type: Object,
+      default: () => {
+      }
+    }
+  },
+  emits: [
+    /**
+     * Emitted when popover is closed
+     *
+     * @event close
+     * @type { Boolean }
+     */
+    "close"
+  ],
+  data() {
+    return {
+      hasSlotContent: L
+    };
+  },
+  methods: {
+    focusCloseButton() {
+      var t;
+      const e = (t = this.$refs["popover__close-button"]) == null ? void 0 : t.$el;
+      e == null || e.focus();
+    }
+  }
+};
+function J(e, t, o, s, i, n) {
+  const c = d("dt-icon"), m = d("dt-button");
+  return r(), E("div", {
+    "data-qa": "dt-popover-header-footer",
+    class: h({
+      "d-popover__header": o.type === "header",
+      "d-popover__footer": o.type === "footer"
+    })
+  }, [
+    i.hasSlotContent(e.$slots.content) ? (r(), E("div", {
+      key: 0,
+      "data-qa": "dt-popover-header-footer-content",
+      class: h(["d-to-ellipsis", "d-w100p", o.contentClass])
+    }, [
+      y(e.$slots, "content")
+    ], 2)) : f("", !0),
+    o.showCloseButton ? (r(), a(m, A({
+      key: 1,
+      ref: "popover__close-button",
+      "data-qa": "dt-popover-close",
+      class: "d-p6 d-mr6 d-bc-transparent",
+      importance: "outlined",
+      kind: "muted",
+      circle: ""
+    }, o.closeButtonProps, {
+      onClick: t[0] || (t[0] = (_) => e.$emit("close"))
+    }), {
+      icon: u(() => [
+        g(c, {
+          name: "close",
+          size: "300"
+        })
+      ]),
+      _: 1
+    }, 16)) : f("", !0)
+  ], 2);
+}
+const Q = /* @__PURE__ */ C($, [["render", J]]);
+const ee = {
+  name: "DtPopover",
+  /********************
+   * CHILD COMPONENTS *
+   ********************/
+  components: {
+    SrOnlyCloseButton: q,
+    DtLazyShow: x,
+    PopoverHeaderFooter: Q
+  },
+  mixins: [M, V],
+  props: {
+    /**
+     * Controls whether the popover is shown. Leaving this null will have the popover trigger on click by default.
+     * If you set this value, the default trigger behavior will be disabled, and you can control it as you need.
+     * Supports v-model
+     * @values null, true, false
+     */
+    open: {
+      type: Boolean,
+      default: null
+    },
+    /**
+     * Opens the popover on right click (context menu). If you set this value to `true`,
+     * the default trigger behavior will be disabled.
+     * @values true, false
+     */
+    openOnContext: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Element type (tag name) of the root element of the component.
+     */
+    elementType: {
+      type: String,
+      default: "div"
+    },
+    /**
+     * Named transition when the content display is toggled.
+     * @see DtLazyShow
+     */
+    transition: {
+      type: String,
+      default: "fade"
+    },
+    /**
+     * ARIA role for the content of the popover. Defaults to "dialog".
+     * <a class="d-link" href="https://www.w3.org/TR/wai-aria/#aria-haspopup" target="_blank">aria-haspopup</a>
+     */
+    role: {
+      type: String,
+      default: "dialog",
+      validator: (e) => G.includes(e)
+    },
+    /**
+     * ID of the element that serves as the label for the popover content.
+     * Defaults to the "anchor" element; this exists to provide a different
+     * ID of the label element if, for example, the anchor slot contains
+     * other items that do not serve as a label. You should provide this
+     * or ariaLabel, but not both.
+     */
+    ariaLabelledby: {
+      type: String,
+      default: null
+    },
+    /**
+     * Descriptive label for the popover content. You should provide this
+     * or ariaLabelledby, but not both.
+     */
+    ariaLabel: {
+      type: String,
+      default: null
+    },
+    /**
+     * A set of props to be passed into the popover's header close button.
+     * Requires an 'ariaLabel' property, when the header popover is visible
+     */
+    closeButtonProps: {
+      type: Object,
+      default: () => ({})
+    },
+    /**
+     * Padding size class for the popover content.
+     * @values none, small, medium, large
+     */
+    padding: {
+      type: String,
+      default: "large",
+      validator: (e) => Object.keys(P).some((t) => t === e)
+    },
+    /**
+     * Additional class name for the content wrapper element.
+     */
+    contentClass: {
+      type: [String, Array, Object],
+      default: ""
+    },
+    /**
+     * Width configuration for the popover content. When its value is 'anchor',
+     * the popover content will have the same width as the anchor.
+     * @values null, anchor
+     */
+    contentWidth: {
+      type: String,
+      default: "",
+      validator: (e) => U.includes(e)
+    },
+    /**
+     * Whether to apply transition on initial render in the content lazy show component.
+     */
+    contentAppear: {
+      type: Boolean,
+      default: null
+    },
+    /**
+     * Tabindex value for the content. Passing null, no tabindex attribute will be set.
+     */
+    contentTabindex: {
+      type: Number || null,
+      default: -1
+    },
+    /**
+     * External anchor id to use in those cases the anchor can't be provided via the slot.
+     * For instance, using the combobox's input as the anchor for the popover.
+     */
+    externalAnchor: {
+      type: String,
+      default: ""
+    },
+    /**
+     * The id of the tooltip
+     */
+    id: {
+      type: String,
+      default() {
+        return O();
+      }
+    },
+    /**
+     *  Displaces the content box from its anchor element
+     *  by the specified number of pixels.
+     *  <a
+     *    class="d-link"
+     *    href="https://atomiks.github.io/tippyjs/v6/all-props/#offset"
+     *    target="_blank"
+     *  >
+     *    Tippy.js docs
+     *  </a>
+     */
+    offset: {
+      type: Array,
+      default: () => [0, 4]
+    },
+    /**
+     * Determines if the popover hides upon clicking the
+     * anchor or outside the content box.
+     * @values true, false
+     */
+    hideOnClick: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * Determines modal state. If enabled popover has a modal overlay
+     * preventing interaction with elements below it, but it is invisible.
+     * @values true, false
+     */
+    modal: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * If the popover does not fit in the direction described by "placement",
+     * it will attempt to change its direction to the "fallbackPlacements".
+     * <a
+     *   class="d-link"
+     *   href="https://popper.js.org/docs/v2/modifiers/flip/#fallbackplacements"
+     *   target="_blank"
+     * >
+     *   Popper.js docs
+     * </a>
+     * */
+    fallbackPlacements: {
+      type: Array,
+      default: () => ["auto"]
+    },
+    /**
+     * The direction the popover displays relative to the anchor.
+     * <a
+     *   class="d-link"
+     *   href="https://atomiks.github.io/tippyjs/v6/all-props/#placement"
+     *   target="_blank"
+     * >
+     *   Tippy.js docs
+     * </a>
+     * @values top, top-start, top-end,
+     * right, right-start, right-end,
+     * left, left-start, left-end,
+     * bottom, bottom-start, bottom-end,
+     * auto, auto-start, auto-end
+     */
+    placement: {
+      type: String,
+      default: "bottom-end"
+    },
+    /**
+     * If set to false the dialog will display over top of the anchor when there is insufficient space.
+     * If set to true it will never move from its position relative to the anchor and will clip instead.
+     * <a
+     *   class="d-link"
+     *   href="https://popper.js.org/docs/v2/modifiers/prevent-overflow/#tether"
+     *   target="_blank"
+     * >
+     *   Popper.js docs
+     * </a>
+     * @values true, false
+     */
+    tether: {
+      type: Boolean,
+      default: !0
+    },
+    /**
+     * If the popover sticks to the anchor. This is usually not needed, but can be needed
+     * if the reference element's position is animating, or to automatically update the popover
+     * position in those cases the DOM layout changes the reference element's position.
+     * `true` enables it, `reference` only checks the "reference" rect for changes and `popper` only
+     * checks the "popper" rect for changes.
+     * <a
+     *   class="d-link"
+     *   href="https://atomiks.github.io/tippyjs/v6/all-props/#sticky"
+     *   target="_blank"
+     * >
+     *   Tippy.js docs
+     * </a>
+     * @values true, false, reference, popper
+     */
+    sticky: {
+      type: [Boolean, String],
+      default: !1,
+      validator: (e) => X.includes(e)
+    },
+    /**
+     * Determines maximum height for the popover before overflow.
+     * Possible units rem|px|em
+     */
+    maxHeight: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Determines maximum width for the popover before overflow.
+     * Possible units rem|px|%|em
+     */
+    maxWidth: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Determines visibility for close button
+     * @values true, false
+     */
+    showCloseButton: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Additional class name for the header content wrapper element.
+     */
+    headerClass: {
+      type: [String, Array, Object],
+      default: ""
+    },
+    /**
+     * Additional class name for the footer content wrapper element.
+     */
+    footerClass: {
+      type: [String, Array, Object],
+      default: ""
+    },
+    /**
+     * Additional class name for the dialog element.
+     */
+    dialogClass: {
+      type: [String, Array, Object],
+      default: ""
+    },
+    /**
+     * The element that is focused when the popover is opened. This can be an
+     * HTMLElement within the popover, a string starting with '#' which will
+     * find the element by ID. 'first' which will automatically focus
+     * the first element, or 'dialog' which will focus the dialog window itself.
+     * If the dialog is modal this prop cannot be 'none'.
+     * @values none, dialog, first
+     */
+    initialFocusElement: {
+      type: [String, HTMLElement],
+      default: "first",
+      validator: (e) => Y.includes(e) || e instanceof HTMLElement || e.startsWith("#")
+    },
+    /**
+     * If the popover should open pressing up or down arrow key on the anchor element.
+     * This can be set when not passing open prop.
+     * @values true, false
+     */
+    openWithArrowKeys: {
+      type: Boolean,
+      default: !1
+    },
+    /**
+     * Sets the element to which the popover is going to append to.
+     * 'body' will append to the nearest body (supports shadow DOM).
+     * @values 'body', 'parent', HTMLElement,
+     */
+    appendTo: {
+      type: [HTMLElement, String],
+      default: "body",
+      validator: (e) => Z.includes(e) || e instanceof HTMLElement
+    }
+  },
+  emits: [
+    /**
+     * Native keydown event
+     *
+     * @event keydown
+     * @type {KeyboardEvent}
+     */
+    "keydown",
+    /**
+     * Event fired to sync the open prop with the parent component
+     * @event update:open
+     */
+    "update:open",
+    /**
+     * Emitted when popover is shown or hidden
+     *
+     * @event opened
+     * @type {Boolean | Array}
+     */
+    "opened"
+  ],
+  data() {
+    return {
+      POPOVER_PADDING_CLASSES: P,
+      POPOVER_HEADER_FOOTER_PADDING_CLASSES: j,
+      intersectionObserver: null,
+      isOutsideViewport: !1,
+      isOpen: !1,
+      toAppear: !1,
+      anchorEl: null,
+      popoverContentEl: null,
+      hasSlotContent: L
+    };
+  },
+  computed: {
+    popoverListeners() {
+      return {
+        keydown: (e) => {
+          this.onKeydown(e);
+        },
+        "after-leave": (e) => {
+          this.onLeaveTransitionComplete();
+        },
+        "after-enter": (e) => {
+          this.onEnterTransitionComplete();
+        }
+      };
+    },
+    calculatedMaxHeight() {
+      return this.isOutsideViewport && this.modal ? "calc(100vh - var(--space-300))" : this.maxHeight;
+    },
+    labelledBy() {
+      return this.ariaLabelledby || !this.ariaLabel && O("DtPopover__anchor");
+    }
+  },
+  watch: {
+    $props: {
+      immediate: !0,
+      deep: !0,
+      handler() {
+        this.validateProps();
+      }
+    },
+    modal(e) {
+      var t;
+      (t = this.tip) == null || t.setProps({
+        zIndex: e ? 650 : this.calculateAnchorZindex()
+      });
+    },
+    offset(e) {
+      var t;
+      (t = this.tip) == null || t.setProps({
+        offset: e
+      });
+    },
+    sticky(e) {
+      var t;
+      (t = this.tip) == null || t.setProps({
+        sticky: e
+      });
+    },
+    fallbackPlacements() {
+      var e;
+      (e = this.tip) == null || e.setProps({
+        popperOptions: this.popperOptions()
+      });
+    },
+    tether() {
+      var e;
+      (e = this.tip) == null || e.setProps({
+        popperOptions: this.popperOptions()
+      });
+    },
+    placement(e) {
+      var t;
+      (t = this.tip) == null || t.setProps({
+        placement: e
+      });
+    },
+    open: {
+      handler: function(e) {
+        e !== null && (this.isOpen = e), e === !0 && (this.toAppear = !0);
+      },
+      immediate: !0
+    },
+    contentAppear: {
+      handler: function(e) {
+        e !== null && (this.toAppear = e);
+      }
+    },
+    isOpen(e, t) {
+      e ? (this.initTippyInstance(), this.tip.show()) : !e && t !== e && (this.removeEventListeners(), this.tip.hide());
+    }
+  },
+  mounted() {
+    const e = this.externalAnchor ? this.$refs.anchor.getRootNode().querySelector(`#${this.externalAnchor}`) : null;
+    this.anchorEl = e ?? this.$refs.anchor.children[0], this.popoverContentEl = this.$refs.content.$el, this.isOpen && (this.initTippyInstance(), this.tip.show()), this.intersectionObserver = new IntersectionObserver(this.hasIntersectedViewport), this.intersectionObserver.observe(this.popoverContentEl);
+  },
+  beforeUnmount() {
+    var e;
+    (e = this.tip) == null || e.destroy(), this.intersectionObserver.disconnect(), this.removeReferences(), this.removeEventListeners();
+  },
+  /******************
+   *     METHODS    *
+   ******************/
+  methods: {
+    hasIntersectedViewport(e) {
+      var s;
+      const t = (s = e == null ? void 0 : e[0]) == null ? void 0 : s.target;
+      if (!t)
+        return;
+      const o = F(t);
+      this.isOutsideViewport = o.bottom || o.top;
+    },
+    popperOptions() {
+      return B({
+        fallbackPlacements: this.fallbackPlacements,
+        tether: this.tether,
+        hasHideModifierEnabled: !0
+      });
+    },
+    validateProps() {
+      this.modal && this.initialFocusElement === "none" && console.error('If the popover is modal you must set the initialFocusElement prop. Possible values: "dialog", "first", HTMLElement');
+    },
+    calculateAnchorZindex() {
+      var e;
+      return this.$el.getRootNode().querySelector('.d-modal[aria-hidden="false"], .d-modal--transparent[aria-hidden="false"]') || // Special case because we don't have any dialtone drawer component yet. Render at 650 when
+      // anchor of popover is within a drawer.
+      (e = this.anchorEl) != null && e.closest(".d-zi-drawer") ? 650 : 300;
+    },
+    defaultToggleOpen(e) {
+      var t, o, s;
+      if (!this.openOnContext && (this.open === null || this.open === void 0)) {
+        if (!((t = this.anchorEl) != null && t.contains(e.target)) && !((o = this.anchorEl) != null && o.isEqualNode(e.target)) || (s = this.anchorEl) != null && s.disabled)
+          return;
+        this.toggleOpen();
+      }
+    },
+    async onContext(e) {
+      this.openOnContext && (e.preventDefault(), this.isOpen = !0, await this.$nextTick(), this.tip.setProps({
+        placement: "right-start",
+        getReferenceClientRect: () => ({
+          width: 0,
+          height: 0,
+          top: e.clientY,
+          bottom: e.clientY,
+          left: e.clientX,
+          right: e.clientX
+        })
+      }));
+    },
+    toggleOpen() {
+      this.isOpen = !this.isOpen;
+    },
+    onArrowKeyPress(e) {
+      var t;
+      this.open === null && (this.openWithArrowKeys && ((t = this.anchorEl) != null && t.contains(e.target)) && (this.isOpen || (this.isOpen = !0)), this.$emit("keydown", e));
+    },
+    addEventListeners() {
+      window.addEventListener("dt-popover-close", this.closePopover), this.contentWidth === "anchor" && window.addEventListener("resize", this.onResize);
+    },
+    removeEventListeners() {
+      window.removeEventListener("dt-popover-close", this.closePopover), this.contentWidth === "anchor" && window.removeEventListener("resize", this.onResize);
+    },
+    closePopover() {
+      this.isOpen = !1;
+    },
+    /*
+    * Prevents scrolling outside of the currently opened modal popover by:
+    *   - when anchor is not within another popover: setting the body to overflow: hidden
+    *   - when anchor is within another popover: set the popover dialog container to it's non-modal z-index
+    *     since it is no longer the active modal. This puts it underneath the overlay and prevents scrolling.
+    **/
+    preventScrolling() {
+      var e;
+      if (this.modal) {
+        const t = (e = this.anchorEl) == null ? void 0 : e.closest("body, .tippy-box");
+        t.tagName.toLowerCase() === "body" ? (t.classList.add("d-of-hidden"), this.tip.setProps({ offset: this.offset })) : t.classList.add("d-zi-popover");
+      }
+    },
+    /*
+    * Resets the prevent scrolling properties set in preventScrolling() back to normal.
+    **/
+    enableScrolling() {
+      var t, o;
+      const e = (t = this.anchorEl) == null ? void 0 : t.closest("body, .tippy-box");
+      e && (((o = e.tagName) == null ? void 0 : o.toLowerCase()) === "body" ? (e.classList.remove("d-of-hidden"), this.tip.setProps({ offset: this.offset })) : e.classList.remove("d-zi-popover"));
+    },
+    removeReferences() {
+      this.anchorEl = null, this.popoverContentEl = null, this.tip = null;
+    },
+    async onShow() {
+      this.contentWidth === "anchor" && await this.setPopoverContentAnchorWidth(), this.contentWidth === null && (this.popoverContentEl.style.width = "auto"), this.addEventListeners();
+    },
+    async onLeaveTransitionComplete() {
+      var e;
+      this.modal && (await this.focusFirstElement(this.$refs.anchor), await this.$nextTick(), this.enableScrolling()), (e = this.tip) == null || e.unmount(), this.$emit("opened", !1), this.open !== null && this.$emit("update:open", !1);
+    },
+    async onEnterTransitionComplete() {
+      this.focusInitialElement(), await this.$nextTick(), this.preventScrolling(), this.$emit("opened", !0, this.$refs.popover__content), this.open !== null && this.$emit("update:open", !0);
+    },
+    focusInitialElement() {
+      this.initialFocusElement === "dialog" && this.$refs.content.$el.focus(), this.initialFocusElement.startsWith("#") && this.focusInitialElementById(), this.initialFocusElement === "first" && this.focusFirstElementIfNeeded(this.$refs.popover__content), this.initialFocusElement instanceof HTMLElement && this.initialFocusElement.focus();
+    },
+    focusInitialElementById() {
+      var t, o, s;
+      const e = (o = (t = this.$refs.content) == null ? void 0 : t.$el) == null ? void 0 : o.querySelector(this.initialFocusElement);
+      e ? e.focus() : console.warn('Could not find the element specified in dt-popover prop "initialFocusElement". Defaulting to focusing the dialog.'), e ? e.focus() : (s = this.$refs.content) == null || s.$el.focus();
+    },
+    onResize() {
+      this.closePopover();
+    },
+    onClickOutside() {
+      if (!this.hideOnClick)
+        return;
+      this.popoverContentEl.querySelector(".d-popover__anchor--opened") || this.closePopover();
+    },
+    onKeydown(e) {
+      e.key === "Tab" && this.modal && this.focusTrappedTabPress(e, this.popoverContentEl), e.key === "Escape" && this.closePopover(), this.$emit("keydown", e);
+    },
+    async setPopoverContentAnchorWidth() {
+      var e;
+      await this.$nextTick(), this.popoverContentEl.style.width = `${(e = this.anchorEl) == null ? void 0 : e.clientWidth}px`;
+    },
+    focusFirstElementIfNeeded(e) {
+      var o, s;
+      this._getFocusableElements(e, !0).length !== 0 ? this.focusFirstElement(e) : this.showCloseButton ? (o = this.$refs.popover__header) == null || o.focusCloseButton() : (s = this.$refs.content) == null || s.$el.focus();
+    },
+    initTippyInstance() {
+      var e, t;
+      this.tip = H(this.anchorEl, {
+        popperOptions: this.popperOptions(),
+        contentElement: this.popoverContentEl,
+        placement: this.placement,
+        offset: this.offset,
+        sticky: this.sticky,
+        appendTo: this.appendTo === "body" ? (t = (e = this.anchorEl) == null ? void 0 : e.getRootNode()) == null ? void 0 : t.querySelector("body") : this.appendTo,
+        interactive: !0,
+        trigger: "manual",
+        // We have to manage hideOnClick functionality manually to handle
+        // popover within popover situations.
+        hideOnClick: !1,
+        zIndex: this.modal ? 650 : this.calculateAnchorZindex(),
+        onClickOutside: this.onClickOutside,
+        onShow: this.onShow
+      });
+    }
+  }
+}, te = ["aria-hidden"], oe = ["id", "tabindex"];
+function ne(e, t, o, s, i, n) {
+  const c = d("popover-header-footer"), m = d("sr-only-close-button"), _ = d("dt-lazy-show");
+  return r(), E("div", null, [
+    o.modal && i.isOpen ? (r(), a(I, {
+      key: 0,
+      to: "body"
+    }, [
+      b("div", {
+        class: "d-modal--transparent",
+        "aria-hidden": o.modal && i.isOpen ? "false" : "true",
+        onClick: t[0] || (t[0] = v(() => {
+        }, ["prevent", "stop"]))
+      }, null, 8, te)
+    ])) : f("", !0),
+    (r(), a(D(o.elementType), {
+      ref: "popover",
+      class: h(["d-popover", { "d-popover__anchor--opened": i.isOpen }]),
+      "data-qa": "dt-popover-container"
+    }, {
+      default: u(() => [
+        b("div", {
+          id: !o.ariaLabelledby && n.labelledBy,
+          ref: "anchor",
+          "data-qa": "dt-popover-anchor",
+          tabindex: o.openOnContext ? 0 : void 0,
+          onClickCapture: t[1] || (t[1] = (...l) => n.defaultToggleOpen && n.defaultToggleOpen(...l)),
+          onContextmenu: t[2] || (t[2] = (...l) => n.onContext && n.onContext(...l)),
+          onKeydown: [
+            t[3] || (t[3] = p(v((...l) => n.onArrowKeyPress && n.onArrowKeyPress(...l), ["prevent"]), ["up"])),
+            t[4] || (t[4] = p(v((...l) => n.onArrowKeyPress && n.onArrowKeyPress(...l), ["prevent"]), ["down"])),
+            t[6] || (t[6] = p((l) => e.$emit("keydown", l), ["enter"])),
+            t[7] || (t[7] = p((l) => e.$emit("keydown", l), ["space"]))
+          ],
+          onKeydownCapture: t[5] || (t[5] = p((...l) => n.closePopover && n.closePopover(...l), ["escape"]))
+        }, [
+          y(e.$slots, "anchor", {
+            attrs: {
+              "aria-expanded": i.isOpen.toString(),
+              "aria-controls": o.id,
+              "aria-haspopup": o.role
+            }
+          })
+        ], 40, oe),
+        g(_, A({
+          id: o.id,
+          ref: "content",
+          role: o.role,
+          "data-qa": "dt-popover",
+          "aria-hidden": `${!i.isOpen}`,
+          "aria-labelledby": n.labelledBy,
+          "aria-label": o.ariaLabel,
+          "aria-modal": `${!o.modal}`,
+          transition: o.transition,
+          show: i.isOpen,
+          appear: i.toAppear,
+          class: ["d-popover__dialog", { "d-popover__dialog--modal": o.modal }, o.dialogClass],
+          style: {
+            "max-height": n.calculatedMaxHeight,
+            "max-width": o.maxWidth
+          },
+          css: e.$attrs.css,
+          tabindex: o.contentTabindex
+        }, R(n.popoverListeners)), {
+          default: u(() => [
+            i.hasSlotContent(e.$slots.headerContent) || o.showCloseButton ? (r(), a(c, {
+              key: 0,
+              ref: "popover__header",
+              class: h(i.POPOVER_HEADER_FOOTER_PADDING_CLASSES[o.padding]),
+              "content-class": o.headerClass,
+              type: "header",
+              "show-close-button": o.showCloseButton,
+              "close-button-props": o.closeButtonProps,
+              onClose: n.closePopover
+            }, {
+              content: u(() => [
+                y(e.$slots, "headerContent", { close: n.closePopover })
+              ]),
+              _: 3
+            }, 8, ["class", "content-class", "show-close-button", "close-button-props", "onClose"])) : f("", !0),
+            b("div", {
+              ref: "popover__content",
+              "data-qa": "dt-popover-content",
+              class: h([
+                "d-popover__content",
+                i.POPOVER_PADDING_CLASSES[o.padding],
+                o.contentClass
+              ])
+            }, [
+              y(e.$slots, "content", { close: n.closePopover })
+            ], 2),
+            i.hasSlotContent(e.$slots.footerContent) ? (r(), a(c, {
+              key: 1,
+              ref: "popover__footer",
+              type: "footer",
+              class: h(i.POPOVER_HEADER_FOOTER_PADDING_CLASSES[o.padding]),
+              "content-class": o.footerClass
+            }, {
+              content: u(() => [
+                y(e.$slots, "footerContent", { close: n.closePopover })
+              ]),
+              _: 3
+            }, 8, ["class", "content-class"])) : f("", !0),
+            e.showVisuallyHiddenClose ? (r(), a(m, {
+              key: 2,
+              "visually-hidden-close-label": e.visuallyHiddenCloseLabel,
+              onClose: n.closePopover
+            }, null, 8, ["visually-hidden-close-label", "onClose"])) : f("", !0)
+          ]),
+          _: 3
+        }, 16, ["id", "role", "aria-hidden", "aria-labelledby", "aria-label", "aria-modal", "transition", "show", "appear", "class", "style", "css", "tabindex"])
+      ]),
+      _: 3
+    }, 8, ["class"]))
+  ]);
+}
+const le = /* @__PURE__ */ C(ee, [["render", ne]]);
+export {
+  le as D,
+  M,
+  Z as P,
+  q as S,
+  V as a,
+  U as b,
+  P as c,
+  j as d,
+  G as e,
+  Y as f
+};