@sbb-esta/lyne-elements-dev 0.0.0 → 4.5.1-dev.1771859294

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

@@ -0,0 +1,287 @@
+import { isServer } from "lit";
+const cssAnchorPositionSupported = !isServer && CSS.supports("anchor-name", "--test");
+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"
+};
+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, _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 = 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)
+    ];
+    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\nimport type { SbbElementInternalsMixinType } from '../mixins.ts';\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-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: ReactiveControllerHost & HTMLElement & SbbElementInternalsMixinType;\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 & SbbElementInternalsMixinType,\n    private _usePolyfill = !cssAnchorPositionSupported,\n  ) {\n    host.addController(this);\n    this._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\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    // eslint-disable-next-line no-useless-assignment\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/property-watcher-controller.d.ts

@@ -0,0 +1,16 @@
+import { ReactiveControllerHost, LitElement, ReactiveController } from 'lit';
+type PropertyWatcherHandler<T extends LitElement> = (reference: T) => void;
+export declare class SbbPropertyWatcherController<T extends LitElement> implements ReactiveController {
+    private readonly _host;
+    private readonly _referenceResolver;
+    private readonly _handlers;
+    private _reference?;
+    private _watchers?;
+    constructor(_host: ReactiveControllerHost & HTMLElement, _referenceResolver: () => T | null, _handlers: Partial<Record<keyof T, PropertyWatcherHandler<T>>>);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    connect(): void;
+    disconnect(): void;
+}
+export {};
+//# sourceMappingURL=property-watcher-controller.d.ts.map

package/development/core/controllers/property-watcher-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"property-watcher-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/property-watcher-controller.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,sBAAsB,EAC3B,KAAK,UAAU,EACf,KAAK,kBAAkB,EAExB,MAAM,KAAK,CAAC;AAEb,KAAK,sBAAsB,CAAC,CAAC,SAAS,UAAU,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,IAAI,CAAC;AAwE3E,qBAAa,4BAA4B,CAAC,CAAC,SAAS,UAAU,CAAE,YAAW,kBAAkB;IAKzF,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS;IAN5B,OAAO,CAAC,UAAU,CAAC,CAAW;IAC9B,OAAO,CAAC,SAAS,CAAC,CAAkC;gBAGjC,KAAK,EAAE,sBAAsB,GAAG,WAAW,EAC3C,kBAAkB,EAAE,MAAM,CAAC,GAAG,IAAI,EAClC,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC;IAK1E,aAAa,IAAI,IAAI;IAIrB,gBAAgB,IAAI,IAAI;IAMxB,OAAO,IAAI,IAAI;IA6Bf,UAAU,IAAI,IAAI;CAmB1B"}

package/development/core/controllers/property-watcher-controller.js

