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

package/development/overlay/overlay-base-element.js

@@ -0,0 +1,247 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { isServer } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbOpenCloseBaseElement } from "../core/base-elements.js";
+import { forceType, idReference } from "../core/decorators.js";
+import { SbbScrollHandler } from "../core/dom.js";
+import { SbbNegativeMixin } from "../core/mixins.js";
+import { SbbEscapableOverlayController, SbbInertController, SbbLanguageController } from "../core/controllers.js";
+import { i18nDialog } from "../core/i18n.js";
+import { removeAriaOverlayTriggerAttributes, setAriaOverlayTriggerAttributes } from "../core/overlay.js";
+import { SbbFocusTrapController } from "../core/a11y.js";
+//#region src/elements/overlay/overlay-base-element.ts
+var overlayResultMap = /* @__PURE__ */ new WeakMap();
+var SbbOverlayCloseEvent = class extends CustomEvent {
+	constructor(name, { cancelable, closeAttribute, closeTarget, result }) {
+		super(name, {
+			cancelable,
+			detail: {
+				returnValue: result,
+				closeTarget
+			}
+		});
+		this.result = result ?? (!closeTarget ? null : overlayResultMap.get(closeTarget) ?? (closeTarget.getAttribute(closeAttribute)?.trim() || null));
+		this.closeTarget = closeTarget ?? null;
+	}
+};
+function assignOverlayResult(element, result) {
+	overlayResultMap.set(element, result);
+}
+var overlayRefs = [];
+var SbbOverlayBaseElement = (() => {
+	let _classSuper = SbbNegativeMixin(SbbOpenCloseBaseElement);
+	let _trigger_decorators;
+	let _trigger_initializers = [];
+	let _trigger_extraInitializers = [];
+	let _accessibilityLabel_decorators;
+	let _accessibilityLabel_initializers = [];
+	let _accessibilityLabel_extraInitializers = [];
+	let _skipFocusRestoration_decorators;
+	let _skipFocusRestoration_initializers = [];
+	let _skipFocusRestoration_extraInitializers = [];
+	return class SbbOverlayBaseElement extends _classSuper {
+		constructor() {
+			super(...arguments);
+			this.#trigger_accessor_storage = __runInitializers(this, _trigger_initializers, null);
+			this.#accessibilityLabel_accessor_storage = (__runInitializers(this, _trigger_extraInitializers), __runInitializers(this, _accessibilityLabel_initializers, ""));
+			this.#skipFocusRestoration_accessor_storage = (__runInitializers(this, _accessibilityLabel_extraInitializers), __runInitializers(this, _skipFocusRestoration_initializers, false));
+			this.lastFocusedElement = __runInitializers(this, _skipFocusRestoration_extraInitializers);
+			this.focusTrapController = new SbbFocusTrapController(this);
+			this.scrollHandler = new SbbScrollHandler();
+			this.language = new SbbLanguageController(this);
+			this.inertController = new SbbInertController(this);
+			this.escapableOverlayController = new SbbEscapableOverlayController(this);
+			this._ariaLiveRefToggle = false;
+			this._triggerElement = null;
+		}
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_trigger_decorators = [idReference(), property()];
+			_accessibilityLabel_decorators = [forceType(), property({ attribute: "accessibility-label" })];
+			_skipFocusRestoration_decorators = [forceType(), property({ type: Boolean })];
+			__esDecorate(this, null, _trigger_decorators, {
+				kind: "accessor",
+				name: "trigger",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "trigger" in obj,
+					get: (obj) => obj.trigger,
+					set: (obj, value) => {
+						obj.trigger = value;
+					}
+				},
+				metadata: _metadata
+			}, _trigger_initializers, _trigger_extraInitializers);
+			__esDecorate(this, null, _accessibilityLabel_decorators, {
+				kind: "accessor",
+				name: "accessibilityLabel",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "accessibilityLabel" in obj,
+					get: (obj) => obj.accessibilityLabel,
+					set: (obj, value) => {
+						obj.accessibilityLabel = value;
+					}
+				},
+				metadata: _metadata
+			}, _accessibilityLabel_initializers, _accessibilityLabel_extraInitializers);
+			__esDecorate(this, null, _skipFocusRestoration_decorators, {
+				kind: "accessor",
+				name: "skipFocusRestoration",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "skipFocusRestoration" in obj,
+					get: (obj) => obj.skipFocusRestoration,
+					set: (obj, value) => {
+						obj.skipFocusRestoration = value;
+					}
+				},
+				metadata: _metadata
+			}, _skipFocusRestoration_initializers, _skipFocusRestoration_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		#trigger_accessor_storage;
+		/**
+		* The element that will trigger the menu overlay.
+		*
+		* For attribute usage, provide an id reference.
+		*/
+		get trigger() {
+			return this.#trigger_accessor_storage;
+		}
+		set trigger(value) {
+			this.#trigger_accessor_storage = value;
+		}
+		#accessibilityLabel_accessor_storage;
+		/** This will be forwarded as aria-label to the relevant nested element to describe the purpose of the overlay. */
+		get accessibilityLabel() {
+			return this.#accessibilityLabel_accessor_storage;
+		}
+		set accessibilityLabel(value) {
+			this.#accessibilityLabel_accessor_storage = value;
+		}
+		#skipFocusRestoration_accessor_storage;
+		/**
+		* Whether to skip restoring focus to the previously-focused element when the overlay is closed.
+		* Note that automatic focus restoration is an accessibility feature, and it is recommended that
+		* you provide your own equivalent, if you decide to turn it off.
+		*/
+		get skipFocusRestoration() {
+			return this.#skipFocusRestoration_accessor_storage;
+		}
+		set skipFocusRestoration(value) {
+			this.#skipFocusRestoration_accessor_storage = value;
+		}
+		/** Opens the component. */
+		open() {
+			if (this.state === "opening" || this.state === "opened" || this._hasClosedParent() || !this.dispatchBeforeOpenEvent()) return;
+			this.lastFocusedElement = document.activeElement;
+			this.showPopover?.();
+			this.state = "opening";
+			this._triggerElement?.setAttribute("aria-expanded", "true");
+			overlayRefs.push(this);
+			this.scrollHandler.disableScroll();
+			this.escapableOverlayController.connect();
+			this.attachOpenOverlayEvents();
+			if (this.isZeroAnimationDuration()) this.handleOpening();
+		}
+		close(result, target) {
+			this._close(result, target);
+		}
+		_close(result, target) {
+			if (this.state === "closing" || this.state === "closed") return;
+			this.returnValue = result ?? null;
+			this.overlayCloseElement = target;
+			if (!this.dispatchBeforeCloseEvent()) return;
+			this.state = "closing";
+			this._triggerElement?.setAttribute("aria-expanded", "false");
+			this.removeAriaLiveRefContent();
+			if (this.isZeroAnimationDuration()) this.handleClosing();
+		}
+		/**
+		* Check if there is a parent dialog or overlay in the DOM that is closed.
+		* In this case, the overlay should not be opened because it would break the state.
+		* Not nested but stacked overlays are supported so this logic does not apply in this case.
+		*/
+		_hasClosedParent() {
+			const parentDialog = this.parentElement?.closest("sbb-dialog, sbb-overlay");
+			return parentDialog?.state === "closed" || parentDialog?.state === "closing";
+		}
+		connectedCallback() {
+			this.popover = "manual";
+			super.connectedCallback();
+			if (this.hasUpdated) this._configureTrigger();
+		}
+		_configureTrigger() {
+			if (this.trigger === this._triggerElement) return;
+			this._triggerAbortController?.abort();
+			removeAriaOverlayTriggerAttributes(this._triggerElement);
+			this._triggerElement = this.trigger;
+			if (!this._triggerElement) return;
+			setAriaOverlayTriggerAttributes(this._triggerElement, "dialog", this.id, this.state);
+			this._triggerAbortController = new AbortController();
+			this._triggerElement.addEventListener("click", () => this.open(), { signal: this._triggerAbortController.signal });
+		}
+		firstUpdated(changedProperties) {
+			super.firstUpdated(changedProperties);
+			this._ariaLiveRef = this.shadowRoot.querySelector("sbb-screen-reader-only");
+			this._configureTrigger();
+			if (this.isOpen) setTimeout(() => {
+				this.focusTrapController.focusInitialElement();
+			}, 0);
+		}
+		disconnectedCallback() {
+			super.disconnectedCallback();
+			this.openOverlayController?.abort();
+			this.removeInstanceFromGlobalCollection();
+			this.scrollHandler.enableScroll();
+			this._triggerElement = null;
+			this._triggerAbortController?.abort();
+		}
+		requestUpdate(name, oldValue, options) {
+			super.requestUpdate(name, oldValue, options);
+			if (!isServer && (!name || name === "trigger") && this.hasUpdated) this._configureTrigger();
+		}
+		attachOpenOverlayEvents() {
+			this.openOverlayController = new AbortController();
+			window.addEventListener("keydown", () => {
+				this.removeAriaLiveRefContent();
+			}, { signal: this.openOverlayController.signal });
+			window.addEventListener("click", () => this.removeAriaLiveRefContent(), { signal: this.openOverlayController.signal });
+		}
+		removeInstanceFromGlobalCollection() {
+			const indexInOverlayRefs = overlayRefs.indexOf(this);
+			if (indexInOverlayRefs > -1) overlayRefs.splice(indexInOverlayRefs, 1);
+		}
+		closeOnSbbOverlayCloseClick(event) {
+			const overlayCloseElement = event.composedPath().filter((e) => e instanceof window.HTMLElement).find((target) => (target.hasAttribute(this.closeAttribute) || target.localName === this.closeTag) && !target.hasAttribute("disabled"));
+			if (!overlayCloseElement || overlayCloseElement.closest(this.localName) !== this && !this.shadowRoot?.contains(overlayCloseElement)) return;
+			if (overlayRefs.length) overlayRefs[overlayRefs.length - 1]._close(null, overlayCloseElement);
+		}
+		removeAriaLiveRefContent() {
+			if (!this._ariaLiveRef) return;
+			this._ariaLiveRef.textContent = "";
+		}
+		setAriaLiveRefContent(label) {
+			if (!this._ariaLiveRef) return;
+			this._ariaLiveRefToggle = !this._ariaLiveRefToggle;
+			this._ariaLiveRef.textContent = `${i18nDialog[this.language.current]}${label ? `, ${label}` : ""}${this._ariaLiveRefToggle ? "\xA0" : ""}`;
+		}
+		onOverlayAnimationEnd(event) {
+			if (event.animationName === "open" && this.state === "opening") this.handleOpening();
+			else if (event.animationName === "close" && this.state === "closing") this.handleClosing();
+		}
+	};
+})();
+//#endregion
+export { SbbOverlayBaseElement, SbbOverlayCloseEvent, assignOverlayResult, overlayRefs };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"overlay-base-element.js","names":[],"sources":["../../../../src/elements/overlay/overlay-base-element.ts"],"sourcesContent":["import { isServer, type PropertyDeclaration, type PropertyValues } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { SbbFocusTrapController } from '../core/a11y.ts';\nimport { SbbOpenCloseBaseElement } from '../core/base-elements.ts';\nimport {\n  SbbEscapableOverlayController,\n  SbbInertController,\n  SbbLanguageController,\n} from '../core/controllers.ts';\nimport { forceType, idReference } from '../core/decorators.ts';\nimport { SbbScrollHandler } from '../core/dom.ts';\nimport { i18nDialog } from '../core/i18n.ts';\nimport type { SbbOverlayCloseEventDetails } from '../core/interfaces.ts';\nimport { SbbNegativeMixin } from '../core/mixins.ts';\nimport {\n  removeAriaOverlayTriggerAttributes,\n  setAriaOverlayTriggerAttributes,\n} from '../core/overlay.ts';\nimport type { SbbScreenReaderOnlyElement } from '../screen-reader-only.ts';\n\nconst overlayResultMap = new WeakMap<HTMLElement, any>();\n\nexport class SbbOverlayCloseEvent<T = any> extends CustomEvent<SbbOverlayCloseEventDetails> {\n  /**\n   * The result associated with the closed overlay.\n   * This is either the result assigned to the `closeTarget` via\n   * `assignOverlayResult` / `assignDialogResult` or the value of the\n   * corresponding close attribute on the `closeTarget`\n   * (e.g. sbb-overlay-close=\"my-result\" or sbb-dialog-close=\"my-result\").\n   */\n  public readonly result: T | null;\n\n  /**\n   * The element that was used to close the overlay/dialog, i.e. the element that the\n   * user clicked on that had the close attribute.\n   * Empty if closed programmatically or via Escape press.\n   */\n  public readonly closeTarget: HTMLElement | null;\n\n  public constructor(\n    name: string,\n    {\n      cancelable,\n      closeAttribute,\n      closeTarget,\n      result,\n    }: { cancelable?: boolean; closeAttribute: string; closeTarget?: HTMLElement; result?: any },\n  ) {\n    // TODO: Remove detail and change base class to Event\n    super(name, { cancelable, detail: { returnValue: result, closeTarget } });\n\n    this.result =\n      result ??\n      (!closeTarget\n        ? null\n        : (overlayResultMap.get(closeTarget) ??\n          (closeTarget.getAttribute(closeAttribute)?.trim() || null)));\n    this.closeTarget = closeTarget ?? null;\n  }\n}\n\nexport function assignOverlayResult<T>(element: HTMLElement, result: T): void {\n  overlayResultMap.set(element, result);\n}\n\n// A global collection of existing overlays.\nexport const overlayRefs: SbbOverlayBaseElement[] = [];\n\nexport abstract class SbbOverlayBaseElement extends SbbNegativeMixin(SbbOpenCloseBaseElement) {\n  /**\n   * The element that will trigger the menu overlay.\n   *\n   * For attribute usage, provide an id reference.\n   */\n  @idReference()\n  @property()\n  public accessor trigger: HTMLElement | null = null;\n\n  /** This will be forwarded as aria-label to the relevant nested element to describe the purpose of the overlay. */\n  @forceType()\n  @property({ attribute: 'accessibility-label' })\n  public accessor accessibilityLabel: string = '';\n\n  /**\n   * Whether to skip restoring focus to the previously-focused element when the overlay is closed.\n   * Note that automatic focus restoration is an accessibility feature, and it is recommended that\n   * you provide your own equivalent, if you decide to turn it off.\n   */\n  @forceType()\n  @property({ type: Boolean })\n  public accessor skipFocusRestoration: boolean = false;\n\n  // The last element which had focus before the component was opened.\n  protected lastFocusedElement?: HTMLElement;\n  // TODO: rename to lastClosedTarget\n  protected overlayCloseElement?: HTMLElement;\n  protected openOverlayController?: AbortController;\n  protected focusTrapController = new SbbFocusTrapController(this);\n  protected scrollHandler = new SbbScrollHandler();\n  // TODO: rename to lastResult\n  protected returnValue: any;\n  protected language = new SbbLanguageController(this);\n  protected inertController = new SbbInertController(this);\n  protected escapableOverlayController = new SbbEscapableOverlayController(this);\n\n  private _ariaLiveRefToggle = false;\n  private _ariaLiveRef?: SbbScreenReaderOnlyElement;\n  private _triggerElement: HTMLElement | null = null;\n  private _triggerAbortController?: AbortController;\n\n  protected abstract closeAttribute: string;\n  protected closeTag?: string;\n  protected abstract handleOpening(): void;\n  protected abstract handleClosing(): void;\n  protected abstract isZeroAnimationDuration(): boolean;\n  protected abstract override dispatchBeforeCloseEvent(\n    detail?: SbbOverlayCloseEventDetails,\n  ): boolean;\n\n  protected abstract override dispatchCloseEvent(detail?: SbbOverlayCloseEventDetails): boolean;\n\n  /** Opens the component. */\n  public open(): void {\n    if (\n      this.state === 'opening' ||\n      this.state === 'opened' ||\n      this._hasClosedParent() ||\n      !this.dispatchBeforeOpenEvent()\n    ) {\n      return;\n    }\n\n    this.lastFocusedElement = document.activeElement as HTMLElement;\n\n    this.showPopover?.();\n    this.state = 'opening';\n    this._triggerElement?.setAttribute('aria-expanded', 'true');\n\n    // Add this overlay to the global collection\n    overlayRefs.push(this);\n\n    this.scrollHandler.disableScroll();\n    this.escapableOverlayController.connect();\n    this.attachOpenOverlayEvents();\n\n    // If the animation duration is zero, the animationend event is not always fired reliably.\n    // In this case we directly set the `opened` state.\n    if (this.isZeroAnimationDuration()) {\n      this.handleOpening();\n    }\n  }\n\n  /** Closes the component. */\n  public close(result?: any): void;\n  /** @deprecated */\n  public close(result?: any, target?: HTMLElement): void;\n  public close(result?: any, target?: HTMLElement): void {\n    this._close(result, target);\n  }\n\n  private _close(result: any, target: HTMLElement | undefined): void {\n    if (this.state === 'closing' || this.state === 'closed') {\n      return;\n    }\n\n    this.returnValue = result ?? null;\n    this.overlayCloseElement = target;\n    if (!this.dispatchBeforeCloseEvent()) {\n      return;\n    }\n    this.state = 'closing';\n    this._triggerElement?.setAttribute('aria-expanded', 'false');\n    this.removeAriaLiveRefContent();\n\n    // If the animation duration is zero, the animationend event is not always fired reliably.\n    // In this case we directly set the `closed` state.\n    if (this.isZeroAnimationDuration()) {\n      this.handleClosing();\n    }\n  }\n\n  /**\n   * Check if there is a parent dialog or overlay in the DOM that is closed.\n   * In this case, the overlay should not be opened because it would break the state.\n   * Not nested but stacked overlays are supported so this logic does not apply in this case.\n   */\n  private _hasClosedParent(): boolean {\n    const parentDialog =\n      this.parentElement?.closest<SbbOverlayBaseElement>('sbb-dialog, sbb-overlay');\n\n    return (parentDialog?.state === 'closed' || parentDialog?.state === 'closing') ?? false;\n  }\n\n  public override connectedCallback(): void {\n    this.popover = 'manual';\n    super.connectedCallback();\n    if (this.hasUpdated) {\n      this._configureTrigger();\n    }\n  }\n\n  // Check if the trigger is valid and attach click event listeners.\n  private _configureTrigger(): void {\n    if (this.trigger === this._triggerElement) {\n      return;\n    }\n\n    this._triggerAbortController?.abort();\n    removeAriaOverlayTriggerAttributes(this._triggerElement);\n    this._triggerElement = this.trigger;\n\n    if (!this._triggerElement) {\n      return;\n    }\n\n    setAriaOverlayTriggerAttributes(this._triggerElement, 'dialog', this.id, this.state);\n    this._triggerAbortController = new AbortController();\n    this._triggerElement.addEventListener('click', () => this.open(), {\n      signal: this._triggerAbortController.signal,\n    });\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n\n    this._ariaLiveRef =\n      this.shadowRoot!.querySelector<SbbScreenReaderOnlyElement>('sbb-screen-reader-only')!;\n    this._configureTrigger();\n\n    // If the component is already open on firstUpdate, fix the focus\n    if (this.isOpen) {\n      // TODO: find better solution\n      // Problem: content's shadow DOM not yet ready, so focusing is impossible.\n      setTimeout(() => {\n        this.focusTrapController.focusInitialElement();\n      }, 0);\n    }\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this.openOverlayController?.abort();\n    this.removeInstanceFromGlobalCollection();\n    this.scrollHandler.enableScroll();\n    this._triggerElement = null;\n    this._triggerAbortController?.abort();\n  }\n\n  public override requestUpdate(\n    name?: PropertyKey,\n    oldValue?: unknown,\n    options?: PropertyDeclaration,\n  ): void {\n    super.requestUpdate(name, oldValue, options);\n\n    if (!isServer && (!name || name === 'trigger') && this.hasUpdated) {\n      this._configureTrigger();\n    }\n  }\n\n  protected attachOpenOverlayEvents(): void {\n    this.openOverlayController = new AbortController();\n    // Remove overlay label as soon as it is not needed any more to prevent accessing it with browse mode.\n    window.addEventListener(\n      'keydown',\n      () => {\n        this.removeAriaLiveRefContent();\n      },\n      {\n        signal: this.openOverlayController.signal,\n      },\n    );\n    window.addEventListener('click', () => this.removeAriaLiveRefContent(), {\n      signal: this.openOverlayController.signal,\n    });\n  }\n\n  protected removeInstanceFromGlobalCollection(): void {\n    const indexInOverlayRefs = overlayRefs.indexOf(this as SbbOverlayBaseElement);\n    if (indexInOverlayRefs > -1) {\n      overlayRefs.splice(indexInOverlayRefs, 1);\n    }\n  }\n\n  // Close the component on click of any element that has the `closeAttribute` attribute.\n  protected closeOnSbbOverlayCloseClick(event: Event): void {\n    const overlayCloseElement = event\n      .composedPath()\n      .filter((e): e is HTMLElement => e instanceof window.HTMLElement)\n      .find(\n        (target) =>\n          (target.hasAttribute(this.closeAttribute) || target.localName === this.closeTag) &&\n          !target.hasAttribute('disabled'),\n      );\n\n    if (\n      !overlayCloseElement ||\n      (overlayCloseElement.closest(this.localName) !== this &&\n        !this.shadowRoot?.contains(overlayCloseElement))\n    ) {\n      return;\n    }\n\n    if (overlayRefs.length) {\n      overlayRefs[overlayRefs.length - 1]._close(null, overlayCloseElement);\n    }\n  }\n\n  protected removeAriaLiveRefContent(): void {\n    if (!this._ariaLiveRef) {\n      return;\n    }\n    this._ariaLiveRef.textContent = '';\n  }\n\n  protected setAriaLiveRefContent(label?: string): void {\n    if (!this._ariaLiveRef) {\n      return;\n    }\n\n    this._ariaLiveRefToggle = !this._ariaLiveRefToggle;\n\n    // If the text content remains the same, on VoiceOver the aria-live region is not announced a second time.\n    // In order to support reading on every opening, we toggle an invisible space.\n    this._ariaLiveRef.textContent = `${i18nDialog[this.language.current]}${\n      label ? `, ${label}` : ''\n    }${this._ariaLiveRefToggle ? ' ' : ''}`;\n  }\n\n  // Wait for dialog transition to complete.\n  // In rare cases, it can be that the animationEnd event is triggered twice.\n  // To avoid entering a corrupt state, exit when state is not expected.\n  protected onOverlayAnimationEnd(event: AnimationEvent): void {\n    if (event.animationName === 'open' && this.state === 'opening') {\n      this.handleOpening();\n    } else if (event.animationName === 'close' && this.state === 'closing') {\n      this.handleClosing();\n    }\n  }\n}\n"],"mappings":"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"}

