@sbb-esta/lyne-elements 4.7.0 → 4.8.0

package/development/core/overlay/overlay-trigger-attributes.js

@@ -1,47 +1,50 @@
+//#region src/elements/core/overlay/overlay-trigger-attributes.ts
+/**
+* Add meaningful aria attributes to trigger elements that are connected to
+* overlay elements such as menus and dialogs.
+*/
 function setAriaOverlayTriggerAttributes(trigger, popupType, overlayId, state) {
-  if (!trigger) {
-    return;
-  }
-  trigger.setAttribute("aria-haspopup", popupType);
-  trigger.setAttribute("aria-controls", overlayId);
-  trigger.setAttribute("aria-expanded", `${state === "opening" || state === "opened"}`);
+	if (!trigger) return;
+	trigger.setAttribute("aria-haspopup", popupType);
+	trigger.setAttribute("aria-controls", overlayId);
+	trigger.setAttribute("aria-expanded", `${state === "opening" || state === "opened"}`);
 }
+/**
+* Remove aria attributes from trigger elements.
+*/
 function removeAriaOverlayTriggerAttributes(trigger) {
-  if (!trigger) {
-    return;
-  }
-  trigger.removeAttribute("aria-haspopup");
-  trigger.removeAttribute("aria-controls");
-  trigger.removeAttribute("aria-expanded");
+	if (!trigger) return;
+	trigger.removeAttribute("aria-haspopup");
+	trigger.removeAttribute("aria-controls");
+	trigger.removeAttribute("aria-expanded");
 }
+/**
+* Add meaningful aria attributes to trigger element of role='combobox'
+*/
 function setAriaComboBoxAttributes(trigger, overlayId, expanded, hasPopup = "listbox") {
-  if (!trigger) {
-    return;
-  }
-  trigger.setAttribute("autocomplete", "off");
-  trigger.setAttribute("role", "combobox");
-  trigger.setAttribute("aria-autocomplete", "list");
-  trigger.setAttribute("aria-haspopup", hasPopup);
-  trigger.setAttribute("aria-controls", overlayId);
-  trigger.setAttribute("aria-owns", overlayId);
-  trigger.setAttribute("aria-expanded", `${expanded}`);
+	if (!trigger) return;
+	trigger.setAttribute("autocomplete", "off");
+	trigger.setAttribute("role", "combobox");
+	trigger.setAttribute("aria-autocomplete", "list");
+	trigger.setAttribute("aria-haspopup", hasPopup);
+	trigger.setAttribute("aria-controls", overlayId);
+	trigger.setAttribute("aria-owns", overlayId);
+	trigger.setAttribute("aria-expanded", `${expanded}`);
 }
+/**
+* Remove aria attributes from trigger elements.
+*/
 function removeAriaComboBoxAttributes(trigger) {
-  if (!trigger) {
-    return;
-  }
-  trigger.removeAttribute("autocomplete");
-  trigger.removeAttribute("role");
-  trigger.removeAttribute("aria-autocomplete");
-  trigger.removeAttribute("aria-haspopup");
-  trigger.removeAttribute("aria-controls");
-  trigger.removeAttribute("aria-owns");
-  trigger.removeAttribute("aria-expanded");
+	if (!trigger) return;
+	trigger.removeAttribute("autocomplete");
+	trigger.removeAttribute("role");
+	trigger.removeAttribute("aria-autocomplete");
+	trigger.removeAttribute("aria-haspopup");
+	trigger.removeAttribute("aria-controls");
+	trigger.removeAttribute("aria-owns");
+	trigger.removeAttribute("aria-expanded");
 }