@@ -0,0 +1,121 @@
+import { isServer } from "lit";
+class PropertyWatcher {
+  get size() {
+    return this._handlers.size;
+  }
+  constructor(_host, _property) {
+    this._host = _host;
+    this._property = _property;
+    this._handlers = /* @__PURE__ */ new Set();
+    this._hostDefinedPromise = null;
+    if (!isServer) {
+      if (customElements.get(this._host.localName)) {
+        customElements.upgrade(this._host);
+      } else {
+        this._hostDefinedPromise = customElements.whenDefined(this._host.localName).then(() => {
+          customElements.upgrade(this._host);
+          this._hostDefinedPromise = null;
+        });
+      }
+    }
+    this._value = this._host[this._property];
+  }
+  addHandler(handler) {
+    if (!this._handlers.size) {
+      if (this._host.addController) {
+        this._host.addController(this);
+      } else if (this._hostDefinedPromise) {
+        this._hostDefinedPromise.then(() => this._host.addController(this));
+      }
+    }
+    this._handlers.add(handler);
+    if (!this._hostDefinedPromise) {
+      handler(this._host);
+    } else {
+      this._hostDefinedPromise.then(() => handler(this._host));
+    }
+  }
+  removeHandler(handler) {
+    this._handlers.delete(handler);
+    if (!this._handlers.size) {
+      if (this._host.removeController) {
+        this._host.removeController(this);
+      } else if (this._hostDefinedPromise) {
+        this._hostDefinedPromise.then(() => this._host.removeController(this));
+      }
+    }
+  }
+  hostUpdate() {
+    const currentValue = this._host[this._property];
+    if (this._value !== currentValue) {
+      this._value = currentValue;
+      for (const handler of this._handlers) {
+        handler(this._host);
+      }
+    }
+  }
+}
+const propertyWatchers = /* @__PURE__ */ new WeakMap();
+class SbbPropertyWatcherController {
+  constructor(_host, _referenceResolver, _handlers) {
+    this._host = _host;
+    this._referenceResolver = _referenceResolver;
+    this._handlers = _handlers;
+    this._host.addController(this);
+  }
+  hostConnected() {
+    this.connect();
+  }
+  hostDisconnected() {
+    if (this._reference !== this._referenceResolver()) {
+      this.disconnect();
+    }
+  }
+  connect() {
+    const reference = this._referenceResolver();
+    if (this._reference === reference) {
+      return;
+    }
+    this.disconnect();
+    this._reference = reference;
+    if (!this._reference) {
+      return;
+    }
+    let watchers = propertyWatchers.get(this._reference);
+    if (!watchers) {
+      watchers = /* @__PURE__ */ new Map();
+      propertyWatchers.set(this._reference, watchers);
+    }
+    this._watchers = watchers;
+    for (const [property, handler] of Object.entries(this._handlers)) {
+      let watcher = this._watchers.get(property);
+      if (!watcher) {
+        watcher = new PropertyWatcher(this._reference, property);
+        this._watchers.set(property, watcher);
+      }
+      watcher.addHandler(handler);
+    }
+  }
+  disconnect() {
+    if (!this._reference) {
+      return;
+    }
+    for (const [property, handler] of Object.entries(this._handlers)) {
+      const watcher = this._watchers?.get(property);
+      if (watcher) {
+        watcher.removeHandler(handler);
+        if (!watcher.size) {
+          this._watchers.delete(property);
+          if (!this._watchers.size && this._reference) {
+            propertyWatchers.delete(this._reference);
+          }
+        }
+      }
+    }
+    this._reference = null;
+  }
+}
+export {
+  SbbPropertyWatcherController
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"property-watcher-controller.js","sources":["../../../../../src/elements/core/controllers/property-watcher-controller.ts"],"sourcesContent":["import {\n  type ReactiveControllerHost,\n  type LitElement,\n  type ReactiveController,\n  isServer,\n} from 'lit';\n\ntype PropertyWatcherHandler<T extends LitElement> = (reference: T) => void;\n\nclass PropertyWatcher<T extends LitElement> implements ReactiveController {\n  private _value: unknown;\n  private _handlers = new Set<PropertyWatcherHandler<T>>();\n  private _hostDefinedPromise: Promise<void> | null = null;\n\n  public get size(): number {\n    return this._handlers.size;\n  }\n\n  public constructor(\n    private readonly _host: T,\n    private readonly _property: string,\n  ) {\n    if (!isServer) {\n      if (customElements.get(this._host.localName)) {\n        customElements.upgrade(this._host);\n      } else {\n        // The host element is not yet defined, wait for its definition before upgrading\n        this._hostDefinedPromise = customElements.whenDefined(this._host.localName).then(() => {\n          customElements.upgrade(this._host);\n          this._hostDefinedPromise = null;\n        });\n      }\n    }\n    this._value = (this._host as unknown as Record<string, unknown>)[this._property];\n  }\n\n  public addHandler(handler: PropertyWatcherHandler<T>): void {\n    if (!this._handlers.size) {\n      // We check if the addController method is available (element was defined && upgraded), otherwise we wait for the host to be defined\n      if (this._host.addController) {\n        this._host.addController(this);\n      } else if (this._hostDefinedPromise) {\n        this._hostDefinedPromise.then(() => this._host.addController(this));\n      }\n    }\n    this._handlers.add(handler);\n\n    if (!this._hostDefinedPromise) {\n      handler(this._host);\n    } else {\n      this._hostDefinedPromise.then(() => handler(this._host));\n    }\n  }\n\n  public removeHandler(handler: PropertyWatcherHandler<T>): void {\n    this._handlers.delete(handler);\n    if (!this._handlers.size) {\n      // We check if the removeController method is available (element was defined && upgraded), otherwise we wait for the host to be defined\n      if (this._host.removeController) {\n        this._host.removeController(this);\n      } else if (this._hostDefinedPromise) {\n        this._hostDefinedPromise.then(() => this._host.removeController(this));\n      }\n    }\n  }\n\n  public hostUpdate(): void {\n    const currentValue = (this._host as unknown as Record<string, unknown>)[this._property];\n    if (this._value !== currentValue) {\n      this._value = currentValue;\n      for (const handler of this._handlers) {\n        handler(this._host);\n      }\n    }\n  }\n}\n\nconst propertyWatchers = new WeakMap<LitElement, Map<string, PropertyWatcher<any>>>();\n\nexport class SbbPropertyWatcherController<T extends LitElement> implements ReactiveController {\n  private _reference?: T | null;\n  private _watchers?: Map<string, PropertyWatcher<T>>;\n\n  public constructor(\n    private readonly _host: ReactiveControllerHost & HTMLElement,\n    private readonly _referenceResolver: () => T | null,\n    private readonly _handlers: Partial<Record<keyof T, PropertyWatcherHandler<T>>>,\n  ) {\n    this._host.addController(this);\n  }\n\n  public hostConnected(): void {\n    this.connect();\n  }\n\n  public hostDisconnected(): void {\n    if (this._reference !== this._referenceResolver()) {\n      this.disconnect();\n    }\n  }\n\n  public connect(): void {\n    const reference = this._referenceResolver();\n    if (this._reference === reference) {\n      return;\n    }\n    this.disconnect();\n    this._reference = reference;\n    if (!this._reference) {\n      return;\n    }\n    let watchers = propertyWatchers.get(this._reference) as\n      | Map<string, PropertyWatcher<T>>\n      | undefined;\n    if (!watchers) {\n      watchers = new Map();\n      propertyWatchers.set(this._reference, watchers);\n    }\n    this._watchers = watchers;\n\n    for (const [property, handler] of Object.entries(this._handlers)) {\n      let watcher = this._watchers.get(property);\n      if (!watcher) {\n        watcher = new PropertyWatcher<T>(this._reference, property);\n        this._watchers.set(property, watcher);\n      }\n      watcher.addHandler(handler);\n    }\n  }\n\n  public disconnect(): void {\n    if (!this._reference) {\n      return;\n    }\n\n    for (const [property, handler] of Object.entries(this._handlers)) {\n      const watcher = this._watchers?.get(property);\n      if (watcher) {\n        watcher.removeHandler(handler);\n        if (!watcher.size) {\n          this._watchers!.delete(property);\n          if (!this._watchers!.size && this._reference) {\n            propertyWatchers.delete(this._reference);\n          }\n        }\n      }\n    }\n    this._reference = null;\n  }\n}\n"],"names":[],"mappings":"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"}

