@sbb-esta/lyne-elements-dev 0.0.0 → 4.0.0-dev.1775551720

package/development/core/overlay/overlay-trigger-attributes.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Add meaningful aria attributes to trigger elements that are connected to
+ * overlay elements such as menus and dialogs.
+ */
+export declare function setAriaOverlayTriggerAttributes(trigger: HTMLElement, popupType: 'menu' | 'dialog', overlayId: string, state: string): void;
+/**
+ * Remove aria attributes from trigger elements.
+ */
+export declare function removeAriaOverlayTriggerAttributes(trigger: HTMLElement | null | undefined): void;
+/**
+ * Add meaningful aria attributes to trigger element of role='combobox'
+ */
+export declare function setAriaComboBoxAttributes(trigger: HTMLElement, overlayId: string, expanded: boolean, hasPopup?: 'listbox' | 'grid'): void;
+/**
+ * Remove aria attributes from trigger elements.
+ */
+export declare function removeAriaComboBoxAttributes(trigger?: HTMLElement | null): void;
+//# sourceMappingURL=overlay-trigger-attributes.d.ts.map

package/development/core/overlay/overlay-trigger-attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay-trigger-attributes.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/overlay/overlay-trigger-attributes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,MAAM,GAAG,QAAQ,EAC5B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,IAAI,CAQN;AAED;;GAEG;AACH,wBAAgB,kCAAkC,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAQhG;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,OAAO,EACjB,QAAQ,GAAE,SAAS,GAAG,MAAkB,GACvC,IAAI,CAYN;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,GAAG,IAAI,CAY/E"}

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

