@sbb-esta/lyne-elements 0.0.0 → 0.52.1

package/development/core/observers/intersection-observer.d.ts

@@ -0,0 +1,14 @@
+export declare class NodeIntersectionObserver implements IntersectionObserver {
+    root: Element | Document | null;
+    rootMargin: string;
+    thresholds: number[];
+    disconnect(): void;
+    observe(): void;
+    takeRecords(): any;
+    unobserve(): void;
+}
+export declare const AgnosticIntersectionObserver: typeof NodeIntersectionObserver | {
+    new (callback: IntersectionObserverCallback, options?: IntersectionObserverInit | undefined): IntersectionObserver;
+    prototype: IntersectionObserver;
+};
+//# sourceMappingURL=intersection-observer.d.ts.map

package/development/core/observers/intersection-observer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersection-observer.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/observers/intersection-observer.ts"],"names":[],"mappings":"AAAA,qBAAa,wBAAyB,YAAW,oBAAoB;IAC5D,IAAI,EAAG,OAAO,GAAG,QAAQ,GAAG,IAAI,CAAC;IACjC,UAAU,EAAG,MAAM,CAAC;IACpB,UAAU,EAAG,MAAM,EAAE,CAAC;IAEtB,UAAU,IAAI,IAAI;IAIlB,OAAO,IAAI,IAAI;IAIf,WAAW,IAAI,GAAG;IAIlB,SAAS,IAAI,IAAI;CAGzB;AAGD,eAAO,MAAM,4BAA4B;;;CACsD,CAAC"}

package/development/core/observers/mutation-observer.d.ts

@@ -0,0 +1,7 @@
+export declare class NodeMutationObserver implements MutationObserver {
+    disconnect(): void;
+    observe(_target: Node, _options?: MutationObserverInit): void;
+    takeRecords(): MutationRecord[];
+}
+export declare const AgnosticMutationObserver: typeof MutationObserver;
+//# sourceMappingURL=mutation-observer.d.ts.map

package/development/core/observers/mutation-observer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-observer.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/observers/mutation-observer.ts"],"names":[],"mappings":"AAAA,qBAAa,oBAAqB,YAAW,gBAAgB;IACpD,UAAU,IAAI,IAAI;IAIlB,OAAO,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,oBAAoB,GAAG,IAAI;IAI7D,WAAW,IAAI,cAAc,EAAE;CAGvC;AAGD,eAAO,MAAM,wBAAwB,EAAE,OAAO,gBACqC,CAAC"}

package/development/core/observers/resize-observer.d.ts

@@ -0,0 +1,10 @@
+export declare class NodeResizeObserver implements ResizeObserver {
+    disconnect(): any;
+    observe(): any;
+    unobserve(): any;
+}
+export declare const AgnosticResizeObserver: {
+    new (callback: ResizeObserverCallback): ResizeObserver;
+    prototype: ResizeObserver;
+};
+//# sourceMappingURL=resize-observer.d.ts.map

package/development/core/observers/resize-observer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize-observer.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/observers/resize-observer.ts"],"names":[],"mappings":"AAAA,qBAAa,kBAAmB,YAAW,cAAc;IAChD,UAAU,IAAI,GAAG;IAIjB,OAAO,IAAI,GAAG;IAId,SAAS,IAAI,GAAG;CAGxB;AAGD,eAAO,MAAM,sBAAsB;;;CAC0C,CAAC"}

package/development/core/observers.d.ts

@@ -0,0 +1,4 @@
+export * from './observers/intersection-observer.js';
+export * from './observers/mutation-observer.js';
+export * from './observers/resize-observer.js';
+//# sourceMappingURL=observers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"observers.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/observers.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAC;AACrD,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAC"}

package/development/core/observers.js

