@sbb-esta/lyne-elements-dev 4.7.0-dev.1773333589 → 4.7.0-dev.1773388991

package/development/slider.component-B7EFECZk.js

@@ -0,0 +1,479 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { css, html, nothing } from "lit";
+import { property } from "lit/decorators.js";
+import { SbbElement } from "./core/base-elements.js";
+import { forceType, hostAttributes } from "./core/decorators.js";
+import { SbbDisabledMixin, SbbFormAssociatedMixin, SbbReadonlyMixin } from "./core/mixins.js";
+import { boxSizingStyles } from "./core/styles.js";
+import "./icon.js";
+import { ref } from "lit/directives/ref.js";
+//#region src/elements/slider/slider.scss?lit&inline
+var slider_default = css`@charset "UTF-8";
+:host {
+  outline: none !important;
+  display: inline-block;
+  min-width: 9.375rem;
+  width: min(25rem, 100%);
+  --sbb-slider-line-height: 0.25rem;
+  --sbb-slider-value-fraction: 0;
+  --sbb-slider-knob-size: 1.75rem;
+  --sbb-slider-knob-size-active: 1.9375rem;
+  --sbb-slider-knob-border-size: 0.1875rem;
+  --sbb-slider-knob-border-style: solid;
+  --sbb-slider-knob-color: var(--sbb-background-color-1);
+  --sbb-slider-knob-border-color: var(--sbb-color-primary);
+  --sbb-slider-icon-color: var(--sbb-color-1);
+  --sbb-slider-selected-line-color: var(--sbb-color-primary);
+  --sbb-slider-selected-line-disabled-color: var(--sbb-color-smoke);
+  --sbb-slider-selected-line-disabled-color: light-dark(
+    var(--sbb-color-smoke),
+    var(--sbb-color-cement)
+  );
+  --sbb-slider-line-color: var(--sbb-border-color-5);
+  --sbb-slider-line-disabled-color: var(--sbb-color-graphite);
+  --sbb-slider-line-disabled-color: light-dark(var(--sbb-color-graphite), var(--sbb-color-granite));
+}
+@media (forced-colors: active) {
+  :host {
+    --sbb-slider-selected-line-color: Highlight;
+    --sbb-slider-line-color: CanvasText;
+  }
+}
+
+:host(:disabled) {
+  --sbb-slider-icon-color: var(--sbb-color-graphite);
+  --sbb-slider-icon-color: light-dark(var(--sbb-color-graphite), var(--sbb-color-smoke));
+  --sbb-slider-knob-border-color: var(--sbb-border-color-5);
+  --sbb-slider-knob-border-size: var(--sbb-border-width-2x);
+  --sbb-slider-knob-border-style: dashed;
+}
+
+:host([readonly]) {
+  --sbb-slider-icon-color: var(--sbb-color-5);
+  --sbb-slider-knob-border-color: var(--sbb-slider-selected-line-disabled-color);
+}
+
+:host(:disabled),
+:host([readonly]) {
+  --sbb-slider-line-color: var(--sbb-slider-line-disabled-color);
+  --sbb-slider-selected-line-color: var(--sbb-slider-selected-line-disabled-color);
+}
+@media (forced-colors: active) {
+  :host(:disabled),
+  :host([readonly]) {
+    --sbb-slider-icon-color: GrayText;
+    --sbb-slider-selected-line-disabled-color: GrayText;
+    --sbb-slider-line-disabled-color: GrayText;
+  }
+}
+
+.sbb-slider__height-container {
+  display: flex;
+  flex-direction: column;
+}
+.sbb-slider__height-container::before {
+  content: "​";
+  user-select: none;
+  width: 0;
+  height: 0;
+}
+
+.sbb-slider__wrapper {
+  display: flex;
+  gap: var(--sbb-spacing-fixed-2x);
+  padding-block: calc(var(--sbb-spacing-fixed-1x) / 2);
+  color: var(--sbb-slider-icon-color);
+}
+
+.sbb-slider__container {
+  position: relative;
+  min-height: var(--sbb-size-icon-ui-small);
+  flex-grow: 1;
+}
+
+.sbb-slider__range-input {
+  position: absolute;
+  width: 100%;
+  inset: 0;
+  opacity: 0;
+  margin: 0;
+}
+
+.sbb-slider__line {
+  position: absolute;
+  top: 50%;
+  transform: translateY(-50%);
+  height: var(--sbb-slider-line-height);
+  width: 100%;
+  background-color: var(--sbb-slider-line-color);
+  border-radius: var(--sbb-slider-line-height);
+  overflow: hidden;
+  pointer-events: none;
+}
+
+.sbb-slider__selected-line {
+  position: relative;
+  height: 100%;
+  background-color: var(--sbb-slider-selected-line-color);
+  width: calc(var(--sbb-slider-value-fraction) * 100%);
+}
+
+.sbb-slider__knob {
+  position: absolute;
+  top: 50%;
+  transform: translateY(-50%);
+  box-shadow: var(--sbb-box-shadow-level-5-hard);
+  width: var(--sbb-slider-knob-size);
+  height: var(--sbb-slider-knob-size);
+  inset-inline-start: calc(var(--sbb-slider-value-fraction) * 100% - var(--sbb-slider-knob-size) * var(--sbb-slider-value-fraction));
+  transition-property: width, height;
+  transition-duration: var(--sbb-disable-animation-duration, var(--sbb-animation-duration-1x));
+  transition-timing-function: ease-in;
+  background-color: var(--sbb-slider-knob-color);
+  border: var(--sbb-slider-knob-border-size) var(--sbb-slider-knob-border-style) var(--sbb-slider-knob-border-color);
+  border-radius: 50%;
+  pointer-events: none;
+}
+:host(:focus-visible) .sbb-slider__knob {
+  outline-offset: var(--sbb-focus-outline-offset);
+  outline: var(--sbb-focus-outline-color) var(--sbb-focus-outline-style, solid) var(--sbb-focus-outline-width);
+  --sbb-slider-knob-size: var(--sbb-slider-knob-size-active);
+}
+:host(:not(:is(:disabled, [readonly]))) .sbb-slider__range-input:active ~ .sbb-slider__knob {
+  --sbb-slider-knob-size: var(--sbb-slider-knob-size-active);
+}`;
+//#endregion
+//#region src/elements/slider/slider.component.ts
+/**
+* It displays an input knob that can be moved in a range.
+*
+* @slot prefix - Use this slot to render an icon on the left side of the input.
+* @slot suffix - Use this slot to render an icon on the right side of the input.
+* @event {InputEvent} input - The input event fires when the value has been changed as a direct result of a user action.
+*/
+var SbbSliderElement = (() => {
+	let _classDecorators = [hostAttributes({ tabindex: "0" })];
+	let _classDescriptor;
+	let _classExtraInitializers = [];
+	let _classThis;
+	let _classSuper = SbbDisabledMixin(SbbReadonlyMixin(SbbFormAssociatedMixin(SbbElement)));
+	let _instanceExtraInitializers = [];
+	let _set_value_decorators;
+	let _set_valueAsNumber_decorators;
+	let _set_min_decorators;
+	let _set_max_decorators;
+	let _startIcon_decorators;
+	let _startIcon_initializers = [];
+	let _startIcon_extraInitializers = [];
+	let _endIcon_decorators;
+	let _endIcon_initializers = [];
+	let _endIcon_extraInitializers = [];
+	var SbbSliderElement = class extends _classSuper {
+		static {
+			_classThis = this;
+		}
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_set_value_decorators = [property()];
+			_set_valueAsNumber_decorators = [property({
+				attribute: "value-as-number",
+				type: Number
+			})];
+			_set_min_decorators = [property()];
+			_set_max_decorators = [property()];
+			_startIcon_decorators = [forceType(), property({ attribute: "start-icon" })];
+			_endIcon_decorators = [forceType(), property({ attribute: "end-icon" })];
+			__esDecorate(this, null, _set_value_decorators, {
+				kind: "setter",
+				name: "value",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "value" in obj,
+					set: (obj, value) => {
+						obj.value = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _set_valueAsNumber_decorators, {
+				kind: "setter",
+				name: "valueAsNumber",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "valueAsNumber" in obj,
+					set: (obj, value) => {
+						obj.valueAsNumber = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _set_min_decorators, {
+				kind: "setter",
+				name: "min",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "min" in obj,
+					set: (obj, value) => {
+						obj.min = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _set_max_decorators, {
+				kind: "setter",
+				name: "max",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "max" in obj,
+					set: (obj, value) => {
+						obj.max = value;
+					}
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _startIcon_decorators, {
+				kind: "accessor",
+				name: "startIcon",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "startIcon" in obj,
+					get: (obj) => obj.startIcon,
+					set: (obj, value) => {
+						obj.startIcon = value;
+					}
+				},
+				metadata: _metadata
+			}, _startIcon_initializers, _startIcon_extraInitializers);
+			__esDecorate(this, null, _endIcon_decorators, {
+				kind: "accessor",
+				name: "endIcon",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "endIcon" in obj,
+					get: (obj) => obj.endIcon,
+					set: (obj, value) => {
+						obj.endIcon = value;
+					}
+				},
+				metadata: _metadata
+			}, _endIcon_initializers, _endIcon_extraInitializers);
+			__esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, {
+				kind: "class",
+				name: _classThis.name,
+				metadata: _metadata
+			}, null, _classExtraInitializers);
+			SbbSliderElement = _classThis = _classDescriptor.value;
+			if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static {
+			this.elementName = "sbb-slider";
+		}
+		static {
+			this.role = "slider";
+		}
+		static {
+			this.styles = [boxSizingStyles, slider_default];
+		}
+		static {
+			this.events = { didChange: "didChange" };
+		}
+		/**
+		* Value of the form element.
+		* If no value is provided, default is the middle point between min and max.
+		*/
+		set value(value) {
+			if (this._isValidNumber(value)) this._value = this._boundBetweenMinMax(value);
+			else this._value = null;
+			this.internals.ariaValueNow = this.value;
+		}
+		get value() {
+			return this._value ?? this._defaultValue();
+		}
+		/** Numeric value for the inner HTMLInputElement. */
+		set valueAsNumber(value) {
+			this.value = value?.toString() ?? null;
+		}
+		get valueAsNumber() {
+			return Number(this.value);
+		}
+		/** Minimum acceptable value for the inner HTMLInputElement. */
+		set min(value) {
+			if (!this._isValidNumber(value)) return;
+			this._min = value;
+			this.internals.ariaValueMin = this.min;
+			const boundValue = this._boundBetweenMinMax(this.value);
+			if (this.value !== boundValue) this.value = boundValue;
+		}
+		get min() {
+			return this._min;
+		}
+		/** Maximum acceptable value for the inner HTMLInputElement. */
+		set max(value) {
+			if (!this._isValidNumber(value)) return;
+			this._max = value;
+			this.internals.ariaValueMax = this.max;
+			const boundValue = this._boundBetweenMinMax(this.value);
+			if (this.value !== boundValue) this.value = boundValue;
+		}
+		get max() {
+			return this._max;
+		}
+		#startIcon_accessor_storage;
+		/** Name of the icon at component's start, which will be forward to the nested `sbb-icon`. */
+		get startIcon() {
+			return this.#startIcon_accessor_storage;
+		}
+		set startIcon(value) {
+			this.#startIcon_accessor_storage = value;
+		}
+		#endIcon_accessor_storage;
+		/** Name of the icon at component's end, which will be forward to the nested `sbb-icon`. */
+		get endIcon() {
+			return this.#endIcon_accessor_storage;
+		}
+		set endIcon(value) {
+			this.#endIcon_accessor_storage = value;
+		}
+		/**
+		* Form type of element.
+		* @default 'range'
+		*/
+		get type() {
+			return "range";
+		}
+		constructor() {
+			super();
+			this._value = (__runInitializers(this, _instanceExtraInitializers), null);
+			this._min = "0";
+			this._max = "100";
+			this.#startIcon_accessor_storage = __runInitializers(this, _startIcon_initializers, "");
+			this.#endIcon_accessor_storage = (__runInitializers(this, _startIcon_extraInitializers), __runInitializers(this, _endIcon_initializers, ""));
+			/** Reference to the inner HTMLInputElement with type='range'. */
+			this._rangeInput = __runInitializers(this, _endIcon_extraInitializers);
+			this.addEventListener?.("keydown", (e) => this._handleKeydown(e));
+		}
+		willUpdate(changedProperties) {
+			super.willUpdate(changedProperties);
+			if (changedProperties.has("readOnly")) this.internals.ariaReadOnly = Boolean(this.readOnly).toString();
+			this.style?.setProperty("--sbb-slider-value-fraction", this._valueFraction().toString());
+		}
+		/**
+		* The reset value is the attribute value (the setup value). If not present, calculates the default.
+		* @internal
+		*/
+		formResetCallback() {
+			this.value = this.getAttribute("value") ?? this._defaultValue();
+		}
+		/**
+		* @internal
+		*/
+		formStateRestoreCallback(state, _reason) {
+			this.value = state;
+		}
+		/**
+		*  If no value is provided, default is the middle point between min and max
+		*  (see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/range#value)
+		*/
+		_defaultValue() {
+			return (+this.min + (+this.max - +this.min) / 2).toString();
+		}
+		_isValidNumber(value) {
+			return !!value && !isNaN(Number(value));
+		}
+		/**
+		* Restrains the value between the min and max
+		*/
+		_boundBetweenMinMax(value) {
+			return Math.max(+this.min, Math.min(+this.max, +value)).toString();
+		}
+		_valueFraction() {
+			const value = this.valueAsNumber;
+			const min = +this.min;
+			const max = +this.max;
+			const mathFraction = (value - min) / (max - min);
+			return isNaN(mathFraction) ? 0 : Math.max(0, Math.min(1, mathFraction));
+		}
+		async _handleKeydown(event) {
+			if (event.key !== "Tab") event.preventDefault();
+			if (this.readOnly) return;
+			if (event.key === "Home") this._rangeInput.value = this.min;
+			else if (event.key === "End") this._rangeInput.value = this.max;
+			else if (event.key === "ArrowLeft" || event.key === "ArrowDown") this._rangeInput.stepDown();
+			else if (event.key === "ArrowRight" || event.key === "ArrowUp") this._rangeInput.stepUp();
+			else if (event.key === "PageDown") this._rangeInput.stepDown((+this.max - +this.min) / 10);
+			else if (event.key === "PageUp") this._rangeInput.stepUp((+this.max - +this.min) / 10);
+			else return;
+			this._rangeInput.dispatchEvent(new InputEvent("input", {
+				bubbles: true,
+				cancelable: true,
+				composed: true
+			}));
+			this._rangeInput.dispatchEvent(new Event("change", { bubbles: true }));
+		}
+		/** Emits the change event. */
+		_dispatchChangeEvent() {
+			/**
+			* The change event is fired when the user modifies the element's value.
+			* Unlike the input event, the change event is not necessarily fired
+			* for each alteration to an element's value.
+			*/
+			this.dispatchEvent(new Event("change", { bubbles: true }));
+			/**
+			* Deprecated. Mirrors change event for React. Will be removed once React properly supports change events.
+			* @deprecated
+			*/
+			this.dispatchEvent(new Event("didChange", { bubbles: true }));
+		}
+		render() {
+			return html`
+      <div class="sbb-slider__height-container">
+        <div class="sbb-slider__wrapper">
+          <slot name="prefix">
+            ${this.startIcon ? html`<sbb-icon name="${this.startIcon}"></sbb-icon>` : nothing}
+          </slot>
+          <div class="sbb-slider__container">
+            <input
+              tabindex="-1"
+              min=${this.min}
+              max=${this.max}
+              ?disabled=${this.disabled || this.formDisabled || this.readOnly}
+              value=${this.value || nothing}
+              class="sbb-slider__range-input"
+              type="range"
+              @change=${() => this._dispatchChangeEvent()}
+              @input=${() => this.value = this._rangeInput.value}
+              ${ref((input) => this._rangeInput = input)}
+            />
+            <div class="sbb-slider__line">
+              <div class="sbb-slider__selected-line"></div>
+            </div>
+            <div class="sbb-slider__knob"></div>
+          </div>
+          <slot name="suffix">
+            ${this.endIcon ? html`<sbb-icon name="${this.endIcon}"></sbb-icon>` : nothing}
+          </slot>
+        </div>
+      </div>
+    `;
+		}
+		static {
+			__runInitializers(_classThis, _classExtraInitializers);
+		}
+	};
+	return _classThis;
+})();
+//#endregion
+export { SbbSliderElement as t };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"slider.component-B7EFECZk.js","names":[],"sources":["../../../src/elements/slider/slider.scss?lit&inline","../../../src/elements/slider/slider.component.ts"],"sourcesContent":["@use '../core/styles' as sbb;\n\n:host {\n  // Use !important here to not interfere with Firefox focus ring definition\n  // which appears in normalize CSS of several frameworks.\n  outline: none !important;\n  display: inline-block;\n  min-width: #{sbb.px-to-rem-build(150)};\n  width: min(#{sbb.px-to-rem-build(400)}, 100%);\n\n  --sbb-slider-line-height: #{sbb.px-to-rem-build(4)};\n  --sbb-slider-value-fraction: 0;\n  --sbb-slider-knob-size: #{sbb.px-to-rem-build(28)};\n  --sbb-slider-knob-size-active: #{sbb.px-to-rem-build(31)};\n  --sbb-slider-knob-border-size: #{sbb.px-to-rem-build(3)};\n  --sbb-slider-knob-border-style: solid;\n  --sbb-slider-knob-color: var(--sbb-background-color-1);\n  --sbb-slider-knob-border-color: var(--sbb-color-primary);\n  --sbb-slider-icon-color: var(--sbb-color-1);\n  --sbb-slider-selected-line-color: var(--sbb-color-primary);\n  --sbb-slider-selected-line-disabled-color: light-dark(\n    var(--sbb-color-smoke),\n    var(--sbb-color-cement)\n  );\n  --sbb-slider-line-color: var(--sbb-border-color-5);\n  --sbb-slider-line-disabled-color: light-dark(var(--sbb-color-graphite), var(--sbb-color-granite));\n\n  @include sbb.if-forced-colors {\n    --sbb-slider-selected-line-color: Highlight;\n    --sbb-slider-line-color: CanvasText;\n  }\n}\n\n:host(:disabled) {\n  --sbb-slider-icon-color: light-dark(var(--sbb-color-graphite), var(--sbb-color-smoke));\n  --sbb-slider-knob-border-color: var(--sbb-border-color-5);\n  --sbb-slider-knob-border-size: var(--sbb-border-width-2x);\n  --sbb-slider-knob-border-style: dashed;\n}\n\n:host([readonly]) {\n  --sbb-slider-icon-color: var(--sbb-color-5);\n  --sbb-slider-knob-border-color: var(--sbb-slider-selected-line-disabled-color);\n}\n\n:host(:disabled),\n:host([readonly]) {\n  --sbb-slider-line-color: var(--sbb-slider-line-disabled-color);\n  --sbb-slider-selected-line-color: var(--sbb-slider-selected-line-disabled-color);\n\n  @include sbb.if-forced-colors {\n    --sbb-slider-icon-color: GrayText;\n    --sbb-slider-selected-line-disabled-color: GrayText;\n    --sbb-slider-line-disabled-color: GrayText;\n  }\n}\n\n.sbb-slider__height-container {\n  display: flex;\n  flex-direction: column;\n\n  @include sbb.zero-width-space;\n}\n\n.sbb-slider__wrapper {\n  display: flex;\n  gap: var(--sbb-spacing-fixed-2x);\n  padding-block: calc(var(--sbb-spacing-fixed-1x) / 2);\n  color: var(--sbb-slider-icon-color);\n}\n\n.sbb-slider__container {\n  position: relative;\n  min-height: var(--sbb-size-icon-ui-small);\n  flex-grow: 1;\n}\n\n.sbb-slider__range-input {\n  position: absolute;\n  width: 100%;\n  inset: 0;\n  opacity: 0;\n  margin: 0;\n}\n\n.sbb-slider__line {\n  @include sbb.absolute-center-y;\n\n  height: var(--sbb-slider-line-height);\n  width: 100%;\n  background-color: var(--sbb-slider-line-color);\n  border-radius: var(--sbb-slider-line-height);\n  overflow: hidden;\n  pointer-events: none;\n}\n\n.sbb-slider__selected-line {\n  position: relative;\n  height: 100%;\n  background-color: var(--sbb-slider-selected-line-color);\n  width: calc(var(--sbb-slider-value-fraction) * 100%);\n}\n\n.sbb-slider__knob {\n  @include sbb.absolute-center-y;\n\n  box-shadow: var(--sbb-box-shadow-level-5-hard);\n  width: var(--sbb-slider-knob-size);\n  height: var(--sbb-slider-knob-size);\n  inset-inline-start: calc(\n    calc(var(--sbb-slider-value-fraction) * 100%) - var(--sbb-slider-knob-size) *\n      var(--sbb-slider-value-fraction)\n  );\n  transition-property: width, height;\n  transition-duration: var(--sbb-disable-animation-duration, var(--sbb-animation-duration-1x));\n  transition-timing-function: ease-in;\n  background-color: var(--sbb-slider-knob-color);\n  border: var(--sbb-slider-knob-border-size) var(--sbb-slider-knob-border-style)\n    var(--sbb-slider-knob-border-color);\n  border-radius: 50%;\n  pointer-events: none;\n\n  :host(:focus-visible) & {\n    @include sbb.focus-outline;\n\n    --sbb-slider-knob-size: var(--sbb-slider-knob-size-active);\n  }\n\n  // slider knob resize on click (active / focus)\n  :host(:not(:is(:disabled, [readonly]))) .sbb-slider__range-input:active ~ & {\n    --sbb-slider-knob-size: var(--sbb-slider-knob-size-active);\n  }\n}\n","import type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';\nimport { html, nothing } from 'lit';\nimport { property } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\n\nimport { SbbElement } from '../core/base-elements.ts';\nimport { forceType, hostAttributes } from '../core/decorators.ts';\nimport {\n  type FormRestoreReason,\n  type FormRestoreState,\n  SbbDisabledMixin,\n  SbbFormAssociatedMixin,\n  SbbReadonlyMixin,\n} from '../core/mixins.ts';\nimport { boxSizingStyles } from '../core/styles.ts';\n\nimport style from './slider.scss?lit&inline';\n\nimport '../icon.ts';\n\n/**\n * It displays an input knob that can be moved in a range.\n *\n * @slot prefix - Use this slot to render an icon on the left side of the input.\n * @slot suffix - Use this slot to render an icon on the right side of the input.\n * @event {InputEvent} input - The input event fires when the value has been changed as a direct result of a user action.\n */\nexport\n@hostAttributes({\n  tabindex: '0',\n})\nclass SbbSliderElement extends SbbDisabledMixin(\n  SbbReadonlyMixin(SbbFormAssociatedMixin(SbbElement)),\n) {\n  public static override readonly elementName: string = 'sbb-slider';\n  public static override readonly role = 'slider';\n  public static override styles: CSSResultGroup = [boxSizingStyles, style];\n  public static readonly events = {\n    didChange: 'didChange',\n  } as const;\n\n  /**\n   * Value of the form element.\n   * If no value is provided, default is the middle point between min and max.\n   */\n  @property()\n  public set value(value: string | null) {\n    if (this._isValidNumber(value)) {\n      this._value = this._boundBetweenMinMax(value);\n    } else {\n      this._value = null;\n    }\n    this.internals.ariaValueNow = this.value;\n  }\n  public get value(): string {\n    return this._value ?? this._defaultValue();\n  }\n  private _value: string | null = null;\n\n  /** Numeric value for the inner HTMLInputElement. */\n  @property({ attribute: 'value-as-number', type: Number })\n  public set valueAsNumber(value: number | null) {\n    this.value = value?.toString() ?? null;\n  }\n  public get valueAsNumber(): number | null {\n    return Number(this.value);\n  }\n\n  /** Minimum acceptable value for the inner HTMLInputElement. */\n  @property()\n  public set min(value: string) {\n    if (!this._isValidNumber(value)) {\n      return;\n    }\n\n    this._min = value;\n    this.internals.ariaValueMin = this.min;\n    const boundValue = this._boundBetweenMinMax(this.value);\n    if (this.value !== boundValue) {\n      this.value = boundValue;\n    }\n  }\n  public get min(): string {\n    return this._min;\n  }\n  private _min: string = '0';\n\n  /** Maximum acceptable value for the inner HTMLInputElement. */\n  @property()\n  public set max(value: string) {\n    if (!this._isValidNumber(value)) {\n      return;\n    }\n\n    this._max = value;\n    this.internals.ariaValueMax = this.max;\n    const boundValue = this._boundBetweenMinMax(this.value);\n    if (this.value !== boundValue) {\n      this.value = boundValue;\n    }\n  }\n  public get max(): string {\n    return this._max;\n  }\n  private _max: string = '100';\n\n  /** Name of the icon at component's start, which will be forward to the nested `sbb-icon`. */\n  @forceType()\n  @property({ attribute: 'start-icon' })\n  public accessor startIcon: string = '';\n\n  /** Name of the icon at component's end, which will be forward to the nested `sbb-icon`. */\n  @forceType()\n  @property({ attribute: 'end-icon' })\n  public accessor endIcon: string = '';\n\n  /**\n   * Form type of element.\n   * @default 'range'\n   */\n  public override get type(): string {\n    return 'range';\n  }\n\n  /** Reference to the inner HTMLInputElement with type='range'. */\n  private _rangeInput!: HTMLInputElement;\n\n  public constructor() {\n    super();\n    this.addEventListener?.('keydown', (e) => this._handleKeydown(e));\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (changedProperties.has('readOnly')) {\n      this.internals.ariaReadOnly = Boolean(this.readOnly).toString();\n    }\n    this.style?.setProperty('--sbb-slider-value-fraction', this._valueFraction().toString());\n  }\n\n  /**\n   * The reset value is the attribute value (the setup value). If not present, calculates the default.\n   * @internal\n   */\n  public formResetCallback(): void {\n    this.value = this.getAttribute('value') ?? this._defaultValue();\n  }\n\n  /**\n   * @internal\n   */\n  public formStateRestoreCallback(\n    state: FormRestoreState | null,\n    _reason: FormRestoreReason,\n  ): void {\n    this.value = state as string | null;\n  }\n\n  /**\n   *  If no value is provided, default is the middle point between min and max\n   *  (see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/range#value)\n   */\n  private _defaultValue(): string {\n    return (+this.min + (+this.max - +this.min) / 2).toString();\n  }\n\n  private _isValidNumber(value: string | null): value is string {\n    return !!value && !isNaN(Number(value));\n  }\n\n  /**\n   * Restrains the value between the min and max\n   */\n  private _boundBetweenMinMax(value: string): string {\n    return Math.max(+this.min, Math.min(+this.max, +value)).toString();\n  }\n\n  private _valueFraction(): number {\n    const value = this.valueAsNumber!;\n    const min = +this.min;\n    const max = +this.max;\n\n    const mathFraction: number = (value - min) / (max - min);\n    return isNaN(mathFraction) ? 0 : Math.max(0, Math.min(1, mathFraction));\n  }\n\n  private async _handleKeydown(event: KeyboardEvent): Promise<void> {\n    if (event.key !== 'Tab') {\n      event.preventDefault();\n    }\n\n    if (this.readOnly) {\n      return;\n    }\n\n    if (event.key === 'Home') {\n      this._rangeInput.value = this.min;\n    } else if (event.key === 'End') {\n      this._rangeInput.value = this.max;\n    } else if (event.key === 'ArrowLeft' || event.key === 'ArrowDown') {\n      this._rangeInput.stepDown();\n    } else if (event.key === 'ArrowRight' || event.key === 'ArrowUp') {\n      this._rangeInput.stepUp();\n    } else if (event.key === 'PageDown') {\n      this._rangeInput.stepDown((+this.max - +this.min) / 10);\n    } else if (event.key === 'PageUp') {\n      this._rangeInput.stepUp((+this.max - +this.min) / 10);\n    } else {\n      return;\n    }\n\n    // We have to manually fire events because programmatic changes don't trigger them\n    this._rangeInput.dispatchEvent(\n      new InputEvent('input', { bubbles: true, cancelable: true, composed: true }),\n    );\n    this._rangeInput.dispatchEvent(new Event('change', { bubbles: true }));\n  }\n\n  /** Emits the change event. */\n  private _dispatchChangeEvent(): void {\n    /**\n     * The change event is fired when the user modifies the element's value.\n     * Unlike the input event, the change event is not necessarily fired\n     * for each alteration to an element's value.\n     */\n    this.dispatchEvent(new Event('change', { bubbles: true }));\n\n    /**\n     * Deprecated. Mirrors change event for React. Will be removed once React properly supports change events.\n     * @deprecated\n     */\n    this.dispatchEvent(new Event('didChange', { bubbles: true }));\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <div class=\"sbb-slider__height-container\">\n        <div class=\"sbb-slider__wrapper\">\n          <slot name=\"prefix\">\n            ${this.startIcon ? html`<sbb-icon name=\"${this.startIcon}\"></sbb-icon>` : nothing}\n          </slot>\n          <div class=\"sbb-slider__container\">\n            <input\n              tabindex=\"-1\"\n              min=${this.min}\n              max=${this.max}\n              ?disabled=${this.disabled || this.formDisabled || this.readOnly}\n              value=${this.value || nothing}\n              class=\"sbb-slider__range-input\"\n              type=\"range\"\n              @change=${() => this._dispatchChangeEvent()}\n              @input=${() => (this.value = this._rangeInput.value)}\n              ${ref((input?: Element) => (this._rangeInput = input as HTMLInputElement))}\n            />\n            <div class=\"sbb-slider__line\">\n              <div class=\"sbb-slider__selected-line\"></div>\n            </div>\n            <div class=\"sbb-slider__knob\"></div>\n          </div>\n          <slot name=\"suffix\">\n            ${this.endIcon ? html`<sbb-icon name=\"${this.endIcon}\"></sbb-icon>` : nothing}\n          </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-slider': SbbSliderElement;\n  }\n}\n"],"mappings":"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"}

package/development/slider.js

@@ -1,6 +1,9 @@
-import { SbbSliderElement } from "./slider/slider.component.js";
+import { t as SbbSliderElement } from "./slider.component-B7EFECZk.js";
+import "./slider.pure.js";
+//#region src/elements/slider.ts
+/** @entrypoint */
 SbbSliderElement.define();
-export {
-  SbbSliderElement
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpZGVyLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZWxlbWVudHMvc2xpZGVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKiBAZW50cnlwb2ludCAqL1xuaW1wb3J0IHsgU2JiU2xpZGVyRWxlbWVudCB9IGZyb20gJy4vc2xpZGVyLnB1cmUudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL3NsaWRlci5wdXJlLnRzJztcblxuU2JiU2xpZGVyRWxlbWVudC5kZWZpbmUoKTtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBS0EsaUJBQWlCLE9BQUE7In0=
+//#endregion
+export { SbbSliderElement };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpZGVyLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9lbGVtZW50cy9zbGlkZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqIEBlbnRyeXBvaW50ICovXG5pbXBvcnQgeyBTYmJTbGlkZXJFbGVtZW50IH0gZnJvbSAnLi9zbGlkZXIucHVyZS50cyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vc2xpZGVyLnB1cmUudHMnO1xuXG5TYmJTbGlkZXJFbGVtZW50LmRlZmluZSgpO1xuIl0sIm1hcHBpbmdzIjoiOzs7O0FBS0EsaUJBQWlCLFFBQVEifQ==

package/development/slider.pure.js

@@ -1,5 +1,2 @@
-import { SbbSliderElement } from "./slider/slider.component.js";
-export {
-  SbbSliderElement
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpZGVyLnB1cmUuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOyJ9
+import { t as SbbSliderElement } from "./slider.component-B7EFECZk.js";
+export { SbbSliderElement };