@ui5/webcomponents 0.0.0-453158269 → 0.0.0-4738ea0dc

package/src/{RangeSlider.js → RangeSlider.ts}

@@ -1,5 +1,8 @@
+import customElement from "@ui5/webcomponents-base/dist/decorators/customElement.js";
+import property from "@ui5/webcomponents-base/dist/decorators/property.js";
 import Float from "@ui5/webcomponents-base/dist/types/Float.js";
 import { getI18nBundle } from "@ui5/webcomponents-base/dist/i18nBundle.js";
+import type I18nBundle from "@ui5/webcomponents-base/dist/i18nBundle.js";
 import {
 	isEscape,
 	isHome,
@@ -19,44 +22,12 @@ import {
 // Styles
 import rangeSliderStyles from "./generated/themes/RangeSlider.css.js";
 
-/**
- * @public
- */
-const metadata = {
-	tag: "ui5-range-slider",
-	languageAware: true,
-	managedSlots: true,
-	properties: /** @lends sap.ui.webcomponents.main.RangeSlider.prototype */  {
-		/**
-		 * Defines start point of a selection - position of a first handle on the slider.
-		 * <br><br>
-		 *
-		 * @type {Float}
-		 * @defaultvalue 0
-		 * @public
-		 */
-		startValue: {
-			type: Float,
-			defaultValue: 0,
-		},
-		/**
-		 * Defines end point of a selection - position of a second handle on the slider.
-		 * <br><br>
-		 *
-		 * @type {Float}
-		 * @defaultvalue 100
-		 * @public
-		 */
-		endValue: {
-			type: Float,
-			defaultValue: 100,
-		},
-
-		rangePressed: {
-			type: Boolean,
-		},
-	},
-};
+type AriaHandlesText = {
+	startHandleText?: string,
+	endHandleText?: string,
+}
+
+type AffectedValue = "startValue" | "endValue";
 
 /**
  * @class
@@ -87,6 +58,17 @@ const metadata = {
  * <h3>Responsive Behavior</h3>
  * You can move the currently selected range by clicking on it and dragging it along the interval.
  *
+ * <h3>CSS Shadow Parts</h3>
+ *
+ * <ui5-link target="_blank" href="https://developer.mozilla.org/en-US/docs/Web/CSS/::part">CSS Shadow Parts</ui5-link> allow developers to style elements inside the Shadow DOM.
+ * <br>
+ * The <code>ui5-range-slider</code> exposes the following CSS Shadow Parts:
+ * <ul>
+ * <li>progress-container - Used to style the progress container(the horizontal bar which visually represents the range between the minimum and maximum value) of the <code>ui5-range-slider</code>.</li>
+ * <li>progress-bar - Used to style the progress bar, which shows the progress of the <code>ui5-range-slider</code>.</li>
+ * <li>handle - Used to style the handles of the <code>ui5-range-slider</code>.</li>
+ * </ul>
+ *
  * <h3>Keyboard Handling</h3>
  *
  * <ul>
@@ -110,49 +92,82 @@ const metadata = {
  *
  * @constructor
  * @author SAP SE
- * @alias sap.ui.webcomponents.main.RangeSlider
- * @extends SliderBase
+ * @alias sap.ui.webc.main.RangeSlider
+ * @extends sap.ui.webc.main.SliderBase
  * @tagname ui5-range-slider
  * @since 1.0.0-rc.11
  * @public
  */
+@customElement({
+	tag: "ui5-range-slider",
+	languageAware: true,
+	template: RangeSliderTemplate,
+	dependencies: [Icon],
+	styles: [SliderBase.styles, rangeSliderStyles],
+})
 class RangeSlider extends SliderBase {
-	static get metadata() {
-		return metadata;
-	}
-
-	static get template() {
-		return RangeSliderTemplate;
-	}
-
-	static get VALUES() {
-		return {
-			start: "startValue",
-			end: "endValue",
-		};
-	}
-
-	static get dependencies() {
-		return [Icon];
-	}
+	/**
+	 * Defines start point of a selection - position of a first handle on the slider.
+	 * <br><br>
+	 *
+	 * @type {sap.ui.webc.base.types.Float}
+	 * @name sap.ui.webc.main.RangeSlider.prototype.startValue
+	 * @defaultvalue 0
+	 * @formEvents change input
+	 * @formProperty
+	 * @public
+	 */
+	@property({ validator: Float, defaultValue: 0 })
+	startValue!: number;
 
-	static get styles() {
-		return [SliderBase.styles, rangeSliderStyles];
-	}
+	/**
+	 * Defines end point of a selection - position of a second handle on the slider.
+	 * <br><br>
+	 *
+	 * @type {sap.ui.webc.base.types.Float}
+	 * @name sap.ui.webc.main.RangeSlider.prototype.endValue
+	 * @defaultvalue 100
+	 * @formEvents change input
+	 * @formProperty
+	 * @public
+	 */
+	@property({ validator: Float, defaultValue: 100 })
+	endValue!: number;
+
+	@property({ type: Boolean })
+	rangePressed!: boolean;
+
+	_startValueInitial?: number;
+	_endValueInitial?: number;
+	_valueAffected?: AffectedValue;
+	_isPressInCurrentRange = false;
+	_handeIsPressed = false;
+	_initialPageXPosition?: number;
+	_startValueAtBeginningOfAction?: number;
+	_endValueAtBeginningOfAction?: number;
+	_initialStartHandlePageX?: number;
+	_firstHandlePositionFromStart?: number;
+	_secondHandlePositionFromStart?: number;
+	_selectedRange?: number;
+	_reversedValues = false;
+
+	static i18nBundle: I18nBundle;
 
 	constructor() {
 		super();
-		this._stateStorage.startValue = null;
-		this._stateStorage.endValue = null;
+		this._stateStorage.startValue = undefined;
+		this._stateStorage.endValue = undefined;
 	}
 
 	get tooltipStartValue() {
-		const stepPrecision = this.constructor._getDecimalPrecisionOfNumber(this._effectiveStep);
+		const ctor = this.constructor as typeof RangeSlider;
+		const stepPrecision = ctor._getDecimalPrecisionOfNumber(this._effectiveStep);
 		return this.startValue.toFixed(stepPrecision);
 	}
 
 	get tooltipEndValue() {
-		const stepPrecision = this.constructor._getDecimalPrecisionOfNumber(this._effectiveStep);
+		const ctor = this.constructor as typeof RangeSlider;
+		const stepPrecision = ctor._getDecimalPrecisionOfNumber(this._effectiveStep);
 		return this.endValue.toFixed(stepPrecision);
 	}
 
@@ -167,7 +182,7 @@ class RangeSlider extends SliderBase {
 	get _ariaHandlesText() {
 		const isRTL = this.effectiveDir === "rtl";
 		const isReversed = this._areValuesReversed();
-		const ariaHandlesText = {};
+		const ariaHandlesText: AriaHandlesText = {};
 
 		if ((isRTL && !isReversed) || (!isRTL && isReversed)) {
 			ariaHandlesText.startHandleText = RangeSlider.i18nBundle.getText(RANGE_SLIDER_END_HANDLE_DESCRIPTION);
@@ -180,10 +195,14 @@ class RangeSlider extends SliderBase {
 		return ariaHandlesText;
 	}
 
+	get _ariaValueNow() {
+		return Math.abs(this.endValue - this.startValue);
+	}
+
 	/**
 	 * Check if the previously saved state is outdated. That would mean
 	 * either it is the initial rendering or that a property has been changed
-	 * programatically - because the previous state is always updated in
+	 * programmatically - because the previous state is always updated in
 	 * the interaction handlers.
 	 *
 	 * Normalize current properties, update the previously stored state.
@@ -191,21 +210,65 @@ class RangeSlider extends SliderBase {
 	 *
 	 */
 	onBeforeRendering() {
+		if (this.startValue > this.endValue) {
+			const affectedValue = this._valueAffected === "startValue" ? "endValue" : "startValue";
+
+			this._swapValues();
+			this._setAffectedValue(affectedValue);
+			this.update(affectedValue, this.startValue, this.endValue);
+		}
+
 		if (!this.isCurrentStateOutdated()) {
 			return;
 		}
 
 		this.notResized = true;
-		this.syncUIAndState("startValue", "endValue");
-		this._updateHandlesAndRange(null);
+		this.syncUIAndState();
+		this._updateHandlesAndRange(0);
+	}
+
+	syncUIAndState() {
+		// Validate step and update the stored state for the step property.
+		if (this.isPropertyUpdated("step")) {
+			this._validateStep(this.step);
+			this.storePropertyState("step");
+		}
+
+		// Recalculate the tickmarks and labels and update the stored state.
+		if (this.isPropertyUpdated("min", "max", "startValue", "endValue")) {
+			this.storePropertyState("min", "max");
+
+			// Here the value props are changed programmatically (not by user interaction)
+			// and it won't be "stepified" (rounded to the nearest step). 'Clip' them within
+			// min and max bounderies and update the previous state reference.
+			const normalizedStartValue = SliderBase.clipValue(this.startValue, this._effectiveMin, this._effectiveMax);
+			this.startValue = normalizedStartValue;
+			this.updateStateStorageAndFireInputEvent("startValue");
+			this.storePropertyState("startValue");
+
+			const normalizedEndValue = SliderBase.clipValue(this.endValue, this._effectiveMin, this._effectiveMax);
+			this.endValue = normalizedEndValue;
+			this.updateStateStorageAndFireInputEvent("endValue");
+			this.storePropertyState("endValue");
+		}
+
+		// Labels must be updated if any of the min/max/step/labelInterval props are changed
+		if (this.labelInterval && this.showTickmarks) {
+			this._createLabels();
+		}
+
+		// Update the stored state for the labelInterval, if changed
+		if (this.isPropertyUpdated("labelInterval")) {
+			this.storePropertyState("labelInterval");
+		}
 	}
 
-	_onfocusin(event) {
+	_onfocusin() {
 		// If this is the initial focusin of the component save its initial
 		// value properties so they could be restored on ESC key press
-		if (!this._getInitialValue("endValue")) {
-			this._setInitialValue("startValue", this.startValue);
-			this._setInitialValue("endValue", this.endValue);
+		if (!this._endValueInitial) {
+			this._startValueInitial = this.startValue;
+			this._endValueInitial = this.endValue;
 		}
 
 		if (this.showTooltip) {
@@ -225,15 +288,15 @@ class RangeSlider extends SliderBase {
 	 *
 	 * @private
 	 */
-	_onfocusout(event) {
+	_onfocusout() {
 		if (this._isFocusing()) {
 			this._preventFocusOut();
 			return;
 		}
 
-		this._setAffectedValue(null);
-		this._setInitialValue("startValue", null);
-		this._setInitialValue("endValue", null);
+		this._setAffectedValue(undefined);
+		this._startValueInitial = undefined;
+		this._endValueInitial = undefined;
 
 		if (this.showTooltip) {
 			this._tooltipVisibility = SliderBase.TOOLTIP_VISIBILITY.HIDDEN;
@@ -247,16 +310,24 @@ class RangeSlider extends SliderBase {
 	*
 	* @private
 	*/
-	_onkeyup(event) {
-		super._onkeyup(event);
+	_onkeyup() {
+		super._onkeyup();
+		this._setAffectedValue(undefined);
 
-		this._swapValues();
-		this._setAffectedValue(null);
+		if (this.startValue !== this._startValueAtBeginningOfAction || this.endValue !== this._endValueAtBeginningOfAction) {
+			this.fireEvent("change");
+		}
+
+		this._startValueAtBeginningOfAction = undefined;
+		this._endValueAtBeginningOfAction = undefined;
 	}
 
-	_handleActionKeyPress(event) {
-		if (isEscape(event)) {
-			this.update(null, this._getInitialValue("startValue"), this._getInitialValue("endValue"));
+	_handleActionKeyPress(e: KeyboardEvent) {
+		this._startValueAtBeginningOfAction = this.startValue;
+		this._endValueAtBeginningOfAction = this.endValue;
+
+		if (isEscape(e)) {
+			this.update(undefined, this._startValueInitial, this._endValueInitial);
 			return;
 		}
 
@@ -265,31 +336,33 @@ class RangeSlider extends SliderBase {
 
 		const min = this._effectiveMin;
 		const max = this._effectiveMax;
-		const affectedValue = this._valueAffected;
+		const affectedValue = this._valueAffected!;
 
 		// If home/end key is pressed and no single handle is focused the active element
 		// is the range selection - update both start and end values. Otherwise, if 'home'
 		// is pressed the 'startValue'will be used for the start-handle offset calculation,
 		// if 'End' is pressed - the 'endValue' will be used for the end-handle update.
-		if ((isEnd(event) || isHome(event)) && !affectedValue) {
-			this._homeEndForSelectedRange(event, isHome(event) ? "startValue" : "endValue", min, max);
+		if ((isEnd(e) || isHome(e)) && !affectedValue) {
+			this._homeEndForSelectedRange(e, isHome(e) ? "startValue" : "endValue", min, max);
 			return;
 		}
 
 		// Calculate how much the value should be increased/decreased based on the action key
-		const newValueOffset = this._handleActionKeyPressBase(event, affectedValue);
+		const newValueOffset = this._handleActionKeyPressBase(e, affectedValue);
 
 		if (!newValueOffset) {
 			return;
 		}
 
 		// Update a single value if one of the handles is focused or the range if not already at min or max
+		const ctor = this.constructor as typeof RangeSlider;
 		if (affectedValue && !this._isPressInCurrentRange) {
-			const newValue = this.constructor.clipValue(newValueOffset + this[affectedValue], min, max);
-			this.update(affectedValue, newValue, null);
+			const propValue = this[affectedValue as keyof RangeSlider] as number;
+			const newValue = ctor.clipValue(newValueOffset + propValue, min, max);
+			this.update(affectedValue, newValue, undefined);
 		} else if ((newValueOffset < 0 && this.startValue > min) || (newValueOffset > 0 && this.endValue < max)) {
-			const newStartValue = this.constructor.clipValue(newValueOffset + this.startValue, min, max);
-			const newEndValue = this.constructor.clipValue(newValueOffset + this.endValue, min, max);
+			const newStartValue = ctor.clipValue(newValueOffset + this.startValue, min, max);
+			const newEndValue = ctor.clipValue(newValueOffset + this.endValue, min, max);
 			this.update(affectedValue, newStartValue, newEndValue);
 		}
 	}
@@ -301,16 +374,16 @@ class RangeSlider extends SliderBase {
 	 * @private
 	 */
 	_setAffectedValueByFocusedElement() {
-		if (this.shadowRoot.activeElement === this._startHandle) {
-			this._setAffectedValue(RangeSlider.VALUES.start);
+		if (this.shadowRoot!.activeElement === this._startHandle) {
+			this._setAffectedValue("startValue");
 		}
 
-		if (this.shadowRoot.activeElement === this._endHandle) {
-			this._setAffectedValue(RangeSlider.VALUES.end);
+		if (this.shadowRoot!.activeElement === this._endHandle) {
+			this._setAffectedValue("endValue");
 		}
 
-		if (this.shadowRoot.activeElement === this._progressBar) {
-			this._setAffectedValue(null);
+		if (this.shadowRoot!.activeElement === this._progressBar) {
+			this._setAffectedValue(undefined);
 		}
 
 		this._setIsPressInCurrentRange(!this._valueAffected);
@@ -322,12 +395,13 @@ class RangeSlider extends SliderBase {
 	 *
 	 * @private
 	 */
-	_homeEndForSelectedRange(event, affectedValue, min, max) {
-		const newValueOffset = this._handleActionKeyPressBase(event, affectedValue);
-		const newStartValue = this.constructor.clipValue(newValueOffset + this.startValue, min, max);
-		const newEndValue = this.constructor.clipValue(newValueOffset + this.endValue, min, max);
+	_homeEndForSelectedRange(e: KeyboardEvent, affectedValue: string, min: number, max: number) {
+		const newValueOffset = this._handleActionKeyPressBase(e, affectedValue);
+		const ctor = this.constructor as typeof RangeSlider;
+		const newStartValue = ctor.clipValue(newValueOffset + this.startValue, min, max);
+		const newEndValue = ctor.clipValue(newValueOffset + this.endValue, min, max);
 
-		this.update(null, newStartValue, newEndValue);
+		this.update(undefined, newStartValue, newEndValue);
 	}
 
 	/**
@@ -337,15 +411,27 @@ class RangeSlider extends SliderBase {
 	 *
 	 * @private
 	 */
-	update(affectedValue, startValue, endValue) {
+	update(affectedValue: string | undefined, startValue: number | undefined, endValue: number | undefined) {
 		if (!affectedValue) {
-			this.updateValue("startValue", startValue);
-			this.updateValue("endValue", endValue);
-			this._updateHandlesAndRange(null);
+			this.startValue = startValue!;
+			this.updateStateStorageAndFireInputEvent("startValue");
+
+			this.endValue = endValue!;
+			this.updateStateStorageAndFireInputEvent("endValue");
+			this._updateHandlesAndRange(0);
 		} else {
-			const newValue = startValue;
-			this._updateHandlesAndRange(newValue);
-			this.updateValue(affectedValue, newValue);
+			const newValue = endValue && affectedValue === "endValue" ? endValue : startValue;
+			this._updateHandlesAndRange(newValue || 0);
+
+			if (affectedValue === "startValue") {
+				this.startValue = newValue!;
+				this.updateStateStorageAndFireInputEvent("startValue");
+			}
+
+			if (affectedValue === "endValue") {
+				this.endValue = newValue!;
+				this.updateStateStorageAndFireInputEvent("endValue");
+			}
 		}
 	}
 
@@ -354,7 +440,7 @@ class RangeSlider extends SliderBase {
 	 *
 	 * @private
 	 */
-	_onmousedown(event) {
+	_onmousedown(e: TouchEvent | MouseEvent) {
 		// If step is 0 no interaction is available because there is no constant
 		// (equal for all user environments) quantitative representation of the value
 		if (this.disabled || this._effectiveStep === 0) {
@@ -362,10 +448,10 @@ class RangeSlider extends SliderBase {
 		}
 
 		// Calculate the new value from the press position of the event
-		const newValue = this.handleDownBase(event);
+		const newValue = this.handleDownBase(e);
 
 		// Determine the rest of the needed details from the start of the interaction.
-		this._saveInteractionStartData(event, newValue);
+		this._saveInteractionStartData(e, newValue);
 
 		this.rangePressed = this._isPressInCurrentRange;
 
@@ -376,7 +462,7 @@ class RangeSlider extends SliderBase {
 		}
 
 		// Update Slider UI and internal state
-		this.update(this._valueAffected, newValue, null);
+		this.update(this._valueAffected, newValue, undefined);
 	}
 
 	/**
@@ -389,15 +475,16 @@ class RangeSlider extends SliderBase {
 	 *
 	 * @private
 	 */
-	_saveInteractionStartData(event, newValue) {
-		const progressBarDom = this.shadowRoot.querySelector(".ui5-slider-progress").getBoundingClientRect();
+	_saveInteractionStartData(e: TouchEvent | MouseEvent, newValue: number) {
+		const progressBarDom = this.shadowRoot!.querySelector(".ui5-slider-progress")!.getBoundingClientRect();
 
 		// Save the state of the value properties on the start of the interaction
 		this._startValueAtBeginningOfAction = this.startValue;
 		this._endValueAtBeginningOfAction = this.endValue;
 
 		// Save the initial press point coordinates (position)
-		this._initialPageXPosition = this.constructor.getPageXValueFromEvent(event);
+		const ctor = this.constructor as typeof RangeSlider;
+		this._initialPageXPosition = ctor.getPageXValueFromEvent(e);
 		// Which element of the Range Slider is pressed and which value property to be modified on further interaction
 		this._pressTargetAndAffectedValue(this._initialPageXPosition, newValue);
 		// Use the progress bar to save the initial coordinates of the start-handle when the interaction begins.
@@ -409,8 +496,8 @@ class RangeSlider extends SliderBase {
 	 *
 	 * @private
 	 */
-	_handleMove(event) {
-		event.preventDefault();
+	_handleMove(e: TouchEvent | MouseEvent) {
+		e.preventDefault();
 
 		// If 'step' is 0 no interaction is available as there is no constant quantitative representation of the value
 		if (this.disabled || this._effectiveStep === 0) {
@@ -419,12 +506,12 @@ class RangeSlider extends SliderBase {
 
 		// Update UI and state when dragging a single Range Slider handle
 		if (!this._isPressInCurrentRange) {
-			this._updateValueOnHandleDrag(event);
+			this._updateValueOnHandleDrag(e);
 			return;
 		}
 
 		// Updates UI and state when dragging of the whole selected range
-		this._updateValueOnRangeDrag(event);
+		this._updateValueOnRangeDrag(e);
 	}
 
 	/**
@@ -432,9 +519,10 @@ class RangeSlider extends SliderBase {
 	 *
 	 * @private
 	 */
-	_updateValueOnHandleDrag(event) {
-		const newValue = this.constructor.getValueFromInteraction(event, this._effectiveStep, this._effectiveMin, this._effectiveMax, this.getBoundingClientRect(), this.directionStart);
-		this.update(this._valueAffected, newValue, null);
+	_updateValueOnHandleDrag(event: TouchEvent | MouseEvent) {
+		const ctor = this.constructor as typeof RangeSlider;
+		const newValue = ctor.getValueFromInteraction(event, this._effectiveStep, this._effectiveMin, this._effectiveMax, this.getBoundingClientRect(), this.directionStart);
+		this.update(this._valueAffected, newValue, undefined);
 	}
 
 	/**
@@ -442,34 +530,33 @@ class RangeSlider extends SliderBase {
 	 *
 	 * @private
 	 */
-	_updateValueOnRangeDrag(event) {
+	_updateValueOnRangeDrag(event: TouchEvent | MouseEvent) {
 		// Calculate the new 'start' and 'end' values from the offset between the original press point and the current position of the mouse
-		const currentPageXPos = this.constructor.getPageXValueFromEvent(event);
-		const newValues = this._calculateRangeOffset(currentPageXPos, this._initialStartHandlePageX);
+		const ctor = this.constructor as typeof RangeSlider;
+		const currentPageXPos = ctor.getPageXValueFromEvent(event);
+		const newValues = this._calculateRangeOffset(currentPageXPos, this._initialStartHandlePageX!);
 
 		// No matter the which value is set as the one to be modified (by prev. user action) we want to modify both of them
-		this._setAffectedValue(null);
+		this._setAffectedValue(undefined);
 
-		// Update the UI and the state acccording to the calculated new values
-		this.update(null, newValues[0], newValues[1]);
+		// Update the UI and the state according to the calculated new values
+		this.update(undefined, newValues[0], newValues[1]);
 	}
 
 	_handleUp() {
+		this._setAffectedValueByFocusedElement();
+		this._setAffectedValue(undefined);
+
 		if (this.startValue !== this._startValueAtBeginningOfAction || this.endValue !== this._endValueAtBeginningOfAction) {
 			this.fireEvent("change");
 		}
 
-		this._swapValues();
-		this._setAffectedValueByFocusedElement();
-		this._setAffectedValue(null);
-
-		this._startValueAtBeginningOfAction = null;
-		this._endValueAtBeginningOfAction = null;
 		this._setIsPressInCurrentRange(false);
-
 		this.handleUpBase();
 
 		this.rangePressed = false;
+		this._startValueAtBeginningOfAction = undefined;
+		this._endValueAtBeginningOfAction = undefined;
 	}
 
 	/**
@@ -486,9 +573,9 @@ class RangeSlider extends SliderBase {
 	 *
 	 * @private
 	 */
-	_pressTargetAndAffectedValue(clientX, value) {
-		const startHandle = this.shadowRoot.querySelector(".ui5-slider-handle--start");
-		const endHandle = this.shadowRoot.querySelector(".ui5-slider-handle--end");
+	_pressTargetAndAffectedValue(clientX: number, value: number) {
+		const startHandle = this.shadowRoot!.querySelector(".ui5-slider-handle--start")!;
+		const endHandle = this.shadowRoot!.querySelector(".ui5-slider-handle--end")!;
 
 		// Check if the press point is in the bounds of any of the Range Slider handles
 		const handleStartDomRect = startHandle.getBoundingClientRect();
@@ -503,16 +590,16 @@ class RangeSlider extends SliderBase {
 
 		// Return that handle that is closer to the press point
 		if (inHandleEndDom || value > this.endValue) {
-			this._setAffectedValue(RangeSlider.VALUES.end);
+			this._setAffectedValue("endValue");
 		}
 
 		// If one of the handle is pressed return that one
 		if (inHandleStartDom || value < this.startValue) {
-			this._setAffectedValue(RangeSlider.VALUES.start);
+			this._setAffectedValue("startValue");
 		}
 
 		// Flag if press is in the current select range
-		const isNewValueInCurrentRange = value >= this._startValueAtBeginningOfAction && value <= this._endValueAtBeginningOfAction;
+		const isNewValueInCurrentRange = this._startValueAtBeginningOfAction !== undefined && this._endValueAtBeginningOfAction !== undefined && value >= this._startValueAtBeginningOfAction && value <= this._endValueAtBeginningOfAction;
 		this._setIsPressInCurrentRange(!(this._valueAffected || this._handeIsPressed) ? isNewValueInCurrentRange : false);
 	}
 
@@ -522,11 +609,11 @@ class RangeSlider extends SliderBase {
 	 * - mouse press position - cursor coordinates relative to the start/end handles
 	 * - selected inner element via a keyboard navigation
 	 *
-	 * @param {string} valuePropAffectedByInteraction The value that will get modified by the interaction
+	 * @param {string} affectedValue The value that will get modified by the interaction
 	 * @private
 	 */
-	_setAffectedValue(valuePropAffectedByInteraction) {
-		this._valueAffected = valuePropAffectedByInteraction;
+	_setAffectedValue(affectedValue: AffectedValue | undefined) {
+		this._valueAffected = affectedValue;
 
 		// If the values have been swapped reset the reversed flag
 		if (this._areValuesReversed()) {
@@ -540,7 +627,7 @@ class RangeSlider extends SliderBase {
 	 * @param {boolean} isPressInCurrentRange Did the current press action occur in the current range (between the two handles)
 	 * @private
 	 */
-	_setIsPressInCurrentRange(isPressInCurrentRange) {
+	_setIsPressInCurrentRange(isPressInCurrentRange: boolean) {
 		this._isPressInCurrentRange = isPressInCurrentRange;
 	}
 
@@ -577,11 +664,11 @@ class RangeSlider extends SliderBase {
 			this._progressBar.focus();
 		}
 
-		if ((affectedValue === RangeSlider.VALUES.start && !isReversed) || (affectedValue === RangeSlider.VALUES.end && isReversed)) {
+		if ((affectedValue === "startValue" && !isReversed) || (affectedValue === "endValue" && isReversed)) {
 			this._startHandle.focus();
 		}
 
-		if ((affectedValue === RangeSlider.VALUES.end && !isReversed) || (affectedValue === RangeSlider.VALUES.start && isReversed)) {
+		if ((affectedValue === "endValue" && !isReversed) || (affectedValue === "startValue" && isReversed)) {
 			this._endHandle.focus();
 		}
 	}
@@ -597,9 +684,9 @@ class RangeSlider extends SliderBase {
 	 *
 	 * @private
 	 */
-	_calculateRangeOffset(currentPageXPos, initialStartHandlePageXPos) {
+	_calculateRangeOffset(currentPageXPos: number, initialStartHandlePageXPos: number) {
 		// Return the current values if there is no difference in the
-		// possitions of the initial press and the current pointer
+		// positions of the initial press and the current pointer
 		if (this._initialPageXPosition === currentPageXPos) {
 			return [this.startValue, this.endValue];
 		}
@@ -613,7 +700,8 @@ class RangeSlider extends SliderBase {
 
 		// When the end handle reaches the max possible value prevent the start handle from moving
 		// And the opposite - if the start handle reaches the beginning of the slider keep the initially selected range.
-		startValue = this.constructor.clipValue(startValue, min, max - selectedRange);
+		const ctor = this.constructor as typeof RangeSlider;
+		startValue = ctor.clipValue(startValue, min, max - selectedRange);
 
 		return [startValue, startValue + selectedRange];
 	}
@@ -627,7 +715,7 @@ class RangeSlider extends SliderBase {
 	 *
 	 * @private
 	 */
-	_calculateStartValueByOffset(currentPageXPos, initialStartHandlePageXPos) {
+	_calculateStartValueByOffset(currentPageXPos: number, initialStartHandlePageXPos: number) {
 		const min = this._effectiveMin;
 		const max = this._effectiveMax;
 		const step = this._effectiveStep;
@@ -641,18 +729,19 @@ class RangeSlider extends SliderBase {
 		- calculate the new position of the start handle from its old pageX value combined with the movement offset;
 		- calculate the start value based on its new pageX coordinates;
 		- 'stepify' the calculated value based on the specified step property; */
-		if (currentPageXPos > this._initialPageXPosition) {
+		const ctor = this.constructor as typeof RangeSlider;
+		if (currentPageXPos > this._initialPageXPosition!) {
 			// Difference between the new position of the pointer and when the press event initial occured
-			positionOffset = currentPageXPos - this._initialPageXPosition;
+			positionOffset = currentPageXPos - this._initialPageXPosition!;
 
 			startValuePageX = initialStartHandlePageXPos + positionOffset;
-			startValue = this.constructor.computedValueFromPageX(startValuePageX, min, max, dom, this.directionStart);
-			startValue = this.constructor.getSteppedValue(startValue, step, min);
+			startValue = ctor.computedValueFromPageX(startValuePageX, min, max, dom, this.directionStart);
+			startValue = ctor.getSteppedValue(startValue, step, min);
 		} else {
-			positionOffset = this._initialPageXPosition - currentPageXPos;
+			positionOffset = this._initialPageXPosition! - currentPageXPos;
 			startValuePageX = initialStartHandlePageXPos - positionOffset;
-			startValue = this.constructor.computedValueFromPageX(startValuePageX, min, max, dom, this.directionStart);
-			startValue = this.constructor.getSteppedValue(startValue, step, min);
+			startValue = ctor.computedValueFromPageX(startValuePageX, min, max, dom, this.directionStart);
+			startValue = ctor.getSteppedValue(startValue, step, min);
 		}
 
 		return startValue;
@@ -664,20 +753,20 @@ class RangeSlider extends SliderBase {
 	 *
 	 * @private
 	 */
-	_updateHandlesAndRange(newValue) {
+	_updateHandlesAndRange(newValue: number) {
 		const max = this._effectiveMax;
 		const min = this._effectiveMin;
-		const prevStartValue = this.getStoredPropertyState("startValue");
-		const prevEndValue = this.getStoredPropertyState("endValue");
+		const prevStartValue = this.getStoredPropertyState("startValue") || 0;
+		const prevEndValue = this.getStoredPropertyState("endValue") || 0;
 		const affectedValue = this._valueAffected;
 
 		// The value according to which we update the UI can be either the startValue
 		// or the endValue property. It is determined in _getClosestHandle()
 		// depending on to which handle is closer the user interaction.
-		if (affectedValue === RangeSlider.VALUES.start) {
+		if (affectedValue === "startValue") {
 			this._selectedRange = (prevEndValue - newValue) / (max - min);
 			this._firstHandlePositionFromStart = ((newValue - min) / (max - min)) * 100;
-		} else if (affectedValue === RangeSlider.VALUES.end) {
+		} else if (affectedValue === "endValue") {
 			this._selectedRange = ((newValue - prevStartValue)) / (max - min);
 			this._secondHandlePositionFromStart = ((newValue - min) / (max - min)) * 100;
 		} else {
@@ -702,24 +791,26 @@ class RangeSlider extends SliderBase {
 	 */
 	_swapValues() {
 		const affectedValue = this._valueAffected;
+		if (!affectedValue) {
+			return;
+		}
 
-		if (affectedValue === RangeSlider.VALUES.start && this.startValue > this.endValue) {
+		if (affectedValue === "startValue" && this.startValue > this.endValue) {
 			const prevEndValue = this.endValue;
 			this.endValue = this.startValue;
 			this.startValue = prevEndValue;
-
-			this._setValuesAreReversed();
-			this.focusInnerElement();
 		}
 
-		if (affectedValue === RangeSlider.VALUES.end && this.endValue < this.startValue) {
+		if (affectedValue === "endValue" && this.endValue < this.startValue) {
 			const prevStartValue = this.startValue;
 			this.startValue = this.endValue;
 			this.endValue = prevStartValue;
-
-			this._setValuesAreReversed();
-			this.focusInnerElement();
 		}
+
+		this._setValuesAreReversed();
+		this._updateHandlesAndRange(this[affectedValue]);
+		this.focusInnerElement();
+		this.syncUIAndState();
 	}
 
 	/**
@@ -757,15 +848,15 @@ class RangeSlider extends SliderBase {
 	}
 
 	get _startHandle() {
-		return this.shadowRoot.querySelector(".ui5-slider-handle--start");
+		return this.shadowRoot!.querySelector<HTMLElement>(".ui5-slider-handle--start")!;
 	}
 
 	get _endHandle() {
-		return this.shadowRoot.querySelector(".ui5-slider-handle--end");
+		return this.shadowRoot!.querySelector<HTMLElement>(".ui5-slider-handle--end")!;
 	}
 
 	get _progressBar() {
-		return this.shadowRoot.querySelector(".ui5-slider-progress");
+		return this.shadowRoot!.querySelector<HTMLElement>(".ui5-slider-progress")!;
 	}
 
 	get _ariaLabelledByStartHandleRefs() {
@@ -783,18 +874,15 @@ class RangeSlider extends SliderBase {
 	get styles() {
 		return {
 			progress: {
-				"width": `${this._selectedRange * 100}%`,
+				"width": `${this._selectedRange! * 100}%`,
 				"transform-origin": `${this.directionStart} top`,
-				[this.directionStart]: `${this._firstHandlePositionFromStart}%`,
+				[this.directionStart]: `${this._firstHandlePositionFromStart!}%`,
 			},
 			startHandle: {
-				[this.directionStart]: `${this._firstHandlePositionFromStart}%`,
+				[this.directionStart]: `${this._firstHandlePositionFromStart!}%`,
 			},
 			endHandle: {
-				[this.directionStart]: `${this._secondHandlePositionFromStart}%`,
-			},
-			tickmarks: {
-				"background": `${this._tickmarks}`,
+				[this.directionStart]: `${this._secondHandlePositionFromStart!}%`,
 			},
 			label: {
 				"width": `${this._labelWidth}%`,