package/development/overlay/overlay.component.d.ts

@@ -0,0 +1,44 @@
+import { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';
+import { SbbOverlayCloseEventDetails } from '../core/interfaces.ts';
+import { SbbOverlayBaseElement } from './overlay-base-element.ts';
+/**
+ * It displays an interactive overlay element.
+ *
+ * @slot - Use the unnamed slot to provide a content for the overlay.
+ * @cssprop [--sbb-overlay-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,
+ * the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the
+ * component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.
+ */
+export declare class SbbOverlayElement extends SbbOverlayBaseElement {
+    static readonly elementName: string;
+    static styles: CSSResultGroup;
+    static readonly events: {
+        readonly beforeopen: "beforeopen";
+        readonly open: "open";
+        readonly beforeclose: "beforeclose";
+        readonly close: "close";
+    };
+    /**
+     * Whether to allow the overlay content to stretch to full width.
+     * By default, the content has the appropriate page size.
+     */
+    accessor expanded: boolean;
+    /** This will be forwarded as aria-label to the close button element. */
+    accessor accessibilityCloseLabel: string;
+    protected closeAttribute: string;
+    private _overlayContentElement;
+    connectedCallback(): void;
+    protected firstUpdated(changedProperties: PropertyValues<this>): void;
+    protected isZeroAnimationDuration(): boolean;
+    protected handleOpening(): void;
+    protected handleClosing(): void;
+    protected dispatchBeforeCloseEvent(_detail?: SbbOverlayCloseEventDetails): boolean;
+    protected dispatchCloseEvent(_detail?: SbbOverlayCloseEventDetails): boolean;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-overlay': SbbOverlayElement;
+    }
+}
+//# sourceMappingURL=overlay.component.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.component.d.ts","sourceRoot":"","sources":["../../../../src/elements/overlay/overlay.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAU/F,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AAGzE,OAAO,EAEL,qBAAqB,EAEtB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,iBAAiB,CAAC;AACzB,OAAO,0BAA0B,CAAC;AAQlC;;;;;;;GAOG;AACH,qBAAa,iBAAkB,SAAQ,qBAAqB;IAC1D,gBAAgC,WAAW,EAAE,MAAM,CAAiB;IACpE,OAAuB,MAAM,EAAE,cAAc,CAAuC;IAGpF,gBAAgC,MAAM;;;;;MAK3B;IAEX;;;OAGG;IACH,SAEgB,QAAQ,EAAE,OAAO,CAAS;IAE1C,wEAAwE;IACxE,SAEgB,uBAAuB,EAAE,MAAM,CAAM;IAErD,SAAS,CAAC,cAAc,EAAE,MAAM,CAAuB;IACvD,OAAO,CAAC,sBAAsB,CAA4B;IAE1C,iBAAiB,IAAI,IAAI;cAMtB,YAAY,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;IAS9E,SAAS,CAAC,uBAAuB,IAAI,OAAO;IAI5C,SAAS,CAAC,aAAa,IAAI,IAAI;cAUZ,aAAa,IAAI,IAAI;cAwBrB,wBAAwB,CAAC,OAAO,CAAC,EAAE,2BAA2B,GAAG,OAAO;cAaxE,kBAAkB,CAAC,OAAO,CAAC,EAAE,2BAA2B,GAAG,OAAO;cAWlE,MAAM,IAAI,cAAc;CAuC5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,aAAa,EAAE,iBAAiB,CAAC;KAClC;CACF"}