package/development/core/controllers/slot-state-controller.d.ts

@@ -0,0 +1,45 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+export declare class SbbSlottedChangeEvent extends Event {
+    readonly slot: HTMLSlotElement;
+    constructor(slot: HTMLSlotElement);
+}
+/**
+ * This controller checks for slotted children. From these it updates
+ * the ElementInternals states with the pattern `slotted-<name>` or `slotted`
+ * for the unnamed slot.
+ *
+ * This allows a :state(slotted-<name>) CSS selector to display/hide/configure
+ * a section of the component as required.
+ *
+ * @example
+ * .example {
+ *   display: none;
+ *
+ *   :host(:state(slotted-icon)) & {
+ *     display: inline;
+ *   }
+ * }
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/:state
+ */
+export declare class SbbSlotStateController implements ReactiveController {
+    private _host;
+    private _internals;
+    private _textObserver;
+    constructor(_host: ReactiveControllerHost & HTMLElement, _internals: ElementInternals);
+    hostConnected: ReactiveController['hostConnected'];
+    private _slotchangeHandler;
+    private _handleSlotChange;
+    private _updateSlottedState;
+    private _observeTextNodesInSlot;
+    private _hasSlottedContent;
+}
+declare global {
+    interface HTMLElementEventMap {
+        slottedchange: SbbSlottedChangeEvent;
+    }
+    interface ShadowRootEventMap {
+        slottedchange: SbbSlottedChangeEvent;
+    }
+}
+//# sourceMappingURL=slot-state-controller.d.ts.map