@@ -0,0 +1,39 @@
+class NodeIntersectionObserver {
+  disconnect() {
+  }
+  observe() {
+  }
+  takeRecords() {
+  }
+  unobserve() {
+  }
+}
+const AgnosticIntersectionObserver = typeof IntersectionObserver === "undefined" ? NodeIntersectionObserver : IntersectionObserver;
+class NodeMutationObserver {
+  disconnect() {
+  }
+  observe(_target, _options) {
+  }
+  takeRecords() {
+    return [];
+  }
+}
+const AgnosticMutationObserver = typeof MutationObserver === "undefined" ? NodeMutationObserver : MutationObserver;
+class NodeResizeObserver {
+  disconnect() {
+  }
+  observe() {
+  }
+  unobserve() {
+  }
+}
+const AgnosticResizeObserver = typeof ResizeObserver === "undefined" ? NodeResizeObserver : ResizeObserver;
+export {
+  AgnosticIntersectionObserver,
+  AgnosticMutationObserver,
+  AgnosticResizeObserver,
+  NodeIntersectionObserver,
+  NodeMutationObserver,
+  NodeResizeObserver
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/overlay/overlay-option-panel.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Places the overlay in the correct position.
+ * @param dialog The reference to the dialog element.
+ * @param originElement The reference to the element the dialog is attached to.
+ * @param optionContainer The reference to the option panel.
+ * @param container The element which has the position:fixed applied.
+ * @param element The reference to the component.
+ */
+export declare function setOverlayPosition(dialog: HTMLElement, originElement: HTMLElement, optionContainer: HTMLElement, container: HTMLElement, element: HTMLElement): void;
+//# sourceMappingURL=overlay-option-panel.d.ts.map

package/development/core/overlay/overlay-option-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay-option-panel.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/overlay/overlay-option-panel.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,WAAW,EAC1B,eAAe,EAAE,WAAW,EAC5B,SAAS,EAAE,WAAW,EACtB,OAAO,EAAE,WAAW,GACnB,IAAI,CAmBN"}

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): void;
+/**
+ * Remove aria attributes from trigger elements.
+ */
+export declare function removeAriaComboBoxAttributes(trigger?: HTMLElement): 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,GAChB,IAAI,CAYN;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAYxE"}

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

@@ -0,0 +1,21 @@
+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;
+/**
+ * Applies inert to every other element on the page except the overlay.
+ */
+export declare function applyInertMechanism(overlay: HTMLElement): void;
+export declare function removeInertMechanism(): void;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        willOpen: CustomEvent<void>;
+        willClose: CustomEvent<void>;
+        didOpen: CustomEvent<void>;
+        didClose: CustomEvent<void>;
+    }
+}
+//# 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;AAK1C;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CASrD;AA4DD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAyB9D;AAED,wBAAgB,oBAAoB,IAAI,IAAI,CAqB3C;AACD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,2BAA2B;QACnC,QAAQ,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;QAC5B,SAAS,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;QAC7B,OAAO,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;QAC3B,QAAQ,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;KAC7B;CACF"}

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

@@ -0,0 +1,41 @@
+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, 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;
+}): 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,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,GAAG,YAAY,GAAG,OAAO,CAYhG;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;CAC5B,GACA,uBAAuB,CAqGzB"}

package/development/core/overlay.d.ts

@@ -0,0 +1,5 @@
+export * from './overlay/overlay.js';
+export * from './overlay/overlay-option-panel.js';
+export * from './overlay/overlay-trigger-attributes.js';
+export * from './overlay/position.js';
+//# 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,cAAc,sBAAsB,CAAC;AACrC,cAAc,mCAAmC,CAAC;AAClD,cAAc,yCAAyC,CAAC;AACxD,cAAc,uBAAuB,CAAC"}

package/development/core/overlay.js