-export {
-  removeAriaComboBoxAttributes,
-  removeAriaOverlayTriggerAttributes,
-  setAriaComboBoxAttributes,
-  setAriaOverlayTriggerAttributes
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//#endregion
+export { removeAriaComboBoxAttributes, removeAriaOverlayTriggerAttributes, setAriaComboBoxAttributes, setAriaOverlayTriggerAttributes };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/overlay/overlay.js

@@ -1,6 +1,11 @@
 import { html } from "lit";
+//#region src/elements/core/overlay/overlay.ts
+/**
+* Used to create the "wrapping" effect around the anchor for overlays (es. autocomplete)
+* Works in conjunction with the 'overlayGapFixCorners()' function in 'overlay.ts'
+*/
 function overlayGapFixCorners() {
-  return html`
+	return html`
     <div class="sbb-gap-fix-wrapper">
       <div class="sbb-gap-fix-corner" id="left"></div>
     </div>
@@ -9,7 +14,7 @@ function overlayGapFixCorners() {
     </div>
   `;
 }
-export {
-  overlayGapFixCorners
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2VsZW1lbnRzL2NvcmUvb3ZlcmxheS9vdmVybGF5LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgVGVtcGxhdGVSZXN1bHQgfSBmcm9tICdsaXQnO1xuaW1wb3J0IHsgaHRtbCB9IGZyb20gJ2xpdCc7XG5cbi8qKlxuICogVXNlZCB0byBjcmVhdGUgdGhlIFwid3JhcHBpbmdcIiBlZmZlY3QgYXJvdW5kIHRoZSBhbmNob3IgZm9yIG92ZXJsYXlzIChlcy4gYXV0b2NvbXBsZXRlKVxuICogV29ya3MgaW4gY29uanVuY3Rpb24gd2l0aCB0aGUgJ292ZXJsYXlHYXBGaXhDb3JuZXJzKCknIGZ1bmN0aW9uIGluICdvdmVybGF5LnRzJ1xuICovXG5leHBvcnQgZnVuY3Rpb24gb3ZlcmxheUdhcEZpeENvcm5lcnMoKTogVGVtcGxhdGVSZXN1bHQge1xuICByZXR1cm4gaHRtbGBcbiAgICA8ZGl2IGNsYXNzPVwic2JiLWdhcC1maXgtd3JhcHBlclwiPlxuICAgICAgPGRpdiBjbGFzcz1cInNiYi1nYXAtZml4LWNvcm5lclwiIGlkPVwibGVmdFwiPjwvZGl2PlxuICAgIDwvZGl2PlxuICAgIDxkaXYgY2xhc3M9XCJzYmItZ2FwLWZpeC13cmFwcGVyXCI+XG4gICAgICA8ZGl2IGNsYXNzPVwic2JiLWdhcC1maXgtY29ybmVyXCIgaWQ9XCJyaWdodFwiPjwvZGl2PlxuICAgIDwvZGl2PlxuICBgO1xufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7U0FPZ0IsdUJBQW9CO0FBQ2xDLFNBQU87QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQVFUOyJ9
+//#endregion
+export { overlayGapFixCorners };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZWxlbWVudHMvY29yZS9vdmVybGF5L292ZXJsYXkudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBUZW1wbGF0ZVJlc3VsdCB9IGZyb20gJ2xpdCc7XG5pbXBvcnQgeyBodG1sIH0gZnJvbSAnbGl0JztcblxuLyoqXG4gKiBVc2VkIHRvIGNyZWF0ZSB0aGUgXCJ3cmFwcGluZ1wiIGVmZmVjdCBhcm91bmQgdGhlIGFuY2hvciBmb3Igb3ZlcmxheXMgKGVzLiBhdXRvY29tcGxldGUpXG4gKiBXb3JrcyBpbiBjb25qdW5jdGlvbiB3aXRoIHRoZSAnb3ZlcmxheUdhcEZpeENvcm5lcnMoKScgZnVuY3Rpb24gaW4gJ292ZXJsYXkudHMnXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBvdmVybGF5R2FwRml4Q29ybmVycygpOiBUZW1wbGF0ZVJlc3VsdCB7XG4gIHJldHVybiBodG1sYFxuICAgIDxkaXYgY2xhc3M9XCJzYmItZ2FwLWZpeC13cmFwcGVyXCI+XG4gICAgICA8ZGl2IGNsYXNzPVwic2JiLWdhcC1maXgtY29ybmVyXCIgaWQ9XCJsZWZ0XCI+PC9kaXY+XG4gICAgPC9kaXY+XG4gICAgPGRpdiBjbGFzcz1cInNiYi1nYXAtZml4LXdyYXBwZXJcIj5cbiAgICAgIDxkaXYgY2xhc3M9XCJzYmItZ2FwLWZpeC1jb3JuZXJcIiBpZD1cInJpZ2h0XCI+PC9kaXY+XG4gICAgPC9kaXY+XG4gIGA7XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQU9BLFNBQWdCLHVCQUFvQjtBQUNsQyxRQUFPLElBQUkifQ==

package/development/core/overlay/position.js

@@ -1,125 +1,151 @@
+//#region src/elements/core/overlay/position.ts
+/**
+* Gets height and width of an element even if it's hidden (`display: none`).
+*/
 function getElementRectangle(el) {
-  const elementStyle = window.getComputedStyle(el), elementDisplay = elementStyle.display, elementMaxHeight = parseInt(elementStyle.maxHeight, 10).toString();
-  if (elementDisplay !== "none" && elementMaxHeight !== "0") {
-    return {
-      scrollHeight: el.scrollHeight,
-      clientHeight: el.clientHeight,
-      offsetHeight: el.offsetHeight,
-      scrollWidth: el.scrollWidth,
-      clientWidth: el.clientWidth,
-      offsetWidth: el.offsetWidth
-    };
-  }
-  el.style.position = "absolute";
-  el.style.visibility = "hidden";
-  el.style.display = "block";
-  const scrollHeight = el.scrollHeight, clientHeight = el.clientHeight, offsetHeight = el.offsetHeight, scrollWidth = el.scrollWidth, clientWidth = el.clientWidth, offsetWidth = el.offsetWidth;
-  el.style.display = "";
-  el.style.position = "";
-  el.style.visibility = "";
-  return { scrollHeight, clientHeight, offsetHeight, scrollWidth, clientWidth, offsetWidth };
+	const elementStyle = window.getComputedStyle(el), elementDisplay = elementStyle.display, elementMaxHeight = parseInt(elementStyle.maxHeight, 10).toString();
+	if (elementDisplay !== "none" && elementMaxHeight !== "0") return {
+		scrollHeight: el.scrollHeight,
+		clientHeight: el.clientHeight,
+		offsetHeight: el.offsetHeight,
+		scrollWidth: el.scrollWidth,
+		clientWidth: el.clientWidth,
+		offsetWidth: el.offsetWidth
+	};
+	el.style.position = "absolute";
+	el.style.visibility = "hidden";
+	el.style.display = "block";
+	const scrollHeight = el.scrollHeight, clientHeight = el.clientHeight, offsetHeight = el.offsetHeight, scrollWidth = el.scrollWidth, clientWidth = el.clientWidth, offsetWidth = el.offsetWidth;
+	el.style.display = "";
+	el.style.position = "";
+	el.style.visibility = "";
+	return {
+		scrollHeight,
+		clientHeight,
+		offsetHeight,
+		scrollWidth,
+		clientWidth,
+		offsetWidth
+	};
 }
+/**
+* Determines whether an event is fired on a specific element.
+*/
 function isEventOnElement(element, event) {
-  if (!element || !event) {
-    return false;
-  }
-  const rect = element.getBoundingClientRect();
-  return rect.top <= event.clientY && event.clientY <= rect.top + rect.height && rect.left <= event.clientX && event.clientX <= rect.left + rect.width;
+	if (!element || !event) return false;
+	const rect = element.getBoundingClientRect();
+	return rect.top <= event.clientY && event.clientY <= rect.top + rect.height && rect.left <= event.clientX && event.clientX <= rect.left + rect.width;
 }
+/**
+* Determines the position of an element relative to a trigger element by evaluating
+* the optimal position based on the available space.
+*
+* @param element The element of which to calculate the position.
+* @param trigger The element relative to which to calculate the position.
+* @param container The element which has the position:fixed applied.
+* @param properties Properties to take into account in calculations (optional).
+* @param properties.verticalOffset The distance to be added between the element and the trigger (optional).
+* @param properties.horizontalOffset The horizontal offset to be applied to the element (optional).
+* @param properties.centered Whether the element should be placed in the center by default (optional).
+* @param properties.responsiveHeight Whether the element calculates its height based on its content (optional).
+* @returns Returns an object containing the left position, the top position, the maximum height
+* of the element and the current alignment object.
+*/
 function getElementPosition(element, trigger, container, properties) {
-  const maxWidthOffset = 16;
-  const verticalOffset = properties?.verticalOffset || 0;
-  const horizontalOffset = properties?.horizontalOffset || 0;
-  const responsiveHeight = properties?.responsiveHeight || false;
-  const triggerRec = trigger.getBoundingClientRect();
-  const elementRec = getElementRectangle(element);
-  const triggerLeft = triggerRec.left;
-  const triggerTop = triggerRec.top;
-  const availableSpaceRight = document.documentElement.clientWidth - (triggerLeft + triggerRec.width);
-  const availableSpaceAbove = triggerTop - verticalOffset;
-  const availableSpaceBelow = document.documentElement.clientHeight - (triggerTop + triggerRec.height + verticalOffset);
-  let elementXPosition = triggerLeft;
-  let elementYPosition = triggerTop + triggerRec.height + verticalOffset;
-  let elementXOverflow = elementRec.offsetWidth - triggerRec.width;
-  const alignment = { horizontal: "start", vertical: "below" };
-  let elementMaxHeight = `${availableSpaceBelow - verticalOffset}px`;
-  if (properties?.centered && triggerLeft - maxWidthOffset + triggerRec.width / 2 > elementRec.offsetWidth / 2 && availableSpaceRight - maxWidthOffset > elementXOverflow / 2) {
-    elementXPosition -= elementXOverflow /= 2;
-    alignment.horizontal = "center";
-  }
-  if (availableSpaceRight < elementXOverflow && triggerLeft > elementXOverflow) {
-    elementXPosition = elementXPosition - elementXOverflow;
-    alignment.horizontal = "end";
-  }
-  if (horizontalOffset && alignment.horizontal !== "center" && triggerRec.width / 2 < horizontalOffset) {
-    elementXPosition += horizontalOffset * (alignment.horizontal === "start" ? -1 : 1);
-  }
-  if (triggerLeft < elementXOverflow && availableSpaceRight < elementXOverflow || document.documentElement.clientWidth < elementRec.offsetWidth) {
-    elementXPosition = document.documentElement.clientWidth / 2 - elementRec.offsetWidth / 2;
-  }
-  const shouldOpenAbove = availableSpaceBelow - verticalOffset < elementRec.scrollHeight && availableSpaceAbove - verticalOffset > (responsiveHeight ? elementRec.clientHeight : elementRec.scrollHeight) || availableSpaceAbove > availableSpaceBelow && availableSpaceBelow - verticalOffset < elementRec.clientHeight && !responsiveHeight;
-  if (!properties?.forceBelow && (properties?.forceAbove || shouldOpenAbove)) {
-    elementYPosition = availableSpaceAbove < elementRec.scrollHeight ? elementYPosition - triggerRec.height - availableSpaceAbove - verticalOffset : triggerTop - elementRec.clientHeight - verticalOffset;
-    elementMaxHeight = `${availableSpaceAbove - verticalOffset}px`;
-    alignment.vertical = "above";
-  }
-  const containerRect = container.getBoundingClientRect();
-  if (containerRect.left < 0) {
-    elementXPosition -= containerRect.left;
-  }
-  if (containerRect.top < 0) {
-    elementYPosition -= containerRect.top;
-  }
-  return {
-    top: elementYPosition,
-    left: elementXPosition,
-    maxHeight: elementMaxHeight,
-    alignment
-  };
+	const maxWidthOffset = 16;
+	const verticalOffset = properties?.verticalOffset || 0;
+	const horizontalOffset = properties?.horizontalOffset || 0;
+	const responsiveHeight = properties?.responsiveHeight || false;
+	const triggerRec = trigger.getBoundingClientRect();
+	const elementRec = getElementRectangle(element);
+	const triggerLeft = triggerRec.left;
+	const triggerTop = triggerRec.top;
+	const availableSpaceRight = document.documentElement.clientWidth - (triggerLeft + triggerRec.width);
+	const availableSpaceAbove = triggerTop - verticalOffset;
+	const availableSpaceBelow = document.documentElement.clientHeight - (triggerTop + triggerRec.height + verticalOffset);
+	let elementXPosition = triggerLeft;
+	let elementYPosition = triggerTop + triggerRec.height + verticalOffset;
+	let elementXOverflow = elementRec.offsetWidth - triggerRec.width;
+	const alignment = {
+		horizontal: "start",
+		vertical: "below"
+	};
+	let elementMaxHeight = `${availableSpaceBelow - verticalOffset}px`;
+	if (properties?.centered && triggerLeft - maxWidthOffset + triggerRec.width / 2 > elementRec.offsetWidth / 2 && availableSpaceRight - maxWidthOffset > elementXOverflow / 2) {
+		elementXPosition -= elementXOverflow /= 2;
+		alignment.horizontal = "center";
+	}
+	if (availableSpaceRight < elementXOverflow && triggerLeft > elementXOverflow) {
+		elementXPosition = elementXPosition - elementXOverflow;
+		alignment.horizontal = "end";
+	}
+	if (horizontalOffset && alignment.horizontal !== "center" && triggerRec.width / 2 < horizontalOffset) elementXPosition += horizontalOffset * (alignment.horizontal === "start" ? -1 : 1);
+	if (triggerLeft < elementXOverflow && availableSpaceRight < elementXOverflow || document.documentElement.clientWidth < elementRec.offsetWidth) elementXPosition = document.documentElement.clientWidth / 2 - elementRec.offsetWidth / 2;
+	const shouldOpenAbove = availableSpaceBelow - verticalOffset < elementRec.scrollHeight && availableSpaceAbove - verticalOffset > (responsiveHeight ? elementRec.clientHeight : elementRec.scrollHeight) || availableSpaceAbove > availableSpaceBelow && availableSpaceBelow - verticalOffset < elementRec.clientHeight && !responsiveHeight;
+	if (!properties?.forceBelow && (properties?.forceAbove || shouldOpenAbove)) {
+		elementYPosition = availableSpaceAbove < elementRec.scrollHeight ? elementYPosition - triggerRec.height - availableSpaceAbove - verticalOffset : triggerTop - elementRec.clientHeight - verticalOffset;
+		elementMaxHeight = `${availableSpaceAbove - verticalOffset}px`;
+		alignment.vertical = "above";
+	}
+	const containerRect = container.getBoundingClientRect();
+	if (containerRect.left < 0) elementXPosition -= containerRect.left;
+	if (containerRect.top < 0) elementYPosition -= containerRect.top;
+	return {
+		top: elementYPosition,
+		left: elementXPosition,
+		maxHeight: elementMaxHeight,
+		alignment
+	};
 }
+/**
+* Determines the position of an element relative to a trigger element by evaluating
+* the optimal position based on the available space.
+*
+* @param element The element of which to calculate the position.
+* @param trigger The element relative to which to calculate the position.
+* @param container The element which has the position:fixed applied.
+* @param properties Properties to take into account in calculations (optional).
+* @param properties.verticalOffset The distance to be added between the element and the trigger (optional).
+* @param properties.horizontalOffset The horizontal offset to be applied to the element (optional).
+* @param properties.responsiveHeight Whether the element calculates its height based on its content (optional).
+* @returns Returns an object containing the left position, the top position, the maximum height
+* of the element and the current alignment object.
+*/
 function getElementPositionHorizontal(element, trigger, container, properties) {
-  const maxHeightOffset = 16;
-  const verticalOffset = properties?.verticalOffset || 0;
-  const horizontalOffset = properties?.horizontalOffset || 0;
-  const triggerRec = trigger.getBoundingClientRect();
-  const elementRec = getElementRectangle(element);
-  const triggerParentRec = trigger.parentElement.shadowRoot.querySelector(properties?.contentSelector ?? `.${element.className}`).getBoundingClientRect();
-  const containerRect = container.getBoundingClientRect();
-  const availableSpaceRight = document.documentElement.clientWidth - triggerParentRec.right;
-  const availableSpaceBelow = document.documentElement.clientHeight - (triggerRec.top - verticalOffset);
-  const availableVerticalSpace = document.documentElement.clientHeight;
-  const elementMaxHeight = `${availableVerticalSpace - maxHeightOffset * 2}px`;
-  const alignment = { horizontal: "end", vertical: "above" };
-  const elementXOverflow = elementRec.offsetWidth + horizontalOffset;
-  let elementXPosition = triggerParentRec.right;
-  let elementYPosition = triggerRec.top + verticalOffset;
-  if (availableSpaceRight < elementXOverflow && triggerRec.left > elementXOverflow) {
-    elementXPosition = elementXPosition - triggerParentRec.width - elementRec.offsetWidth;
-    alignment.horizontal = "start";
-  }
-  if (horizontalOffset && alignment.horizontal !== "center") {
-    elementXPosition += horizontalOffset * (alignment.horizontal === "start" ? -1 : 1);
-  }
-  if (availableSpaceBelow < elementRec.scrollHeight) {
-    elementYPosition = availableVerticalSpace - elementRec.clientHeight - maxHeightOffset;
-  }
-  if (containerRect.left < 0) {
-    elementXPosition -= containerRect.left;
-  }
-  if (containerRect.top < 0) {
-    elementYPosition -= containerRect.top;
-  }
-  return {
-    top: elementYPosition,
-    left: elementXPosition,
-    maxHeight: elementMaxHeight,
-    alignment
-  };
+	const maxHeightOffset = 16;
+	const verticalOffset = properties?.verticalOffset || 0;
+	const horizontalOffset = properties?.horizontalOffset || 0;
+	const triggerRec = trigger.getBoundingClientRect();
+	const elementRec = getElementRectangle(element);
+	const triggerParentRec = trigger.parentElement.shadowRoot.querySelector(properties?.contentSelector ?? `.${element.className}`).getBoundingClientRect();
+	const containerRect = container.getBoundingClientRect();
+	const availableSpaceRight = document.documentElement.clientWidth - triggerParentRec.right;
+	const availableSpaceBelow = document.documentElement.clientHeight - (triggerRec.top - verticalOffset);
+	const availableVerticalSpace = document.documentElement.clientHeight;
+	const elementMaxHeight = `${availableVerticalSpace - maxHeightOffset * 2}px`;
+	const alignment = {
+		horizontal: "end",
+		vertical: "above"
+	};
+	const elementXOverflow = elementRec.offsetWidth + horizontalOffset;
+	let elementXPosition = triggerParentRec.right;
+	let elementYPosition = triggerRec.top + verticalOffset;
+	if (availableSpaceRight < elementXOverflow && triggerRec.left > elementXOverflow) {
+		elementXPosition = elementXPosition - triggerParentRec.width - elementRec.offsetWidth;
+		alignment.horizontal = "start";
+	}
+	if (horizontalOffset && alignment.horizontal !== "center") elementXPosition += horizontalOffset * (alignment.horizontal === "start" ? -1 : 1);
+	if (availableSpaceBelow < elementRec.scrollHeight) elementYPosition = availableVerticalSpace - elementRec.clientHeight - maxHeightOffset;
+	if (containerRect.left < 0) elementXPosition -= containerRect.left;
+	if (containerRect.top < 0) elementYPosition -= containerRect.top;
+	return {
+		top: elementYPosition,
+		left: elementXPosition,
+		maxHeight: elementMaxHeight,
+		alignment
+	};
 }
-export {
-  getElementPosition,
-  getElementPositionHorizontal,
-  getElementRectangle,
-  isEventOnElement
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"position.js","sources":["../../../../../src/elements/core/overlay/position.ts"],"sourcesContent":["export type ElementRectangle = Pick<\n  HTMLElement,\n  'scrollHeight' | 'clientHeight' | 'offsetHeight' | 'scrollWidth' | 'clientWidth' | 'offsetWidth'\n>;\n\nexport interface SbbAlignment {\n  horizontal: 'start' | 'center' | 'end';\n  vertical: 'above' | 'below';\n}\n\nexport interface SbbElementPositionInfos {\n  top: number;\n  left: number;\n  maxHeight: string;\n  alignment: SbbAlignment;\n}\n\n/**\n * Gets height and width of an element even if it's hidden (`display: none`).\n */\nexport function getElementRectangle(el: HTMLElement): ElementRectangle {\n  const elementStyle = window.getComputedStyle(el),\n    elementDisplay = elementStyle.display,\n    elementMaxHeight = parseInt(elementStyle.maxHeight, 10).toString();\n\n  // If it is not hidden we just return normal height\n  if (elementDisplay !== 'none' && elementMaxHeight !== '0') {\n    return {\n      scrollHeight: el.scrollHeight,\n      clientHeight: el.clientHeight,\n      offsetHeight: el.offsetHeight,\n      scrollWidth: el.scrollWidth,\n      clientWidth: el.clientWidth,\n      offsetWidth: el.offsetWidth,\n    };\n  }\n\n  // The element is hidden so:\n  // make the el block in order to measure its height but still be hidden\n  el.style.position = 'absolute';\n  el.style.visibility = 'hidden';\n  el.style.display = 'block';\n\n  const scrollHeight = el.scrollHeight,\n    clientHeight = el.clientHeight,\n    offsetHeight = el.offsetHeight,\n    scrollWidth = el.scrollWidth,\n    clientWidth = el.clientWidth,\n    offsetWidth = el.offsetWidth;\n\n  // Reverting to the original values\n  el.style.display = '';\n  el.style.position = '';\n  el.style.visibility = '';\n\n  return { scrollHeight, clientHeight, offsetHeight, scrollWidth, clientWidth, offsetWidth };\n}\n\n/**\n * Determines whether an event is fired on a specific element.\n */\nexport function isEventOnElement(\n  element: HTMLElement | null,\n  event: MouseEvent | PointerEvent,\n): boolean {\n  if (!element || !event) {\n    return false;\n  }\n\n  const rect = element.getBoundingClientRect();\n  return (\n    rect.top <= event.clientY &&\n    event.clientY <= rect.top + rect.height &&\n    rect.left <= event.clientX &&\n    event.clientX <= rect.left + rect.width\n  );\n}\n\n/**\n * Determines the position of an element relative to a trigger element by evaluating\n * the optimal position based on the available space.\n *\n * @param element The element of which to calculate the position.\n * @param trigger The element relative to which to calculate the position.\n * @param container The element which has the position:fixed applied.\n * @param properties Properties to take into account in calculations (optional).\n * @param properties.verticalOffset The distance to be added between the element and the trigger (optional).\n * @param properties.horizontalOffset The horizontal offset to be applied to the element (optional).\n * @param properties.centered Whether the element should be placed in the center by default (optional).\n * @param properties.responsiveHeight Whether the element calculates its height based on its content (optional).\n * @returns Returns an object containing the left position, the top position, the maximum height\n * of the element and the current alignment object.\n */\nexport function getElementPosition(\n  element: HTMLElement,\n  trigger: HTMLElement,\n  container: HTMLElement,\n  properties?: {\n    verticalOffset?: number;\n    horizontalOffset?: number;\n    centered?: boolean;\n    responsiveHeight?: boolean;\n    forceAbove?: boolean;\n    forceBelow?: boolean;\n  },\n): SbbElementPositionInfos {\n  const maxWidthOffset = 16;\n  const verticalOffset = properties?.verticalOffset || 0;\n  const horizontalOffset = properties?.horizontalOffset || 0;\n  const responsiveHeight = properties?.responsiveHeight || false;\n\n  const triggerRec = trigger.getBoundingClientRect();\n  const elementRec = getElementRectangle(element);\n\n  const triggerLeft = triggerRec.left;\n  const triggerTop = triggerRec.top;\n\n  const availableSpaceRight =\n    document.documentElement.clientWidth - (triggerLeft + triggerRec.width);\n  const availableSpaceAbove = triggerTop - verticalOffset;\n  const availableSpaceBelow =\n    document.documentElement.clientHeight - (triggerTop + triggerRec.height + verticalOffset);\n\n  // Default element alignment is \"start/below\"\n  let elementXPosition = triggerLeft;\n  let elementYPosition = triggerTop + triggerRec.height + verticalOffset;\n  let elementXOverflow = elementRec.offsetWidth - triggerRec.width;\n  const alignment: SbbAlignment = { horizontal: 'start', vertical: 'below' };\n\n  // Calculate element max-height\n  let elementMaxHeight = `${availableSpaceBelow - verticalOffset}px`;\n\n  // Check if horizontal alignment needs to be changed to \"center\"\n  if (\n    properties?.centered &&\n    triggerLeft - maxWidthOffset + triggerRec.width / 2 > elementRec.offsetWidth / 2 &&\n    availableSpaceRight - maxWidthOffset > elementXOverflow / 2\n  ) {\n    elementXPosition -= elementXOverflow /= 2;\n    alignment.horizontal = 'center';\n  }\n\n  // Check if horizontal alignment needs to be changed to \"end\"\n  if (availableSpaceRight < elementXOverflow && triggerLeft > elementXOverflow) {\n    elementXPosition = elementXPosition - elementXOverflow;\n    alignment.horizontal = 'end';\n  }\n\n  // Add horizontal offset\n  if (\n    horizontalOffset &&\n    alignment.horizontal !== 'center' &&\n    triggerRec.width / 2 < horizontalOffset\n  ) {\n    elementXPosition += horizontalOffset * (alignment.horizontal === 'start' ? -1 : 1);\n  }\n\n  // Check whether there is insufficient space on both sides\n  if (\n    (triggerLeft < elementXOverflow && availableSpaceRight < elementXOverflow) ||\n    document.documentElement.clientWidth < elementRec.offsetWidth\n  ) {\n    elementXPosition = document.documentElement.clientWidth / 2 - elementRec.offsetWidth / 2;\n  }\n\n  // Check if vertical alignment needs to be changed to \"above\":\n  const shouldOpenAbove =\n    (availableSpaceBelow - verticalOffset < elementRec.scrollHeight &&\n      availableSpaceAbove - verticalOffset >\n        (responsiveHeight ? elementRec.clientHeight : elementRec.scrollHeight)) ||\n    (availableSpaceAbove > availableSpaceBelow &&\n      availableSpaceBelow - verticalOffset < elementRec.clientHeight &&\n      !responsiveHeight);\n\n  if (!properties?.forceBelow && (properties?.forceAbove || shouldOpenAbove)) {\n    elementYPosition =\n      availableSpaceAbove < elementRec.scrollHeight\n        ? elementYPosition - triggerRec.height - availableSpaceAbove - verticalOffset\n        : triggerTop - elementRec.clientHeight - verticalOffset;\n\n    elementMaxHeight = `${availableSpaceAbove - verticalOffset}px`;\n    alignment.vertical = 'above';\n  }\n\n  const containerRect = container.getBoundingClientRect();\n\n  // When zooming in Safari the container rectangle contains negative values for the position,\n  // and we need to re-add them to the calculated coordinates.\n  if (containerRect.left < 0) {\n    elementXPosition -= containerRect.left;\n  }\n\n  // Normally the containerRect's top value would be zero, however when the overlay is attached to an input\n  // (e.g. in an autocomplete), mobile browsers will shift everything in order to put the input in the middle\n  // of the screen and to make space for the virtual keyboard. We need to account for this offset,\n  // otherwise our positioning will be thrown off.\n  // Additionally, when zooming in Safari this fixes the vertical position.\n  if (containerRect.top < 0) {\n    elementYPosition -= containerRect.top;\n  }\n\n  return {\n    top: elementYPosition,\n    left: elementXPosition,\n    maxHeight: elementMaxHeight,\n    alignment: alignment,\n  };\n}\n\n/**\n * Determines the position of an element relative to a trigger element by evaluating\n * the optimal position based on the available space.\n *\n * @param element The element of which to calculate the position.\n * @param trigger The element relative to which to calculate the position.\n * @param container The element which has the position:fixed applied.\n * @param properties Properties to take into account in calculations (optional).\n * @param properties.verticalOffset The distance to be added between the element and the trigger (optional).\n * @param properties.horizontalOffset The horizontal offset to be applied to the element (optional).\n * @param properties.responsiveHeight Whether the element calculates its height based on its content (optional).\n * @returns Returns an object containing the left position, the top position, the maximum height\n * of the element and the current alignment object.\n */\nexport function getElementPositionHorizontal(\n  element: HTMLElement,\n  trigger: HTMLElement,\n  container: HTMLElement,\n  properties?: {\n    verticalOffset?: number;\n    horizontalOffset?: number;\n    responsiveHeight?: boolean;\n    contentSelector?: string;\n  },\n): SbbElementPositionInfos {\n  const maxHeightOffset = 16;\n\n  const verticalOffset = properties?.verticalOffset || 0;\n  const horizontalOffset = properties?.horizontalOffset || 0;\n\n  const triggerRec = trigger.getBoundingClientRect();\n  const elementRec = getElementRectangle(element);\n  const triggerParentRec = trigger\n    .parentElement!.shadowRoot!.querySelector(\n      properties?.contentSelector ?? `.${element.className}`,\n    )!\n    .getBoundingClientRect();\n  const containerRect = container.getBoundingClientRect();\n\n  const availableSpaceRight = document.documentElement.clientWidth - triggerParentRec.right;\n  const availableSpaceBelow =\n    document.documentElement.clientHeight - (triggerRec.top - verticalOffset);\n  const availableVerticalSpace = document.documentElement.clientHeight;\n  const elementMaxHeight = `${availableVerticalSpace - maxHeightOffset * 2}px`;\n  const alignment: SbbAlignment = { horizontal: 'end', vertical: 'above' };\n  const elementXOverflow = elementRec.offsetWidth + horizontalOffset;\n\n  // Default element alignment is \"end/above\"\n  let elementXPosition = triggerParentRec.right;\n  let elementYPosition = triggerRec.top + verticalOffset;\n\n  // Check if horizontal alignment needs to be changed to \"start\"\n  if (availableSpaceRight < elementXOverflow && triggerRec.left > elementXOverflow) {\n    elementXPosition = elementXPosition - triggerParentRec.width - elementRec.offsetWidth;\n    alignment.horizontal = 'start';\n  }\n\n  // Add horizontal offset\n  if (horizontalOffset && alignment.horizontal !== 'center') {\n    elementXPosition += horizontalOffset * (alignment.horizontal === 'start' ? -1 : 1);\n  }\n\n  // Check if vertical alignment needs to be changed to \"above\":\n  if (availableSpaceBelow < elementRec.scrollHeight) {\n    elementYPosition = availableVerticalSpace - elementRec.clientHeight - maxHeightOffset;\n  }\n\n  // When zooming in Safari the container rectangle contains negative values for the position,\n  // and we need to re-add them to the calculated coordinates.\n  if (containerRect.left < 0) {\n    elementXPosition -= containerRect.left;\n  }\n\n  // Normally the containerRect's top value would be zero, however when the overlay is attached to an input\n  // (e.g. in an autocomplete), mobile browsers will shift everything in order to put the input in the middle\n  // of the screen and to make space for the virtual keyboard. We need to account for this offset,\n  // otherwise our positioning will be thrown off.\n  // Additionally, when zooming in Safari this fixes the vertical position.\n  if (containerRect.top < 0) {\n    elementYPosition -= containerRect.top;\n  }\n\n  return {\n    top: elementYPosition,\n    left: elementXPosition,\n    maxHeight: elementMaxHeight,\n    alignment: alignment,\n  };\n}\n"],"names":[],"mappings":"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"}
+//#endregion
+export { getElementPosition, getElementPositionHorizontal, getElementRectangle, isEventOnElement };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"position.js","names":[],"sources":["../../../../../src/elements/core/overlay/position.ts"],"sourcesContent":["export type ElementRectangle = Pick<\n  HTMLElement,\n  'scrollHeight' | 'clientHeight' | 'offsetHeight' | 'scrollWidth' | 'clientWidth' | 'offsetWidth'\n>;\n\nexport interface SbbAlignment {\n  horizontal: 'start' | 'center' | 'end';\n  vertical: 'above' | 'below';\n}\n\nexport interface SbbElementPositionInfos {\n  top: number;\n  left: number;\n  maxHeight: string;\n  alignment: SbbAlignment;\n}\n\n/**\n * Gets height and width of an element even if it's hidden (`display: none`).\n */\nexport function getElementRectangle(el: HTMLElement): ElementRectangle {\n  const elementStyle = window.getComputedStyle(el),\n    elementDisplay = elementStyle.display,\n    elementMaxHeight = parseInt(elementStyle.maxHeight, 10).toString();\n\n  // If it is not hidden we just return normal height\n  if (elementDisplay !== 'none' && elementMaxHeight !== '0') {\n    return {\n      scrollHeight: el.scrollHeight,\n      clientHeight: el.clientHeight,\n      offsetHeight: el.offsetHeight,\n      scrollWidth: el.scrollWidth,\n      clientWidth: el.clientWidth,\n      offsetWidth: el.offsetWidth,\n    };\n  }\n\n  // The element is hidden so:\n  // make the el block in order to measure its height but still be hidden\n  el.style.position = 'absolute';\n  el.style.visibility = 'hidden';\n  el.style.display = 'block';\n\n  const scrollHeight = el.scrollHeight,\n    clientHeight = el.clientHeight,\n    offsetHeight = el.offsetHeight,\n    scrollWidth = el.scrollWidth,\n    clientWidth = el.clientWidth,\n    offsetWidth = el.offsetWidth;\n\n  // Reverting to the original values\n  el.style.display = '';\n  el.style.position = '';\n  el.style.visibility = '';\n\n  return { scrollHeight, clientHeight, offsetHeight, scrollWidth, clientWidth, offsetWidth };\n}\n\n/**\n * Determines whether an event is fired on a specific element.\n */\nexport function isEventOnElement(\n  element: HTMLElement | null,\n  event: MouseEvent | PointerEvent,\n): boolean {\n  if (!element || !event) {\n    return false;\n  }\n\n  const rect = element.getBoundingClientRect();\n  return (\n    rect.top <= event.clientY &&\n    event.clientY <= rect.top + rect.height &&\n    rect.left <= event.clientX &&\n    event.clientX <= rect.left + rect.width\n  );\n}\n\n/**\n * Determines the position of an element relative to a trigger element by evaluating\n * the optimal position based on the available space.\n *\n * @param element The element of which to calculate the position.\n * @param trigger The element relative to which to calculate the position.\n * @param container The element which has the position:fixed applied.\n * @param properties Properties to take into account in calculations (optional).\n * @param properties.verticalOffset The distance to be added between the element and the trigger (optional).\n * @param properties.horizontalOffset The horizontal offset to be applied to the element (optional).\n * @param properties.centered Whether the element should be placed in the center by default (optional).\n * @param properties.responsiveHeight Whether the element calculates its height based on its content (optional).\n * @returns Returns an object containing the left position, the top position, the maximum height\n * of the element and the current alignment object.\n */\nexport function getElementPosition(\n  element: HTMLElement,\n  trigger: HTMLElement,\n  container: HTMLElement,\n  properties?: {\n    verticalOffset?: number;\n    horizontalOffset?: number;\n    centered?: boolean;\n    responsiveHeight?: boolean;\n    forceAbove?: boolean;\n    forceBelow?: boolean;\n  },\n): SbbElementPositionInfos {\n  const maxWidthOffset = 16;\n  const verticalOffset = properties?.verticalOffset || 0;\n  const horizontalOffset = properties?.horizontalOffset || 0;\n  const responsiveHeight = properties?.responsiveHeight || false;\n\n  const triggerRec = trigger.getBoundingClientRect();\n  const elementRec = getElementRectangle(element);\n\n  const triggerLeft = triggerRec.left;\n  const triggerTop = triggerRec.top;\n\n  const availableSpaceRight =\n    document.documentElement.clientWidth - (triggerLeft + triggerRec.width);\n  const availableSpaceAbove = triggerTop - verticalOffset;\n  const availableSpaceBelow =\n    document.documentElement.clientHeight - (triggerTop + triggerRec.height + verticalOffset);\n\n  // Default element alignment is \"start/below\"\n  let elementXPosition = triggerLeft;\n  let elementYPosition = triggerTop + triggerRec.height + verticalOffset;\n  let elementXOverflow = elementRec.offsetWidth - triggerRec.width;\n  const alignment: SbbAlignment = { horizontal: 'start', vertical: 'below' };\n\n  // Calculate element max-height\n  let elementMaxHeight = `${availableSpaceBelow - verticalOffset}px`;\n\n  // Check if horizontal alignment needs to be changed to \"center\"\n  if (\n    properties?.centered &&\n    triggerLeft - maxWidthOffset + triggerRec.width / 2 > elementRec.offsetWidth / 2 &&\n    availableSpaceRight - maxWidthOffset > elementXOverflow / 2\n  ) {\n    elementXPosition -= elementXOverflow /= 2;\n    alignment.horizontal = 'center';\n  }\n\n  // Check if horizontal alignment needs to be changed to \"end\"\n  if (availableSpaceRight < elementXOverflow && triggerLeft > elementXOverflow) {\n    elementXPosition = elementXPosition - elementXOverflow;\n    alignment.horizontal = 'end';\n  }\n\n  // Add horizontal offset\n  if (\n    horizontalOffset &&\n    alignment.horizontal !== 'center' &&\n    triggerRec.width / 2 < horizontalOffset\n  ) {\n    elementXPosition += horizontalOffset * (alignment.horizontal === 'start' ? -1 : 1);\n  }\n\n  // Check whether there is insufficient space on both sides\n  if (\n    (triggerLeft < elementXOverflow && availableSpaceRight < elementXOverflow) ||\n    document.documentElement.clientWidth < elementRec.offsetWidth\n  ) {\n    elementXPosition = document.documentElement.clientWidth / 2 - elementRec.offsetWidth / 2;\n  }\n\n  // Check if vertical alignment needs to be changed to \"above\":\n  const shouldOpenAbove =\n    (availableSpaceBelow - verticalOffset < elementRec.scrollHeight &&\n      availableSpaceAbove - verticalOffset >\n        (responsiveHeight ? elementRec.clientHeight : elementRec.scrollHeight)) ||\n    (availableSpaceAbove > availableSpaceBelow &&\n      availableSpaceBelow - verticalOffset < elementRec.clientHeight &&\n      !responsiveHeight);\n\n  if (!properties?.forceBelow && (properties?.forceAbove || shouldOpenAbove)) {\n    elementYPosition =\n      availableSpaceAbove < elementRec.scrollHeight\n        ? elementYPosition - triggerRec.height - availableSpaceAbove - verticalOffset\n        : triggerTop - elementRec.clientHeight - verticalOffset;\n\n    elementMaxHeight = `${availableSpaceAbove - verticalOffset}px`;\n    alignment.vertical = 'above';\n  }\n\n  const containerRect = container.getBoundingClientRect();\n\n  // When zooming in Safari the container rectangle contains negative values for the position,\n  // and we need to re-add them to the calculated coordinates.\n  if (containerRect.left < 0) {\n    elementXPosition -= containerRect.left;\n  }\n\n  // Normally the containerRect's top value would be zero, however when the overlay is attached to an input\n  // (e.g. in an autocomplete), mobile browsers will shift everything in order to put the input in the middle\n  // of the screen and to make space for the virtual keyboard. We need to account for this offset,\n  // otherwise our positioning will be thrown off.\n  // Additionally, when zooming in Safari this fixes the vertical position.\n  if (containerRect.top < 0) {\n    elementYPosition -= containerRect.top;\n  }\n\n  return {\n    top: elementYPosition,\n    left: elementXPosition,\n    maxHeight: elementMaxHeight,\n    alignment: alignment,\n  };\n}\n\n/**\n * Determines the position of an element relative to a trigger element by evaluating\n * the optimal position based on the available space.\n *\n * @param element The element of which to calculate the position.\n * @param trigger The element relative to which to calculate the position.\n * @param container The element which has the position:fixed applied.\n * @param properties Properties to take into account in calculations (optional).\n * @param properties.verticalOffset The distance to be added between the element and the trigger (optional).\n * @param properties.horizontalOffset The horizontal offset to be applied to the element (optional).\n * @param properties.responsiveHeight Whether the element calculates its height based on its content (optional).\n * @returns Returns an object containing the left position, the top position, the maximum height\n * of the element and the current alignment object.\n */\nexport function getElementPositionHorizontal(\n  element: HTMLElement,\n  trigger: HTMLElement,\n  container: HTMLElement,\n  properties?: {\n    verticalOffset?: number;\n    horizontalOffset?: number;\n    responsiveHeight?: boolean;\n    contentSelector?: string;\n  },\n): SbbElementPositionInfos {\n  const maxHeightOffset = 16;\n\n  const verticalOffset = properties?.verticalOffset || 0;\n  const horizontalOffset = properties?.horizontalOffset || 0;\n\n  const triggerRec = trigger.getBoundingClientRect();\n  const elementRec = getElementRectangle(element);\n  const triggerParentRec = trigger\n    .parentElement!.shadowRoot!.querySelector(\n      properties?.contentSelector ?? `.${element.className}`,\n    )!\n    .getBoundingClientRect();\n  const containerRect = container.getBoundingClientRect();\n\n  const availableSpaceRight = document.documentElement.clientWidth - triggerParentRec.right;\n  const availableSpaceBelow =\n    document.documentElement.clientHeight - (triggerRec.top - verticalOffset);\n  const availableVerticalSpace = document.documentElement.clientHeight;\n  const elementMaxHeight = `${availableVerticalSpace - maxHeightOffset * 2}px`;\n  const alignment: SbbAlignment = { horizontal: 'end', vertical: 'above' };\n  const elementXOverflow = elementRec.offsetWidth + horizontalOffset;\n\n  // Default element alignment is \"end/above\"\n  let elementXPosition = triggerParentRec.right;\n  let elementYPosition = triggerRec.top + verticalOffset;\n\n  // Check if horizontal alignment needs to be changed to \"start\"\n  if (availableSpaceRight < elementXOverflow && triggerRec.left > elementXOverflow) {\n    elementXPosition = elementXPosition - triggerParentRec.width - elementRec.offsetWidth;\n    alignment.horizontal = 'start';\n  }\n\n  // Add horizontal offset\n  if (horizontalOffset && alignment.horizontal !== 'center') {\n    elementXPosition += horizontalOffset * (alignment.horizontal === 'start' ? -1 : 1);\n  }\n\n  // Check if vertical alignment needs to be changed to \"above\":\n  if (availableSpaceBelow < elementRec.scrollHeight) {\n    elementYPosition = availableVerticalSpace - elementRec.clientHeight - maxHeightOffset;\n  }\n\n  // When zooming in Safari the container rectangle contains negative values for the position,\n  // and we need to re-add them to the calculated coordinates.\n  if (containerRect.left < 0) {\n    elementXPosition -= containerRect.left;\n  }\n\n  // Normally the containerRect's top value would be zero, however when the overlay is attached to an input\n  // (e.g. in an autocomplete), mobile browsers will shift everything in order to put the input in the middle\n  // of the screen and to make space for the virtual keyboard. We need to account for this offset,\n  // otherwise our positioning will be thrown off.\n  // Additionally, when zooming in Safari this fixes the vertical position.\n  if (containerRect.top < 0) {\n    elementYPosition -= containerRect.top;\n  }\n\n  return {\n    top: elementYPosition,\n    left: elementXPosition,\n    maxHeight: elementMaxHeight,\n    alignment: alignment,\n  };\n}\n"],"mappings":"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"}

package/development/core/overlay.d.ts

@@ -1,6 +1,4 @@
-/**
- * @entrypoint
- */
+/** @entrypoint */
 export * from './overlay/overlay.ts';
 export * from './overlay/overlay-option-panel.ts';
 export * from './overlay/overlay-outside-pointer-event-listener.ts';

package/development/core/overlay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/overlay.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,sBAAsB,CAAC;AACrC,cAAc,mCAAmC,CAAC;AAClD,cAAc,qDAAqD,CAAC;AACpE,cAAc,yCAAyC,CAAC;AACxD,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/overlay.ts"],"names":[],"mappings":"AAAA,kBAAkB;AAClB,cAAc,sBAAsB,CAAC;AACrC,cAAc,mCAAmC,CAAC;AAClD,cAAc,qDAAqD,CAAC;AACpE,cAAc,yCAAyC,CAAC;AACxD,cAAc,uBAAuB,CAAC"}

package/development/core/overlay.js

@@ -1,20 +1,6 @@
 import { overlayGapFixCorners } from "./overlay/overlay.js";
+import { getElementPosition, getElementPositionHorizontal, getElementRectangle, isEventOnElement } from "./overlay/position.js";
 import { setOverlayPosition } from "./overlay/overlay-option-panel.js";
 import { SbbOverlayOutsidePointerEventListener, sbbOverlayOutsidePointerEventListener } from "./overlay/overlay-outside-pointer-event-listener.js";
 import { removeAriaComboBoxAttributes, removeAriaOverlayTriggerAttributes, setAriaComboBoxAttributes, setAriaOverlayTriggerAttributes } from "./overlay/overlay-trigger-attributes.js";
-import { getElementPosition, getElementPositionHorizontal, getElementRectangle, isEventOnElement } from "./overlay/position.js";
-export {
-  SbbOverlayOutsidePointerEventListener,
-  getElementPosition,
-  getElementPositionHorizontal,
-  getElementRectangle,
-  isEventOnElement,
-  overlayGapFixCorners,
-  removeAriaComboBoxAttributes,
-  removeAriaOverlayTriggerAttributes,
-  sbbOverlayOutsidePointerEventListener,
-  setAriaComboBoxAttributes,
-  setAriaOverlayTriggerAttributes,
-  setOverlayPosition
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OyJ9
+export { SbbOverlayOutsidePointerEventListener, getElementPosition, getElementPositionHorizontal, getElementRectangle, isEventOnElement, overlayGapFixCorners, removeAriaComboBoxAttributes, removeAriaOverlayTriggerAttributes, sbbOverlayOutsidePointerEventListener, setAriaComboBoxAttributes, setAriaOverlayTriggerAttributes, setOverlayPosition };

package/development/core/styles.d.ts

@@ -1,4 +1,2 @@
-/**
- * @entrypoint
- */
+/** @entrypoint */
 //# sourceMappingURL=styles.d.ts.map

package/development/core/styles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/styles.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,qCAAqC,CAAC"}
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/styles.ts"],"names":[],"mappings":"AAAA,kBAAkB;AAClB,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,qCAAqC,CAAC"}

package/development/core/styles.js

@@ -1,10 +1,11 @@
 import { css } from "lit";
-const boxSizing = css`*,
+//#region src/elements/core/styles/box-sizing.scss?lit&inline
+var box_sizing_default = css`*,
 ::before,
 ::after {
   box-sizing: border-box;
 }`;
-export {
-  boxSizing as boxSizingStyles
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3R5bGVzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7OyJ9
+//#endregion
+export { box_sizing_default as boxSizingStyles };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3R5bGVzLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9lbGVtZW50cy9jb3JlL3N0eWxlcy9ib3gtc2l6aW5nLnNjc3M/bGl0JmlubGluZSJdLCJzb3VyY2VzQ29udGVudCI6WyJAdXNlICcuL21peGlucy9oZWxwZXJzJztcblxuQGluY2x1ZGUgaGVscGVycy5ib3gtc2l6aW5nO1xuIl0sIm1hcHBpbmdzIjoiIn0=