package/development/overlay/overlay.component.js

@@ -0,0 +1,2 @@
+import { t as SbbOverlayElement } from "../overlay.component-M0JuSq4C.js";
+export { SbbOverlayElement };

package/development/overlay.component-M0JuSq4C.js

@@ -0,0 +1,216 @@
+import { SbbOverlayBaseElement, SbbOverlayCloseEvent, overlayRefs } from "./overlay/overlay-base-element.js";
+import { __esDecorate, __runInitializers } from "tslib";
+import { unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
+import { forceType } from "./core/decorators.js";
+import { isZeroAnimationDuration } from "./core/dom.js";
+import { forwardEvent } from "./core/eventing.js";
+import { boxSizingStyles } from "./core/styles.js";
+import { html as html$1 } from "lit/static-html.js";
+import { SbbSecondaryButtonElement, SbbTransparentButtonElement } from "./button.pure.js";
+import { i18nCloseDialog } from "./core/i18n.js";
+import { ref } from "lit/directives/ref.js";
+import "./screen-reader-only.js";
+import "./container.js";
+//#region src/elements/overlay/overlay.scss?inline
+var overlay_default = ":host {\n  --sbb-scrollbar-thumb-width: 0.125rem;\n  --sbb-scrollbar-thumb-width-hover: 0.25rem;\n  --sbb-scrollbar-width-firefox: thin;\n  --sbb-scrollbar-color: color-mix(in srgb, var(--sbb-color-black) 30%, transparent);\n  --sbb-scrollbar-color: light-dark(\n    color-mix(in srgb, var(--sbb-color-black) 30%, transparent),\n    color-mix(in srgb, var(--sbb-color-white) 30%, transparent)\n  );\n  --sbb-scrollbar-color-hover: color-mix(in srgb, var(--sbb-color-black) 60%, transparent);\n  --sbb-scrollbar-color-hover: light-dark(\n    color-mix(in srgb, var(--sbb-color-black) 60%, transparent),\n    color-mix(in srgb, var(--sbb-color-white) 60%, transparent)\n  );\n  --sbb-scrollbar-track-color: transparent;\n  --_sbb-overlay-padding-block: calc(\n    var(--sbb-spacing-fixed-14x) + var(--sbb-spacing-responsive-l)\n  );\n  --sbb-overlay-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-6x)\n  );\n  display: var(--sbb-overlay-display);\n  position: fixed;\n  inset: var(--sbb-overlay-inset);\n  z-index: var(--sbb-overlay-z-index, var(--sbb-overlay-default-z-index));\n}\n\n:host(:is(:is(:state(state-opening),[state--state-opening]), :is(:state(state-opened),[state--state-opened]), :is(:state(state-closing),[state--state-closing]))) {\n  --sbb-overlay-display: block;\n  --sbb-overlay-container-display: flex;\n}\n\n:host(:is(:is(:state(state-opening),[state--state-opening]), :is(:state(state-opened),[state--state-opened]))) {\n  --sbb-overlay-pointer-events: all;\n}\n\n:host([negative]) {\n  --sbb-scrollbar-color: color-mix(in srgb, var(--sbb-color-white) 30%, transparent);\n  --sbb-scrollbar-color-hover: color-mix(in srgb, var(--sbb-color-white) 60%, transparent);\n  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);\n  --sbb-overlay-color: var(--sbb-color-1-negative);\n  --sbb-overlay-background-color: var(--sbb-background-color-3-negative);\n}\n\n:host(:not(:is(:state(state-closed),[state--state-closed]))) {\n  --sbb-overlay-inset: 0;\n}\n\n.sbb-overlay__container {\n  background-color: var(--sbb-overlay-background-color);\n  pointer-events: var(--sbb-overlay-pointer-events);\n  display: var(--sbb-overlay-container-display);\n  align-items: center;\n  position: fixed;\n  inset: var(--sbb-overlay-inset);\n}\n:host(:is(:is(:state(state-opening),[state--state-opening]), :is(:state(state-opened),[state--state-opened]), :is(:state(state-closing),[state--state-closing]))) .sbb-overlay__container {\n  animation-name: open;\n  animation-duration: var(--sbb-overlay-animation-duration);\n  animation-timing-function: var(--sbb-overlay-animation-easing);\n}\n:host(:is(:state(state-closing),[state--state-closing])) .sbb-overlay__container {\n  pointer-events: none;\n  animation-name: close;\n}\n\n.sbb-overlay {\n  position: absolute;\n  inset-inline: 0;\n  margin: auto;\n  padding: 0;\n  border: none;\n  height: var(--sbb-overlay-height);\n  overflow: auto;\n  color: var(--sbb-overlay-color);\n}\n:host(:is(:is(:state(state-opening),[state--state-opening]), :is(:state(state-opened),[state--state-opened]), :is(:state(state-closing),[state--state-closing]))) .sbb-overlay {\n  animation-name: open-move-in;\n  animation-duration: var(--sbb-overlay-animation-duration);\n  animation-timing-function: var(--sbb-overlay-animation-easing);\n}\n:host(:is(:state(state-closing),[state--state-closing])) .sbb-overlay {\n  animation-name: close-move-out;\n}\n\n.sbb-overlay__wrapper {\n  display: flex;\n  flex-direction: column;\n  width: 100%;\n  height: var(--sbb-overlay-height);\n  outline: none;\n  position: fixed;\n}\n@media (min-width: calc(64rem)) {\n  .sbb-overlay__wrapper {\n    position: sticky;\n    inset-block-start: 0;\n    height: auto;\n  }\n}\n\n.sbb-overlay__header {\n  position: absolute;\n  inset-inline-start: 0;\n  display: flex;\n  pointer-events: none;\n  align-items: start;\n  justify-content: space-between;\n  width: 100%;\n  padding: var(--sbb-spacing-responsive-xs);\n  padding-block-end: 0;\n  z-index: 1;\n}\n.sbb-overlay__header * {\n  pointer-events: all;\n}\n\n.sbb-overlay__close {\n  margin-inline-start: auto;\n}\n\n.sbb-overlay__content {\n  --sbb-scrollbar-width: var(--sbb-spacing-fixed-3x);\n}\n.sbb-overlay__content::-webkit-scrollbar {\n  width: var(--sbb-scrollbar-width);\n  height: var(--sbb-scrollbar-width);\n  background-color: var(--sbb-scrollbar-track-color, transparent);\n}\n.sbb-overlay__content::-webkit-scrollbar-corner {\n  background-color: var(--sbb-scrollbar-track-color, transparent);\n}\n.sbb-overlay__content::-webkit-scrollbar-thumb {\n  background-color: var(--sbb-scrollbar-color, currentcolor);\n  border: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width))) solid transparent;\n  border-radius: var(--sbb-border-radius-4x);\n  background-clip: padding-box;\n}\n.sbb-overlay__content::-webkit-scrollbar-thumb:hover {\n  background-color: var(--sbb-scrollbar-color-hover, currentcolor);\n  border-width: calc(0.5 * (var(--sbb-scrollbar-width) - var(--sbb-scrollbar-thumb-width-hover)));\n}\n.sbb-overlay__content::-webkit-scrollbar-button, .sbb-overlay__content::-webkit-scrollbar-corner {\n  display: none;\n}\n@supports not selector(::-webkit-scrollbar) {\n  .sbb-overlay__content {\n    scrollbar-width: var(--sbb-scrollbar-width-firefox);\n    scrollbar-color: var(--sbb-scrollbar-color, currentcolor) var(--sbb-scrollbar-track-color, transparent);\n  }\n}\n.sbb-overlay__content {\n  height: 100vh;\n  overflow: auto;\n  -webkit-overflow-scrolling: touch;\n}\n\n.sbb-overlay__content-container {\n  padding-block: var(--_sbb-overlay-padding-block);\n}\n\n@keyframes open {\n  from {\n    opacity: 0;\n  }\n  to {\n    opacity: 1;\n  }\n}\n@keyframes open-move-in {\n  from {\n    transform: translateY(var(--sbb-spacing-fixed-4x));\n  }\n  to {\n    transform: translateY(0%);\n  }\n}\n@keyframes close {\n  from {\n    opacity: 1;\n  }\n  to {\n    opacity: 0;\n  }\n}\n@keyframes close-move-out {\n  from {\n    transform: translateY(0%);\n  }\n  to {\n    transform: translateY(var(--sbb-spacing-fixed-4x));\n  }\n}";
+//#endregion
+//#region src/elements/overlay/overlay.component.ts
+SbbSecondaryButtonElement.define();
+SbbTransparentButtonElement.define();
+var nextId = 0;
+/**
+* It displays an interactive overlay element.
+*
+* @slot - Use the unnamed slot to provide a content for the overlay.
+* @cssprop [--sbb-overlay-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,
+* the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the
+* component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.
+*/
+var SbbOverlayElement = (() => {
+	let _classSuper = SbbOverlayBaseElement;
+	let _expanded_decorators;
+	let _expanded_initializers = [];
+	let _expanded_extraInitializers = [];
+	let _accessibilityCloseLabel_decorators;
+	let _accessibilityCloseLabel_initializers = [];
+	let _accessibilityCloseLabel_extraInitializers = [];
+	return class SbbOverlayElement extends _classSuper {
+		constructor() {
+			super(...arguments);
+			this.#expanded_accessor_storage = __runInitializers(this, _expanded_initializers, false);
+			this.#accessibilityCloseLabel_accessor_storage = (__runInitializers(this, _expanded_extraInitializers), __runInitializers(this, _accessibilityCloseLabel_initializers, ""));
+			this.closeAttribute = (__runInitializers(this, _accessibilityCloseLabel_extraInitializers), "sbb-overlay-close");
+			this._overlayContentElement = null;
+		}
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_expanded_decorators = [forceType(), property({
+				reflect: true,
+				type: Boolean
+			})];
+			_accessibilityCloseLabel_decorators = [forceType(), property({ attribute: "accessibility-close-label" })];
+			__esDecorate(this, null, _expanded_decorators, {
+				kind: "accessor",
+				name: "expanded",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "expanded" in obj,
+					get: (obj) => obj.expanded,
+					set: (obj, value) => {
+						obj.expanded = value;
+					}
+				},
+				metadata: _metadata
+			}, _expanded_initializers, _expanded_extraInitializers);
+			__esDecorate(this, null, _accessibilityCloseLabel_decorators, {
+				kind: "accessor",
+				name: "accessibilityCloseLabel",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "accessibilityCloseLabel" in obj,
+					get: (obj) => obj.accessibilityCloseLabel,
+					set: (obj, value) => {
+						obj.accessibilityCloseLabel = value;
+					}
+				},
+				metadata: _metadata
+			}, _accessibilityCloseLabel_initializers, _accessibilityCloseLabel_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-overlay";
+		}
+		static {
+			this.styles = [boxSizingStyles, unsafeCSS(overlay_default)];
+		}
+		static {
+			this.events = {
+				beforeopen: "beforeopen",
+				open: "open",
+				beforeclose: "beforeclose",
+				close: "close"
+			};
+		}
+		#expanded_accessor_storage;
+		/**
+		* Whether to allow the overlay content to stretch to full width.
+		* By default, the content has the appropriate page size.
+		*/
+		get expanded() {
+			return this.#expanded_accessor_storage;
+		}
+		set expanded(value) {
+			this.#expanded_accessor_storage = value;
+		}
+		#accessibilityCloseLabel_accessor_storage;
+		/** This will be forwarded as aria-label to the close button element. */
+		get accessibilityCloseLabel() {
+			return this.#accessibilityCloseLabel_accessor_storage;
+		}
+		set accessibilityCloseLabel(value) {
+			this.#accessibilityCloseLabel_accessor_storage = value;
+		}
+		connectedCallback() {
+			this.id ||= `sbb-overlay-${nextId++}`;
+			super.connectedCallback();
+		}
+		firstUpdated(changedProperties) {
+			super.firstUpdated(changedProperties);
+			if (this.isOpen) this.setAriaLiveRefContent();
+		}
+		isZeroAnimationDuration() {
+			return isZeroAnimationDuration(this, "--sbb-overlay-animation-duration");
+		}
+		handleOpening() {
+			this.state = "opened";
+			this.inertController.activate();
+			this.focusTrapController.focusInitialElement();
+			setTimeout(() => this.setAriaLiveRefContent(this.accessibilityLabel));
+			this.focusTrapController.enabled = true;
+			this.dispatchOpenEvent();
+		}
+		handleClosing() {
+			this._overlayContentElement?.scrollTo(0, 0);
+			this.state = "closed";
+			this.hidePopover?.();
+			this.inertController.deactivate();
+			if (!this.skipFocusRestoration) this.lastFocusedElement?.focus();
+			this.openOverlayController?.abort();
+			this.focusTrapController.enabled = false;
+			this.removeInstanceFromGlobalCollection();
+			if (!overlayRefs.length) this.scrollHandler.enableScroll();
+			this.escapableOverlayController.disconnect();
+			this.dispatchCloseEvent({
+				returnValue: this.returnValue,
+				closeTarget: this.overlayCloseElement
+			});
+		}
+		dispatchBeforeCloseEvent(_detail) {
+			/** @type {SbbOverlayCloseEvent} Emits whenever the component begins the closing transition. Can be canceled. */
+			return this.dispatchEvent(new SbbOverlayCloseEvent("beforeclose", {
+				cancelable: true,
+				closeAttribute: this.closeAttribute,
+				closeTarget: this.overlayCloseElement,
+				result: this.returnValue
+			}));
+		}
+		dispatchCloseEvent(_detail) {
+			/** @type {SbbOverlayCloseEvent} Emits whenever the component is closed. */
+			return this.dispatchEvent(new SbbOverlayCloseEvent("close", {
+				closeAttribute: this.closeAttribute,
+				closeTarget: this.overlayCloseElement,
+				result: this.returnValue
+			}));
+		}
+		render() {
+			return html$1`
+      <div class="sbb-overlay__container" @animationend=${this.onOverlayAnimationEnd}>
+        <div class="sbb-overlay">
+          <div
+            @click=${(event) => this.closeOnSbbOverlayCloseClick(event)}
+            class="sbb-overlay__wrapper"
+          >
+            <div class="sbb-overlay__header">
+              <sbb-secondary-button
+                class="sbb-overlay__close"
+                aria-label="${this.accessibilityCloseLabel || i18nCloseDialog[this.language.current]}"
+                ?negative=${this.negative}
+                size="m"
+                type="button"
+                icon-name="cross-small"
+                sbb-overlay-close
+              ></sbb-secondary-button>
+            </div>
+            <div
+              class="sbb-overlay__content"
+              ${ref((el) => this._overlayContentElement = el)}
+              @scroll=${(e) => forwardEvent(e, document)}
+            >
+              <sbb-container
+                class="sbb-overlay__content-container"
+                ?expanded=${this.expanded}
+                color="transparent"
+              >
+                <slot></slot>
+              </sbb-container>
+            </div>
+          </div>
+        </div>
+      </div>
+      <sbb-screen-reader-only aria-live="polite"></sbb-screen-reader-only>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbOverlayElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"overlay.component-M0JuSq4C.js","names":[],"sources":["../../../src/elements/overlay/overlay.scss?inline","../../../src/elements/overlay/overlay.component.ts"],"sourcesContent":["@use '../core/styles' as sbb;\n\n:host {\n  @include sbb.scrollbar-variables;\n\n  --_sbb-overlay-padding-block: calc(\n    var(--sbb-spacing-fixed-14x) + var(--sbb-spacing-responsive-l)\n  );\n  --sbb-overlay-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-6x)\n  );\n\n  display: var(--sbb-overlay-display);\n  position: fixed;\n  inset: var(--sbb-overlay-inset);\n  z-index: var(--sbb-overlay-z-index, var(--sbb-overlay-default-z-index));\n}\n\n:host(:is(:state(state-opening), :state(state-opened), :state(state-closing))) {\n  --sbb-overlay-display: block;\n  --sbb-overlay-container-display: flex;\n}\n\n:host(:is(:state(state-opening), :state(state-opened))) {\n  --sbb-overlay-pointer-events: all;\n}\n\n:host([negative]) {\n  @include sbb.scrollbar-variables--color-negative;\n\n  --sbb-focus-outline-color: var(--sbb-focus-outline-color-dark);\n  --sbb-overlay-color: var(--sbb-color-1-negative);\n  --sbb-overlay-background-color: var(--sbb-background-color-3-negative);\n}\n\n:host(:not(:state(state-closed))) {\n  --sbb-overlay-inset: 0;\n}\n\n.sbb-overlay__container {\n  background-color: var(--sbb-overlay-background-color);\n  pointer-events: var(--sbb-overlay-pointer-events);\n  display: var(--sbb-overlay-container-display);\n  align-items: center;\n  position: fixed;\n  inset: var(--sbb-overlay-inset);\n\n  :host(:is(:state(state-opening), :state(state-opened), :state(state-closing))) & {\n    animation: {\n      name: open;\n      duration: var(--sbb-overlay-animation-duration);\n      timing-function: var(--sbb-overlay-animation-easing);\n    }\n  }\n\n  :host(:state(state-closing)) & {\n    pointer-events: none;\n    animation-name: close;\n  }\n}\n\n.sbb-overlay {\n  position: absolute;\n  inset-inline: 0;\n  margin: auto;\n  padding: 0;\n  border: none;\n  height: var(--sbb-overlay-height);\n  overflow: auto;\n  color: var(--sbb-overlay-color);\n\n  :host(:is(:state(state-opening), :state(state-opened), :state(state-closing))) & {\n    animation: {\n      name: open-move-in;\n      duration: var(--sbb-overlay-animation-duration);\n      timing-function: var(--sbb-overlay-animation-easing);\n    }\n  }\n\n  :host(:state(state-closing)) & {\n    animation-name: close-move-out;\n  }\n}\n\n.sbb-overlay__wrapper {\n  display: flex;\n  flex-direction: column;\n  width: 100%;\n  height: var(--sbb-overlay-height);\n  outline: none;\n  position: fixed;\n\n  @include sbb.mq($from: large) {\n    position: sticky;\n    inset-block-start: 0;\n    height: auto;\n  }\n}\n\n.sbb-overlay__header {\n  position: absolute;\n  inset-inline-start: 0;\n  display: flex;\n  pointer-events: none;\n  align-items: start;\n  justify-content: space-between;\n  width: 100%;\n  padding: var(--sbb-spacing-responsive-xs);\n  padding-block-end: 0;\n  z-index: 1;\n\n  * {\n    pointer-events: all;\n  }\n}\n\n.sbb-overlay__close {\n  margin-inline-start: auto;\n}\n\n.sbb-overlay__content {\n  @include sbb.scrollbar-rules;\n\n  height: 100vh;\n  overflow: auto;\n  -webkit-overflow-scrolling: touch;\n}\n\n.sbb-overlay__content-container {\n  padding-block: var(--_sbb-overlay-padding-block);\n}\n\n// It is necessary to use animations with keyframes instead of transitions in order not to alter\n// the default `display: block` of the modal otherwise it causes several problems,\n// especially for accessibility.\n@keyframes open {\n  from {\n    opacity: 0;\n  }\n\n  to {\n    opacity: 1;\n  }\n}\n\n@keyframes open-move-in {\n  from {\n    transform: translateY(var(--sbb-spacing-fixed-4x));\n  }\n\n  to {\n    transform: translateY(0%);\n  }\n}\n\n@keyframes close {\n  from {\n    opacity: 1;\n  }\n\n  to {\n    opacity: 0;\n  }\n}\n\n@keyframes close-move-out {\n  from {\n    transform: translateY(0%);\n  }\n\n  to {\n    transform: translateY(var(--sbb-spacing-fixed-4x));\n  }\n}\n","import { unsafeCSS, type CSSResultGroup, type PropertyValues, type TemplateResult } from 'lit';\nimport { property } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\nimport { html } from 'lit/static-html.js';\n\nimport { SbbSecondaryButtonElement, SbbTransparentButtonElement } from '../button.pure.ts';\nimport { forceType } from '../core/decorators.ts';\nimport { isZeroAnimationDuration } from '../core/dom.ts';\nimport { forwardEvent } from '../core/eventing.ts';\nimport { i18nCloseDialog } from '../core/i18n.ts';\nimport type { SbbOverlayCloseEventDetails } from '../core/interfaces.ts';\nimport { boxSizingStyles } from '../core/styles.ts';\n\nimport {\n  overlayRefs,\n  SbbOverlayBaseElement,\n  SbbOverlayCloseEvent,\n} from './overlay-base-element.ts';\nimport style from './overlay.scss?inline';\n\nimport '../container.ts';\nimport '../screen-reader-only.ts';\n\n// TODO(breaking-change): Remove call to define.\nSbbSecondaryButtonElement.define();\nSbbTransparentButtonElement.define();\n\nlet nextId = 0;\n\n/**\n * It displays an interactive overlay element.\n *\n * @slot - Use the unnamed slot to provide a content for the overlay.\n * @cssprop [--sbb-overlay-z-index=var(--sbb-overlay-default-z-index)] - To specify a custom stack order,\n * the `z-index` can be overridden by defining this CSS variable. The default `z-index` of the\n * component is set to `var(--sbb-overlay-default-z-index)` with a value of `1000`.\n */\nexport class SbbOverlayElement extends SbbOverlayBaseElement {\n  public static override readonly elementName: string = 'sbb-overlay';\n  public static override styles: CSSResultGroup = [boxSizingStyles, unsafeCSS(style)];\n\n  // TODO: fix using ...super.events requires: https://github.com/sbb-design-systems/lyne-components/issues/2600\n  public static override readonly events = {\n    beforeopen: 'beforeopen',\n    open: 'open',\n    beforeclose: 'beforeclose',\n    close: 'close',\n  } as const;\n\n  /**\n   * Whether to allow the overlay content to stretch to full width.\n   * By default, the content has the appropriate page size.\n   */\n  @forceType()\n  @property({ reflect: true, type: Boolean })\n  public accessor expanded: boolean = false;\n\n  /** This will be forwarded as aria-label to the close button element. */\n  @forceType()\n  @property({ attribute: 'accessibility-close-label' })\n  public accessor accessibilityCloseLabel: string = '';\n\n  protected closeAttribute: string = 'sbb-overlay-close';\n  private _overlayContentElement: HTMLElement | null = null;\n\n  public override connectedCallback(): void {\n    this.id ||= `sbb-overlay-${nextId++}`;\n\n    super.connectedCallback();\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n\n    // If the component is already open on firstUpdate, announce the title\n    if (this.isOpen) {\n      this.setAriaLiveRefContent();\n    }\n  }\n\n  protected isZeroAnimationDuration(): boolean {\n    return isZeroAnimationDuration(this, '--sbb-overlay-animation-duration');\n  }\n\n  protected handleOpening(): void {\n    this.state = 'opened';\n    this.inertController.activate();\n    this.focusTrapController.focusInitialElement();\n    // Use timeout to read label after focused element\n    setTimeout(() => this.setAriaLiveRefContent(this.accessibilityLabel));\n    this.focusTrapController.enabled = true;\n    this.dispatchOpenEvent();\n  }\n\n  protected override handleClosing(): void {\n    this._overlayContentElement?.scrollTo(0, 0);\n    this.state = 'closed';\n    this.hidePopover?.();\n    this.inertController.deactivate();\n    if (!this.skipFocusRestoration) {\n      // Manually focus last focused element\n      this.lastFocusedElement?.focus();\n    }\n    this.openOverlayController?.abort();\n    this.focusTrapController.enabled = false;\n    this.removeInstanceFromGlobalCollection();\n    // Enable scrolling for content below the overlay if no overlay is open\n    if (!overlayRefs.length) {\n      this.scrollHandler.enableScroll();\n    }\n    this.escapableOverlayController.disconnect();\n    this.dispatchCloseEvent({\n      returnValue: this.returnValue,\n      closeTarget: this.overlayCloseElement,\n    });\n  }\n\n  // TODO: remove parameter `detail`\n  protected override dispatchBeforeCloseEvent(_detail?: SbbOverlayCloseEventDetails): boolean {\n    /** @type {SbbOverlayCloseEvent} Emits whenever the component begins the closing transition. Can be canceled. */\n    return this.dispatchEvent(\n      new SbbOverlayCloseEvent('beforeclose', {\n        cancelable: true,\n        closeAttribute: this.closeAttribute,\n        closeTarget: this.overlayCloseElement,\n        result: this.returnValue,\n      }),\n    );\n  }\n\n  // TODO: remove parameter `detail`\n  protected override dispatchCloseEvent(_detail?: SbbOverlayCloseEventDetails): boolean {\n    /** @type {SbbOverlayCloseEvent} Emits whenever the component is closed. */\n    return this.dispatchEvent(\n      new SbbOverlayCloseEvent('close', {\n        closeAttribute: this.closeAttribute,\n        closeTarget: this.overlayCloseElement,\n        result: this.returnValue,\n      }),\n    );\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-overlay__container\" @animationend=${this.onOverlayAnimationEnd}>\n        <div class=\"sbb-overlay\">\n          <div\n            @click=${(event: Event) => this.closeOnSbbOverlayCloseClick(event)}\n            class=\"sbb-overlay__wrapper\"\n          >\n            <div class=\"sbb-overlay__header\">\n              <sbb-secondary-button\n                class=\"sbb-overlay__close\"\n                aria-label=\"${this.accessibilityCloseLabel ||\n                i18nCloseDialog[this.language.current]}\"\n                ?negative=${this.negative}\n                size=\"m\"\n                type=\"button\"\n                icon-name=\"cross-small\"\n                sbb-overlay-close\n              ></sbb-secondary-button>\n            </div>\n            <div\n              class=\"sbb-overlay__content\"\n              ${ref((el?: Element) => (this._overlayContentElement = el as HTMLDivElement))}\n              @scroll=${(e: Event) => forwardEvent(e, document)}\n            >\n              <sbb-container\n                class=\"sbb-overlay__content-container\"\n                ?expanded=${this.expanded}\n                color=\"transparent\"\n              >\n                <slot></slot>\n              </sbb-container>\n            </div>\n          </div>\n        </div>\n      </div>\n      <sbb-screen-reader-only aria-live=\"polite\"></sbb-screen-reader-only>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-overlay': SbbOverlayElement;\n  }\n}\n"],"mappings":"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"}

package/development/overlay.d.ts

@@ -0,0 +1,2 @@
+export * from './overlay.pure.ts';
+//# sourceMappingURL=overlay.d.ts.map

package/development/overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../../src/elements/overlay.ts"],"names":[],"mappings":"AAGA,cAAc,mBAAmB,CAAC"}

package/development/overlay.js

@@ -0,0 +1,10 @@
+import { SbbOverlayBaseElement, SbbOverlayCloseEvent, assignOverlayResult, overlayRefs } from "./overlay/overlay-base-element.js";
+import { t as SbbOverlayElement } from "./overlay.component-M0JuSq4C.js";
+import "./overlay.pure.js";
+//#region src/elements/overlay.ts
+/** @entrypoint */
+SbbOverlayElement.define();
+//#endregion
+export { SbbOverlayBaseElement, SbbOverlayCloseEvent, SbbOverlayElement, assignOverlayResult, overlayRefs };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZWxlbWVudHMvb3ZlcmxheS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYk92ZXJsYXlFbGVtZW50IH0gZnJvbSAnLi9vdmVybGF5LnB1cmUudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL292ZXJsYXkucHVyZS50cyc7XG5cblNiYk92ZXJsYXlFbGVtZW50LmRlZmluZSgpO1xuIl0sIm1hcHBpbmdzIjoiOzs7OztBQUtBLGtCQUFrQixRQUFRIn0=

package/development/overlay.pure.d.ts

@@ -0,0 +1,4 @@
+/** @entrypoint */
+export * from './overlay/overlay-base-element.ts';
+export * from './overlay/overlay.component.ts';
+//# sourceMappingURL=overlay.pure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.pure.d.ts","sourceRoot":"","sources":["../../../src/elements/overlay.pure.ts"],"names":[],"mappings":"AAAA,kBAAkB;AAClB,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC"}

package/development/overlay.pure.js

@@ -0,0 +1,3 @@
+import { SbbOverlayBaseElement, SbbOverlayCloseEvent, assignOverlayResult, overlayRefs } from "./overlay/overlay-base-element.js";
+import { t as SbbOverlayElement } from "./overlay.component-M0JuSq4C.js";
+export { SbbOverlayBaseElement, SbbOverlayCloseEvent, SbbOverlayElement, assignOverlayResult, overlayRefs };