@sbb-esta/lyne-elements 3.10.0 → 3.11.0

package/development/core/controllers/escapable-overlay-controller.d.ts

@@ -1,5 +1,8 @@
 import { ReactiveController, ReactiveControllerHost } from 'lit';
 import { SbbOpenCloseBaseElement } from '../base-elements/open-close-base-element.js';
+/**
+ * Handles the stack of overlays and closes the last opened one when pressing Escape.
+ */
 export declare class SbbEscapableOverlayController implements ReactiveController {
     private _host;
     private _overlayStack;

package/development/core/controllers/escapable-overlay-controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"escapable-overlay-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/escapable-overlay-controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAErF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6CAA6C,CAAC;AAa3F,qBAAa,6BAA8B,YAAW,kBAAkB;IAEpE,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,aAAa;gBADb,KAAK,EAAE,sBAAsB,GAAG,uBAAuB,EACvD,aAAa,GAAE,uBAAuB,EAAiB;IAK1D,gBAAgB,IAAI,IAAI;IAKxB,OAAO,IAAI,IAAI;IAQf,UAAU,IAAI,IAAI;CAQ1B"}
+{"version":3,"file":"escapable-overlay-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/escapable-overlay-controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAErF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6CAA6C,CAAC;AAa3F;;GAEG;AACH,qBAAa,6BAA8B,YAAW,kBAAkB;IAEpE,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,aAAa;gBADb,KAAK,EAAE,sBAAsB,GAAG,uBAAuB,EACvD,aAAa,GAAE,uBAAuB,EAAiB;IAK1D,gBAAgB,IAAI,IAAI;IAKxB,OAAO,IAAI,IAAI;IAQf,UAAU,IAAI,IAAI;CAQ1B"}

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

