@sbb-esta/lyne-elements 3.10.0 → 3.12.0

package/development/core/controllers/overlay-position-controller.js

@@ -0,0 +1,306 @@
+import { isServer } from "lit";
+const cssAnchorPositionSupported = !isServer && CSS.supports("anchor-name", "--test");
+const physicalSupportedPositions = [
+  "top",
+  "bottom",
+  "left",
+  "right",
+  "top span-left",
+  "top span-right",
+  "bottom span-left",
+  "bottom span-right",
+  "left span-top",
+  "left span-bottom",
+  "right span-top",
+  "right span-bottom"
+];
+const logicalSupportedPositions = [
+  "block-start",
+  "block-end",
+  "inline-start",
+  "inline-end",
+  "block-start span-inline-start",
+  "block-start span-inline-end",
+  "block-end span-inline-start",
+  "block-end span-inline-end",
+  "inline-start span-block-start",
+  "inline-start span-block-end",
+  "inline-end span-block-start",
+  "inline-end span-block-end"
+];
+const rtlPositionMapping = {
+  "block-start": "block-start",
+  "block-end": "block-end",
+  "inline-start": "inline-end",
+  "inline-end": "inline-start",
+  "block-start span-inline-start": "block-start span-inline-end",
+  "block-start span-inline-end": "block-start span-inline-start",
+  "block-end span-inline-start": "block-end span-inline-end",
+  "block-end span-inline-end": "block-end span-inline-start",
+  "inline-start span-block-start": "inline-end span-block-start",
+  "inline-start span-block-end": "inline-end span-block-end",
+  "inline-end span-block-start": "inline-start span-block-start",
+  "inline-end span-block-end": "inline-start span-block-end"
+};
+const supportedPositions = [...physicalSupportedPositions, ...logicalSupportedPositions];
+let nextId = 0;
+class SbbOverlayPositionController {
+  /** Get the current position. (e.g. block-end, block-start, etc.) */
+  get currentPosition() {
+    if (this._usePolyfill) {
+      return this._lastPosition ?? this._positions[0] ?? "";
+    } else {
+      this._overlayStyles ??= getComputedStyle(this._overlay);
+      return this._overlayStyles.getPropertyValue("position-area");
+    }
+  }
+  constructor(host, overlay, _usePolyfill = !cssAnchorPositionSupported) {
+    this._usePolyfill = _usePolyfill;
+    this._resizeObserver = !isServer ? new ResizeObserver(() => this._requestCalculatePosition()) : null;
+    this._anchorName = `--sbb-overlay-anchor-${++nextId}`;
+    this._positions = [];
+    host.addController(this);
+    this._overlay = overlay ?? host;
+  }
+  hostConnected() {
+    if (!this._usePolyfill) {
+      this._overlay.style.setProperty("position-anchor", this._anchorName);
+    } else {
+      this._overlay.style.setProperty("position-area", "initial");
+    }
+  }
+  hostUpdate() {
+    if (isServer) {
+      return;
+    }
+    this._readPositionsFromCss();
+  }
+  /**
+   * Connects the overlay to the given trigger element and determines the optimal position.
+   * Usually, this is called when the overlay is opened.
+   * @param anchor The anchor element.
+   */
+  connect(anchor) {
+    if (isServer) {
+      return;
+    }
+    if (this._anchor) {
+      this.disconnect();
+    }
+    this._anchor = anchor;
+    if (!this._usePolyfill) {
+      this._anchor.style.setProperty("anchor-name", this._anchorName);
+    }
+    this._readPositionsFromCss();
+    this._calculatePosition();
+    this._abortController?.abort();
+    this._abortController = new AbortController();
+    document.addEventListener("scroll", () => this._requestCalculatePosition(), {
+      capture: true,
+      passive: true,
+      signal: this._abortController.signal
+    });
+    window.addEventListener("resize", () => this._requestCalculatePosition(), {
+      passive: true,
+      signal: this._abortController.signal
+    });
+    this._resizeObserver.observe(anchor, { box: "border-box" });
+    this._resizeObserver.observe(this._overlay, { box: "border-box" });
+  }
+  disconnect() {
+    this._anchor?.style.removeProperty("anchor-name");
+    this._anchor = void 0;
+    this._abortController?.abort();
+    this._resizeObserver.disconnect();
+  }
+  _requestCalculatePosition() {
+    this._frame ??= requestAnimationFrame(() => {
+      this._calculatePosition();
+      this._frame = void 0;
+    });
+  }
+  _calculatePosition() {
+    if (!this._anchor) {
+      return;
+    }
+    if (this._usePolyfill) {
+      const position = this._getOptimalPosition(this._positions);
+      this._applyOverlayPosition(position.position, position.left, position.top);
+    }
+    this._overlay.setAttribute("data-position", this.currentPosition);
+  }
+  /**
+   * Calculates the optimal position that fits the overlay.
+   * @param positions The list of positions to check.
+   * @private
+   */
+  _getOptimalPosition(positions) {
+    const { offsetHeight: overlayHeight, offsetWidth: overlayWidth } = this._overlay;
+    const { innerHeight: viewportHeight, innerWidth: viewportWidth } = window;
+    const { top: triggerOffsetTop, left: triggerOffsetLeft, height: triggerHeight, width: triggerWidth } = this._anchor.getBoundingClientRect();
+    const isRtl = this._overlay.matches(":dir(rtl)");
+    const topSpace = triggerOffsetTop;
+    const bottomSpace = viewportHeight - triggerHeight - triggerOffsetTop;
+    const leftSpace = triggerOffsetLeft;
+    const rightSpace = viewportWidth - triggerWidth - triggerOffsetLeft;
+    const overlayWidthNet = overlayWidth - triggerWidth;
+    const overlayHeightNet = overlayHeight - triggerHeight;
+    const overlayWidthOverlap = overlayWidthNet / 2;
+    const overlayHeightOverlap = overlayHeightNet / 2;
+    this._overlay.style.setProperty("--sbb-overlay-controller-trigger-height", `${triggerHeight}px`);
+    this._overlay.style.setProperty("--sbb-overlay-controller-trigger-width", `${triggerWidth}px`);
+    let result = { left: 0, top: 0, position: "" };
+    let firstPosition = void 0;
+    for (const position of positions) {
+      const physicalPosition = isRtl && logicalSupportedPositions.includes(position) ? rtlPositionMapping[position] : position;
+      switch (physicalPosition) {
+        default:
+        case "bottom":
+        case "block-end":
+          result = {
+            position,
+            left: triggerOffsetLeft - overlayWidthOverlap,
+            top: triggerOffsetTop + triggerHeight,
+            fits: overlayHeight <= bottomSpace && overlayWidthOverlap <= leftSpace && overlayWidthOverlap <= rightSpace
+          };
+          break;
+        case "top":
+        case "block-start":
+          result = {
+            position,
+            left: triggerOffsetLeft - overlayWidthOverlap,
+            top: triggerOffsetTop - overlayHeight,
+            fits: overlayHeight <= topSpace && overlayWidthOverlap <= leftSpace && overlayWidthOverlap <= rightSpace
+          };
+          break;
+        case "right":
+        case "inline-end":
+          result = {
+            position,
+            left: triggerOffsetLeft + triggerWidth,
+            top: triggerOffsetTop - overlayHeightOverlap,
+            fits: overlayWidth <= rightSpace && overlayHeightOverlap <= topSpace && overlayHeightOverlap <= bottomSpace
+          };
+          break;
+        case "left":
+        case "inline-start":
+          result = {
+            position,
+            left: triggerOffsetLeft - overlayWidth,
+            top: triggerOffsetTop - overlayHeightOverlap,
+            fits: overlayWidth <= leftSpace && overlayHeightOverlap <= topSpace && overlayHeightOverlap <= bottomSpace
+          };
+          break;
+        case "top span-left":
+        case "block-start span-inline-start":
+          result = {
+            position,
+            left: triggerOffsetLeft - overlayWidthNet,
+            top: triggerOffsetTop - overlayHeight,
+            fits: overlayHeight <= topSpace && overlayWidthNet <= leftSpace
+          };
+          break;
+        case "top span-right":
+        case "block-start span-inline-end":
+          result = {
+            position,
+            left: triggerOffsetLeft,
+            top: triggerOffsetTop - overlayHeight,
+            fits: overlayHeight <= topSpace && overlayWidthNet <= rightSpace
+          };
+          break;
+        case "bottom span-left":
+        case "block-end span-inline-start":
+          result = {
+            position,
+            left: triggerOffsetLeft - overlayWidthNet,
+            top: triggerOffsetTop + triggerHeight,
+            fits: overlayHeight <= bottomSpace && overlayWidthNet <= leftSpace
+          };
+          break;
+        case "bottom span-right":
+        case "block-end span-inline-end":
+          result = {
+            position,
+            left: triggerOffsetLeft,
+            top: triggerOffsetTop + triggerHeight,
+            fits: overlayHeight <= bottomSpace && overlayWidthNet <= rightSpace
+          };
+          break;
+        case "left span-top":
+        case "inline-start span-block-start":
+          result = {
+            position,
+            left: triggerOffsetLeft - overlayWidth,
+            top: triggerOffsetTop + triggerHeight - overlayHeight,
+            fits: overlayWidth <= leftSpace && overlayHeightNet <= topSpace
+          };
+          break;
+        case "left span-bottom":
+        case "inline-start span-block-end":
+          result = {
+            position,
+            left: triggerOffsetLeft - overlayWidth,
+            top: triggerOffsetTop,
+            fits: overlayWidth <= leftSpace && overlayHeightNet <= bottomSpace
+          };
+          break;
+        case "right span-top":
+        case "inline-end span-block-start":
+          result = {
+            position,
+            left: triggerOffsetLeft + triggerWidth,
+            top: triggerOffsetTop + triggerHeight - overlayHeight,
+            fits: overlayWidth <= rightSpace && overlayHeightNet <= topSpace
+          };
+          break;
+        case "right span-bottom":
+        case "inline-end span-block-end":
+          result = {
+            position,
+            left: triggerOffsetLeft + triggerWidth,
+            top: triggerOffsetTop,
+            fits: overlayWidth <= rightSpace && overlayHeightNet <= bottomSpace
+          };
+          break;
+      }
+      if (result.fits) {
+        return result;
+      }
+      firstPosition ??= result;
+    }
+    return firstPosition;
+  }
+  _applyOverlayPosition(position, left, top) {
+    this._lastPosition = position;
+    this._overlay.style.left = `${left}px`;
+    this._overlay.style.top = `${top}px`;
+  }
+  /**
+   * Only used in polyfill mode.
+   * Reads the list of the configured positions from the CSS variables.
+   * @private
+   */
+  _readPositionsFromCss() {
+    if (!this._usePolyfill) {
+      return;
+    }
+    this._overlayStyles ??= getComputedStyle(this._overlay);
+    const positions = [
+      this._overlayStyles.getPropertyValue("--sbb-overlay-position-area") || "block-end",
+      ...this._overlayStyles.getPropertyValue("--sbb-overlay-position-try-fallbacks").split(",").map((f) => f.trim()).filter((f) => !!f)
+    ];
+    if (positions.some((p) => !supportedPositions.includes(p))) {
+      const unsupportedPositions = positions.filter((p) => !supportedPositions.includes(p)).sort().join(", ");
+      throw new Error(`Unsupported position-try-fallbacks ${unsupportedPositions} (Supported: ${supportedPositions.join(", ")})`);
+    }
+    this._positions = positions;
+    if (this._lastPosition && !this._positions.includes(this._lastPosition)) {
+      this._lastPosition = void 0;
+    }
+  }
+}
+export {
+  SbbOverlayPositionController
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"overlay-position-controller.js","sources":["../../../../../src/elements/core/controllers/overlay-position-controller.ts"],"sourcesContent":["import { isServer, type ReactiveController, type ReactiveControllerHost } from 'lit';\n\nconst cssAnchorPositionSupported = !isServer && CSS.supports('anchor-name', '--test');\n\nconst physicalSupportedPositions = [\n  'top',\n  'bottom',\n  'left',\n  'right',\n  'top span-left',\n  'top span-right',\n  'bottom span-left',\n  'bottom span-right',\n  'left span-top',\n  'left span-bottom',\n  'right span-top',\n  'right span-bottom',\n];\n\n// Note: if you add new logical supported positions, update also the 'rtlPositionMapping'\nconst logicalSupportedPositions = [\n  'block-start',\n  'block-end',\n  'inline-start',\n  'inline-end',\n  'block-start span-inline-start',\n  'block-start span-inline-end',\n  'block-end span-inline-start',\n  'block-end span-inline-end',\n  'inline-start span-block-start',\n  'inline-start span-block-end',\n  'inline-end span-block-start',\n  'inline-end span-block-end',\n];\n\nconst rtlPositionMapping: { [key: string]: string } = {\n  'block-start': 'block-start',\n  'block-end': 'block-end',\n  'inline-start': 'inline-end',\n  'inline-end': 'inline-start',\n  'block-start span-inline-start': 'block-start span-inline-end',\n  'block-start span-inline-end': 'block-start span-inline-start',\n  'block-end span-inline-start': 'block-end span-inline-end',\n  'block-end span-inline-end': 'block-end span-inline-start',\n  'inline-start span-block-start': 'inline-end span-block-start',\n  'inline-start span-block-end': 'inline-end span-block-end',\n  'inline-end span-block-start': 'inline-start span-block-start',\n  'inline-end span-block-end': 'inline-start span-block-end',\n};\n\nconst supportedPositions = [...physicalSupportedPositions, ...logicalSupportedPositions];\nlet nextId = 0;\n\n/**\n * Controller for managing overlays positioning. Also acts as a polyfill when native\n * CSS Anchor Positioning is not supported (enough).\n * Applies unique anchor names when using native CSS Anchor Positioning\n * or calculates and applies correct positions in polyfill mode.\n *\n * Also, the controller sets the 'data-overlay-position' attribute on the overlay element.\n * This can be used to apply specific styles based on the current position of the overlay.\n *\n * ### Implementation\n * Define and apply the following CSS variables on the overlay element:\n * ```scss\n *   --sbb-overlay-position-area: block-end; // Default\n *   --sbb-overlay-position-try-fallbacks: block-start, inline-end, inline-start; // Fallbacks\n *\n *   position-area: var(--sbb-overlay-position-area);\n *   position-try-fallbacks: var(--sbb-overlay-position-try-fallbacks);\n * ```\n */\nexport class SbbOverlayPositionController implements ReactiveController {\n  private readonly _resizeObserver = !isServer\n    ? new ResizeObserver(() => this._requestCalculatePosition())\n    : null!;\n  private readonly _overlay: HTMLElement;\n  private _abortController?: AbortController;\n  private _anchor?: HTMLElement;\n  private _overlayStyles?: CSSStyleDeclaration;\n  private _frame?: ReturnType<typeof requestAnimationFrame>;\n  private _anchorName = `--sbb-overlay-anchor-${++nextId}`;\n  private _positions: string[] = [];\n  private _lastPosition?: string;\n\n  /** Get the current position. (e.g. block-end, block-start, etc.) */\n  public get currentPosition(): string {\n    if (this._usePolyfill) {\n      return this._lastPosition ?? this._positions[0] ?? '';\n    } else {\n      this._overlayStyles ??= getComputedStyle(this._overlay);\n      return this._overlayStyles.getPropertyValue('position-area');\n    }\n  }\n\n  public constructor(\n    host: ReactiveControllerHost & HTMLElement,\n    overlay?: HTMLElement,\n    private _usePolyfill = !cssAnchorPositionSupported,\n  ) {\n    host.addController(this);\n    this._overlay = overlay ?? host;\n  }\n\n  public hostConnected(): void {\n    if (!this._usePolyfill) {\n      this._overlay.style.setProperty('position-anchor', this._anchorName);\n    } else {\n      // Reset the 'position-area' value to avoid any unwanted side effect when using the polyfill.\n      this._overlay.style.setProperty('position-area', 'initial');\n    }\n  }\n\n  public hostUpdate(): void {\n    if (isServer) {\n      return;\n    }\n    this._readPositionsFromCss();\n  }\n\n  /**\n   * Connects the overlay to the given trigger element and determines the optimal position.\n   * Usually, this is called when the overlay is opened.\n   * @param anchor The anchor element.\n   */\n  public connect(anchor: HTMLElement): void {\n    if (isServer) {\n      return;\n    }\n\n    if (this._anchor) {\n      this.disconnect();\n    }\n    this._anchor = anchor;\n\n    if (!this._usePolyfill) {\n      this._anchor.style.setProperty('anchor-name', this._anchorName!);\n    }\n\n    this._readPositionsFromCss();\n    this._calculatePosition();\n    this._abortController?.abort();\n    this._abortController = new AbortController();\n\n    // We need to use capture here to react to all scroll events.\n    // If capture was not used, then scroll events inside separate scroll\n    // containers would not be caught.\n    document.addEventListener('scroll', () => this._requestCalculatePosition(), {\n      capture: true,\n      passive: true,\n      signal: this._abortController.signal,\n    });\n    window.addEventListener('resize', () => this._requestCalculatePosition(), {\n      passive: true,\n      signal: this._abortController.signal,\n    });\n    this._resizeObserver.observe(anchor, { box: 'border-box' });\n    this._resizeObserver.observe(this._overlay, { box: 'border-box' });\n  }\n\n  public disconnect(): void {\n    this._anchor?.style.removeProperty('anchor-name');\n    this._anchor = undefined;\n    this._abortController?.abort();\n    this._resizeObserver.disconnect();\n  }\n\n  private _requestCalculatePosition(): void {\n    this._frame ??= requestAnimationFrame(() => {\n      this._calculatePosition();\n      this._frame = undefined;\n    });\n  }\n\n  private _calculatePosition(): void {\n    if (!this._anchor) {\n      return;\n    }\n\n    if (this._usePolyfill) {\n      const position = this._getOptimalPosition(this._positions);\n      this._applyOverlayPosition(position.position, position.left, position.top);\n    }\n    this._overlay.setAttribute('data-position', this.currentPosition);\n  }\n\n  /**\n   * Calculates the optimal position that fits the overlay.\n   * @param positions The list of positions to check.\n   * @private\n   */\n  private _getOptimalPosition(positions: string[]): {\n    left: number;\n    top: number;\n    position: string;\n    fits?: boolean;\n  } {\n    const { offsetHeight: overlayHeight, offsetWidth: overlayWidth } = this._overlay;\n    const { innerHeight: viewportHeight, innerWidth: viewportWidth } = window;\n    const {\n      top: triggerOffsetTop,\n      left: triggerOffsetLeft,\n      height: triggerHeight,\n      width: triggerWidth,\n    } = this._anchor!.getBoundingClientRect();\n\n    const isRtl = this._overlay.matches(':dir(rtl)');\n    const topSpace = triggerOffsetTop;\n    const bottomSpace = viewportHeight - triggerHeight - triggerOffsetTop;\n    const leftSpace = triggerOffsetLeft;\n    const rightSpace = viewportWidth - triggerWidth - triggerOffsetLeft;\n\n    // The difference between the overlay and the trigger width/height.\n    const overlayWidthNet = overlayWidth - triggerWidth;\n    const overlayHeightNet = overlayHeight - triggerHeight;\n\n    // The amount that would exceed the trigger if the overlay were centered on it.\n    const overlayWidthOverlap = overlayWidthNet / 2;\n    const overlayHeightOverlap = overlayHeightNet / 2;\n\n    this._overlay.style.setProperty(\n      '--sbb-overlay-controller-trigger-height',\n      `${triggerHeight}px`,\n    );\n    this._overlay.style.setProperty('--sbb-overlay-controller-trigger-width', `${triggerWidth}px`);\n\n    let result: ReturnType<typeof this._getOptimalPosition> = { left: 0, top: 0, position: '' };\n    let firstPosition: ReturnType<typeof this._getOptimalPosition> | undefined = undefined;\n    for (const position of positions) {\n      // If rtl is enabled, we map the logical position to their RTL equivalent. (e.g. 'inline-start' -> 'inline-end')\n      const physicalPosition =\n        isRtl && logicalSupportedPositions.includes(position)\n          ? rtlPositionMapping[position]\n          : position;\n\n      switch (physicalPosition) {\n        default:\n        case 'bottom':\n        case 'block-end':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidthOverlap,\n            top: triggerOffsetTop + triggerHeight,\n            fits:\n              overlayHeight <= bottomSpace &&\n              overlayWidthOverlap <= leftSpace &&\n              overlayWidthOverlap <= rightSpace,\n          };\n          break;\n        case 'top':\n        case 'block-start':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidthOverlap,\n            top: triggerOffsetTop - overlayHeight,\n            fits:\n              overlayHeight <= topSpace &&\n              overlayWidthOverlap <= leftSpace &&\n              overlayWidthOverlap <= rightSpace,\n          };\n          break;\n        case 'right':\n        case 'inline-end':\n          result = {\n            position,\n            left: triggerOffsetLeft + triggerWidth,\n            top: triggerOffsetTop - overlayHeightOverlap,\n            fits:\n              overlayWidth <= rightSpace &&\n              overlayHeightOverlap <= topSpace &&\n              overlayHeightOverlap <= bottomSpace,\n          };\n          break;\n        case 'left':\n        case 'inline-start':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidth,\n            top: triggerOffsetTop - overlayHeightOverlap,\n            fits:\n              overlayWidth <= leftSpace &&\n              overlayHeightOverlap <= topSpace &&\n              overlayHeightOverlap <= bottomSpace,\n          };\n          break;\n        case 'top span-left':\n        case 'block-start span-inline-start':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidthNet,\n            top: triggerOffsetTop - overlayHeight,\n            fits: overlayHeight <= topSpace && overlayWidthNet <= leftSpace,\n          };\n          break;\n        case 'top span-right':\n        case 'block-start span-inline-end':\n          result = {\n            position,\n            left: triggerOffsetLeft,\n            top: triggerOffsetTop - overlayHeight,\n            fits: overlayHeight <= topSpace && overlayWidthNet <= rightSpace,\n          };\n          break;\n        case 'bottom span-left':\n        case 'block-end span-inline-start':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidthNet,\n            top: triggerOffsetTop + triggerHeight,\n            fits: overlayHeight <= bottomSpace && overlayWidthNet <= leftSpace,\n          };\n          break;\n        case 'bottom span-right':\n        case 'block-end span-inline-end':\n          result = {\n            position,\n            left: triggerOffsetLeft,\n            top: triggerOffsetTop + triggerHeight,\n            fits: overlayHeight <= bottomSpace && overlayWidthNet <= rightSpace,\n          };\n          break;\n        case 'left span-top':\n        case 'inline-start span-block-start':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidth,\n            top: triggerOffsetTop + triggerHeight - overlayHeight,\n            fits: overlayWidth <= leftSpace && overlayHeightNet <= topSpace,\n          };\n          break;\n        case 'left span-bottom':\n        case 'inline-start span-block-end':\n          result = {\n            position,\n            left: triggerOffsetLeft - overlayWidth,\n            top: triggerOffsetTop,\n            fits: overlayWidth <= leftSpace && overlayHeightNet <= bottomSpace,\n          };\n          break;\n        case 'right span-top':\n        case 'inline-end span-block-start':\n          result = {\n            position,\n            left: triggerOffsetLeft + triggerWidth,\n            top: triggerOffsetTop + triggerHeight - overlayHeight,\n            fits: overlayWidth <= rightSpace && overlayHeightNet <= topSpace,\n          };\n          break;\n        case 'right span-bottom':\n        case 'inline-end span-block-end':\n          result = {\n            position,\n            left: triggerOffsetLeft + triggerWidth,\n            top: triggerOffsetTop,\n            fits: overlayWidth <= rightSpace && overlayHeightNet <= bottomSpace,\n          };\n          break;\n      }\n      if (result.fits) {\n        return result;\n      }\n      firstPosition ??= result;\n    }\n\n    // If no position fits, we return the first one.\n    return firstPosition!;\n  }\n\n  private _applyOverlayPosition(position: string, left: number, top: number): void {\n    this._lastPosition = position;\n    this._overlay.style.left = `${left}px`;\n    this._overlay.style.top = `${top}px`;\n  }\n\n  /**\n   * Only used in polyfill mode.\n   * Reads the list of the configured positions from the CSS variables.\n   * @private\n   */\n  private _readPositionsFromCss(): void {\n    if (!this._usePolyfill) {\n      return;\n    }\n    this._overlayStyles ??= getComputedStyle(this._overlay);\n    const positions = [\n      this._overlayStyles.getPropertyValue('--sbb-overlay-position-area') || 'block-end',\n      ...this._overlayStyles\n        .getPropertyValue('--sbb-overlay-position-try-fallbacks')\n        .split(',')\n        .map((f) => f.trim())\n        .filter((f) => !!f),\n    ];\n\n    if (import.meta.env.DEV && positions.some((p) => !supportedPositions.includes(p))) {\n      const unsupportedPositions = positions\n        .filter((p) => !supportedPositions.includes(p))\n        .sort()\n        .join(', ');\n      throw new Error(\n        `Unsupported position-try-fallbacks ${unsupportedPositions} (Supported: ${supportedPositions.join(', ')})`,\n      );\n    }\n\n    this._positions = positions;\n    if (this._lastPosition && !this._positions.includes(this._lastPosition)) {\n      this._lastPosition = undefined;\n    }\n  }\n}\n"],"names":[],"mappings":"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"}

