@umbraco-ui/uui 2.0.0-rc.2 → 2.0.1

package/dist/components/popover-container/popover-container.element.js

@@ -1,315 +1,271 @@
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _targetElement, _scrollParents, _sizeObserver, _size, _onBeforeToggle, _initUpdate, _updatePosition, _UUIPopoverContainerElement_instances, calculateAlignedPosition_fn, clampAndFlip_fn, _updatePadding, flipPlacement_fn, startScrollListener_fn, stopScrollListener_fn, calculateScrollParents_fn, getAncestorElement_fn;
-import { LitElement, html, css } from "lit";
-import { property, state } from "lit/decorators.js";
-import "../scroll-container/scroll-container.js";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.138.0/helpers/esm/decorate.js";
 import { findAncestorByAttributeValue } from "../../internal/utils/findAncestorByAttributeValue.js";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-const _UUIPopoverContainerElement = class _UUIPopoverContainerElement extends LitElement {
-  constructor() {
-    super();
-    __privateAdd(this, _UUIPopoverContainerElement_instances);
-    __privateAdd(this, _targetElement);
-    __privateAdd(this, _scrollParents);
-    __privateAdd(this, _sizeObserver);
-    __privateAdd(this, _size);
-    __privateAdd(this, _onBeforeToggle);
-    __privateAdd(this, _initUpdate);
-    __privateAdd(this, _updatePosition);
-    __privateAdd(this, _updatePadding);
-    this.margin = 0;
-    this._placement = "bottom-start";
-    this._open = false;
-    this._actualPlacement = this._placement;
-    __privateSet(this, _targetElement, null);
-    __privateSet(this, _scrollParents, []);
-    __privateSet(this, _sizeObserver, null);
-    __privateSet(this, _size, { width: 0, height: 0 });
-    __privateSet(this, _onBeforeToggle, (event) => {
-      this._open = event.newState === "open";
-      __privateSet(this, _targetElement, findAncestorByAttributeValue(
-        this,
-        "popovertarget",
-        this.id
-      ));
-      __privateGet(this, _targetElement)?.dispatchEvent(
-        new CustomEvent("uui-popover-before-toggle", {
-          bubbles: false,
-          composed: false,
-          detail: { oldState: event.oldState, newState: event.newState }
-        })
-      );
-      if (this._open) {
-        __privateMethod(this, _UUIPopoverContainerElement_instances, calculateScrollParents_fn).call(this);
-        __privateMethod(this, _UUIPopoverContainerElement_instances, startScrollListener_fn).call(this);
-        requestAnimationFrame(() => {
-          __privateGet(this, _initUpdate).call(this);
-        });
-      } else {
-        __privateMethod(this, _UUIPopoverContainerElement_instances, stopScrollListener_fn).call(this);
-        this.style.removeProperty("--_available-height");
-      }
-    });
-    __privateSet(this, _initUpdate, () => {
-      if (!this._open) return;
-      this._actualPlacement = this._placement;
-      this.style.opacity = "0";
-      __privateGet(this, _updatePosition).call(this, 3);
-    });
-    __privateSet(this, _updatePosition, (iteration) => {
-      __privateGet(this, _updatePadding).call(this);
-      iteration--;
-      if (__privateGet(this, _targetElement) === null) return;
-      const targetRect = __privateGet(this, _targetElement).getBoundingClientRect();
-      const popoverRect = this.getBoundingClientRect();
-      let { top, left } = __privateMethod(this, _UUIPopoverContainerElement_instances, calculateAlignedPosition_fn).call(this, targetRect, popoverRect);
-      const result = __privateMethod(this, _UUIPopoverContainerElement_instances, clampAndFlip_fn).call(this, top, left, targetRect, popoverRect, iteration);
-      if (result === null) return;
-      top = result.top;
-      left = result.left;
-      const screenWidth = window.innerWidth;
-      const screenHeight = window.innerHeight;
-      const isCompletelyOutsideScreen = top + popoverRect.height < 0 || top > screenHeight || left + popoverRect.width < 0 || left > screenWidth;
-      if (isCompletelyOutsideScreen) {
-        this.hidePopover();
-        return;
-      }
-      const isTopPlacement = this._actualPlacement.startsWith("top");
-      const isBottomPlacement = this._actualPlacement.startsWith("bottom");
-      let availableHeight;
-      if (isTopPlacement) {
-        availableHeight = targetRect.top - 2 * this.margin;
-      } else if (isBottomPlacement) {
-        availableHeight = screenHeight - (targetRect.top + targetRect.height) - 2 * this.margin;
-      } else {
-        availableHeight = screenHeight - targetRect.top - this.margin;
-      }
-      this.style.setProperty(
-        "--_available-height",
-        `${Math.max(availableHeight, 0)}px`
-      );
-      this.style.transform = `translate(${left}px, ${top}px)`;
-      this.style.opacity = "1";
-    });
-    __privateSet(this, _updatePadding, () => {
-      const oppositeSides = {
-        top: "bottom",
-        bottom: "top",
-        left: "right",
-        right: "left"
-      };
-      let side = this._actualPlacement.split("-")[0];
-      side = oppositeSides[side] || side;
-      side = side.charAt(0).toUpperCase() + side.slice(1);
-      const marginSide = `margin${side}`;
-      this.style.margin = "0";
-      this.style[marginSide] = `${this.margin}px`;
-    });
-    this.addEventListener("beforetoggle", __privateGet(this, _onBeforeToggle), {
-      passive: true
-    });
-  }
-  get open() {
-    return this._open;
-  }
-  get placement() {
-    return this._placement;
-  }
-  set placement(newValue) {
-    this._placement = newValue;
-    this._actualPlacement = newValue;
-    __privateGet(this, _initUpdate).call(this);
-  }
-  connectedCallback() {
-    super.connectedCallback();
-    if (!this.hasAttribute("popover")) {
-      this.setAttribute("popover", "");
-    }
-    if (!__privateGet(this, _sizeObserver)) {
-      __privateSet(this, _sizeObserver, new ResizeObserver((entries) => {
-        const element = entries[0];
-        const width = element.contentRect.width;
-        const height = element.contentRect.height;
-        if (width === __privateGet(this, _size).width && height === __privateGet(this, _size).height) {
-          return;
-        }
-        __privateSet(this, _size, { width, height });
-        __privateGet(this, _initUpdate).call(this);
-      }));
-      __privateGet(this, _sizeObserver).observe(this);
-    }
-  }
-  disconnectedCallback() {
-    super.disconnectedCallback();
-    __privateMethod(this, _UUIPopoverContainerElement_instances, stopScrollListener_fn).call(this);
-    __privateGet(this, _sizeObserver)?.disconnect();
-    __privateSet(this, _sizeObserver, null);
-  }
-  /**
-   * @internal
-   */
-  _getScrollParents() {
-    return __privateGet(this, _scrollParents);
-  }
-  render() {
-    return html`<uui-scroll-container><slot></slot></uui-scroll-container>`;
-  }
-};
-_targetElement = new WeakMap();
-_scrollParents = new WeakMap();
-_sizeObserver = new WeakMap();
-_size = new WeakMap();
-_onBeforeToggle = new WeakMap();
-_initUpdate = new WeakMap();
-_updatePosition = new WeakMap();
-_UUIPopoverContainerElement_instances = new WeakSet();
-calculateAlignedPosition_fn = function(targetRect, popoverRect) {
-  const isStart = this._actualPlacement.includes("-start");
-  const isEnd = this._actualPlacement.includes("-end");
-  const align = (pos, targetSize, popoverSize) => {
-    if (isStart) return pos;
-    if (isEnd) return pos + targetSize - popoverSize;
-    return pos + targetSize / 2 - popoverSize / 2;
-  };
-  const side = this._actualPlacement.split("-")[0];
-  const positions = {
-    bottom: {
-      top: targetRect.top + targetRect.height,
-      left: align(targetRect.left, targetRect.width, popoverRect.width)
-    },
-    top: {
-      top: targetRect.top - popoverRect.height,
-      left: align(targetRect.left, targetRect.width, popoverRect.width)
-    },
-    left: {
-      top: align(targetRect.top, targetRect.height, popoverRect.height),
-      left: targetRect.left - popoverRect.width
-    },
-    right: {
-      top: align(targetRect.top, targetRect.height, popoverRect.height),
-      left: targetRect.left + targetRect.width
-    }
-  };
-  return positions[side] ?? { top: 0, left: 0 };
-};
-clampAndFlip_fn = function(top, left, targetRect, popoverRect, iteration) {
-  const screenWidth = window.innerWidth;
-  const screenHeight = window.innerHeight;
-  const side = this._actualPlacement.split("-")[0];
-  const isVertical = side === "top" || side === "bottom";
-  const topTargetVsScreenTop = Math.min(
-    0,
-    targetRect.top + targetRect.height
-  );
-  const topTargetVsScreenBottom = Math.max(
-    Math.min(top, screenHeight - popoverRect.height),
-    targetRect.top - popoverRect.height
-  );
-  const topClamped = Math.max(topTargetVsScreenTop, topTargetVsScreenBottom);
-  if (topClamped !== top && isVertical && iteration > 0) {
-    __privateMethod(this, _UUIPopoverContainerElement_instances, flipPlacement_fn).call(this);
-    __privateGet(this, _updatePosition).call(this, iteration);
-    return null;
-  }
-  const leftTargetVsScreenLeft = Math.min(
-    0,
-    targetRect.left + targetRect.width
-  );
-  const leftTargetVsScreenRight = Math.max(
-    Math.min(left, screenWidth - popoverRect.width),
-    targetRect.left - popoverRect.width
-  );
-  const leftClamped = Math.max(
-    leftTargetVsScreenLeft,
-    leftTargetVsScreenRight
-  );
-  if (leftClamped !== left && !isVertical && iteration > 0) {
-    __privateMethod(this, _UUIPopoverContainerElement_instances, flipPlacement_fn).call(this);
-    __privateGet(this, _updatePosition).call(this, iteration);
-    return null;
-  }
-  return { top: topClamped, left: leftClamped };
-};
-_updatePadding = new WeakMap();
-flipPlacement_fn = function() {
-  const [direction, position] = this._actualPlacement.split("-");
-  const opposites = {
-    top: "bottom",
-    bottom: "top",
-    left: "right",
-    right: "left"
-  };
-  const oppositeDirection = opposites[direction] ?? direction;
-  this._actualPlacement = `${oppositeDirection}-${position}`;
-};
-startScrollListener_fn = function() {
-  __privateGet(this, _scrollParents).forEach((el) => {
-    el.addEventListener("scroll", __privateGet(this, _initUpdate), { passive: true });
-  });
-  document.addEventListener("scroll", __privateGet(this, _initUpdate), { passive: true });
-};
-stopScrollListener_fn = function() {
-  __privateGet(this, _scrollParents).forEach((el) => {
-    el.removeEventListener("scroll", __privateGet(this, _initUpdate));
-  });
-  document.removeEventListener("scroll", __privateGet(this, _initUpdate));
-};
-calculateScrollParents_fn = function() {
-  __privateSet(this, _scrollParents, []);
-  if (!__privateGet(this, _targetElement)) return;
-  let style = getComputedStyle(__privateGet(this, _targetElement));
-  if (style.position === "fixed") {
-    return;
-  }
-  let excludeStaticParent = style.position === "absolute";
-  const overflowRegex = /(auto|scroll)/;
-  let el = __privateGet(this, _targetElement);
-  while (el) {
-    style = getComputedStyle(el);
-    if (excludeStaticParent && style.position === "static") {
-      el = __privateMethod(this, _UUIPopoverContainerElement_instances, getAncestorElement_fn).call(this, el);
-      continue;
-    }
-    if (style.position !== "static") {
-      excludeStaticParent = style.position === "absolute";
-    }
-    if (overflowRegex.test(style.overflow + style.overflowY + style.overflowX)) {
-      __privateGet(this, _scrollParents).push(el);
-    }
-    if (style.position === "fixed") {
-      return;
-    }
-    el = __privateMethod(this, _UUIPopoverContainerElement_instances, getAncestorElement_fn).call(this, el);
-  }
-  __privateGet(this, _scrollParents).push(document.body);
-};
-getAncestorElement_fn = function(el) {
-  if (el?.assignedSlot) {
-    return el.assignedSlot;
-  }
-  if (el?.parentElement) {
-    return el.parentElement;
-  }
-  return el?.getRootNode()?.host;
-};
-_UUIPopoverContainerElement.styles = [
-  css`
+import "../scroll-container/scroll-container.js";
+import { LitElement, css, html } from "lit";
+import { property, state } from "lit/decorators.js";
+//#region src/components/popover-container/popover-container.element.ts
+/**
+* @element uui-popover-container
+* @attr popover - Indicates that the element is a popover container
+*/
+var UUIPopoverContainerElement = class extends LitElement {
+	/**
+	* Read-only attribute to check if the popover is open
+	* @type {boolean}
+	* @readonly
+	* @attr open
+	* @default false
+	*/
+	get open() {
+		return this._open;
+	}
+	/**
+	* Define the placement of the popover container.
+	* @attr placement
+	* @default 'bottom-start'
+	*/
+	get placement() {
+		return this._placement;
+	}
+	set placement(newValue) {
+		this._placement = newValue;
+		this._actualPlacement = newValue;
+		this.#initUpdate();
+	}
+	#targetElement;
+	#scrollParents;
+	#sizeObserver;
+	#size;
+	constructor() {
+		super();
+		this.margin = 0;
+		this.noScroll = false;
+		this._placement = "bottom-start";
+		this._open = false;
+		this._actualPlacement = this._placement;
+		this.#targetElement = null;
+		this.#scrollParents = [];
+		this.#sizeObserver = null;
+		this.#size = {
+			width: 0,
+			height: 0
+		};
+		this.#onBeforeToggle = (event) => {
+			this._open = event.newState === "open";
+			this.#targetElement = findAncestorByAttributeValue(this, "popovertarget", this.id);
+			this.#targetElement?.dispatchEvent(new CustomEvent("uui-popover-before-toggle", {
+				bubbles: false,
+				composed: false,
+				detail: {
+					oldState: event.oldState,
+					newState: event.newState
+				}
+			}));
+			if (this._open) {
+				this.#calculateScrollParents();
+				this.#startScrollListener();
+				requestAnimationFrame(() => {
+					this.#initUpdate();
+				});
+			} else {
+				this.#stopScrollListener();
+				this.style.removeProperty("--_available-height");
+			}
+		};
+		this.#initUpdate = () => {
+			if (!this._open) return;
+			this._actualPlacement = this._placement;
+			this.style.opacity = "0";
+			this.#updatePosition(3);
+		};
+		this.#updatePosition = (iteration) => {
+			this.#updatePadding();
+			iteration--;
+			if (this.#targetElement === null) return;
+			const targetRect = this.#targetElement.getBoundingClientRect();
+			const popoverRect = this.getBoundingClientRect();
+			let { top, left } = this.#calculateAlignedPosition(targetRect, popoverRect);
+			const result = this.#clampAndFlip(top, left, targetRect, popoverRect, iteration);
+			if (result === null) return;
+			top = result.top;
+			left = result.left;
+			const screenWidth = window.innerWidth;
+			const screenHeight = window.innerHeight;
+			if (top + popoverRect.height < 0 || top > screenHeight || left + popoverRect.width < 0 || left > screenWidth) {
+				this.hidePopover();
+				return;
+			}
+			const isTopPlacement = this._actualPlacement.startsWith("top");
+			const isBottomPlacement = this._actualPlacement.startsWith("bottom");
+			let availableHeight;
+			if (isTopPlacement) availableHeight = targetRect.top - 2 * this.margin;
+			else if (isBottomPlacement) availableHeight = screenHeight - (targetRect.top + targetRect.height) - 2 * this.margin;
+			else availableHeight = screenHeight - targetRect.top - this.margin;
+			this.style.setProperty("--_available-height", `${Math.max(availableHeight, 0)}px`);
+			this.style.transform = `translate(${left}px, ${top}px)`;
+			this.style.opacity = "1";
+		};
+		this.#updatePadding = () => {
+			const oppositeSides = {
+				top: "bottom",
+				bottom: "top",
+				left: "right",
+				right: "left"
+			};
+			let side = this._actualPlacement.split("-")[0];
+			side = oppositeSides[side] || side;
+			side = side.charAt(0).toUpperCase() + side.slice(1);
+			const marginSide = `margin${side}`;
+			this.style.margin = "0";
+			this.style[marginSide] = `${this.margin}px`;
+		};
+		this.addEventListener("beforetoggle", this.#onBeforeToggle, { passive: true });
+	}
+	connectedCallback() {
+		super.connectedCallback();
+		if (!this.hasAttribute("popover")) this.setAttribute("popover", "");
+		if (!this.#sizeObserver) {
+			this.#sizeObserver = new ResizeObserver((entries) => {
+				const element = entries[0];
+				const width = element.contentRect.width;
+				const height = element.contentRect.height;
+				if (width === this.#size.width && height === this.#size.height) return;
+				this.#size = {
+					width,
+					height
+				};
+				this.#initUpdate();
+			});
+			this.#sizeObserver.observe(this);
+		}
+	}
+	disconnectedCallback() {
+		super.disconnectedCallback();
+		this.#stopScrollListener();
+		this.#sizeObserver?.disconnect();
+		this.#sizeObserver = null;
+	}
+	#onBeforeToggle;
+	#initUpdate;
+	#updatePosition;
+	#calculateAlignedPosition(targetRect, popoverRect) {
+		const isStart = this._actualPlacement.includes("-start");
+		const isEnd = this._actualPlacement.includes("-end");
+		const align = (pos, targetSize, popoverSize) => {
+			if (isStart) return pos;
+			if (isEnd) return pos + targetSize - popoverSize;
+			return pos + targetSize / 2 - popoverSize / 2;
+		};
+		const side = this._actualPlacement.split("-")[0];
+		return {
+			bottom: {
+				top: targetRect.top + targetRect.height,
+				left: align(targetRect.left, targetRect.width, popoverRect.width)
+			},
+			top: {
+				top: targetRect.top - popoverRect.height,
+				left: align(targetRect.left, targetRect.width, popoverRect.width)
+			},
+			left: {
+				top: align(targetRect.top, targetRect.height, popoverRect.height),
+				left: targetRect.left - popoverRect.width
+			},
+			right: {
+				top: align(targetRect.top, targetRect.height, popoverRect.height),
+				left: targetRect.left + targetRect.width
+			}
+		}[side] ?? {
+			top: 0,
+			left: 0
+		};
+	}
+	#clampAndFlip(top, left, targetRect, popoverRect, iteration) {
+		const screenWidth = window.innerWidth;
+		const screenHeight = window.innerHeight;
+		const side = this._actualPlacement.split("-")[0];
+		const isVertical = side === "top" || side === "bottom";
+		const topTargetVsScreenTop = Math.min(0, targetRect.top + targetRect.height);
+		const topTargetVsScreenBottom = Math.max(Math.min(top, screenHeight - popoverRect.height), targetRect.top - popoverRect.height);
+		const topClamped = Math.max(topTargetVsScreenTop, topTargetVsScreenBottom);
+		if (topClamped !== top && isVertical && iteration > 0) {
+			this.#flipPlacement();
+			this.#updatePosition(iteration);
+			return null;
+		}
+		const leftTargetVsScreenLeft = Math.min(0, targetRect.left + targetRect.width);
+		const leftTargetVsScreenRight = Math.max(Math.min(left, screenWidth - popoverRect.width), targetRect.left - popoverRect.width);
+		const leftClamped = Math.max(leftTargetVsScreenLeft, leftTargetVsScreenRight);
+		if (leftClamped !== left && !isVertical && iteration > 0) {
+			this.#flipPlacement();
+			this.#updatePosition(iteration);
+			return null;
+		}
+		return {
+			top: topClamped,
+			left: leftClamped
+		};
+	}
+	#updatePadding;
+	#flipPlacement() {
+		const [direction, position] = this._actualPlacement.split("-");
+		const oppositeDirection = {
+			top: "bottom",
+			bottom: "top",
+			left: "right",
+			right: "left"
+		}[direction] ?? direction;
+		this._actualPlacement = `${oppositeDirection}-${position}`;
+	}
+	#startScrollListener() {
+		this.#scrollParents.forEach((el) => {
+			el.addEventListener("scroll", this.#initUpdate, { passive: true });
+		});
+		document.addEventListener("scroll", this.#initUpdate, { passive: true });
+	}
+	#stopScrollListener() {
+		this.#scrollParents.forEach((el) => {
+			el.removeEventListener("scroll", this.#initUpdate);
+		});
+		document.removeEventListener("scroll", this.#initUpdate);
+	}
+	/**
+	* @internal
+	*/
+	_getScrollParents() {
+		return this.#scrollParents;
+	}
+	#calculateScrollParents() {
+		this.#scrollParents = [];
+		if (!this.#targetElement) return;
+		let style = getComputedStyle(this.#targetElement);
+		if (style.position === "fixed") return;
+		let excludeStaticParent = style.position === "absolute";
+		const overflowRegex = /(auto|scroll)/;
+		let el = this.#targetElement;
+		while (el) {
+			style = getComputedStyle(el);
+			if (excludeStaticParent && style.position === "static") {
+				el = this.#getAncestorElement(el);
+				continue;
+			}
+			if (style.position !== "static") excludeStaticParent = style.position === "absolute";
+			if (overflowRegex.test(style.overflow + style.overflowY + style.overflowX)) this.#scrollParents.push(el);
+			if (style.position === "fixed") return;
+			el = this.#getAncestorElement(el);
+		}
+		this.#scrollParents.push(document.body);
+	}
+	#getAncestorElement(el) {
+		if (el?.assignedSlot) return el.assignedSlot;
+		if (el?.parentElement) return el.parentElement;
+		return (el?.getRootNode())?.host;
+	}
+	render() {
+		if (this.noScroll) return html`<slot></slot>`;
+		return html`<uui-scroll-container><slot></slot></uui-scroll-container>`;
+	}
+	static {
+		this.styles = [css`
       :host {
         margin: 0;
         width: fit-content;
@@ -322,32 +278,31 @@ _UUIPopoverContainerElement.styles = [
         box-shadow: var(--uui-shadow-depth-4);
         border-radius: var(--uui-border-radius);
       }
+      :host([no-scroll]) {
+        overflow: visible;
+      }
 
       uui-scroll-container {
         max-height: var(--_available-height, none);
       }
-    `
-];
-let UUIPopoverContainerElement = _UUIPopoverContainerElement;
-__decorateClass([
-  property({ type: Number })
-], UUIPopoverContainerElement.prototype, "margin", 2);
-__decorateClass([
-  property({ type: Boolean })
-], UUIPopoverContainerElement.prototype, "open", 1);
-__decorateClass([
-  property({ type: String, reflect: true })
-], UUIPopoverContainerElement.prototype, "placement", 1);
-__decorateClass([
-  state()
-], UUIPopoverContainerElement.prototype, "_placement", 2);
-__decorateClass([
-  state()
-], UUIPopoverContainerElement.prototype, "_open", 2);
-__decorateClass([
-  state()
-], UUIPopoverContainerElement.prototype, "_actualPlacement", 2);
-export {
-  UUIPopoverContainerElement
+    `];
+	}
 };
-//# sourceMappingURL=popover-container.element.js.map
+__decorate([property({ type: Number })], UUIPopoverContainerElement.prototype, "margin", void 0);
+__decorate([property({ type: Boolean })], UUIPopoverContainerElement.prototype, "open", null);
+__decorate([property({
+	type: String,
+	reflect: true
+})], UUIPopoverContainerElement.prototype, "placement", null);
+__decorate([property({
+	type: Boolean,
+	reflect: true,
+	attribute: "no-scroll"
+})], UUIPopoverContainerElement.prototype, "noScroll", void 0);
+__decorate([state()], UUIPopoverContainerElement.prototype, "_placement", void 0);
+__decorate([state()], UUIPopoverContainerElement.prototype, "_open", void 0);
+__decorate([state()], UUIPopoverContainerElement.prototype, "_actualPlacement", void 0);
+//#endregion
+export { UUIPopoverContainerElement };
+
+//# sourceMappingURL=popover-container.element.js.map