@sbb-esta/lyne-elements-dev 4.7.0-dev.1773648103 → 4.7.0-dev.1773648656

package/development/core/mixins/selection-panel-mixin.js

@@ -1,57 +1,52 @@
-import { SbbPropertyWatcherController } from "../controllers.js";
 import { SbbElementInternalsMixin } from "./element-internals-mixin.js";
-const SbbSelectionPanelMixin = (superClass) => {
-  const conditionalSuperClass = superClass["_$sbbElement$"] ? superClass : SbbElementInternalsMixin(superClass);
-  class SbbSelectionPanelElement extends conditionalSuperClass {
-    /** Group element if present */
-    get group() {
-      return this.closest?.("sbb-radio-button-group, sbb-checkbox-group") ?? null;
-    }
-    /** Input panel element */
-    get panel() {
-      return this.querySelector?.("sbb-radio-button-panel, sbb-checkbox-panel") ?? null;
-    }
-    constructor(...args) {
-      super(args);
-      this._propertyWatcher = new SbbPropertyWatcherController(this, () => this.panel, {
-        checked: (panel) => {
-          this.toggleState("checked", panel.checked);
-          this.onInputStateChange?.();
-        },
-        disabled: (panel) => {
-          this.toggleState("disabled", panel.disabled);
-          this.onInputStateChange?.();
-        },
-        size: (panel) => {
-          if (this._previousSize) {
-            this.internals.states.delete(`size-${this._previousSize}`);
-          }
-          this._previousSize = panel.size;
-          if (this._previousSize) {
-            this.internals.states.add(`size-${this._previousSize}`);
-          }
-        },
-        borderless: (panel) => {
-          this.toggleState("borderless", panel.borderless);
-        },
-        color: (panel) => {
-          if (this._previousColor) {
-            this.internals.states.delete(`color-${this._previousColor}`);
-          }
-          this._previousColor = panel.color;
-          if (this._previousColor) {
-            this.internals.states.add(`color-${this._previousColor}`);
-          }
-        }
-      });
-      this.addEventListener?.("panelconnected", () => this._propertyWatcher.connect());
-    }
-    onInputStateChange() {
-    }
-  }
-  return SbbSelectionPanelElement;
-};
-export {
-  SbbSelectionPanelMixin
+import { SbbPropertyWatcherController } from "../controllers.js";
+//#region src/elements/core/mixins/selection-panel-mixin.ts
+/**
+* Mixin for common selection panel behaviors
+*/
+var SbbSelectionPanelMixin = (superClass) => {
+	const conditionalSuperClass = superClass["_$sbbElement$"] ? superClass : SbbElementInternalsMixin(superClass);
+	class SbbSelectionPanelElement extends conditionalSuperClass {
+		/** Group element if present */
+		get group() {
+			return this.closest?.("sbb-radio-button-group, sbb-checkbox-group") ?? null;
+		}
+		/** Input panel element */
+		get panel() {
+			return this.querySelector?.("sbb-radio-button-panel, sbb-checkbox-panel") ?? null;
+		}
+		constructor(...args) {
+			super(args);
+			this._propertyWatcher = new SbbPropertyWatcherController(this, () => this.panel, {
+				checked: (panel) => {
+					this.toggleState("checked", panel.checked);
+					this.onInputStateChange?.();
+				},
+				disabled: (panel) => {
+					this.toggleState("disabled", panel.disabled);
+					this.onInputStateChange?.();
+				},
+				size: (panel) => {
+					if (this._previousSize) this.internals.states.delete(`size-${this._previousSize}`);
+					this._previousSize = panel.size;
+					if (this._previousSize) this.internals.states.add(`size-${this._previousSize}`);
+				},
+				borderless: (panel) => {
+					this.toggleState("borderless", panel.borderless);
+				},
+				color: (panel) => {
+					if (this._previousColor) this.internals.states.delete(`color-${this._previousColor}`);
+					this._previousColor = panel.color;
+					if (this._previousColor) this.internals.states.add(`color-${this._previousColor}`);
+				}
+			});
+			this.addEventListener?.("panelconnected", () => this._propertyWatcher.connect());
+		}
+		onInputStateChange() {}
+	}
+	return SbbSelectionPanelElement;
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//#endregion
+export { SbbSelectionPanelMixin };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/mixins/update-scheduler-mixin.js

@@ -1,26 +1,31 @@
-const SbbUpdateSchedulerMixin = (base) => {
-  class SbbUpdateSchedulerElement extends base {
-    constructor() {
-      super(...arguments);
-      this._updatePromise = Promise.resolve();
-      this._updateResolve = () => {
-      };
-    }
-    startUpdate() {
-      this._updatePromise = new Promise((r) => this._updateResolve = r);
-    }
-    completeUpdate() {
-      this._updateResolve();
-    }
-    async getUpdateComplete() {
-      const result = await super.getUpdateComplete();
-      await this._updatePromise;
-      return result;
-    }
-  }
-  return SbbUpdateSchedulerElement;
+//#region src/elements/core/mixins/update-scheduler-mixin.ts
+/**
+* This mixin allows scheduling manual updates, which affect updateComplete.
+* @param base The class to extend.
+* @returns A class extended with the slot child observer functionality.
+*/
+var SbbUpdateSchedulerMixin = (base) => {
+	class SbbUpdateSchedulerElement extends base {
+		constructor() {
+			super(...arguments);
+			this._updatePromise = Promise.resolve();
+			this._updateResolve = () => {};
+		}
+		startUpdate() {
+			this._updatePromise = new Promise((r) => this._updateResolve = r);
+		}
+		completeUpdate() {
+			this._updateResolve();
+		}
+		async getUpdateComplete() {
+			const result = await super.getUpdateComplete();
+			await this._updatePromise;
+			return result;
+		}
+	}
+	return SbbUpdateSchedulerElement;
 };
-export {
-  SbbUpdateSchedulerMixin
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//#endregion
+export { SbbUpdateSchedulerMixin };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/mixins.js

@@ -1,20 +1,22 @@
 import { SbbAnimationCompleteMixin } from "./mixins/animation-complete-mixin.js";
+import "./mixins/constructor.js";
 import { SbbDisabledInteractiveMixin, SbbDisabledMixin, SbbDisabledTabIndexActionMixin } from "./mixins/disabled-mixin.js";
 import { SbbElementInternalsMixin, appendAriaElements, removeAriaElements, ɵstateController } from "./mixins/element-internals-mixin.js";
+import { SbbFormAssociatedMixin } from "./mixins/form-associated-mixin.js";
+import { SbbRequiredMixin } from "./mixins/required-mixin.js";
 import { SbbFormAssociatedCheckboxMixin } from "./mixins/form-associated-checkbox-mixin.js";
+import { SbbReadonlyMixin } from "./mixins/readonly-mixin.js";
 import { SbbFormAssociatedInputMixin } from "./mixins/form-associated-input-mixin.js";
-import { SbbFormAssociatedMixin } from "./mixins/form-associated-mixin.js";
 import { SbbFormAssociatedRadioButtonMixin, radioButtonRegistry } from "./mixins/form-associated-radio-button-mixin.js";
 import { SbbHydrationMixin } from "./mixins/hydration-mixin.js";
 import { SbbNamedSlotListMixin } from "./mixins/named-slot-list-mixin.js";
 import { SbbNegativeMixin } from "./mixins/negative-mixin.js";
 import { SbbPanelMixin } from "./mixins/panel-mixin.js";
-import { SbbRequiredMixin } from "./mixins/required-mixin.js";
-import { SbbReadonlyMixin } from "./mixins/readonly-mixin.js";
 import { SbbSelectionPanelMixin } from "./mixins/selection-panel-mixin.js";
 import { SbbUpdateSchedulerMixin } from "./mixins/update-scheduler-mixin.js";
 import { css } from "lit";
-const panelCommon = css`:host {
+//#region src/elements/core/mixins/panel-common.scss?lit&inline
+var panel_common_default = css`:host {
   --sbb-selection-panel-background: var(
     --sbb-selection-panel-inner-background,
     var(--sbb-selection-panel-background-default)
@@ -121,28 +123,7 @@ slot[name=subtext] {
 :host(:not(:is(:state(slotted-subtext),[state--slotted-subtext]))) slot[name=subtext] {
   display: none;
 }`;
-export {
-  SbbAnimationCompleteMixin,
-  SbbDisabledInteractiveMixin,
-  SbbDisabledMixin,
-  SbbDisabledTabIndexActionMixin,
-  SbbElementInternalsMixin,
-  SbbFormAssociatedCheckboxMixin,
-  SbbFormAssociatedInputMixin,
-  SbbFormAssociatedMixin,
-  SbbFormAssociatedRadioButtonMixin,
-  SbbHydrationMixin,
-  SbbNamedSlotListMixin,
-  SbbNegativeMixin,
-  SbbPanelMixin,
-  SbbReadonlyMixin,
-  SbbRequiredMixin,
-  SbbSelectionPanelMixin,
-  SbbUpdateSchedulerMixin,
-  appendAriaElements,
-  panelCommon as panelCommonStyle,
-  radioButtonRegistry,
-  removeAriaElements,
-  ɵstateController
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWl4aW5zLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//#endregion
+export { SbbAnimationCompleteMixin, SbbDisabledInteractiveMixin, SbbDisabledMixin, SbbDisabledTabIndexActionMixin, SbbElementInternalsMixin, SbbFormAssociatedCheckboxMixin, SbbFormAssociatedInputMixin, SbbFormAssociatedMixin, SbbFormAssociatedRadioButtonMixin, SbbHydrationMixin, SbbNamedSlotListMixin, SbbNegativeMixin, SbbPanelMixin, SbbReadonlyMixin, SbbRequiredMixin, SbbSelectionPanelMixin, SbbUpdateSchedulerMixin, appendAriaElements, panel_common_default as panelCommonStyle, radioButtonRegistry, removeAriaElements, ɵstateController };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -1,29 +1,37 @@
-import { ɵstateController as _stateController } from "../mixins.js";
 import { getElementPosition } from "./position.js";
+import { ɵstateController } from "../mixins.js";
+//#region src/elements/core/overlay/overlay-option-panel.ts
+/**
+* Places the overlay in the correct position.
+* @param dialog The reference to the dialog element.
+* @param originElement The reference to the element the dialog is attached to.
+* @param optionContainer The reference to the option panel.
+* @param container The element which has the position:fixed applied.
+* @param element The reference to the component.
+* @param position The allowed position of the overlay relative to the origin.
+*/
 function setOverlayPosition(dialog, originElement, optionContainer, container, element, position = "auto") {
-  if (!dialog || !originElement) {
-    return;
-  }
-  element.style.setProperty("--sbb-options-panel-width", `${originElement.offsetWidth}px`);
-  element.style.setProperty("--sbb-options-panel-origin-height", `${originElement.offsetHeight}px`);
-  const panelPosition = getElementPosition(optionContainer, originElement, container, {
-    forceBelow: position === "below",
-    forceAbove: position === "above"
-  });
-  element.style.setProperty("--sbb-options-panel-position-x", `${panelPosition.left}px`);
-  element.style.setProperty("--sbb-options-panel-position-y", `${panelPosition.top}px`);
-  element.style.setProperty("--sbb-options-panel-max-height-calculated", panelPosition.maxHeight);
-  const controller = _stateController(element);
-  if (panelPosition.alignment.vertical === "above") {
-    controller.add("options-panel-position-above");
-    controller.delete("options-panel-position-below");
-  } else {
-    controller.add("options-panel-position-below");
-    controller.delete("options-panel-position-above");
-  }
-  originElement.setAttribute("data-options-panel-position", panelPosition.alignment.vertical);
+	if (!dialog || !originElement) return;
+	element.style.setProperty("--sbb-options-panel-width", `${originElement.offsetWidth}px`);
+	element.style.setProperty("--sbb-options-panel-origin-height", `${originElement.offsetHeight}px`);
+	const panelPosition = getElementPosition(optionContainer, originElement, container, {
+		forceBelow: position === "below",
+		forceAbove: position === "above"
+	});
+	element.style.setProperty("--sbb-options-panel-position-x", `${panelPosition.left}px`);
+	element.style.setProperty("--sbb-options-panel-position-y", `${panelPosition.top}px`);
+	element.style.setProperty("--sbb-options-panel-max-height-calculated", panelPosition.maxHeight);
+	const controller = ɵstateController(element);
+	if (panelPosition.alignment.vertical === "above") {
+		controller.add("options-panel-position-above");
+		controller.delete("options-panel-position-below");
+	} else {
+		controller.add("options-panel-position-below");
+		controller.delete("options-panel-position-above");
+	}
+	originElement.setAttribute("data-options-panel-position", panelPosition.alignment.vertical);
 }
-export {
-  setOverlayPosition
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//#endregion
+export { setOverlayPosition };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/development/core/overlay/overlay-outside-pointer-event-listener.js

@@ -1,61 +1,65 @@
-import { containsPierceShadowDom, isIOS, isAndroid } from "../dom.js";
-class SbbOverlayOutsidePointerEventListener {
-  constructor() {
-    this._overlays = /* @__PURE__ */ new Set();
-    this._pointerDownListener = (event) => {
-      this._pointerDownEventTarget = event.composedPath()[0];
-    };
-    this._clickListener = (event) => {
-      const target = event.composedPath()[0];
-      const origin = event.type === "click" && this._pointerDownEventTarget ? this._pointerDownEventTarget : target;
-      this._pointerDownEventTarget = void 0;
-      for (const overlay of Array.from(this._overlays).reverse()) {
-        if (containsPierceShadowDom(overlay, target) || containsPierceShadowDom(overlay, origin)) {
-          break;
-        }
-        overlay.dispatchEvent(new CustomEvent("overlayOutsidePointer"));
-      }
-    };
-  }
-  connect(overlay) {
-    if (!this._overlays.size) {
-      this._addGlobalEventListeners();
-      if (isIOS) {
-        this._cursorOriginalValue = document.body.style.cursor;
-        document.body.style.cursor = "pointer";
-      }
-    }
-    this._overlays.add(overlay);
-  }
-  disconnect(overlay) {
-    this._overlays.delete(overlay);
-    if (!this._overlays.size) {
-      this._abortController?.abort();
-      this._abortController = void 0;
-      if (isIOS) {
-        document.body.style.cursor = this._cursorOriginalValue;
-      }
-    }
-  }
-  _addGlobalEventListeners() {
-    const body = document.body;
-    this._abortController = new AbortController();
-    const options = {
-      capture: true,
-      passive: true,
-      signal: this._abortController.signal
-    };
-    body.addEventListener("click", this._clickListener, options);
-    if (!isAndroid && !isIOS) {
-      body.addEventListener("pointerdown", this._pointerDownListener, options);
-      body.addEventListener("auxclick", this._clickListener, options);
-      body.addEventListener("contextmenu", this._clickListener, options);
-    }
-  }
-}
-const sbbOverlayOutsidePointerEventListener = new SbbOverlayOutsidePointerEventListener();
-export {
-  SbbOverlayOutsidePointerEventListener,
-  sbbOverlayOutsidePointerEventListener
+import { containsPierceShadowDom, isAndroid, isIOS } from "../dom.js";
+//#region src/elements/core/overlay/overlay-outside-pointer-event-listener.ts
+/**
+* Listens globally to pointer events that happen outside the overlay area.
+*
+* Ref: https://github.com/angular/components/blob/main/src/cdk/overlay/dispatchers/overlay-outside-click-dispatcher.ts
+*/
+var SbbOverlayOutsidePointerEventListener = class {
+	constructor() {
+		this._overlays = /* @__PURE__ */ new Set();
+		/** Store pointerdown event target to track origin of click. */
+		this._pointerDownListener = (event) => {
+			this._pointerDownEventTarget = event.composedPath()[0];
+		};
+		/** Click event listener that will be attached to the body propagate phase. */
+		this._clickListener = (event) => {
+			const target = event.composedPath()[0];
+			const origin = event.type === "click" && this._pointerDownEventTarget ? this._pointerDownEventTarget : target;
+			this._pointerDownEventTarget = void 0;
+			for (const overlay of Array.from(this._overlays).reverse()) {
+				if (containsPierceShadowDom(overlay, target) || containsPierceShadowDom(overlay, origin)) break;
+				overlay.dispatchEvent(new CustomEvent("overlayOutsidePointer"));
+			}
+		};
+	}
+	connect(overlay) {
+		if (!this._overlays.size) {
+			this._addGlobalEventListeners();
+			if (isIOS) {
+				this._cursorOriginalValue = document.body.style.cursor;
+				document.body.style.cursor = "pointer";
+			}
+		}
+		this._overlays.add(overlay);
+	}
+	disconnect(overlay) {
+		this._overlays.delete(overlay);
+		if (!this._overlays.size) {
+			this._abortController?.abort();
+			this._abortController = void 0;
+			if (isIOS) document.body.style.cursor = this._cursorOriginalValue;
+		}
+	}
+	_addGlobalEventListeners() {
+		const body = document.body;
+		this._abortController = new AbortController();
+		const options = {
+			capture: true,
+			passive: true,
+			signal: this._abortController.signal
+		};
+		body.addEventListener("click", this._clickListener, options);
+		if (!isAndroid && !isIOS) {
+			body.addEventListener("pointerdown", this._pointerDownListener, options);
+			body.addEventListener("auxclick", this._clickListener, options);
+			body.addEventListener("contextmenu", this._clickListener, options);
+		}
+	}
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+/** The global instance for listening for outside pointer events. */
+var sbbOverlayOutsidePointerEventListener = new SbbOverlayOutsidePointerEventListener();
+//#endregion
+export { SbbOverlayOutsidePointerEventListener, sbbOverlayOutsidePointerEventListener };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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