package/development/core/controllers.d.ts

@@ -7,4 +7,5 @@ export * from './controllers/inert-controller.js';
 export * from './controllers/language-controller.js';
 export * from './controllers/media-matchers-controller.js';
 export * from './controllers/slot-state-controller.js';
+export * from './controllers/overlay-position-controller.js';
 //# sourceMappingURL=controllers.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"controllers.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/controllers.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,+CAA+C,CAAC;AAC9D,cAAc,0CAA0C,CAAC;AACzD,cAAc,mCAAmC,CAAC;AAClD,cAAc,sCAAsC,CAAC;AACrD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,wCAAwC,CAAC"}
+{"version":3,"file":"controllers.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/controllers.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,+CAA+C,CAAC;AAC9D,cAAc,0CAA0C,CAAC;AACzD,cAAc,mCAAmC,CAAC;AAClD,cAAc,sCAAsC,CAAC;AACrD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,wCAAwC,CAAC;AACvD,cAAc,8CAA8C,CAAC"}

package/development/core/controllers.js

@@ -4,6 +4,7 @@ import { SbbInertController } from "./controllers/inert-controller.js";
 import { SbbLanguageController } from "./controllers/language-controller.js";
 import { SbbDarkModeController, SbbMediaMatcherController, SbbMediaQueryBreakpointMediumAndAbove, SbbMediaQueryBreakpointMediumAndBelow, SbbMediaQueryBreakpointSmallAndBelow, SbbMediaQueryDarkMode, SbbMediaQueryForcedColors, SbbMediaQueryHover, SbbMediaQueryPointerCoarse } from "./controllers/media-matchers-controller.js";
 import { SbbSlotStateController } from "./controllers/slot-state-controller.js";