package/development/core/controllers/slot-state-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-state-controller.d.ts","sourceRoot":"","sources":["../../../../../src/elements/core/controllers/slot-state-controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,KAAK,CAAC;AAErF,qBAAa,qBAAsB,SAAQ,KAAK;aACX,IAAI,EAAE,eAAe;gBAArB,IAAI,EAAE,eAAe;CAGzD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,sBAAuB,YAAW,kBAAkB;IAa7D,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,UAAU;IAbpB,OAAO,CAAC,aAAa,CAShB;gBAGK,KAAK,EAAE,sBAAsB,GAAG,WAAW,EAC3C,UAAU,EAAE,gBAAgB;IAK/B,aAAa,EAAE,kBAAkB,CAAC,eAAe,CAAC,CAavD;IAEF,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,iBAAiB;IAOzB,OAAO,CAAC,mBAAmB;IAY3B,OAAO,CAAC,uBAAuB;IAc/B,OAAO,CAAC,kBAAkB;CAW3B;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,mBAAmB;QAC3B,aAAa,EAAE,qBAAqB,CAAC;KACtC;IACD,UAAU,kBAAkB;QAC1B,aAAa,EAAE,qBAAqB,CAAC;KACtC;CACF"}

package/development/core/controllers/slot-state-controller.js