@@ -0,0 +1,240 @@
+import { html } from "lit";
+const IS_OPEN_OVERLAY_QUERY = `:is(sbb-dialog, sbb-navigation, sbb-menu, sbb-overlay)[data-state='opened']`;
+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>
+  `;
+}
+const getAncestors = (overlay, root) => {
+  let el = overlay.parentElement;
+  const ancestors = [];
+  while (el) {
+    ancestors.push(el);
+    if (el !== root) {
+      el = el.parentElement;
+    } else {
+      break;
+    }
+  }
+  return ancestors;
+};
+const setDataSbbInert = (el) => {
+  el.setAttribute(
+    "data-sbb-inert",
+    `${+(el.getAttribute("data-sbb-inert") ?? void 0) + 1 || 0}`
+  );
+};
+const setSbbInert = (el) => {
+  if (!el.inert) {
+    el.inert = true;
+    if (el.matches(IS_OPEN_OVERLAY_QUERY)) {
+      setDataSbbInert(el);
+    } else {
+      el.toggleAttribute("data-sbb-inert", true);
+    }
+  }
+  if (!el.hasAttribute("aria-hidden")) {
+    el.setAttribute("aria-hidden", "true");
+    el.toggleAttribute("data-sbb-aria-hidden", true);
+  }
+};
+const removeSbbInert = (el) => {
+  if (el.hasAttribute("data-sbb-inert")) {
+    el.inert = false;
+    el.removeAttribute("data-sbb-inert");
+  }
+  if (el.hasAttribute("data-sbb-aria-hidden")) {
+    el.removeAttribute("aria-hidden");
+    el.removeAttribute("data-sbb-aria-hidden");
+  }
+};
+function applyInertMechanism(overlay) {
+  removeSbbInert(overlay);
+  const overlayRoot = overlay.closest("body > *");
+  const documentChildren = Array.from(document.querySelectorAll("body > *")).filter(
+    (el) => el !== overlayRoot
+  );
+  documentChildren.forEach((el) => setSbbInert(el));
+  let children = [];
+  const ancestors = getAncestors(overlay, overlayRoot);
+  for (const el of ancestors) {
+    children = children.concat(
+      Array.from(el.children).filter(
+        (el2) => el2 !== overlay && !ancestors.includes(el2)
+      )
+    );
+    if (el.matches(IS_OPEN_OVERLAY_QUERY)) {
+      setDataSbbInert(el);
+    }
+  }
+  children.forEach((el) => setSbbInert(el));
+}
+function removeInertMechanism() {
+  const openOverlays = Array.from(
+    document.documentElement.querySelectorAll(IS_OPEN_OVERLAY_QUERY)
+  );
+  if (openOverlays.length) {
+    openOverlays.forEach((el) => {
+      const newValue = +el.getAttribute("data-sbb-inert") - 1;
+      el.setAttribute("data-sbb-inert", `${newValue}`);
+      if (newValue && newValue < 0) {
+        removeSbbInert(el);
+        Array.from(el.children).forEach((el2) => removeSbbInert(el2));
+      }
+    });
+    return;
+  }
+  Array.from(document.documentElement.querySelectorAll("[data-sbb-inert]")).forEach(
+    (el) => removeSbbInert(el)
+  );
+}
+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 };
+}
+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;
+}
+function getElementPosition(element, trigger, container, properties) {
+  const maxWidthOffset = 16;
+  const verticalOffset = (properties == null ? void 0 : properties.verticalOffset) || 0;
+  const horizontalOffset = (properties == null ? void 0 : properties.horizontalOffset) || 0;
+  const responsiveHeight = (properties == null ? void 0 : 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 == null ? void 0 : 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;
+  }
+  if (availableSpaceBelow - verticalOffset < elementRec.scrollHeight && availableSpaceAbove - verticalOffset > (responsiveHeight ? elementRec.clientHeight : elementRec.scrollHeight) || availableSpaceAbove > availableSpaceBelow && availableSpaceBelow - verticalOffset < elementRec.clientHeight && !responsiveHeight) {
+    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
+  };
+}
+function setOverlayPosition(dialog, originElement, optionContainer, container, element) {
+  if (!dialog || !originElement) {
+    return;
+  }
+  element.style.setProperty("--sbb-options-panel-width", `${originElement.offsetWidth}px`);
+  element.style.setProperty("--sbb-options-panel-origin-height", `${originElement.offsetHeight}px`);
+  const panelPosition = getElementPosition(optionContainer, originElement, container);
+  element.style.setProperty("--sbb-options-panel-position-x", `${panelPosition.left}px`);
+  element.style.setProperty("--sbb-options-panel-position-y", `${panelPosition.top}px`);
+  element.style.setProperty("--sbb-options-panel-max-height", panelPosition.maxHeight);
+  element.setAttribute("data-options-panel-position", panelPosition.alignment.vertical);
+  originElement.setAttribute("data-options-panel-position", panelPosition.alignment.vertical);
+}
+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"}`);
+}
+function removeAriaOverlayTriggerAttributes(trigger) {
+  if (!trigger) {
+    return;
+  }
+  trigger.removeAttribute("aria-haspopup");
+  trigger.removeAttribute("aria-controls");
+  trigger.removeAttribute("aria-expanded");
+}
+function setAriaComboBoxAttributes(trigger, overlayId, expanded) {
+  if (!trigger) {
+    return;
+  }
+  trigger.setAttribute("autocomplete", "off");
+  trigger.setAttribute("role", "combobox");
+  trigger.setAttribute("aria-autocomplete", "list");
+  trigger.setAttribute("aria-haspopup", "listbox");
+  trigger.setAttribute("aria-controls", overlayId);
+  trigger.setAttribute("aria-owns", overlayId);
+  trigger.setAttribute("aria-expanded", `${expanded}`);
+}
+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");
+}
+export {
+  applyInertMechanism,
+  getElementPosition,
+  getElementRectangle,
+  isEventOnElement,
+  overlayGapFixCorners,
+  removeAriaComboBoxAttributes,
+  removeAriaOverlayTriggerAttributes,
+  removeInertMechanism,
+  setAriaComboBoxAttributes,
+  setAriaOverlayTriggerAttributes,
+  setOverlayPosition
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"overlay.js","sources":["../../../../src/elements/core/overlay/overlay.ts","../../../../src/elements/core/overlay/position.ts","../../../../src/elements/core/overlay/overlay-option-panel.ts","../../../../src/elements/core/overlay/overlay-trigger-attributes.ts"],"sourcesContent":["import type { TemplateResult } from 'lit';\nimport { html } from 'lit';\n\nconst IS_OPEN_OVERLAY_QUERY = `:is(sbb-dialog, sbb-navigation, sbb-menu, sbb-overlay)[data-state='opened']`;\n\n/**\n * Used to create the \"wrapping\" effect around the anchor for overlays (es. autocomplete)\n * Works in conjunction with the 'overlayGapFixCorners()' function in 'overlay.ts'\n */\nexport function overlayGapFixCorners(): TemplateResult {\n  return html`\n    <div class=\"sbb-gap-fix-wrapper\">\n      <div class=\"sbb-gap-fix-corner\" id=\"left\"></div>\n    </div>\n    <div class=\"sbb-gap-fix-wrapper\">\n      <div class=\"sbb-gap-fix-corner\" id=\"right\"></div>\n    </div>\n  `;\n}\n\n/**\n * Returns all the ancestors of the overlay.\n */\nconst getAncestors = (overlay: HTMLElement, root: HTMLElement): HTMLElement[] => {\n  let el = overlay.parentElement;\n  const ancestors: HTMLElement[] = [];\n  while (el) {\n    ancestors.push(el);\n    if (el !== root) {\n      el = el.parentElement;\n    } else {\n      break;\n    }\n  }\n  return ancestors;\n};\n\nconst setDataSbbInert = (el: HTMLElement): void => {\n  el.setAttribute(\n    'data-sbb-inert',\n    `${+(el.getAttribute('data-sbb-inert') ?? undefined)! + 1 || 0}`,\n  );\n};\n\n/**\n * Set the inert and the data-sbb-inert attributes.\n */\nconst setSbbInert = (el: HTMLElement): void => {\n  if (!el.inert) {\n    el.inert = true;\n    if (el.matches(IS_OPEN_OVERLAY_QUERY)) {\n      setDataSbbInert(el);\n    } else {\n      el.toggleAttribute('data-sbb-inert', true);\n    }\n  }\n\n  if (!el.hasAttribute('aria-hidden')) {\n    el.setAttribute('aria-hidden', 'true');\n    el.toggleAttribute('data-sbb-aria-hidden', true);\n  }\n};\n\n/**\n * Removes the inert and the data-sbb-inert attributes.\n */\nconst removeSbbInert = (el: HTMLElement): void => {\n  if (el.hasAttribute('data-sbb-inert')) {\n    el.inert = false;\n    el.removeAttribute('data-sbb-inert');\n  }\n\n  if (el.hasAttribute('data-sbb-aria-hidden')) {\n    el.removeAttribute('aria-hidden');\n    el.removeAttribute('data-sbb-aria-hidden');\n  }\n};\n\n/**\n * Applies inert to every other element on the page except the overlay.\n */\nexport function applyInertMechanism(overlay: HTMLElement): void {\n  removeSbbInert(overlay);\n\n  const overlayRoot = overlay.closest('body > *') as HTMLElement;\n  const documentChildren = Array.from(document.querySelectorAll('body > *')).filter(\n    (el) => el !== overlayRoot,\n  ) as HTMLElement[];\n\n  documentChildren.forEach((el) => setSbbInert(el));\n\n  let children: HTMLElement[] = [];\n  const ancestors = getAncestors(overlay, overlayRoot);\n\n  for (const el of ancestors) {\n    children = children.concat(\n      Array.from(el.children).filter(\n        (el: Element) => el !== overlay && !ancestors.includes(el as HTMLElement),\n      ) as HTMLElement[],\n    );\n    if (el.matches(IS_OPEN_OVERLAY_QUERY)) {\n      setDataSbbInert(el);\n    }\n  }\n\n  children.forEach((el) => setSbbInert(el));\n}\n\nexport function removeInertMechanism(): void {\n  const openOverlays = Array.from(\n    document.documentElement.querySelectorAll(IS_OPEN_OVERLAY_QUERY),\n  ) as HTMLElement[];\n\n  if (openOverlays.length) {\n    openOverlays.forEach((el) => {\n      const newValue = +el.getAttribute('data-sbb-inert')! - 1;\n      el.setAttribute('data-sbb-inert', `${newValue}`);\n\n      if (newValue && newValue < 0) {\n        removeSbbInert(el);\n        Array.from(el.children).forEach((el: Element) => removeSbbInert(el as HTMLElement));\n      }\n    });\n    return;\n  }\n\n  Array.from(document.documentElement.querySelectorAll('[data-sbb-inert]')).forEach((el: Element) =>\n    removeSbbInert(el as HTMLElement),\n  );\n}\ndeclare global {\n  interface GlobalEventHandlersEventMap {\n    willOpen: CustomEvent<void>;\n    willClose: CustomEvent<void>;\n    didOpen: CustomEvent<void>;\n    didClose: CustomEvent<void>;\n  }\n}\n","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(element: HTMLElement, event: MouseEvent | PointerEvent): 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  },\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  if (\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    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","import { getElementPosition } from './position.js';\n\n/**\n * Places the overlay in the correct position.\n * @param dialog The reference to the dialog element.\n * @param originElement The reference to the element the dialog is attached to.\n * @param optionContainer The reference to the option panel.\n * @param container The element which has the position:fixed applied.\n * @param element The reference to the component.\n */\nexport function setOverlayPosition(\n  dialog: HTMLElement,\n  originElement: HTMLElement,\n  optionContainer: HTMLElement,\n  container: HTMLElement,\n  element: HTMLElement,\n): void {\n  if (!dialog || !originElement) {\n    return;\n  }\n\n  // Set the width to match the trigger element\n  element.style.setProperty('--sbb-options-panel-width', `${originElement.offsetWidth}px`);\n\n  // Set the origin height\n  element.style.setProperty('--sbb-options-panel-origin-height', `${originElement.offsetHeight}px`);\n\n  // Calculate and set the position\n  const panelPosition = getElementPosition(optionContainer, originElement, container);\n\n  element.style.setProperty('--sbb-options-panel-position-x', `${panelPosition.left}px`);\n  element.style.setProperty('--sbb-options-panel-position-y', `${panelPosition.top}px`);\n  element.style.setProperty('--sbb-options-panel-max-height', panelPosition.maxHeight);\n  element.setAttribute('data-options-panel-position', panelPosition.alignment.vertical);\n  originElement.setAttribute('data-options-panel-position', panelPosition.alignment.vertical);\n}\n","/**\n * Add meaningful aria attributes to trigger elements that are connected to\n * overlay elements such as menus and dialogs.\n */\nexport function setAriaOverlayTriggerAttributes(\n  trigger: HTMLElement,\n  popupType: 'menu' | 'dialog',\n  overlayId: string,\n  state: string,\n): void {\n  if (!trigger) {\n    return;\n  }\n\n  trigger.setAttribute('aria-haspopup', popupType);\n  trigger.setAttribute('aria-controls', overlayId);\n  trigger.setAttribute('aria-expanded', `${state === 'opening' || state === 'opened'}`);\n}\n\n/**\n * Remove aria attributes from trigger elements.\n */\nexport function removeAriaOverlayTriggerAttributes(trigger: HTMLElement | null | undefined): void {\n  if (!trigger) {\n    return;\n  }\n\n  trigger.removeAttribute('aria-haspopup');\n  trigger.removeAttribute('aria-controls');\n  trigger.removeAttribute('aria-expanded');\n}\n\n/**\n * Add meaningful aria attributes to trigger element of role='combobox'\n */\nexport function setAriaComboBoxAttributes(\n  trigger: HTMLElement,\n  overlayId: string,\n  expanded: boolean,\n): void {\n  if (!trigger) {\n    return;\n  }\n\n  trigger.setAttribute('autocomplete', 'off');\n  trigger.setAttribute('role', 'combobox');\n  trigger.setAttribute('aria-autocomplete', 'list');\n  trigger.setAttribute('aria-haspopup', 'listbox');\n  trigger.setAttribute('aria-controls', overlayId);\n  trigger.setAttribute('aria-owns', overlayId); // From Aria 1.2 this should not be necessary but safari still needs it\n  trigger.setAttribute('aria-expanded', `${expanded}`);\n}\n\n/**\n * Remove aria attributes from trigger elements.\n */\nexport function removeAriaComboBoxAttributes(trigger?: HTMLElement): void {\n  if (!trigger) {\n    return;\n  }\n\n  trigger.removeAttribute('autocomplete');\n  trigger.removeAttribute('role');\n  trigger.removeAttribute('aria-autocomplete');\n  trigger.removeAttribute('aria-haspopup');\n  trigger.removeAttribute('aria-controls');\n  trigger.removeAttribute('aria-owns');\n  trigger.removeAttribute('aria-expanded');\n}\n"],"names":["el"],"mappings":"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"}

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