@@ -35,4 +35,4 @@ class SbbEscapableOverlayController {
 export {
   SbbEscapableOverlayController
 };
-//# 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/controllers/overlay-position-controller.d.ts

@@ -0,0 +1,60 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+/**
+ * Controller for managing overlays positioning. Also acts as a polyfill when native
+ * CSS Anchor Positioning is not supported (enough).
+ * Applies unique anchor names when using native CSS Anchor Positioning
+ * or calculates and applies correct positions in polyfill mode.
+ *
+ * Also, the controller sets the 'data-overlay-position' attribute on the overlay element.
+ * This can be used to apply specific styles based on the current position of the overlay.
+ *
+ * ### Implementation
+ * Define and apply the following CSS variables on the overlay element:
+ * ```scss
+ *   --sbb-overlay-position-area: block-end; // Default
+ *   --sbb-overlay-position-try-fallbacks: block-start, inline-end, inline-start; // Fallbacks
+ *
+ *   position-area: var(--sbb-overlay-position-area);
+ *   position-try-fallbacks: var(--sbb-overlay-position-try-fallbacks);
+ * ```
+ */
+export declare class SbbOverlayPositionController implements ReactiveController {
+    private _usePolyfill;
+    private readonly _resizeObserver;
+    private readonly _overlay;
+    private _abortController?;
+    private _anchor?;
+    private _overlayStyles?;
+    private _frame?;
+    private _anchorName;
+    private _positions;
+    private _lastPosition?;
+    /** Get the current position. (e.g. block-end, block-start, etc.) */
+    get currentPosition(): string;
+    constructor(host: ReactiveControllerHost & HTMLElement, overlay?: HTMLElement, _usePolyfill?: boolean);
+    hostConnected(): void;
+    hostUpdate(): void;
+    /**
+     * 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: HTMLElement): void;
+    disconnect(): void;
+    private _requestCalculatePosition;
+    private _calculatePosition;
+    /**
+     * Calculates the optimal position that fits the overlay.
+     * @param positions The list of positions to check.
+     * @private
+     */
+    private _getOptimalPosition;
+    private _applyOverlayPosition;
+    /**
+     * Only used in polyfill mode.
+     * Reads the list of the configured positions from the CSS variables.
+     * @private
+     */
+    private _readPositionsFromCss;
+}
+//# sourceMappingURL=overlay-position-controller.d.ts.map

package/development/core/controllers/overlay-position-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay-position-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/overlay-position-controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAqDrF;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,4BAA6B,YAAW,kBAAkB;IA0BnE,OAAO,CAAC,YAAY;IAzBtB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAEtB;IACV,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;IACvC,OAAO,CAAC,gBAAgB,CAAC,CAAkB;IAC3C,OAAO,CAAC,OAAO,CAAC,CAAc;IAC9B,OAAO,CAAC,cAAc,CAAC,CAAsB;IAC7C,OAAO,CAAC,MAAM,CAAC,CAA2C;IAC1D,OAAO,CAAC,WAAW,CAAsC;IACzD,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,aAAa,CAAC,CAAS;IAE/B,oEAAoE;IACpE,IAAW,eAAe,IAAI,MAAM,CAOnC;gBAGC,IAAI,EAAE,sBAAsB,GAAG,WAAW,EAC1C,OAAO,CAAC,EAAE,WAAW,EACb,YAAY,UAA8B;IAM7C,aAAa,IAAI,IAAI;IASrB,UAAU,IAAI,IAAI;IAOzB;;;;OAIG;IACI,OAAO,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAmClC,UAAU,IAAI,IAAI;IAOzB,OAAO,CAAC,yBAAyB;IAOjC,OAAO,CAAC,kBAAkB;IAY1B;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;IAiL3B,OAAO,CAAC,qBAAqB;IAM7B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;CA6B9B"}

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/mini-calendar/mini-calendar/mini-calendar.component.d.ts

@@ -0,0 +1,35 @@
+import { CSSResultGroup, TemplateResult, LitElement } from 'lit';
+import { SbbOrientation } from '../../core/interfaces.js';
+/**
+ * It displays a minimal calendar, together with the `sbb-mini-calendar-month` and `sbb-mini-calendar-day`.
+ *
+ * @slot - Use the unnamed slot to add `sbb-mini-calendar-month` elements.
+ */
+export declare class SbbMiniCalendarElement<T = Date> extends LitElement {
+    static styles: CSSResultGroup;
+    /** The orientation of days in the calendar. */
+    accessor orientation: SbbOrientation;
+    private _keydownAbortController;
+    private _dateAdapter;
+    constructor();
+    private _getMiniCalendarMonths;
+    private _getMiniCalendarDays;
+    private _setMonthsShowYear;
+    private _handleKeydownCalendarDay;
+    private _navigateByKeyboardDayView;
+    private _findDayArrowKeys;
+    private _findDaySpecialKeys;
+    private _handleSlotchange;
+    private _setupKeydownListener;
+    /** @internal */
+    focus(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-mini-calendar': SbbMiniCalendarElement;
+    }
+}
+//# sourceMappingURL=mini-calendar.component.d.ts.map

package/development/mini-calendar/mini-calendar/mini-calendar.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mini-calendar.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/mini-calendar/mini-calendar/mini-calendar.component.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAC1D,OAAO,EAAQ,UAAU,EAAE,MAAM,KAAK,CAAC;AAOvC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAM/D;;;;GAIG;AACH,qBAEM,sBAAsB,CAAC,CAAC,GAAG,IAAI,CAAE,SAAQ,UAAU;IACvD,OAAuB,MAAM,EAAE,cAAc,CAAS;IAEtD,+CAA+C;IAC/C,SACgB,WAAW,EAAE,cAAc,CAAgB;IAE3D,OAAO,CAAC,uBAAuB,CAAgC;IAC/D,OAAO,CAAC,YAAY,CAA4E;;IAahG,OAAO,CAAC,sBAAsB;IAI9B,OAAO,CAAC,oBAAoB;IAQ5B,OAAO,CAAC,kBAAkB;IAe1B,OAAO,CAAC,yBAAyB;IAgBjC,OAAO,CAAC,0BAA0B;IAwDlC,OAAO,CAAC,iBAAiB;IAiBzB,OAAO,CAAC,mBAAmB;IAkB3B,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,qBAAqB;IAa7B,gBAAgB;IACA,KAAK,IAAI,IAAI;IAMb,iBAAiB,IAAI,IAAI;IAKzB,oBAAoB,IAAI,IAAI;cAKzB,MAAM,IAAI,cAAc;CAO5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,mBAAmB,EAAE,sBAAsB,CAAC;KAC7C;CACF"}