+import { SbbOverlayPositionController } from "./controllers/overlay-position-controller.js";
 export {
   SbbDarkModeController,
   SbbEscapableOverlayController,
@@ -18,6 +19,7 @@ export {
   SbbMediaQueryForcedColors,
   SbbMediaQueryHover,
   SbbMediaQueryPointerCoarse,
+  SbbOverlayPositionController,
   SbbSlotStateController
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJvbGxlcnMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJvbGxlcnMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7OyJ9

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

@@ -5,6 +5,7 @@
  * @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.
+ * @param position The allowed position of the overlay relative to the origin.
  */
-export declare function setOverlayPosition(dialog: HTMLElement, originElement: HTMLElement, optionContainer: HTMLElement, container: HTMLElement, element: HTMLElement): void;
+export declare function setOverlayPosition(dialog: HTMLElement, originElement: HTMLElement, optionContainer: HTMLElement, container: HTMLElement, element: HTMLElement, position?: 'auto' | 'above' | 'below'): void;
 //# sourceMappingURL=overlay-option-panel.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"overlay-option-panel.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/overlay/overlay-option-panel.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,WAAW,EAC1B,eAAe,EAAE,WAAW,EAC5B,SAAS,EAAE,WAAW,EACtB,OAAO,EAAE,WAAW,EACpB,QAAQ,GAAE,MAAM,GAAG,OAAO,GAAG,OAAgB,GAC5C,IAAI,CAsBN"}

package/development/core/overlay/overlay-option-panel.js

@@ -1,11 +1,14 @@
 import { getElementPosition } from "./position.js";
-function setOverlayPosition(dialog, originElement, optionContainer, container, element) {
+function setOverlayPosition(dialog, originElement, optionContainer, container, element, position = "auto") {
   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);
+  const panelPosition = getElementPosition(optionContainer, originElement, container, {
+    forceBelow: position === "below",
+    forceAbove: position === "above"
+  });
   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);
@@ -15,4 +18,4 @@ function setOverlayPosition(dialog, originElement, optionContainer, container, e
 export {
   setOverlayPosition
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -37,6 +37,8 @@ export declare function getElementPosition(element: HTMLElement, trigger: HTMLEl
     horizontalOffset?: number;
     centered?: boolean;
     responsiveHeight?: boolean;
+    forceAbove?: boolean;
+    forceBelow?: boolean;
 }): SbbElementPositionInfos;
 /**
  * Determines the position of an element relative to a trigger element by evaluating

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

@@ -1 +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;CAC5B,GACA,uBAAuB,CAqGzB;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"}
+{"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

@@ -57,7 +57,8 @@ function getElementPosition(element, trigger, container, properties) {
   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) {
+  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";
@@ -121,4 +122,4 @@ export {
   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  },\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\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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"}
+//# 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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"}

package/development/footer/footer.component.js

@@ -57,17 +57,17 @@ const style = css`*,
 }
 
 :host(:not([expanded])) .sbb-footer-wrapper {
-  padding-inline: var(--sbb-layout-base-offset-responsive);
+  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-layout-base-offset-responsive));
   margin-inline: auto;
   width: 100%;
 }
 @media (min-width: calc(90rem)) {
   :host(:not([expanded])) .sbb-footer-wrapper {
-    max-width: calc(var(--sbb-layout-base-page-max-width) + 2 * var(--sbb-layout-base-offset-responsive));
+    max-width: var(--sbb-spacing-max-width, calc(var(--sbb-layout-base-page-max-width) + 2 * var(--sbb-layout-base-offset-responsive)));
   }
 }
 :host([expanded]) .sbb-footer-wrapper {
-  padding-inline: var(--sbb-spacing-responsive-xxs);
+  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-spacing-responsive-xxs));
 }
 
 .sbb-footer__title {

package/development/header/header/header.component.js

@@ -92,17 +92,17 @@ const style = css`*,
   height: var(--sbb-header-height);
 }
 :host(:not([expanded])) .sbb-header__wrapper {
-  padding-inline: var(--sbb-layout-base-offset-responsive);
+  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-layout-base-offset-responsive));
   margin-inline: auto;
   width: 100%;
 }
 @media (min-width: calc(90rem)) {
   :host(:not([expanded])) .sbb-header__wrapper {
-    max-width: calc(var(--sbb-layout-base-page-max-width) + 2 * var(--sbb-layout-base-offset-responsive));
+    max-width: var(--sbb-spacing-max-width, calc(var(--sbb-layout-base-page-max-width) + 2 * var(--sbb-layout-base-offset-responsive)));
   }
 }
 :host([expanded]) .sbb-header__wrapper {
-  padding-inline: var(--sbb-spacing-responsive-xxs);
+  padding-inline: var(--sbb-page-spacing-padding, var(--sbb-spacing-responsive-xxs));
 }
 
 ::slotted(:is(sbb-header-button, sbb-header-link):first-child) {