@@ -0,0 +1,19 @@
+/**
+ * This class exists to facilitate the test migration from stencil to lit.
+ * It mimics the API that stencil provided to test events.
+ *
+ * TODO: Document me
+ */
+export declare class EventSpy<T extends Event> {
+    private _event;
+    private readonly _target;
+    private _count;
+    get count(): number;
+    private _events;
+    get events(): T[];
+    get firstEvent(): T | null;
+    get lastEvent(): T | null;
+    constructor(_event: string, _target?: Node | null);
+    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":"AAAA;;;;;GAKG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,KAAK;IAoBjC,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ,CAAC,OAAO;IApB1B,OAAO,CAAC,MAAM,CAAa;IAC3B,IAAW,KAAK,IAAI,MAAM,CAEzB;IAED,OAAO,CAAC,OAAO,CAAW;IAC1B,IAAW,MAAM,IAAI,CAAC,EAAE,CAEvB;IAED,IAAW,UAAU,IAAI,CAAC,GAAG,IAAI,CAEhC;IAED,IAAW,SAAS,IAAI,CAAC,GAAG,IAAI,CAE/B;gBAGS,MAAM,EAAE,MAAM,EACL,OAAO,GAAE,IAAI,GAAG,IAAW;IAQ9C,OAAO,CAAC,eAAe;CAMxB"}

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

@@ -0,0 +1,11 @@
+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,cACV,OAAO,SACX,MAAM,MACT,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,KACxB,KAAK,GAAG,IAIV,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,MAAM,cAAe,OAAO,SAAS,MAAM,OAAO,IAAI,KAAG,IAAI,GAAG,IAI5E,CAAC"}

package/development/core/testing/private.d.ts

@@ -0,0 +1,11 @@
+export * from './private/a11y-tree-snapshot.js';
+export * from './private/describe-each.js';
+export * from './private/describe-viewports.js';
+export * from './private/dispatch-events.js';
+export * from './private/event-objects.js';
+export * from './private/fixture.js';
+export * from './private/load-asset-as-base64.js';
+export * from './private/platform.js';
+export * from './private/type-in-element.js';
+export * from './private/visual-regression-snapshot.js';
+//# sourceMappingURL=private.d.ts.map

package/development/core/testing/private.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"private.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/testing/private.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,mCAAmC,CAAC;AAClD,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yCAAyC,CAAC"}

package/development/core/testing/scroll.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Can be used in tests where scroll events are not triggered by default.
+ * @param options ScrollToOptions
+ */
+export declare function mockScrollTo(options: ScrollToOptions): void;
+//# sourceMappingURL=scroll.d.ts.map

package/development/core/testing/scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/testing/scroll.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,CAM3D"}

package/development/core/testing/test-setup-ssr.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test-setup-ssr.d.ts.map

package/development/core/testing/test-setup-ssr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-setup-ssr.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/testing/test-setup-ssr.ts"],"names":[],"mappings":""}

package/development/core/testing/test-setup.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test-setup.d.ts.map

package/development/core/testing/test-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-setup.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/testing/test-setup.ts"],"names":[],"mappings":""}

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-image-ready.d.ts

@@ -0,0 +1,4 @@
+import { SbbImageElement } from '../../image.js';
+
+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;AAEtD,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,gBAAgB,GAAG,eAAe,EAC3C,qBAAqB,SAAW,GAC/B,OAAO,CAAC,IAAI,CAAC,CAcf"}