@sbb-esta/lyne-elements 4.7.0 → 4.8.1

package/development/selection-expansion-panel.component-B9v1yqif.js

@@ -0,0 +1,326 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { css, html } from "lit";
+import { property, state } from "lit/decorators.js";
+import { SbbElement } from "./core/base-elements.js";
+import { forceType } from "./core/decorators.js";
+import { isZeroAnimationDuration } from "./core/dom.js";
+import { SbbSelectionPanelMixin } from "./core/mixins.js";
+import { boxSizingStyles } from "./core/styles.js";
+import { SbbLanguageController } from "./core/controllers.js";
+import { i18nCollapsed, i18nExpanded } from "./core/i18n.js";
+import "./divider.js";
+//#region src/elements/selection-expansion-panel/selection-expansion-panel.scss?lit&inline
+var selection_expansion_panel_default = css`:host {
+  --sbb-selection-panel-inner-background: transparent;
+  --sbb-selection-panel-inner-border-width: 0px;
+  --sbb-selection-expansion-panel-animation-duration: var(
+    --sbb-disable-animation-duration,
+    var(--sbb-animation-duration-4x)
+  );
+  --sbb-focus-outline-color: var(--sbb-focus-outline-color-default);
+  --sbb-focus-outline-color: light-dark(
+    var(--sbb-focus-outline-color-default),
+    var(--sbb-focus-outline-color-dark)
+  );
+  display: block;
+  flex: auto;
+  position: relative;
+  width: var(--sbb-selection-group-elements-width, 100%);
+  background-color: var(--sbb-selection-expansion-panel-background);
+  border-radius: var(--sbb-selection-panel-border-radius);
+  box-shadow: inset 0 0 0 var(--sbb-selection-expansion-panel-border-width) var(--sbb-selection-expansion-panel-border-color);
+  transition-duration: var(--sbb-selection-expansion-panel-animation-duration);
+  transition-timing-function: var(--sbb-animation-easing);
+  transition-property: box-shadow;
+}
+@media (forced-colors: active) {
+  :host::after {
+    content: "";
+    display: block;
+    position: absolute;
+    inset: 0;
+    pointer-events: none;
+    border: var(--sbb-selection-expansion-panel-border-width) solid var(--sbb-selection-expansion-panel-border-color);
+    border-radius: var(--sbb-selection-panel-border-radius);
+  }
+}
+
+:host(:is(:state(size-xs),[state--size-xs])) {
+  --sbb-selection-expansion-panel-content-padding-inline: var(
+    --sbb-selection-panel-input-padding-inline-xs
+  );
+}
+
+:host(:is(:state(size-s),[state--size-s])) {
+  --sbb-selection-expansion-panel-content-padding-inline: var(
+    --sbb-selection-panel-input-padding-inline-s
+  );
+}
+
+:host(:is(:state(size-m),[state--size-m])) {
+  --sbb-selection-expansion-panel-content-padding-inline: var(
+    --sbb-selection-panel-input-padding-inline-m
+  );
+}
+
+:host(:is(:state(color-milk),[state--color-milk])) {
+  --sbb-selection-expansion-panel-background: var(--sbb-selection-panel-background-milk);
+}
+
+:host(:where(:is(:state(checked),[state--checked])):not(:where(:is(:state(disabled),[state--disabled])))) {
+  --sbb-selection-expansion-panel-border-color: var(--sbb-selection-panel-border-color-checked);
+  --sbb-selection-expansion-panel-border-width: var(--sbb-selection-panel-border-width-checked);
+}
+
+:host(:is(:state(slotted-content),[state--slotted-content]):where(:is(:state(disabled),[state--disabled]))) {
+  --sbb-selection-expansion-panel-border-color: var(--sbb-selection-panel-border-color-default);
+}
+
+:host(:is(:state(borderless),[state--borderless]):not(:where(:is(:state(checked),[state--checked])))) {
+  --sbb-selection-expansion-panel-border-color: transparent;
+}
+
+:host(:not(:is(:state(slotted-content),[state--slotted-content]):where(:is(:state(state-opening),[state--state-opening]), :is(:state(state-opened),[state--state-opened])))) {
+  --sbb-selection-expansion-panel-content-padding-block-end: 0px;
+  --sbb-selection-expansion-panel-content-visibility: hidden;
+}
+
+.sbb-selection-expansion-panel__content--wrapper {
+  display: grid;
+  visibility: var(--sbb-selection-expansion-panel-content-visibility);
+  grid-template-rows: 0fr;
+  opacity: 0;
+}
+:host(:is(:state(state-opened),[state--state-opened])) .sbb-selection-expansion-panel__content--wrapper {
+  grid-template-rows: 1fr;
+  opacity: 1;
+}
+:host(:is(:state(state-opening),[state--state-opening])) .sbb-selection-expansion-panel__content--wrapper {
+  animation-name: open, open-opacity;
+  animation-fill-mode: forwards;
+  animation-duration: var(--sbb-selection-expansion-panel-animation-duration);
+  animation-timing-function: var(--sbb-animation-easing);
+  animation-delay: 0s, var(--sbb-selection-expansion-panel-animation-duration);
+}
+:host(:is(:state(state-closing),[state--state-closing])) .sbb-selection-expansion-panel__content--wrapper {
+  animation-name: close;
+  animation-duration: var(--sbb-selection-expansion-panel-animation-duration);
+  animation-timing-function: var(--sbb-animation-easing);
+}
+:host(:not(:is(:state(slotted-content),[state--slotted-content]))) .sbb-selection-expansion-panel__content--wrapper {
+  display: none;
+}
+
+.sbb-selection-expansion-panel__content {
+  overflow: hidden;
+  padding-inline: var(--sbb-selection-expansion-panel-content-padding-inline);
+  padding-block-end: var(--sbb-selection-expansion-panel-content-padding-block-end);
+  transition: padding var(--sbb-selection-expansion-panel-animation-duration) var(--sbb-animation-easing);
+}
+
+sbb-divider {
+  margin-block-end: var(--sbb-selection-expansion-panel-content-padding-block-start);
+}
+
+@keyframes open {
+  from {
+    grid-template-rows: 0fr;
+  }
+  to {
+    grid-template-rows: 1fr;
+  }
+}
+@keyframes open-opacity {
+  from {
+    opacity: 0;
+  }
+  to {
+    opacity: 1;
+  }
+}
+@keyframes close {
+  from {
+    grid-template-rows: 1fr;
+    opacity: 1;
+  }
+  to {
+    grid-template-rows: 0fr;
+    opacity: 0;
+  }
+}`;
+//#endregion
+//#region src/elements/selection-expansion-panel/selection-expansion-panel.component.ts
+/**
+* It displays an expandable panel connected to a `sbb-checkbox` or to a `sbb-radio-button`.
+*
+* @slot - Use the unnamed slot to add `sbb-checkbox-panel` or `sbb-radio-button-panel` elements to the `sbb-selection-expansion-panel`.
+* @slot content - Use this slot to provide custom content for the panel (optional).
+*/
+var SbbSelectionExpansionPanelElement = (() => {
+	let _classSuper = SbbSelectionPanelMixin(SbbElement);
+	let _instanceExtraInitializers = [];
+	let _forceOpen_decorators;
+	let _forceOpen_initializers = [];
+	let _forceOpen_extraInitializers = [];
+	let _set__state_decorators;
+	return class SbbSelectionExpansionPanelElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_forceOpen_decorators = [forceType(), property({
+				attribute: "force-open",
+				type: Boolean
+			})];
+			_set__state_decorators = [state()];
+			__esDecorate(this, null, _forceOpen_decorators, {
+				kind: "accessor",
+				name: "forceOpen",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "forceOpen" in obj,
+					get: (obj) => obj.forceOpen,
+					set: (obj, value) => {
+						obj.forceOpen = value;
+					}
+				},
+				metadata: _metadata
+			}, _forceOpen_initializers, _forceOpen_extraInitializers);
+			__esDecorate(this, null, _set__state_decorators, {
+				kind: "setter",
+				name: "_state",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "_state" in obj,
+					set: (obj, value) => {
+						obj._state = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-selection-expansion-panel";
+		}
+		static {
+			this.styles = [boxSizingStyles, selection_expansion_panel_default];
+		}
+		static {
+			this.events = {
+				beforeopen: "beforeopen",
+				open: "open",
+				beforeclose: "beforeclose",
+				close: "close"
+			};
+		}
+		#forceOpen_accessor_storage;
+		/** Whether the content section is always visible. */
+		get forceOpen() {
+			return this.#forceOpen_accessor_storage;
+		}
+		set forceOpen(value) {
+			this.#forceOpen_accessor_storage = value;
+		}
+		/** The state of the component. */
+		set _state(state) {
+			if (this._stateInternal) this.internals.states.delete(`state-${this._stateInternal}`);
+			this._stateInternal = state;
+			if (this._stateInternal) this.internals.states.add(`state-${this._stateInternal}`);
+		}
+		get _state() {
+			return this._stateInternal;
+		}
+		/** Whether it has an expandable content */
+		get _hasContent() {
+			return this.querySelectorAll?.("[slot=\"content\"]").length > 0;
+		}
+		constructor() {
+			super();
+			this.#forceOpen_accessor_storage = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _forceOpen_initializers, false));
+			this._stateInternal = __runInitializers(this, _forceOpen_extraInitializers);
+			this._language = new SbbLanguageController(this);
+			this._state = "closed";
+		}
+		willUpdate(changedProperties) {
+			super.willUpdate(changedProperties);
+			if (changedProperties.has("forceOpen")) this._updateState();
+		}
+		onInputStateChange() {
+			this._updateState();
+		}
+		_updateState() {
+			if (!this._hasContent) return;
+			if (this.forceOpen || this.matches(":is(:state(checked),[state--checked])")) this._open();
+			else this._close();
+			this._updateExpandedLabel(this.forceOpen || this.matches(":is(:state(checked),[state--checked])"));
+		}
+		_open() {
+			if (this._state !== "closed" && this._state !== "closing") return;
+			this._state = "opening";
+			/** Emits whenever the content section starts the opening transition. */
+			this.dispatchEvent(new Event("beforeopen", { cancelable: true }));
+			if (!this.hasUpdated || this._isZeroAnimationDuration()) this._handleOpening();
+		}
+		_close() {
+			if (this._state !== "opened" && this._state !== "opening") return;
+			this._state = "closing";
+			/** Emits whenever the content section begins the closing transition. */
+			this.dispatchEvent(new Event("beforeclose", { cancelable: true }));
+			if (this._isZeroAnimationDuration()) this._handleClosing();
+		}
+		_isZeroAnimationDuration() {
+			return isZeroAnimationDuration(this, "--sbb-selection-expansion-panel-animation-duration");
+		}
+		_handleClosing() {
+			this._state = "closed";
+			/** Emits whenever the content section is closed. */
+			this.dispatchEvent(new Event("close"));
+		}
+		_handleOpening() {
+			this._state = "opened";
+			/** Emits whenever the content section is opened. */
+			this.dispatchEvent(new Event("open"));
+		}
+		_onAnimationEnd(event) {
+			if (event.animationName === "open-opacity" && this._state === "opening") this._handleOpening();
+			else if (event.animationName === "close" && this._state === "closing") this._handleClosing();
+		}
+		async _updateExpandedLabel(open) {
+			await this.hydrationComplete;
+			const panelElement = this.panel;
+			if (!panelElement) return;
+			if (!this._hasContent) {
+				panelElement.expansionState = "";
+				return;
+			}
+			panelElement.expansionState = open ? ", " + i18nExpanded[this._language.current] : ", " + i18nCollapsed[this._language.current];
+		}
+		render() {
+			return html`
+      <div class="sbb-selection-expansion-panel__input">
+        <slot></slot>
+      </div>
+      <div
+        class="sbb-selection-expansion-panel__content--wrapper"
+        ?inert=${this._state !== "opened"}
+        @animationend=${this._onAnimationEnd}
+      >
+        <div class="sbb-selection-expansion-panel__content">
+          <sbb-divider></sbb-divider>
+          <slot name="content"></slot>
+        </div>
+      </div>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbSelectionExpansionPanelElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"selection-expansion-panel.component-B9v1yqif.js","names":[],"sources":["../../../src/elements/selection-expansion-panel/selection-expansion-panel.scss?lit&inline","../../../src/elements/selection-expansion-panel/selection-expansion-panel.component.ts"],"sourcesContent":["@use '../core/styles' as sbb;\n\n// Open/Close animation vars\n$open-anim-rows-from: 0fr;\n$open-anim-rows-to: 1fr;\n$open-anim-opacity-from: 0;\n$open-anim-opacity-to: 1;\n\n:host {\n  // Variable used to override background color of selection panels.\n  --sbb-selection-panel-inner-background: transparent;\n\n  // Variable used to override border width of selection panels.\n  --sbb-selection-panel-inner-border-width: 0px;\n  --sbb-selection-expansion-panel-animation-duration: var(\n    --sbb-disable-animation-duration,\n    var(--sbb-animation-duration-4x)\n  );\n\n  // As the selection panel has always a white/milk background, we have to fix the focus outline color\n  // to default color for cases where the selection panel is used in a negative context.\n  --sbb-focus-outline-color: light-dark(\n    var(--sbb-focus-outline-color-default),\n    var(--sbb-focus-outline-color-dark)\n  );\n\n  display: block;\n  flex: auto;\n  position: relative;\n  width: var(--sbb-selection-group-elements-width, 100%);\n  background-color: var(--sbb-selection-expansion-panel-background);\n  border-radius: var(--sbb-selection-panel-border-radius);\n\n  // To provide a smooth transition of width, we use box-shadow to imitate the border.\n  box-shadow: inset 0 0 0 var(--sbb-selection-expansion-panel-border-width)\n    var(--sbb-selection-expansion-panel-border-color);\n\n  transition: {\n    duration: var(--sbb-selection-expansion-panel-animation-duration);\n    timing-function: var(--sbb-animation-easing);\n    property: box-shadow;\n  }\n\n  // For high contrast mode we need a real border\n  @include sbb.if-forced-colors {\n    &::after {\n      content: '';\n      display: block;\n      position: absolute;\n      inset: 0;\n      pointer-events: none;\n      border: var(--sbb-selection-expansion-panel-border-width) solid\n        var(--sbb-selection-expansion-panel-border-color);\n      border-radius: var(--sbb-selection-panel-border-radius);\n    }\n  }\n}\n\n:host(:state(size-xs)) {\n  --sbb-selection-expansion-panel-content-padding-inline: var(\n    --sbb-selection-panel-input-padding-inline-xs\n  );\n}\n\n:host(:state(size-s)) {\n  --sbb-selection-expansion-panel-content-padding-inline: var(\n    --sbb-selection-panel-input-padding-inline-s\n  );\n}\n\n:host(:state(size-m)) {\n  --sbb-selection-expansion-panel-content-padding-inline: var(\n    --sbb-selection-panel-input-padding-inline-m\n  );\n}\n\n:host(:state(color-milk)) {\n  --sbb-selection-expansion-panel-background: var(--sbb-selection-panel-background-milk);\n}\n\n// :where is to align specificity\n:host(:where(:state(checked)):not(:where(:state(disabled)))) {\n  --sbb-selection-expansion-panel-border-color: var(--sbb-selection-panel-border-color-checked);\n  --sbb-selection-expansion-panel-border-width: var(--sbb-selection-panel-border-width-checked);\n}\n\n// :where is to align specificity\n:host(:state(slotted-content):where(:state(disabled))) {\n  --sbb-selection-expansion-panel-border-color: var(--sbb-selection-panel-border-color-default);\n}\n\n// :where is to align specificity\n:host(:state(borderless):not(:where(:state(checked)))) {\n  --sbb-selection-expansion-panel-border-color: transparent;\n}\n\n// When the panel is closed, we remove the padding at the bottom for a nice transition when opening.\n:host(:not(:state(slotted-content):where(:state(state-opening), :state(state-opened)))) {\n  --sbb-selection-expansion-panel-content-padding-block-end: 0px;\n  --sbb-selection-expansion-panel-content-visibility: hidden;\n}\n\n.sbb-selection-expansion-panel__content--wrapper {\n  display: grid;\n  visibility: var(--sbb-selection-expansion-panel-content-visibility);\n  grid-template-rows: #{$open-anim-rows-from};\n  opacity: #{$open-anim-opacity-from};\n\n  :host(:state(state-opened)) & {\n    grid-template-rows: #{$open-anim-rows-to};\n    opacity: #{$open-anim-opacity-to};\n  }\n\n  :host(:state(state-opening)) & {\n    animation-name: open, open-opacity;\n    animation-fill-mode: forwards;\n    animation-duration: var(--sbb-selection-expansion-panel-animation-duration);\n    animation-timing-function: var(--sbb-animation-easing);\n    animation-delay: 0s, var(--sbb-selection-expansion-panel-animation-duration);\n  }\n\n  :host(:state(state-closing)) & {\n    animation-name: close;\n    animation-duration: var(--sbb-selection-expansion-panel-animation-duration);\n    animation-timing-function: var(--sbb-animation-easing);\n  }\n\n  :host(:not(:state(slotted-content))) & {\n    display: none;\n  }\n}\n\n.sbb-selection-expansion-panel__content {\n  overflow: hidden;\n  padding-inline: var(--sbb-selection-expansion-panel-content-padding-inline);\n  padding-block-end: var(--sbb-selection-expansion-panel-content-padding-block-end);\n  transition: padding var(--sbb-selection-expansion-panel-animation-duration)\n    var(--sbb-animation-easing);\n}\n\nsbb-divider {\n  margin-block-end: var(--sbb-selection-expansion-panel-content-padding-block-start);\n}\n\n@keyframes open {\n  from {\n    grid-template-rows: #{$open-anim-rows-from};\n  }\n\n  to {\n    grid-template-rows: #{$open-anim-rows-to};\n  }\n}\n\n@keyframes open-opacity {\n  from {\n    opacity: #{$open-anim-opacity-from};\n  }\n\n  to {\n    opacity: #{$open-anim-opacity-to};\n  }\n}\n\n@keyframes close {\n  from {\n    grid-template-rows: #{$open-anim-rows-to};\n    opacity: #{$open-anim-opacity-to};\n  }\n\n  to {\n    grid-template-rows: #{$open-anim-rows-from};\n    opacity: #{$open-anim-opacity-from};\n  }\n}\n","import { type CSSResultGroup, html, type PropertyValues, type TemplateResult } from 'lit';\nimport { property, state } from 'lit/decorators.js';\n\nimport { SbbElement } from '../core/base-elements.ts';\nimport { SbbLanguageController } from '../core/controllers.ts';\nimport { forceType } from '../core/decorators.ts';\nimport { isZeroAnimationDuration } from '../core/dom.ts';\nimport { i18nCollapsed, i18nExpanded } from '../core/i18n.ts';\nimport type { SbbOpenedClosedState } from '../core/interfaces.ts';\nimport { SbbSelectionPanelMixin } from '../core/mixins.ts';\nimport { boxSizingStyles } from '../core/styles.ts';\n\nimport style from './selection-expansion-panel.scss?lit&inline';\n\nimport '../divider.ts';\n\n/**\n * It displays an expandable panel connected to a `sbb-checkbox` or to a `sbb-radio-button`.\n *\n * @slot - Use the unnamed slot to add `sbb-checkbox-panel` or `sbb-radio-button-panel` elements to the `sbb-selection-expansion-panel`.\n * @slot content - Use this slot to provide custom content for the panel (optional).\n */\nexport class SbbSelectionExpansionPanelElement extends SbbSelectionPanelMixin(SbbElement) {\n  public static override readonly elementName: string = 'sbb-selection-expansion-panel';\n  // TODO: fix inheriting from SbbOpenCloseBaseElement requires: https://github.com/open-wc/custom-elements-manifest/issues/253\n  public static override styles: CSSResultGroup = [boxSizingStyles, style];\n  public static readonly events = {\n    beforeopen: 'beforeopen',\n    open: 'open',\n    beforeclose: 'beforeclose',\n    close: 'close',\n  } as const;\n\n  /** Whether the content section is always visible. */\n  @forceType()\n  @property({ attribute: 'force-open', type: Boolean })\n  public accessor forceOpen: boolean = false;\n\n  /** The state of the component. */\n  @state()\n  private set _state(state: SbbOpenedClosedState) {\n    if (this._stateInternal) {\n      this.internals.states.delete(`state-${this._stateInternal}`);\n    }\n    this._stateInternal = state;\n    if (this._stateInternal) {\n      this.internals.states.add(`state-${this._stateInternal}`);\n    }\n  }\n  private get _state(): SbbOpenedClosedState {\n    return this._stateInternal;\n  }\n  private _stateInternal!: SbbOpenedClosedState;\n\n  private _language = new SbbLanguageController(this);\n\n  /** Whether it has an expandable content */\n  private get _hasContent(): boolean {\n    // We cannot use the NamedSlots because it's too slow to initialize\n    return this.querySelectorAll?.('[slot=\"content\"]').length > 0;\n  }\n\n  public constructor() {\n    super();\n\n    this._state = 'closed';\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('forceOpen')) {\n      this._updateState();\n    }\n  }\n\n  protected override onInputStateChange(): void {\n    this._updateState();\n  }\n\n  private _updateState(): void {\n    if (!this._hasContent) {\n      return;\n    }\n\n    if (this.forceOpen || this.matches(':state(checked)')) {\n      this._open();\n    } else {\n      this._close();\n    }\n    this._updateExpandedLabel(this.forceOpen || this.matches(':state(checked)'));\n  }\n\n  private _open(): void {\n    if (this._state !== 'closed' && this._state !== 'closing') {\n      return;\n    }\n\n    this._state = 'opening';\n    /** Emits whenever the content section starts the opening transition. */\n    this.dispatchEvent(new Event('beforeopen', { cancelable: true }));\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.hasUpdated || this._isZeroAnimationDuration()) {\n      this._handleOpening();\n    }\n  }\n\n  private _close(): void {\n    if (this._state !== 'opened' && this._state !== 'opening') {\n      return;\n    }\n\n    this._state = 'closing';\n    /** Emits whenever the content section begins the closing transition. */\n    this.dispatchEvent(new Event('beforeclose', { cancelable: true }));\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  private _isZeroAnimationDuration(): boolean {\n    return isZeroAnimationDuration(this, '--sbb-selection-expansion-panel-animation-duration');\n  }\n\n  private _handleClosing(): void {\n    this._state = 'closed';\n    /** Emits whenever the content section is closed. */\n    this.dispatchEvent(new Event('close'));\n  }\n\n  private _handleOpening(): void {\n    this._state = 'opened';\n    /** Emits whenever the content section is opened. */\n    this.dispatchEvent(new Event('open'));\n  }\n\n  private _onAnimationEnd(event: AnimationEvent): void {\n    if (event.animationName === 'open-opacity' && this._state === 'opening') {\n      this._handleOpening();\n    } else if (event.animationName === 'close' && this._state === 'closing') {\n      this._handleClosing();\n    }\n  }\n\n  private async _updateExpandedLabel(open: boolean): Promise<void> {\n    await this.hydrationComplete;\n\n    const panelElement = this.panel;\n    if (!panelElement) {\n      return;\n    }\n\n    if (!this._hasContent) {\n      panelElement.expansionState = '';\n      return;\n    }\n\n    panelElement.expansionState = open\n      ? ', ' + i18nExpanded[this._language.current]\n      : ', ' + i18nCollapsed[this._language.current];\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-selection-expansion-panel__input\">\n        <slot></slot>\n      </div>\n      <div\n        class=\"sbb-selection-expansion-panel__content--wrapper\"\n        ?inert=${this._state !== 'opened'}\n        @animationend=${this._onAnimationEnd}\n      >\n        <div class=\"sbb-selection-expansion-panel__content\">\n          <sbb-divider></sbb-divider>\n          <slot name=\"content\"></slot>\n        </div>\n      </div>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-selection-expansion-panel': SbbSelectionExpansionPanelElement;\n  }\n}\n"],"mappings":"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"}

package/development/selection-expansion-panel.d.ts

@@ -1,5 +1,2 @@
-/**
- * @entrypoint
- */
-export * from './selection-expansion-panel/selection-expansion-panel.component.ts';
+export * from './selection-expansion-panel.pure.ts';
 //# sourceMappingURL=selection-expansion-panel.d.ts.map

package/development/selection-expansion-panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selection-expansion-panel.d.ts","sourceRoot":"","sources":["../../../src/elements/selection-expansion-panel.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,oEAAoE,CAAC"}
+{"version":3,"file":"selection-expansion-panel.d.ts","sourceRoot":"","sources":["../../../src/elements/selection-expansion-panel.ts"],"names":[],"mappings":"AAGA,cAAc,qCAAqC,CAAC"}

package/development/selection-expansion-panel.js

@@ -1,5 +1,9 @@
-import { SbbSelectionExpansionPanelElement } from "./selection-expansion-panel/selection-expansion-panel.component.js";
-export {
-  SbbSelectionExpansionPanelElement
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0aW9uLWV4cGFuc2lvbi1wYW5lbC5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7In0=
+import { t as SbbSelectionExpansionPanelElement } from "./selection-expansion-panel.component-B9v1yqif.js";
+import "./selection-expansion-panel.pure.js";
+//#region src/elements/selection-expansion-panel.ts
+/** @entrypoint */
+SbbSelectionExpansionPanelElement.define();
+//#endregion
+export { SbbSelectionExpansionPanelElement };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0aW9uLWV4cGFuc2lvbi1wYW5lbC5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZWxlbWVudHMvc2VsZWN0aW9uLWV4cGFuc2lvbi1wYW5lbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGVudHJ5cG9pbnQgKi9cbmltcG9ydCB7IFNiYlNlbGVjdGlvbkV4cGFuc2lvblBhbmVsRWxlbWVudCB9IGZyb20gJy4vc2VsZWN0aW9uLWV4cGFuc2lvbi1wYW5lbC5wdXJlLnRzJztcblxuZXhwb3J0ICogZnJvbSAnLi9zZWxlY3Rpb24tZXhwYW5zaW9uLXBhbmVsLnB1cmUudHMnO1xuXG5TYmJTZWxlY3Rpb25FeHBhbnNpb25QYW5lbEVsZW1lbnQuZGVmaW5lKCk7XG4iXSwibWFwcGluZ3MiOiI7Ozs7QUFLQSxrQ0FBa0MsUUFBUSJ9

package/development/selection-expansion-panel.pure.d.ts

@@ -0,0 +1,3 @@
+/** @entrypoint */
+export * from './selection-expansion-panel/selection-expansion-panel.component.ts';
+//# sourceMappingURL=selection-expansion-panel.pure.d.ts.map

package/development/selection-expansion-panel.pure.d.ts.map

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

package/development/selection-expansion-panel.pure.js

@@ -0,0 +1,2 @@
+import { t as SbbSelectionExpansionPanelElement } from "./selection-expansion-panel.component-B9v1yqif.js";
+export { SbbSelectionExpansionPanelElement };

package/development/selection-group-base-element-DrTO_80I.js

@@ -0,0 +1,220 @@
+import { SbbElement } from "./core/base-elements/element.js";
+import { __esDecorate, __runInitializers } from "tslib";
+import { css, html } from "lit";
+import { property } from "lit/decorators.js";
+import { isLean } from "./core/dom.js";
+import { SbbDisabledMixin, SbbRequiredMixin } from "./core/mixins.js";
+import { boxSizingStyles } from "./core/styles.js";
+import { MutationController } from "@lit-labs/observers/mutation-controller.js";
+//#region src/elements/core/base-elements/selection-group-base-element.scss?lit&inline
+var selection_group_base_element_default = css`:host {
+  display: flex;
+  flex-flow: var(--sbb-selection-group-orientation) wrap;
+  gap: var(--sbb-selection-group-gap);
+  align-items: flex-start;
+  width: var(--sbb-selection-group-width);
+}
+
+:host([orientation=vertical]) {
+  --sbb-selection-group-orientation: column;
+  --sbb-selection-group-width: 100%;
+  --sbb-selection-group-elements-width: 100%;
+}
+
+:host(:is(:state(has-panel),[state--has-panel])) {
+  --sbb-selection-group-width: 100%;
+  --sbb-selection-group-gap: var(--sbb-spacing-fixed-2x) var(--sbb-spacing-fixed-4x);
+  --sbb-selection-group-elements-flex: auto;
+}
+
+@media (min-width: calc(0rem)) {
+  :host([orientation=vertical][horizontal-from=zero]) {
+    --sbb-selection-group-orientation: row;
+    --sbb-selection-group-elements-width: auto;
+  }
+  :host([orientation=vertical][horizontal-from=zero]:not(:is(:state(has-panel),[state--has-panel]))) {
+    --sbb-selection-group-width: auto;
+  }
+}
+@media (min-width: calc(37.5rem)) {
+  :host([orientation=vertical][horizontal-from=small]) {
+    --sbb-selection-group-orientation: row;
+    --sbb-selection-group-elements-width: auto;
+  }
+  :host([orientation=vertical][horizontal-from=small]:not(:is(:state(has-panel),[state--has-panel]))) {
+    --sbb-selection-group-width: auto;
+  }
+}
+@media (min-width: calc(64rem)) {
+  :host([orientation=vertical][horizontal-from=large]) {
+    --sbb-selection-group-orientation: row;
+    --sbb-selection-group-elements-width: auto;
+  }
+  :host([orientation=vertical][horizontal-from=large]:not(:is(:state(has-panel),[state--has-panel]))) {
+    --sbb-selection-group-width: auto;
+  }
+}
+@media (min-width: calc(90rem)) {
+  :host([orientation=vertical][horizontal-from=ultra]) {
+    --sbb-selection-group-orientation: row;
+    --sbb-selection-group-elements-width: auto;
+  }
+  :host([orientation=vertical][horizontal-from=ultra]:not(:is(:state(has-panel),[state--has-panel]))) {
+    --sbb-selection-group-width: auto;
+  }
+}
+slot[name=error]::slotted(*) {
+  flex-basis: 100%;
+}
+
+::slotted(:is(sbb-checkbox-panel, sbb-radio-button-panel)) {
+  flex: var(--sbb-selection-group-elements-flex);
+}
+
+::slotted(:is(sbb-checkbox, sbb-checkbox-panel, sbb-radio-button-panel)) {
+  width: var(--sbb-selection-group-elements-width);
+}`;
+//#endregion
+//#region src/elements/core/base-elements/selection-group-base-element.ts
+/**
+* It can be used as a container for one or more `sbb-checkbox`.
+*
+* @slot - Use the unnamed slot to add `sbb-checkbox` elements to the `sbb-checkbox-group`.
+* @slot error - Slot used to render a `sbb-error` inside the `sbb-checkbox-group`.
+*/
+var SbbSelectionGroupBaseElement = (() => {
+	let _classSuper = SbbDisabledMixin(SbbRequiredMixin(SbbElement));
+	let _size_decorators;
+	let _size_initializers = [];
+	let _size_extraInitializers = [];
+	let _horizontalFrom_decorators;
+	let _horizontalFrom_initializers = [];
+	let _horizontalFrom_extraInitializers = [];
+	let _orientation_decorators;
+	let _orientation_initializers = [];
+	let _orientation_extraInitializers = [];
+	return class SbbSelectionGroupBaseElement extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_size_decorators = [property()];
+			_horizontalFrom_decorators = [property({
+				attribute: "horizontal-from",
+				reflect: true
+			})];
+			_orientation_decorators = [property({ reflect: true })];
+			__esDecorate(this, null, _size_decorators, {
+				kind: "accessor",
+				name: "size",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "size" in obj,
+					get: (obj) => obj.size,
+					set: (obj, value) => {
+						obj.size = value;
+					}
+				},
+				metadata: _metadata
+			}, _size_initializers, _size_extraInitializers);
+			__esDecorate(this, null, _horizontalFrom_decorators, {
+				kind: "accessor",
+				name: "horizontalFrom",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "horizontalFrom" in obj,
+					get: (obj) => obj.horizontalFrom,
+					set: (obj, value) => {
+						obj.horizontalFrom = value;
+					}
+				},
+				metadata: _metadata
+			}, _horizontalFrom_initializers, _horizontalFrom_extraInitializers);
+			__esDecorate(this, null, _orientation_decorators, {
+				kind: "accessor",
+				name: "orientation",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "orientation" in obj,
+					get: (obj) => obj.orientation,
+					set: (obj, value) => {
+						obj.orientation = value;
+					}
+				},
+				metadata: _metadata
+			}, _orientation_initializers, _orientation_extraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.styles = [boxSizingStyles, selection_group_base_element_default];
+		}
+		#size_accessor_storage = __runInitializers(this, _size_initializers, isLean() ? "xs" : "m");
+		/**
+		* Size variant, either xs, s or m.
+		* @default 'm' / 'xs' (lean)
+		*/
+		get size() {
+			return this.#size_accessor_storage;
+		}
+		set size(value) {
+			this.#size_accessor_storage = value;
+		}
+		#horizontalFrom_accessor_storage = (__runInitializers(this, _size_extraInitializers), __runInitializers(this, _horizontalFrom_initializers, null));
+		/** Overrides the behavior of `orientation` property. */
+		get horizontalFrom() {
+			return this.#horizontalFrom_accessor_storage;
+		}
+		set horizontalFrom(value) {
+			this.#horizontalFrom_accessor_storage = value;
+		}
+		#orientation_accessor_storage = (__runInitializers(this, _horizontalFrom_extraInitializers), __runInitializers(this, _orientation_initializers, "horizontal"));
+		/** Indicates the orientation of the checkboxes or panels inside the group. */
+		get orientation() {
+			return this.#orientation_accessor_storage;
+		}
+		set orientation(value) {
+			this.#orientation_accessor_storage = value;
+		}
+		/**
+		* List of contained selection elements.
+		* @internal
+		*/
+		get selectionElements() {
+			return Array.from(this.querySelectorAll?.(this.selectionElementSelectors) ?? []).filter((el) => el.closest?.(this.localName) === this);
+		}
+		constructor() {
+			super();
+			__runInitializers(this, _orientation_extraInitializers);
+			this.addController(new MutationController(this, {
+				config: {
+					childList: true,
+					subtree: true
+				},
+				callback: () => this.toggleState("has-panel", !!this.querySelector?.(this.panelElementSelector))
+			}));
+		}
+		willUpdate(changedProperties) {
+			super.willUpdate(changedProperties);
+			if (changedProperties.has("disabled")) this.selectionElements.forEach((c) => c.requestUpdate?.("disabled"));
+			if (changedProperties.has("required")) this.selectionElements.forEach((c) => c.requestUpdate?.("required"));
+			if (changedProperties.has("size")) this.selectionElements.forEach((c) => c.requestUpdate?.("size"));
+		}
+		onSlotChange() {}
+		render() {
+			return html`
+      <slot @slotchange=${() => this.onSlotChange()}></slot>
+      <slot name="error"></slot>
+    `;
+		}
+	};
+})();
+//#endregion
+export { SbbSelectionGroupBaseElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"selection-group-base-element-DrTO_80I.js","names":[],"sources":["../../../src/elements/core/base-elements/selection-group-base-element.scss?lit&inline","../../../src/elements/core/base-elements/selection-group-base-element.ts"],"sourcesContent":["@use '../styles' as sbb;\n\n@mixin horizontal-orientation {\n  --sbb-selection-group-orientation: row;\n  --sbb-selection-group-elements-width: auto;\n}\n\n$breakpoints: 'zero', 'small', 'large', 'ultra';\n\n:host {\n  display: flex;\n  flex-flow: var(--sbb-selection-group-orientation) wrap;\n  gap: var(--sbb-selection-group-gap);\n  align-items: flex-start;\n  width: var(--sbb-selection-group-width);\n}\n\n:host([orientation='vertical']) {\n  --sbb-selection-group-orientation: column;\n  --sbb-selection-group-width: 100%;\n  --sbb-selection-group-elements-width: 100%;\n}\n\n:host(:state(has-panel)) {\n  --sbb-selection-group-width: 100%;\n  --sbb-selection-group-gap: var(--sbb-spacing-fixed-2x) var(--sbb-spacing-fixed-4x);\n\n  // Distribute available space to the panels\n  --sbb-selection-group-elements-flex: auto;\n}\n\n@each $breakpoint in $breakpoints {\n  @include sbb.mq($from: #{$breakpoint}) {\n    // horizontal-from overrides orientation vertical\n    :host([orientation='vertical'][horizontal-from='#{$breakpoint}']) {\n      @include horizontal-orientation;\n    }\n\n    :host([orientation='vertical'][horizontal-from='#{$breakpoint}']:not(:state(has-panel))) {\n      --sbb-selection-group-width: auto;\n    }\n  }\n}\n\n// Move the error message to a separate line.\nslot[name='error']::slotted(*) {\n  flex-basis: 100%;\n}\n\n::slotted(:is(sbb-checkbox-panel, sbb-radio-button-panel)) {\n  flex: var(--sbb-selection-group-elements-flex);\n}\n\n::slotted(:is(sbb-checkbox, sbb-checkbox-panel, sbb-radio-button-panel)) {\n  width: var(--sbb-selection-group-elements-width);\n}\n","import { MutationController } from '@lit-labs/observers/mutation-controller.js';\nimport type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';\nimport { html } from 'lit';\nimport { property } from 'lit/decorators.js';\n\nimport { isLean } from '../dom.ts';\nimport type { SbbHorizontalFrom, SbbOrientation } from '../interfaces.ts';\nimport { SbbDisabledMixin, SbbRequiredMixin } from '../mixins.ts';\nimport { boxSizingStyles } from '../styles.ts';\n\nimport { SbbElement } from './element.ts';\nimport style from './selection-group-base-element.scss?lit&inline';\n\n/**\n * It can be used as a container for one or more `sbb-checkbox`.\n *\n * @slot - Use the unnamed slot to add `sbb-checkbox` elements to the `sbb-checkbox-group`.\n * @slot error - Slot used to render a `sbb-error` inside the `sbb-checkbox-group`.\n */\nexport abstract class SbbSelectionGroupBaseElement<T extends SbbElement> extends SbbDisabledMixin(\n  SbbRequiredMixin(SbbElement),\n) {\n  public static override styles: CSSResultGroup = [boxSizingStyles, style];\n\n  /**\n   * Size variant, either xs, s or m.\n   * @default 'm' / 'xs' (lean)\n   */\n  @property() public accessor size: 'xs' | 's' | 'm' = isLean() ? 'xs' : 'm';\n\n  /** Overrides the behavior of `orientation` property. */\n  @property({ attribute: 'horizontal-from', reflect: true })\n  public accessor horizontalFrom: SbbHorizontalFrom | null = null;\n\n  /** Indicates the orientation of the checkboxes or panels inside the group. */\n  @property({ reflect: true })\n  public accessor orientation: SbbOrientation = 'horizontal';\n\n  protected abstract readonly selectionElementSelectors: string;\n  protected abstract readonly panelElementSelector: string;\n\n  /**\n   * List of contained selection elements.\n   * @internal\n   */\n  public get selectionElements(): T[] {\n    return <T[]>(\n      Array.from(this.querySelectorAll?.(this.selectionElementSelectors) ?? []).filter(\n        (el) => el.closest?.(this.localName) === this,\n      )\n    );\n  }\n\n  protected constructor() {\n    super();\n    this.addController(\n      new MutationController(this, {\n        config: { childList: true, subtree: true },\n        callback: () =>\n          this.toggleState('has-panel', !!this.querySelector?.(this.panelElementSelector)),\n      }),\n    );\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    // TODO: Use PropertyWatcherController in selection elements\n    if (changedProperties.has('disabled')) {\n      this.selectionElements.forEach((c) => c.requestUpdate?.('disabled'));\n    }\n    if (changedProperties.has('required')) {\n      this.selectionElements.forEach((c) => c.requestUpdate?.('required'));\n    }\n    if (changedProperties.has('size')) {\n      this.selectionElements.forEach((c) => c.requestUpdate?.('size'));\n    }\n  }\n\n  protected onSlotChange(): void {}\n\n  protected override render(): TemplateResult {\n    return html`\n      <slot @slotchange=${() => this.onSlotChange()}></slot>\n      <slot name=\"error\"></slot>\n    `;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ICmBsB,sCAA4B;mBAA+B,iBAC/E,iBAAiB,WAAW,CAC7B;;;;;;;;;;cAFqB,qCAA2D,YAEhF;;;uBAOE,UAAU,CAAA;iCAGV,SAAS;IAAE,WAAW;IAAmB,SAAS;IAAM,CAAC,CAAA;8BAIzD,SAAS,EAAE,SAAS,MAAM,CAAC,CAAA;AAPhB,gBAAA,MAAA,MAAA,kBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,UAAA;KAAA,MAAA,QAAA,IAAgB;KAAI,MAAA,KAAA,UAAA;AAAA,UAAJ,OAAI;;KAAA;IAAA,UAAA;IAAA,EAAA,oBAAA,wBAAA;AAIhC,gBAAA,MAAA,MAAA,4BAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,oBAAA;KAAA,MAAA,QAAA,IAAgB;KAAc,MAAA,KAAA,UAAA;AAAA,UAAd,iBAAc;;KAAA;IAAA,UAAA;IAAA,EAAA,8BAAA,kCAAA;AAI9B,gBAAA,MAAA,MAAA,yBAAA;IAAA,MAAA;IAAA,MAAA;IAAA,QAAA;IAAA,SAAA;IAAA,QAAA;KAAA,MAAA,QAAA,iBAAA;KAAA,MAAA,QAAA,IAAgB;KAAW,MAAA,KAAA,UAAA;AAAA,UAAX,cAAW;;KAAA;IAAA,UAAA;IAAA,EAAA,2BAAA,+BAAA;;;;;;;;;AAdJ,QAAA,SAAyB,CAAC,iBAAiB,qCAAM;;EAM5D,yBAAA,kBAAA,MAAA,oBAAyC,QAAQ,GAAG,OAAO,IAAG;;;;;EAA9D,IAAgB,OAAI;AAAA,UAAA,MAAA;;EAApB,IAAgB,KAAI,OAAA;AAAA,SAAA,wBAAA;;EAIhC,oCAAA,kBAAA,MAAA,wBAAA,EAAA,kBAAA,MAAA,8BAA2D,KAAI;;EAA/D,IAAgB,iBAAc;AAAA,UAAA,MAAA;;EAA9B,IAAgB,eAAc,OAAA;AAAA,SAAA,kCAAA;;EAI9B,iCAAA,kBAAA,MAAA,kCAAA,EAAA,kBAAA,MAAA,2BAA8C,aAAY;;EAA1D,IAAgB,cAAW;AAAA,UAAA,MAAA;;EAA3B,IAAgB,YAAW,OAAA;AAAA,SAAA,+BAAA;;;;;;EAS3B,IAAW,oBAAiB;AAC1B,UACE,MAAM,KAAK,KAAK,mBAAmB,KAAK,0BAA0B,IAAI,EAAE,CAAC,CAAC,QACvE,OAAO,GAAG,UAAU,KAAK,UAAU,KAAK,KAC1C;;EAIL,cAAA;AACE,UAAO;;AACP,QAAK,cACH,IAAI,mBAAmB,MAAM;IAC3B,QAAQ;KAAE,WAAW;KAAM,SAAS;KAAM;IAC1C,gBACE,KAAK,YAAY,aAAa,CAAC,CAAC,KAAK,gBAAgB,KAAK,qBAAqB,CAAA;IAClF,CAAC,CACH;;EAGgB,WAAW,mBAAuC;AACnE,SAAM,WAAW,kBAAkB;AAGnC,OAAI,kBAAkB,IAAI,WAAW,CACnC,MAAK,kBAAkB,SAAS,MAAM,EAAE,gBAAgB,WAAW,CAAC;AAEtE,OAAI,kBAAkB,IAAI,WAAW,CACnC,MAAK,kBAAkB,SAAS,MAAM,EAAE,gBAAgB,WAAW,CAAC;AAEtE,OAAI,kBAAkB,IAAI,OAAO,CAC/B,MAAK,kBAAkB,SAAS,MAAM,EAAE,gBAAgB,OAAO,CAAC;;EAI1D,eAAY;EAEH,SAAM;AACvB,UAAO,IAAI;gCACiB,KAAK,cAAc,CAAA"}

package/development/sidebar/common/styles.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=styles.d.ts.map

package/development/sidebar/common/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../../../src/elements/sidebar/common/styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AACpG,OAAO,EAAE,OAAO,IAAI,yBAAyB,EAAE,MAAM,0CAA0C,CAAC;AAChG,OAAO,EAAE,OAAO,IAAI,4BAA4B,EAAE,MAAM,8CAA8C,CAAC"}

package/development/sidebar/common/styles.js

@@ -0,0 +1,2 @@
+import { n as sidebar_content_common_default, r as sidebar_container_common_default, t as icon_sidebar_button_common_default } from "../../styles-BlQUk9lF.js";
+export { icon_sidebar_button_common_default as iconSidebarButtonCommonStyle, sidebar_container_common_default as sidebarContainerCommonStyle, sidebar_content_common_default as sidebarContentCommonStyle };

package/development/sidebar/common.d.ts

@@ -1,4 +1,3 @@
-/**
- * @entrypoint
- */
+/** @entrypoint */
+export * from './common/styles.ts';
 //# sourceMappingURL=common.d.ts.map

package/development/sidebar/common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/elements/sidebar/common.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,OAAO,IAAI,2BAA2B,EAAE,MAAM,mDAAmD,CAAC;AAC3G,OAAO,EAAE,OAAO,IAAI,yBAAyB,EAAE,MAAM,iDAAiD,CAAC;AACvG,OAAO,EAAE,OAAO,IAAI,4BAA4B,EAAE,MAAM,qDAAqD,CAAC"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/elements/sidebar/common.ts"],"names":[],"mappings":"AAAA,kBAAkB;AAClB,cAAc,oBAAoB,CAAC"}