@@ -0,0 +1,65 @@
+import { isServer } from "lit";
+class SbbSlottedChangeEvent extends Event {
+  constructor(slot) {
+    super("slottedchange", { composed: true });
+    this.slot = slot;
+  }
+}
+class SbbSlotStateController {
+  constructor(_host, _internals) {
+    this._host = _host;
+    this._internals = _internals;
+    this._textObserver = !isServer && new MutationObserver(() => {
+      const slot = this._host.shadowRoot.querySelector("slot:not([name])");
+      if (slot) {
+        this._updateSlottedState(slot);
+      } else {
+        this._textObserver.disconnect();
+      }
+    });
+    this.hostConnected = () => {
+      this._host.shadowRoot?.addEventListener("slotchange", (e) => this._slotchangeHandler(e, e.target));
+      this._host.shadowRoot?.addEventListener("slottedchange", (e) => this._slotchangeHandler(e, e.slot), { capture: true });
+      this._internals.shadowRoot?.querySelectorAll("slot").forEach((slot) => this._handleSlotChange(slot));
+      this.hostConnected = void 0;
+    };
+    this._host.addController(this);
+  }
+  _slotchangeHandler(event, slot) {
+    const resolvedSlot = this._host.shadowRoot.contains(slot) ? slot : event.composedPath().find((el) => el instanceof HTMLSlotElement && this._host.shadowRoot.contains(el));
+    if (resolvedSlot) {
+      this._handleSlotChange(resolvedSlot);
+    }
+  }
+  _handleSlotChange(slot) {
+    this._updateSlottedState(slot);
+    if (!slot.name) {
+      this._observeTextNodesInSlot(slot);
+    }
+  }
+  _updateSlottedState(slot) {
+    const stateName = slot.name ? `slotted-${slot.name}` : "slotted";
+    const hasSlottedContent = this._hasSlottedContent(slot);
+    if (hasSlottedContent && !this._internals.states.has(stateName)) {
+      this._internals.states.add(stateName);
+      this._host.dispatchEvent(new SbbSlottedChangeEvent(slot));
+    } else if (!hasSlottedContent && this._internals.states.has(stateName)) {
+      this._internals.states.delete(stateName);
+      this._host.dispatchEvent(new SbbSlottedChangeEvent(slot));
+    }
+  }
+  _observeTextNodesInSlot(slot) {
+    this._textObserver.disconnect();
+    slot.assignedNodes().filter((n) => n.nodeType === n.TEXT_NODE).forEach((node) => this._textObserver.observe(node, { characterData: true }));
+  }
+  _hasSlottedContent(slot) {
+    return slot.name ? slot.assignedElements().some((node) => !(node instanceof HTMLSlotElement) || this._hasSlottedContent(node)) : slot.assignedNodes().some((node) => {
+      return node instanceof HTMLSlotElement ? this._hasSlottedContent(node) : node.nodeType !== node.TEXT_NODE || !!node.textContent?.trim();
+    });
+  }
+}
+export {
+  SbbSlotStateController,
+  SbbSlottedChangeEvent
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"slot-state-controller.js","sources":["../../../../../src/elements/core/controllers/slot-state-controller.ts"],"sourcesContent":["import { isServer, type ReactiveController, type ReactiveControllerHost } from 'lit';\n\nexport class SbbSlottedChangeEvent extends Event {\n  public constructor(public readonly slot: HTMLSlotElement) {\n    super('slottedchange', { composed: true });\n  }\n}\n\n/**\n * This controller checks for slotted children. From these it updates\n * the ElementInternals states with the pattern `slotted-<name>` or `slotted`\n * for the unnamed slot.\n *\n * This allows a :state(slotted-<name>) CSS selector to display/hide/configure\n * a section of the component as required.\n *\n * @example\n * .example {\n *   display: none;\n *\n *   :host(:state(slotted-icon)) & {\n *     display: inline;\n *   }\n * }\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/:state\n */\nexport class SbbSlotStateController implements ReactiveController {\n  private _textObserver =\n    !isServer &&\n    new MutationObserver(() => {\n      const slot = this._host.shadowRoot!.querySelector<HTMLSlotElement>('slot:not([name])');\n      if (slot) {\n        this._updateSlottedState(slot);\n      } else {\n        this._textObserver.disconnect();\n      }\n    });\n\n  public constructor(\n    private _host: ReactiveControllerHost & HTMLElement,\n    private _internals: ElementInternals,\n  ) {\n    this._host.addController(this);\n  }\n\n  public hostConnected: ReactiveController['hostConnected'] = (): void => {\n    this._host.shadowRoot?.addEventListener('slotchange', (e) =>\n      this._slotchangeHandler(e, e.target as HTMLSlotElement),\n    );\n    this._host.shadowRoot?.addEventListener(\n      'slottedchange',\n      (e) => this._slotchangeHandler(e, e.slot),\n      { capture: true },\n    );\n    this._internals.shadowRoot\n      ?.querySelectorAll('slot')\n      .forEach((slot) => this._handleSlotChange(slot));\n    this.hostConnected = undefined;\n  };\n\n  private _slotchangeHandler(event: Event, slot: HTMLSlotElement): void {\n    const resolvedSlot = this._host.shadowRoot!.contains(slot)\n      ? slot\n      : event\n          .composedPath()\n          .find(\n            (el): el is HTMLSlotElement =>\n              el instanceof HTMLSlotElement && this._host.shadowRoot!.contains(el),\n          );\n    if (resolvedSlot) {\n      this._handleSlotChange(resolvedSlot);\n    }\n  }\n\n  private _handleSlotChange(slot: HTMLSlotElement): void {\n    this._updateSlottedState(slot);\n    if (!slot.name) {\n      this._observeTextNodesInSlot(slot);\n    }\n  }\n\n  private _updateSlottedState(slot: HTMLSlotElement): void {\n    const stateName = slot.name ? `slotted-${slot.name}` : 'slotted';\n    const hasSlottedContent = this._hasSlottedContent(slot);\n    if (hasSlottedContent && !this._internals.states.has(stateName)) {\n      this._internals.states.add(stateName);\n      this._host.dispatchEvent(new SbbSlottedChangeEvent(slot));\n    } else if (!hasSlottedContent && this._internals.states.has(stateName)) {\n      this._internals.states.delete(stateName);\n      this._host.dispatchEvent(new SbbSlottedChangeEvent(slot));\n    }\n  }\n\n  private _observeTextNodesInSlot(slot: HTMLSlotElement): void {\n    this._textObserver.disconnect();\n    // Text nodes can be empty and filled later (or vice versa).\n    // Filling an existing node later would not trigger another slotchange event.\n    // Therefore, we need to observe text nodes and check if they become filled or empty.\n    // This is only needed for the unnamed slot as for every other there would\n    // be a tag which triggers the slot change event.\n    // The main reason is that Angular creates empty text nodes and fills them later.\n    slot\n      .assignedNodes()\n      .filter((n) => n.nodeType === n.TEXT_NODE)\n      .forEach((node) => this._textObserver.observe(node, { characterData: true }));\n  }\n\n  private _hasSlottedContent(slot: HTMLSlotElement): boolean {\n    return slot.name\n      ? slot\n          .assignedElements()\n          .some((node) => !(node instanceof HTMLSlotElement) || this._hasSlottedContent(node))\n      : slot.assignedNodes().some((node) => {\n          return node instanceof HTMLSlotElement\n            ? this._hasSlottedContent(node)\n            : node.nodeType !== node.TEXT_NODE || !!node.textContent?.trim();\n        });\n  }\n}\n\ndeclare global {\n  interface HTMLElementEventMap {\n    slottedchange: SbbSlottedChangeEvent;\n  }\n  interface ShadowRootEventMap {\n    slottedchange: SbbSlottedChangeEvent;\n  }\n}\n"],"names":[],"mappings":";AAEM,MAAO,8BAA8B,MAAK;AAAA,EAC9C,YAAmC,MAAqB;AACtD,UAAM,iBAAiB,EAAE,UAAU,KAAA,CAAM;AADR,SAAA,OAAA;AAAA,EAEnC;AACD;MAqBY,uBAAsB;AAAA,EAYjC,YACU,OACA,YAA4B;AAD5B,SAAA,QAAA;AACA,SAAA,aAAA;AAbF,SAAA,gBACN,CAAC,YACD,IAAI,iBAAiB,MAAK;AACxB,YAAM,OAAO,KAAK,MAAM,WAAY,cAA+B,kBAAkB;AACrF,UAAI,MAAM;AACR,aAAK,oBAAoB,IAAI;AAAA,MAC/B,OAAO;AACL,aAAK,cAAc,WAAA;AAAA,MACrB;AAAA,IACF,CAAC;AASI,SAAA,gBAAqD,MAAW;AACrE,WAAK,MAAM,YAAY,iBAAiB,cAAc,CAAC,MACrD,KAAK,mBAAmB,GAAG,EAAE,MAAyB,CAAC;AAEzD,WAAK,MAAM,YAAY,iBACrB,iBACA,CAAC,MAAM,KAAK,mBAAmB,GAAG,EAAE,IAAI,GACxC,EAAE,SAAS,MAAM;AAEnB,WAAK,WAAW,YACZ,iBAAiB,MAAM,EACxB,QAAQ,CAAC,SAAS,KAAK,kBAAkB,IAAI,CAAC;AACjD,WAAK,gBAAgB;AAAA,IACvB;AAhBE,SAAK,MAAM,cAAc,IAAI;AAAA,EAC/B;AAAA,EAiBQ,mBAAmB,OAAc,MAAqB;AAC5D,UAAM,eAAe,KAAK,MAAM,WAAY,SAAS,IAAI,IACrD,OACA,MACG,aAAA,EACA,KACC,CAAC,OACC,cAAc,mBAAmB,KAAK,MAAM,WAAY,SAAS,EAAE,CAAC;AAE9E,QAAI,cAAc;AAChB,WAAK,kBAAkB,YAAY;AAAA,IACrC;AAAA,EACF;AAAA,EAEQ,kBAAkB,MAAqB;AAC7C,SAAK,oBAAoB,IAAI;AAC7B,QAAI,CAAC,KAAK,MAAM;AACd,WAAK,wBAAwB,IAAI;AAAA,IACnC;AAAA,EACF;AAAA,EAEQ,oBAAoB,MAAqB;AAC/C,UAAM,YAAY,KAAK,OAAO,WAAW,KAAK,IAAI,KAAK;AACvD,UAAM,oBAAoB,KAAK,mBAAmB,IAAI;AACtD,QAAI,qBAAqB,CAAC,KAAK,WAAW,OAAO,IAAI,SAAS,GAAG;AAC/D,WAAK,WAAW,OAAO,IAAI,SAAS;AACpC,WAAK,MAAM,cAAc,IAAI,sBAAsB,IAAI,CAAC;AAAA,IAC1D,WAAW,CAAC,qBAAqB,KAAK,WAAW,OAAO,IAAI,SAAS,GAAG;AACtE,WAAK,WAAW,OAAO,OAAO,SAAS;AACvC,WAAK,MAAM,cAAc,IAAI,sBAAsB,IAAI,CAAC;AAAA,IAC1D;AAAA,EACF;AAAA,EAEQ,wBAAwB,MAAqB;AACnD,SAAK,cAAc,WAAA;AAOnB,SACG,cAAA,EACA,OAAO,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,EACxC,QAAQ,CAAC,SAAS,KAAK,cAAc,QAAQ,MAAM,EAAE,eAAe,KAAA,CAAM,CAAC;AAAA,EAChF;AAAA,EAEQ,mBAAmB,MAAqB;AAC9C,WAAO,KAAK,OACR,KACG,iBAAA,EACA,KAAK,CAAC,SAAS,EAAE,gBAAgB,oBAAoB,KAAK,mBAAmB,IAAI,CAAC,IACrF,KAAK,cAAA,EAAgB,KAAK,CAAC,SAAQ;AACjC,aAAO,gBAAgB,kBACnB,KAAK,mBAAmB,IAAI,IAC5B,KAAK,aAAa,KAAK,aAAa,CAAC,CAAC,KAAK,aAAa,KAAA;AAAA,IAC9D,CAAC;AAAA,EACP;AACD;"}

package/development/core/controllers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @entrypoint
+ */
+export * from './controllers/property-watcher-controller.ts';
+export * from './controllers/escapable-overlay-controller.ts';
+export * from './controllers/id-reference-controller.ts';
+export * from './controllers/inert-controller.ts';
+export * from './controllers/language-controller.ts';
+export * from './controllers/media-matchers-controller.ts';
+export * from './controllers/slot-state-controller.ts';
+export * from './controllers/overlay-position-controller.ts';
+//# sourceMappingURL=controllers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"controllers.d.ts","sourceRoot":"","sources":["../../../../src/elements/core/controllers.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,8CAA8C,CAAC;AAC7D,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"}