@@ -0,0 +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"}`);
+}
+/**
+* Remove aria attributes from trigger elements.
+*/
+function removeAriaOverlayTriggerAttributes(trigger) {
+	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}`);
+}
+/**
+* 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");
+}
+//#endregion
+export { removeAriaComboBoxAttributes, removeAriaOverlayTriggerAttributes, setAriaComboBoxAttributes, setAriaOverlayTriggerAttributes };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,7 @@
+import { TemplateResult } from 'lit';
+/**
+ * Used to create the "wrapping" effect around the anchor for overlays (es. autocomplete)
+ * Works in conjunction with the 'overlayGapFixCorners()' function in 'overlay.ts'
+ */
+export declare function overlayGapFixCorners(): TemplateResult;
+//# sourceMappingURL=overlay.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/overlay/overlay.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAG1C;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CASrD"}

package/development/core/overlay/overlay.js

@@ -0,0 +1,20 @@
+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`
+    <div class="sbb-gap-fix-wrapper">
+      <div class="sbb-gap-fix-corner" id="left"></div>
+    </div>
+    <div class="sbb-gap-fix-wrapper">
+      <div class="sbb-gap-fix-corner" id="right"></div>
+    </div>
+  `;
+}
+//#endregion
+export { overlayGapFixCorners };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZWxlbWVudHMvY29yZS9vdmVybGF5L292ZXJsYXkudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBUZW1wbGF0ZVJlc3VsdCB9IGZyb20gJ2xpdCc7XG5pbXBvcnQgeyBodG1sIH0gZnJvbSAnbGl0JztcblxuLyoqXG4gKiBVc2VkIHRvIGNyZWF0ZSB0aGUgXCJ3cmFwcGluZ1wiIGVmZmVjdCBhcm91bmQgdGhlIGFuY2hvciBmb3Igb3ZlcmxheXMgKGVzLiBhdXRvY29tcGxldGUpXG4gKiBXb3JrcyBpbiBjb25qdW5jdGlvbiB3aXRoIHRoZSAnb3ZlcmxheUdhcEZpeENvcm5lcnMoKScgZnVuY3Rpb24gaW4gJ292ZXJsYXkudHMnXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBvdmVybGF5R2FwRml4Q29ybmVycygpOiBUZW1wbGF0ZVJlc3VsdCB7XG4gIHJldHVybiBodG1sYFxuICAgIDxkaXYgY2xhc3M9XCJzYmItZ2FwLWZpeC13cmFwcGVyXCI+XG4gICAgICA8ZGl2IGNsYXNzPVwic2JiLWdhcC1maXgtY29ybmVyXCIgaWQ9XCJsZWZ0XCI+PC9kaXY+XG4gICAgPC9kaXY+XG4gICAgPGRpdiBjbGFzcz1cInNiYi1nYXAtZml4LXdyYXBwZXJcIj5cbiAgICAgIDxkaXYgY2xhc3M9XCJzYmItZ2FwLWZpeC1jb3JuZXJcIiBpZD1cInJpZ2h0XCI+PC9kaXY+XG4gICAgPC9kaXY+XG4gIGA7XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQU9BLFNBQWdCLHVCQUFvQjtBQUNsQyxRQUFPLElBQUkifQ==

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

@@ -0,0 +1,63 @@
+export type ElementRectangle = Pick<HTMLElement, 'scrollHeight' | 'clientHeight' | 'offsetHeight' | 'scrollWidth' | 'clientWidth' | 'offsetWidth'>;
+export interface SbbAlignment {
+    horizontal: 'start' | 'center' | 'end';
+    vertical: 'above' | 'below';
+}
+export interface SbbElementPositionInfos {
+    top: number;
+    left: number;
+    maxHeight: string;
+    alignment: SbbAlignment;
+}
+/**
+ * Gets height and width of an element even if it's hidden (`display: none`).
+ */
+export declare function getElementRectangle(el: HTMLElement): ElementRectangle;
+/**
+ * Determines whether an event is fired on a specific element.
+ */
+export declare function isEventOnElement(element: HTMLElement | null, event: MouseEvent | PointerEvent): boolean;
+/**
+ * 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.
+ */
+export declare function getElementPosition(element: HTMLElement, trigger: HTMLElement, container: HTMLElement, properties?: {
+    verticalOffset?: number;
+    horizontalOffset?: number;
+    centered?: boolean;
+    responsiveHeight?: boolean;
+    forceAbove?: boolean;
+    forceBelow?: boolean;
+}): SbbElementPositionInfos;
+/**
+ * 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.
+ */
+export declare function getElementPositionHorizontal(element: HTMLElement, trigger: HTMLElement, container: HTMLElement, properties?: {
+    verticalOffset?: number;
+    horizontalOffset?: number;
+    responsiveHeight?: boolean;
+    contentSelector?: string;
+}): SbbElementPositionInfos;
+//# sourceMappingURL=position.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"position.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/overlay/position.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,IAAI,CACjC,WAAW,EACX,cAAc,GAAG,cAAc,GAAG,cAAc,GAAG,aAAa,GAAG,aAAa,GAAG,aAAa,CACjG,CAAC;AAEF,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;IACvC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,YAAY,CAAC;CACzB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,WAAW,GAAG,gBAAgB,CAoCrE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,WAAW,GAAG,IAAI,EAC3B,KAAK,EAAE,UAAU,GAAG,YAAY,GAC/B,OAAO,CAYT;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,WAAW,EACtB,UAAU,CAAC,EAAE;IACX,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,GACA,uBAAuB,CAsGzB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,WAAW,EACtB,UAAU,CAAC,EAAE;IACX,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,GACA,uBAAuB,CAgEzB"}

package/development/core/overlay/position.js

@@ -0,0 +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
+	};
+}
+/**
+* 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;
+}
+/**
+* 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
+	};
+}
+/**
+* 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
+	};
+}
+//#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

@@ -0,0 +1,7 @@
+/** @entrypoint */
+export * from './overlay/overlay.ts';
+export * from './overlay/overlay-option-panel.ts';
+export * from './overlay/overlay-outside-pointer-event-listener.ts';
+export * from './overlay/overlay-trigger-attributes.ts';
+export * from './overlay/position.ts';
+//# sourceMappingURL=overlay.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +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";
+export { SbbOverlayOutsidePointerEventListener, getElementPosition, getElementPositionHorizontal, getElementRectangle, isEventOnElement, overlayGapFixCorners, removeAriaComboBoxAttributes, removeAriaOverlayTriggerAttributes, sbbOverlayOutsidePointerEventListener, setAriaComboBoxAttributes, setAriaOverlayTriggerAttributes, setOverlayPosition };

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

@@ -0,0 +1,2 @@
+export declare const boxSizingStyles: import('lit').CSSResult;
+//# sourceMappingURL=styles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/styles/styles.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe,yBAAmC,CAAC"}

package/development/core/styles/styles.js

@@ -0,0 +1,2 @@
+import { t as boxSizingStyles } from "../../styles-D8-q-irv.js";
+export { boxSizingStyles };

package/development/core/styles.d.ts

@@ -0,0 +1,3 @@
+/** @entrypoint */
+export * from './styles/styles.ts';
+//# sourceMappingURL=styles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/styles.ts"],"names":[],"mappings":"AAAA,kBAAkB;AAClB,cAAc,oBAAoB,CAAC"}

package/development/core/styles.js

@@ -0,0 +1,2 @@
+import { t as boxSizingStyles } from "../styles-D8-q-irv.js";
+export { boxSizingStyles };

package/development/core/testing/event-spy.d.ts

@@ -0,0 +1,22 @@
+/**
+ * This class exists to facilitate the test migration from stencil to lit.
+ * It mimics the API that stencil provided to test events.
+ */
+export declare class EventSpy<T extends Event> {
+    private _event;
+    private readonly _target;
+    private readonly _options;
+    get count(): number;
+    private _count;
+    get events(): T[];
+    private _events;
+    get firstEvent(): T | null;
+    get lastEvent(): T | null;
+    private _promiseEventMap;
+    constructor(_event: string, _target?: Node | null, _options?: AddEventListenerOptions | null);
+    calledOnce(timeout?: number): Promise<T>;
+    calledTimes(count: number, timeout?: number): Promise<T>;
+    private _wrapPromiseWithTimeout;
+    private _listenForEvent;
+}
+//# sourceMappingURL=event-spy.d.ts.map

package/development/core/testing/event-spy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-spy.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/testing/event-spy.ts"],"names":[],"mappings":"AAMA;;;GAGG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,KAAK;IAsBjC,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAvB3B,IAAW,KAAK,IAAI,MAAM,CAEzB;IACD,OAAO,CAAC,MAAM,CAAa;IAE3B,IAAW,MAAM,IAAI,CAAC,EAAE,CAEvB;IACD,OAAO,CAAC,OAAO,CAAW;IAE1B,IAAW,UAAU,IAAI,CAAC,GAAG,IAAI,CAEhC;IAED,IAAW,SAAS,IAAI,CAAC,GAAG,IAAI,CAE/B;IAED,OAAO,CAAC,gBAAgB,CAA6C;gBAG3D,MAAM,EAAE,MAAM,EACL,OAAO,GAAE,IAAI,GAAG,IAAW,EAC3B,QAAQ,GAAE,uBAAuB,GAAG,IAAW;IAS3D,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAIxC,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,SAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IA6B7D,OAAO,CAAC,uBAAuB;IAgB/B,OAAO,CAAC,eAAe;CAWxB"}

package/development/core/testing/event-spy.js

@@ -0,0 +1,67 @@
+//#region src/elements/core/testing/event-spy.ts
+/**
+* This class exists to facilitate the test migration from stencil to lit.
+* It mimics the API that stencil provided to test events.
+*/
+var EventSpy = class {
+	get count() {
+		return this._count;
+	}
+	get events() {
+		return this._events;
+	}
+	get firstEvent() {
+		return this.events.length ? this.events[0] : null;
+	}
+	get lastEvent() {
+		return this.events.length ? this.events[this.events.length - 1] : null;
+	}
+	constructor(_event, _target = null, _options = null) {
+		this._event = _event;
+		this._target = _target;
+		this._options = _options;
+		this._count = 0;
+		this._events = [];
+		this._promiseEventMap = /* @__PURE__ */ new Map();
+		if (!this._target) this._target = document;
+		this._listenForEvent();
+	}
+	calledOnce(timeout) {
+		return this.calledTimes(1, timeout);
+	}
+	calledTimes(count, timeout = 2e3) {
+		if (this.count > count) return Promise.reject(`Event '${this._event}' has been emitted more than expected (expected ${count}, actual ${this.count}`);
+		else if (this.count === count) return Promise.resolve(this.events[count - 1]);
+		else if (this._promiseEventMap.has(count)) return this._promiseEventMap.get(count).promise;
+		else {
+			let resolve;
+			let reject;
+			const promiseWithExecutor = {
+				promise: new Promise((resolveFunction, rejectFunction) => {
+					resolve = resolveFunction;
+					reject = rejectFunction;
+				}),
+				resolve,
+				reject
+			};
+			this._promiseEventMap.set(count, promiseWithExecutor);
+			return this._wrapPromiseWithTimeout(promiseWithExecutor, count, timeout);
+		}
+	}
+	_wrapPromiseWithTimeout(promiseWithExecutor, count, timeout) {
+		const clearTimeoutId = setTimeout(() => promiseWithExecutor.reject(`awaiting calledTimes(${count}) for event '${this._event}' results in timeout`), timeout);
+		promiseWithExecutor.promise.then(() => clearTimeout(clearTimeoutId));
+		return promiseWithExecutor.promise;
+	}
+	_listenForEvent() {
+		this._target?.addEventListener(this._event, (ev) => {
+			this._events.push(ev);
+			this._count++;
+			this._promiseEventMap.get(this.count)?.resolve(ev);
+		}, this._options ?? void 0);
+	}
+};
+//#endregion
+export { EventSpy };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/testing/mocha-extensions.d.ts

@@ -0,0 +1,10 @@
+import { Func, Suite, Test } from 'mocha';
+/**
+ * Skip the `describe` if the condition is not met
+ */
+export declare const describeIf: (condition: boolean, title: string, fn: (this: Suite) => void) => Suite | void;
+/**
+ * Skip the `test` if the condition is not met
+ */
+export declare const testIf: (condition: boolean, title: string, fn?: Func) => Test | void;
+//# sourceMappingURL=mocha-extensions.d.ts.map

package/development/core/testing/mocha-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mocha-extensions.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/testing/mocha-extensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,UAAU,GACrB,WAAW,OAAO,EAClB,OAAO,MAAM,EACb,IAAI,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,KACxB,KAAK,GAAG,IAIV,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,MAAM,GAAI,WAAW,OAAO,EAAE,OAAO,MAAM,EAAE,KAAK,IAAI,KAAG,IAAI,GAAG,IAI5E,CAAC"}

package/development/core/testing/mocha-extensions.js

@@ -0,0 +1,17 @@
+//#region src/elements/core/testing/mocha-extensions.ts
+/**
+* Skip the `describe` if the condition is not met
+*/
+var describeIf = (condition, title, fn) => {
+	if (condition) return Mocha.describe(title, fn);
+};
+/**
+* Skip the `test` if the condition is not met
+*/
+var testIf = (condition, title, fn) => {
+	if (condition) return Mocha.test(title, fn);
+};
+//#endregion
+export { describeIf, testIf };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9jaGEtZXh0ZW5zaW9ucy5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZWxlbWVudHMvY29yZS90ZXN0aW5nL21vY2hhLWV4dGVuc2lvbnMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBGdW5jLCBTdWl0ZSwgVGVzdCB9IGZyb20gJ21vY2hhJztcblxuLyoqXG4gKiBTa2lwIHRoZSBgZGVzY3JpYmVgIGlmIHRoZSBjb25kaXRpb24gaXMgbm90IG1ldFxuICovXG5leHBvcnQgY29uc3QgZGVzY3JpYmVJZiA9IChcbiAgY29uZGl0aW9uOiBib29sZWFuLFxuICB0aXRsZTogc3RyaW5nLFxuICBmbjogKHRoaXM6IFN1aXRlKSA9PiB2b2lkLFxuKTogU3VpdGUgfCB2b2lkID0+IHtcbiAgaWYgKGNvbmRpdGlvbikge1xuICAgIHJldHVybiBNb2NoYS5kZXNjcmliZSh0aXRsZSwgZm4pO1xuICB9XG59O1xuXG4vKipcbiAqIFNraXAgdGhlIGB0ZXN0YCBpZiB0aGUgY29uZGl0aW9uIGlzIG5vdCBtZXRcbiAqL1xuZXhwb3J0IGNvbnN0IHRlc3RJZiA9IChjb25kaXRpb246IGJvb2xlYW4sIHRpdGxlOiBzdHJpbmcsIGZuPzogRnVuYyk6IFRlc3QgfCB2b2lkID0+IHtcbiAgaWYgKGNvbmRpdGlvbikge1xuICAgIHJldHVybiBNb2NoYS50ZXN0KHRpdGxlLCBmbik7XG4gIH1cbn07XG4iXSwibWFwcGluZ3MiOiI7Ozs7QUFLQSxJQUFhLGNBQ1gsV0FDQSxPQUNBLE9BQ2dCO0FBQ2hCLEtBQUksVUFDRixRQUFPLE1BQU0sU0FBUyxPQUFPLEdBQUc7Ozs7O0FBT3BDLElBQWEsVUFBVSxXQUFvQixPQUFlLE9BQTBCO0FBQ2xGLEtBQUksVUFDRixRQUFPLE1BQU0sS0FBSyxPQUFPLEdBQUcifQ==

package/development/core/testing/wait-for-condition.d.ts

@@ -0,0 +1,2 @@
+export declare function waitForCondition(condition: () => boolean | Promise<boolean>, interval?: number, timeoutInMilliseconds?: number): Promise<boolean>;
+//# sourceMappingURL=wait-for-condition.d.ts.map

package/development/core/testing/wait-for-condition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-for-condition.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/testing/wait-for-condition.ts"],"names":[],"mappings":"AAAA,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EAC3C,QAAQ,SAAK,EACb,qBAAqB,SAAW,GAC/B,OAAO,CAAC,OAAO,CAAC,CAmBlB"}

package/development/core/testing/wait-for-condition.js

@@ -0,0 +1,16 @@
+//#region src/elements/core/testing/wait-for-condition.ts
+async function waitForCondition(condition, interval = 30, timeoutInMilliseconds = 2 * 1e3) {
+	const start = /* @__PURE__ */ new Date();
+	let counter = 0;
+	function checkCondition() {
+		counter++;
+		return condition();
+	}
+	while (!await checkCondition() && start.getTime() + timeoutInMilliseconds >= (/* @__PURE__ */ new Date()).getTime()) await new Promise((resolve) => setTimeout(resolve, interval));
+	if (start.getTime() + timeoutInMilliseconds < (/* @__PURE__ */ new Date()).getTime()) return Promise.reject(`waitForCondition timeout: ${condition.toString()}, attempts: ${counter}, start: ${start.getTime()}, end: ${(/* @__PURE__ */ new Date()).getTime()}`);
+	return Promise.resolve(true);
+}
+//#endregion
+export { waitForCondition };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2FpdC1mb3ItY29uZGl0aW9uLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9lbGVtZW50cy9jb3JlL3Rlc3Rpbmcvd2FpdC1mb3ItY29uZGl0aW9uLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBhc3luYyBmdW5jdGlvbiB3YWl0Rm9yQ29uZGl0aW9uKFxuICBjb25kaXRpb246ICgpID0+IGJvb2xlYW4gfCBQcm9taXNlPGJvb2xlYW4+LFxuICBpbnRlcnZhbCA9IDMwLFxuICB0aW1lb3V0SW5NaWxsaXNlY29uZHMgPSAyICogMTAwMCxcbik6IFByb21pc2U8Ym9vbGVhbj4ge1xuICBjb25zdCBzdGFydCA9IG5ldyBEYXRlKCk7XG4gIGxldCBjb3VudGVyID0gMDtcbiAgZnVuY3Rpb24gY2hlY2tDb25kaXRpb24oKTogYm9vbGVhbiB8IFByb21pc2U8Ym9vbGVhbj4ge1xuICAgIGNvdW50ZXIrKztcbiAgICByZXR1cm4gY29uZGl0aW9uKCk7XG4gIH1cbiAgd2hpbGUgKFxuICAgICEoYXdhaXQgY2hlY2tDb25kaXRpb24oKSkgJiZcbiAgICBzdGFydC5nZXRUaW1lKCkgKyB0aW1lb3V0SW5NaWxsaXNlY29uZHMgPj0gbmV3IERhdGUoKS5nZXRUaW1lKClcbiAgKSB7XG4gICAgYXdhaXQgbmV3IFByb21pc2UoKHJlc29sdmUpID0+IHNldFRpbWVvdXQocmVzb2x2ZSwgaW50ZXJ2YWwpKTtcbiAgfVxuICBpZiAoc3RhcnQuZ2V0VGltZSgpICsgdGltZW91dEluTWlsbGlzZWNvbmRzIDwgbmV3IERhdGUoKS5nZXRUaW1lKCkpIHtcbiAgICByZXR1cm4gUHJvbWlzZS5yZWplY3QoXG4gICAgICBgd2FpdEZvckNvbmRpdGlvbiB0aW1lb3V0OiAke2NvbmRpdGlvbi50b1N0cmluZygpfSwgYXR0ZW1wdHM6ICR7Y291bnRlcn0sIHN0YXJ0OiAke3N0YXJ0LmdldFRpbWUoKX0sIGVuZDogJHtuZXcgRGF0ZSgpLmdldFRpbWUoKX1gLFxuICAgICk7XG4gIH1cbiAgcmV0dXJuIFByb21pc2UucmVzb2x2ZSh0cnVlKTtcbn1cbiJdLCJtYXBwaW5ncyI6IjtBQUFBLGVBQXNCLGlCQUNwQixXQUNBLFdBQVcsSUFDWCx3QkFBd0IsSUFBSSxLQUFJO0NBRWhDLE1BQU0sd0JBQVEsSUFBSSxNQUFNO0NBQ3hCLElBQUksVUFBVTtDQUNkLFNBQVMsaUJBQWM7QUFDckI7QUFDQSxTQUFPLFdBQVc7O0FBRXBCLFFBQ0UsQ0FBRSxNQUFNLGdCQUFnQixJQUN4QixNQUFNLFNBQVMsR0FBRywwQ0FBeUIsSUFBSSxNQUFNLEVBQUMsU0FBUyxDQUUvRCxPQUFNLElBQUksU0FBUyxZQUFZLFdBQVcsU0FBUyxTQUFTLENBQUM7QUFFL0QsS0FBSSxNQUFNLFNBQVMsR0FBRyx5Q0FBd0IsSUFBSSxNQUFNLEVBQUMsU0FBUyxDQUNoRSxRQUFPLFFBQVEsT0FDYiw2QkFBNkIsVUFBVSxVQUFVLENBQUEsY0FBZSxRQUFPLFdBQVksTUFBTSxTQUFTLENBQUEsMEJBQVUsSUFBSSxNQUFNLEVBQUMsU0FBUyxHQUNqSTtBQUVILFFBQU8sUUFBUSxRQUFRLEtBQUsifQ==

package/development/core/testing/wait-for-image-ready.d.ts

@@ -0,0 +1,3 @@
+import { SbbImageElement } from '../../image.ts';
+export declare function waitForImageReady(element: HTMLImageElement | SbbImageElement, timeoutInMilliseconds?: number): Promise<void>;
+//# sourceMappingURL=wait-for-image-ready.d.ts.map

package/development/core/testing/wait-for-image-ready.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-for-image-ready.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/testing/wait-for-image-ready.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGtD,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,gBAAgB,GAAG,eAAe,EAC3C,qBAAqB,SAAW,GAC/B,OAAO,CAAC,IAAI,CAAC,CA+Bf"}