@angular/material 15.0.0-rc.0 → 15.0.0-rc.2

package/esm2020/slider/slider-input.mjs

@@ -0,0 +1,611 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { coerceBooleanProperty, coerceNumberProperty, } from '@angular/cdk/coercion';
+import { ChangeDetectorRef, Directive, ElementRef, EventEmitter, forwardRef, Inject, Input, NgZone, Output, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { MAT_SLIDER_RANGE_THUMB, MAT_SLIDER_THUMB, MAT_SLIDER, } from './slider-interface';
+import * as i0 from "@angular/core";
+/**
+ * Provider that allows the slider thumb to register as a ControlValueAccessor.
+ * @docs-private
+ */
+export const MAT_SLIDER_THUMB_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => MatSliderThumb),
+    multi: true,
+};
+/**
+ * Provider that allows the range slider thumb to register as a ControlValueAccessor.
+ * @docs-private
+ */
+export const MAT_SLIDER_RANGE_THUMB_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => MatSliderRangeThumb),
+    multi: true,
+};
+/**
+ * Directive that adds slider-specific behaviors to an input element inside `<mat-slider>`.
+ * Up to two may be placed inside of a `<mat-slider>`.
+ *
+ * If one is used, the selector `matSliderThumb` must be used, and the outcome will be a normal
+ * slider. If two are used, the selectors `matSliderStartThumb` and `matSliderEndThumb` must be
+ * used, and the outcome will be a range slider with two slider thumbs.
+ */
+export class MatSliderThumb {
+    constructor(_ngZone, _elementRef, _cdr, _slider) {
+        this._ngZone = _ngZone;
+        this._elementRef = _elementRef;
+        this._cdr = _cdr;
+        this._slider = _slider;
+        this.valueChange = new EventEmitter();
+        /** Event emitted when the slider thumb starts being dragged. */
+        this.dragStart = new EventEmitter();
+        /** Event emitted when the slider thumb stops being dragged. */
+        this.dragEnd = new EventEmitter();
+        /** Indicates whether this thumb is the start or end thumb. */
+        this.thumbPosition = 2 /* _MatThumb.END */;
+        /** The radius of a native html slider's knob. */
+        this._knobRadius = 8;
+        /** Whether user's cursor is currently in a mouse down state on the input. */
+        this._isActive = false;
+        /** Whether the input is currently focused (either by tab or after clicking). */
+        this._isFocused = false;
+        /**
+         * Whether the initial value has been set.
+         * This exists because the initial value cannot be immediately set because the min and max
+         * must first be relayed from the parent MatSlider component, which can only happen later
+         * in the component lifecycle.
+         */
+        this._hasSetInitialValue = false;
+        /** Emits when the component is destroyed. */
+        this._destroyed = new Subject();
+        /**
+         * Indicates whether UI updates should be skipped.
+         *
+         * This flag is used to avoid flickering
+         * when correcting values on pointer up/down.
+         */
+        this._skipUIUpdate = false;
+        /** Callback called when the slider input value changes. */
+        this._onChangeFn = () => { };
+        /** Callback called when the slider input has been touched. */
+        this._onTouchedFn = () => { };
+        this._hostElement = _elementRef.nativeElement;
+        this._ngZone.runOutsideAngular(() => {
+            this._hostElement.addEventListener('pointerdown', this._onPointerDown.bind(this));
+            this._hostElement.addEventListener('pointermove', this._onPointerMove.bind(this));
+            this._hostElement.addEventListener('pointerup', this._onPointerUp.bind(this));
+        });
+    }
+    get value() {
+        return coerceNumberProperty(this._hostElement.value);
+    }
+    set value(v) {
+        const val = coerceNumberProperty(v).toString();
+        if (!this._hasSetInitialValue) {
+            this._initialValue = val;
+            return;
+        }
+        if (this._isActive) {
+            return;
+        }
+        this._hostElement.value = val;
+        this._updateThumbUIByValue();
+        this._slider._onValueChange(this);
+        this._cdr.detectChanges();
+    }
+    /** The current translateX in px of the slider visual thumb. */
+    get translateX() {
+        if (this._slider.min >= this._slider.max) {
+            this._translateX = 0;
+            return this._translateX;
+        }
+        if (this._translateX === undefined) {
+            this._translateX = this._calcTranslateXByValue();
+        }
+        return this._translateX;
+    }
+    set translateX(v) {
+        this._translateX = v;
+    }
+    get min() {
+        return coerceNumberProperty(this._hostElement.min);
+    }
+    set min(v) {
+        this._hostElement.min = coerceNumberProperty(v).toString();
+        this._cdr.detectChanges();
+    }
+    get max() {
+        return coerceNumberProperty(this._hostElement.max);
+    }
+    set max(v) {
+        this._hostElement.max = coerceNumberProperty(v).toString();
+        this._cdr.detectChanges();
+    }
+    get step() {
+        return coerceNumberProperty(this._hostElement.step);
+    }
+    set step(v) {
+        this._hostElement.step = coerceNumberProperty(v).toString();
+        this._cdr.detectChanges();
+    }
+    get disabled() {
+        return coerceBooleanProperty(this._hostElement.disabled);
+    }
+    set disabled(v) {
+        this._hostElement.disabled = coerceBooleanProperty(v);
+        this._cdr.detectChanges();
+        if (this._slider.disabled !== this.disabled) {
+            this._slider.disabled = this.disabled;
+        }
+    }
+    get percentage() {
+        if (this._slider.min >= this._slider.max) {
+            return this._slider._isRtl ? 1 : 0;
+        }
+        return (this.value - this._slider.min) / (this._slider.max - this._slider.min);
+    }
+    get fillPercentage() {
+        if (!this._slider._cachedWidth) {
+            return this._slider._isRtl ? 1 : 0;
+        }
+        if (this._translateX === 0) {
+            return 0;
+        }
+        return this.translateX / this._slider._cachedWidth;
+    }
+    /** Used to relay updates to _isFocused to the slider visual thumbs. */
+    _setIsFocused(v) {
+        this._isFocused = v;
+    }
+    ngOnDestroy() {
+        this._hostElement.removeEventListener('pointerdown', this._onPointerDown);
+        this._hostElement.removeEventListener('pointermove', this._onPointerMove);
+        this._hostElement.removeEventListener('pointerup', this._onPointerUp);
+        this._destroyed.next();
+        this._destroyed.complete();
+        this.dragStart.complete();
+        this.dragEnd.complete();
+    }
+    initProps() {
+        this._updateWidthInactive();
+        this.disabled = this._slider.disabled;
+        this.step = this._slider.step;
+        this.min = this._slider.min;
+        this.max = this._slider.max;
+        this._initValue();
+    }
+    initUI() {
+        this._updateThumbUIByValue();
+    }
+    _initValue() {
+        this._hasSetInitialValue = true;
+        if (this._initialValue === undefined) {
+            this.value = this._getDefaultValue();
+        }
+        else {
+            this._hostElement.value = this._initialValue;
+            this._updateThumbUIByValue();
+            this._slider._onValueChange(this);
+            this._cdr.detectChanges();
+        }
+    }
+    _getDefaultValue() {
+        return this.min;
+    }
+    _onBlur() {
+        this._setIsFocused(false);
+        this._onTouchedFn();
+    }
+    _onFocus() {
+        this._setIsFocused(true);
+    }
+    _onChange() {
+        // only used to handle the edge case where user
+        // mousedown on the slider then uses arrow keys.
+        if (this._isActive) {
+            this._updateThumbUIByValue({ withAnimation: true });
+        }
+    }
+    _onInput() {
+        this.valueChange.emit(this.value);
+        this._onChangeFn(this.value);
+        // handles arrowing and updating the value when
+        // a step is defined.
+        if (this._slider.step || !this._isActive) {
+            this._updateThumbUIByValue({ withAnimation: true });
+        }
+        this._slider._onValueChange(this);
+    }
+    _onNgControlValueChange() {
+        // only used to handle when the value change
+        // originates outside of the slider.
+        if (!this._isActive || !this._isFocused) {
+            this._slider._onValueChange(this);
+            this._updateThumbUIByValue();
+        }
+        this._slider.disabled = this._formControl.disabled;
+    }
+    _onPointerDown(event) {
+        if (this.disabled || event.button !== 0) {
+            return;
+        }
+        this._isActive = true;
+        this._setIsFocused(true);
+        this._updateWidthActive();
+        this._slider._updateDimensions();
+        // Does nothing if a step is defined because we
+        // want the value to snap to the values on input.
+        if (!this._slider.step) {
+            this._updateThumbUIByPointerEvent(event, { withAnimation: true });
+        }
+        if (!this.disabled) {
+            this._handleValueCorrection(event);
+        }
+    }
+    /**
+     * Corrects the value of the slider on pointer up/down.
+     *
+     * Called on pointer down and up because the value is set based
+     * on the inactive width instead of the active width.
+     */
+    _handleValueCorrection(event) {
+        // Don't update the UI with the current value! The value on pointerdown
+        // and pointerup is calculated in the split second before the input(s)
+        // resize. See _updateWidthInactive() and _updateWidthActive() for more
+        // details.
+        this._skipUIUpdate = true;
+        // Note that this function gets triggered before the actual value of the
+        // slider is updated. This means if we were to set the value here, it
+        // would immediately be overwritten. Using setTimeout ensures the setting
+        // of the value happens after the value has been updated by the
+        // pointerdown event.
+        setTimeout(() => {
+            this._skipUIUpdate = false;
+            this._fixValue(event);
+        }, 0);
+    }
+    /** Corrects the value of the slider based on the pointer event's position. */
+    _fixValue(event) {
+        const xPos = event.clientX - this._slider._cachedLeft;
+        const width = this._slider._cachedWidth;
+        const step = this._slider.step === 0 ? 1 : this._slider.step;
+        const numSteps = Math.floor((this._slider.max - this._slider.min) / step);
+        const percentage = this._slider._isRtl ? 1 - xPos / width : xPos / width;
+        // To ensure the percentage is rounded to the necessary number of decimals.
+        const fixedPercentage = Math.round(percentage * numSteps) / numSteps;
+        const impreciseValue = fixedPercentage * (this._slider.max - this._slider.min) + this._slider.min;
+        const value = Math.round(impreciseValue / step) * step;
+        const prevValue = this.value;
+        const dragEvent = { source: this, parent: this._slider, value: value };
+        this._isActive ? this.dragStart.emit(dragEvent) : this.dragEnd.emit(dragEvent);
+        if (value === prevValue) {
+            // Because we prevented UI updates, if it turns out that the race
+            // condition didn't happen and the value is already correct, we
+            // have to apply the ui updates now.
+            this._slider._onValueChange(this);
+            this._slider.step > 0
+                ? this._updateThumbUIByValue()
+                : this._updateThumbUIByPointerEvent(event, { withAnimation: this._slider._hasAnimation });
+            return;
+        }
+        this.value = value;
+        this.valueChange.emit(this.value);
+        this._onChangeFn(this.value);
+        this._slider._onValueChange(this);
+        this._slider.step > 0
+            ? this._updateThumbUIByValue()
+            : this._updateThumbUIByPointerEvent(event, { withAnimation: this._slider._hasAnimation });
+    }
+    _onPointerMove(event) {
+        // Again, does nothing if a step is defined because
+        // we want the value to snap to the values on input.
+        if (!this._slider.step && this._isActive) {
+            this._updateThumbUIByPointerEvent(event);
+        }
+    }
+    _onPointerUp(event) {
+        this._isActive = false;
+        this._updateWidthInactive();
+        if (!this.disabled) {
+            this._handleValueCorrection(event);
+        }
+    }
+    _clamp(v) {
+        return Math.max(Math.min(v, this._slider._cachedWidth), 0);
+    }
+    _calcTranslateXByValue() {
+        if (this._slider._isRtl) {
+            return (1 - this.percentage) * this._slider._cachedWidth;
+        }
+        return this.percentage * this._slider._cachedWidth;
+    }
+    _calcTranslateXByPointerEvent(event) {
+        return event.clientX - this._slider._cachedLeft;
+    }
+    /**
+     * Used to set the slider width to the correct
+     * dimensions while the user is dragging.
+     */
+    _updateWidthActive() {
+        this._hostElement.style.padding = `0 ${this._slider._inputPadding}px`;
+        this._hostElement.style.width = `calc(100% + ${this._slider._inputPadding}px)`;
+    }
+    /**
+     * Sets the slider input to disproportionate dimensions to allow for touch
+     * events to be captured on touch devices.
+     */
+    _updateWidthInactive() {
+        this._hostElement.style.padding = '0px';
+        this._hostElement.style.width = 'calc(100% + 48px)';
+        this._hostElement.style.left = '-24px';
+    }
+    _updateThumbUIByValue(options) {
+        this.translateX = this._clamp(this._calcTranslateXByValue());
+        this._updateThumbUI(options);
+    }
+    _updateThumbUIByPointerEvent(event, options) {
+        this.translateX = this._clamp(this._calcTranslateXByPointerEvent(event));
+        this._updateThumbUI(options);
+    }
+    _updateThumbUI(options) {
+        this._slider._setTransition(!!options?.withAnimation);
+        this._slider._onTranslateXChange(this);
+    }
+    /**
+     * Sets the input's value.
+     * @param value The new value of the input
+     * @docs-private
+     */
+    writeValue(value) {
+        this.value = value;
+    }
+    /**
+     * Registers a callback to be invoked when the input's value changes from user input.
+     * @param fn The callback to register
+     * @docs-private
+     */
+    registerOnChange(fn) {
+        this._onChangeFn = fn;
+    }
+    /**
+     * Registers a callback to be invoked when the input is blurred by the user.
+     * @param fn The callback to register
+     * @docs-private
+     */
+    registerOnTouched(fn) {
+        this._onTouchedFn = fn;
+    }
+    /**
+     * Sets the disabled state of the slider.
+     * @param isDisabled The new disabled state
+     * @docs-private
+     */
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    focus() {
+        this._hostElement.focus();
+    }
+    blur() {
+        this._hostElement.blur();
+    }
+}
+MatSliderThumb.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0-rc.1", ngImport: i0, type: MatSliderThumb, deps: [{ token: i0.NgZone }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: MAT_SLIDER }], target: i0.ɵɵFactoryTarget.Directive });
+MatSliderThumb.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0-rc.1", type: MatSliderThumb, selector: "input[matSliderThumb]", inputs: { value: "value" }, outputs: { valueChange: "valueChange", dragStart: "dragStart", dragEnd: "dragEnd" }, host: { attributes: { "type": "range" }, listeners: { "change": "_onChange()", "input": "_onInput()", "blur": "_onBlur()", "focus": "_onFocus()" }, properties: { "attr.aria-valuetext": "_valuetext" }, classAttribute: "mdc-slider__input" }, providers: [
+        MAT_SLIDER_THUMB_VALUE_ACCESSOR,
+        { provide: MAT_SLIDER_THUMB, useExisting: MatSliderThumb },
+    ], exportAs: ["matSliderThumb"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0-rc.1", ngImport: i0, type: MatSliderThumb, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[matSliderThumb]',
+                    exportAs: 'matSliderThumb',
+                    host: {
+                        'class': 'mdc-slider__input',
+                        'type': 'range',
+                        '[attr.aria-valuetext]': '_valuetext',
+                        '(change)': '_onChange()',
+                        '(input)': '_onInput()',
+                        // TODO(wagnermaciel): Consider using a global event listener instead.
+                        // Reason: I have found a semi-consistent way to mouse up without triggering this event.
+                        '(blur)': '_onBlur()',
+                        '(focus)': '_onFocus()',
+                    },
+                    providers: [
+                        MAT_SLIDER_THUMB_VALUE_ACCESSOR,
+                        { provide: MAT_SLIDER_THUMB, useExisting: MatSliderThumb },
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_SLIDER]
+                }] }]; }, propDecorators: { value: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], dragStart: [{
+                type: Output
+            }], dragEnd: [{
+                type: Output
+            }] } });
+export class MatSliderRangeThumb extends MatSliderThumb {
+    constructor(_ngZone, _slider, _elementRef, _cdr) {
+        super(_ngZone, _elementRef, _cdr, _slider);
+        this._cdr = _cdr;
+        this._isEndThumb = this._hostElement.hasAttribute('matSliderEndThumb');
+        this._setIsLeftThumb();
+        this.thumbPosition = this._isEndThumb ? 2 /* _MatThumb.END */ : 1 /* _MatThumb.START */;
+    }
+    getSibling() {
+        if (!this._sibling) {
+            this._sibling = this._slider._getInput(this._isEndThumb ? 1 /* _MatThumb.START */ : 2 /* _MatThumb.END */);
+        }
+        return this._sibling;
+    }
+    /** Returns the minimum translateX position allowed for this slider input's visual thumb. */
+    getMinPos() {
+        const sibling = this.getSibling();
+        if (!this._isLeftThumb && sibling) {
+            return sibling.translateX;
+        }
+        return 0;
+    }
+    /** Returns the maximum translateX position allowed for this slider input's visual thumb. */
+    getMaxPos() {
+        const sibling = this.getSibling();
+        if (this._isLeftThumb && sibling) {
+            return sibling.translateX;
+        }
+        return this._slider._cachedWidth;
+    }
+    _setIsLeftThumb() {
+        this._isLeftThumb =
+            (this._isEndThumb && this._slider._isRtl) || (!this._isEndThumb && !this._slider._isRtl);
+    }
+    _getDefaultValue() {
+        return this._isEndThumb && this._slider._isRange ? this.max : this.min;
+    }
+    _onInput() {
+        super._onInput();
+        this._updateSibling();
+        if (!this._isActive) {
+            this._updateWidthInactive();
+        }
+    }
+    _onNgControlValueChange() {
+        super._onNgControlValueChange();
+        this.getSibling()?._updateMinMax();
+    }
+    _onPointerDown(event) {
+        if (this.disabled) {
+            return;
+        }
+        if (this._sibling) {
+            this._sibling._updateWidthActive();
+            this._sibling._hostElement.classList.add('mat-mdc-slider-input-no-pointer-events');
+        }
+        super._onPointerDown(event);
+    }
+    _onPointerUp(event) {
+        super._onPointerUp(event);
+        if (this._sibling) {
+            this._sibling._updateWidthInactive();
+            this._sibling._hostElement.classList.remove('mat-mdc-slider-input-no-pointer-events');
+        }
+    }
+    _onPointerMove(event) {
+        super._onPointerMove(event);
+        if (!this._slider.step && this._isActive) {
+            this._updateSibling();
+        }
+    }
+    _fixValue(event) {
+        super._fixValue(event);
+        this._sibling?._updateMinMax();
+    }
+    _clamp(v) {
+        return Math.max(Math.min(v, this.getMaxPos()), this.getMinPos());
+    }
+    _updateMinMax() {
+        const sibling = this.getSibling();
+        if (!sibling) {
+            return;
+        }
+        if (this._isEndThumb) {
+            this.min = Math.max(this._slider.min, sibling.value);
+            this.max = this._slider.max;
+        }
+        else {
+            this.min = this._slider.min;
+            this.max = Math.min(this._slider.max, sibling.value);
+        }
+    }
+    _updateWidthActive() {
+        const minWidth = this._slider._rippleRadius * 2 - this._slider._inputPadding * 2;
+        const maxWidth = this._slider._cachedWidth + this._slider._inputPadding - minWidth;
+        const percentage = this._slider.min < this._slider.max
+            ? (this.max - this.min) / (this._slider.max - this._slider.min)
+            : 1;
+        const width = maxWidth * percentage + minWidth;
+        this._hostElement.style.width = `${width}px`;
+        this._hostElement.style.padding = `0 ${this._slider._inputPadding}px`;
+    }
+    _updateWidthInactive() {
+        const sibling = this.getSibling();
+        if (!sibling) {
+            return;
+        }
+        const maxWidth = this._slider._cachedWidth;
+        const midValue = this._isEndThumb
+            ? this.value - (this.value - sibling.value) / 2
+            : this.value + (sibling.value - this.value) / 2;
+        const _percentage = this._isEndThumb
+            ? (this.max - midValue) / (this._slider.max - this._slider.min)
+            : (midValue - this.min) / (this._slider.max - this._slider.min);
+        const percentage = this._slider.min < this._slider.max ? _percentage : 1;
+        const width = maxWidth * percentage + 24;
+        this._hostElement.style.width = `${width}px`;
+        this._hostElement.style.padding = '0px';
+        if (this._isLeftThumb) {
+            this._hostElement.style.left = '-24px';
+            this._hostElement.style.right = 'auto';
+        }
+        else {
+            this._hostElement.style.left = 'auto';
+            this._hostElement.style.right = '-24px';
+        }
+    }
+    _updateStaticStyles() {
+        this._hostElement.classList.toggle('mat-slider__right-input', !this._isLeftThumb);
+    }
+    _updateSibling() {
+        const sibling = this.getSibling();
+        if (!sibling) {
+            return;
+        }
+        sibling._updateMinMax();
+        if (this._isActive) {
+            sibling._updateWidthActive();
+        }
+        else {
+            sibling._updateWidthInactive();
+        }
+    }
+    /**
+     * Sets the input's value.
+     * @param value The new value of the input
+     * @docs-private
+     */
+    writeValue(value) {
+        this.value = value;
+        this._updateWidthInactive();
+        this._updateSibling();
+    }
+}
+MatSliderRangeThumb.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0-rc.1", ngImport: i0, type: MatSliderRangeThumb, deps: [{ token: i0.NgZone }, { token: MAT_SLIDER }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+MatSliderRangeThumb.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0-rc.1", type: MatSliderRangeThumb, selector: "input[matSliderStartThumb], input[matSliderEndThumb]", providers: [
+        MAT_SLIDER_RANGE_THUMB_VALUE_ACCESSOR,
+        { provide: MAT_SLIDER_RANGE_THUMB, useExisting: MatSliderRangeThumb },
+    ], exportAs: ["matSliderRangeThumb"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0-rc.1", ngImport: i0, type: MatSliderRangeThumb, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[matSliderStartThumb], input[matSliderEndThumb]',
+                    exportAs: 'matSliderRangeThumb',
+                    providers: [
+                        MAT_SLIDER_RANGE_THUMB_VALUE_ACCESSOR,
+                        { provide: MAT_SLIDER_RANGE_THUMB, useExisting: MatSliderRangeThumb },
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_SLIDER]
+                }] }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slider-input.js","sourceRoot":"","sources":["../../../../../../src/material/slider/slider-input.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  BooleanInput,\n  coerceBooleanProperty,\n  coerceNumberProperty,\n  NumberInput,\n} from '@angular/cdk/coercion';\nimport {\n  ChangeDetectorRef,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  Inject,\n  Input,\n  NgZone,\n  OnDestroy,\n  Output,\n} from '@angular/core';\nimport {ControlValueAccessor, FormControl, NG_VALUE_ACCESSOR} from '@angular/forms';\nimport {Subject} from 'rxjs';\nimport {\n  _MatThumb,\n  MatSliderDragEvent,\n  _MatSlider,\n  _MatSliderRangeThumb,\n  _MatSliderThumb,\n  MAT_SLIDER_RANGE_THUMB,\n  MAT_SLIDER_THUMB,\n  MAT_SLIDER,\n} from './slider-interface';\n\n/**\n * Provider that allows the slider thumb to register as a ControlValueAccessor.\n * @docs-private\n */\nexport const MAT_SLIDER_THUMB_VALUE_ACCESSOR: any = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => MatSliderThumb),\n  multi: true,\n};\n\n/**\n * Provider that allows the range slider thumb to register as a ControlValueAccessor.\n * @docs-private\n */\nexport const MAT_SLIDER_RANGE_THUMB_VALUE_ACCESSOR: any = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => MatSliderRangeThumb),\n  multi: true,\n};\n\n/**\n * Directive that adds slider-specific behaviors to an input element inside `<mat-slider>`.\n * Up to two may be placed inside of a `<mat-slider>`.\n *\n * If one is used, the selector `matSliderThumb` must be used, and the outcome will be a normal\n * slider. If two are used, the selectors `matSliderStartThumb` and `matSliderEndThumb` must be\n * used, and the outcome will be a range slider with two slider thumbs.\n */\n@Directive({\n  selector: 'input[matSliderThumb]',\n  exportAs: 'matSliderThumb',\n  host: {\n    'class': 'mdc-slider__input',\n    'type': 'range',\n    '[attr.aria-valuetext]': '_valuetext',\n    '(change)': '_onChange()',\n    '(input)': '_onInput()',\n    // TODO(wagnermaciel): Consider using a global event listener instead.\n    // Reason: I have found a semi-consistent way to mouse up without triggering this event.\n    '(blur)': '_onBlur()',\n    '(focus)': '_onFocus()',\n  },\n  providers: [\n    MAT_SLIDER_THUMB_VALUE_ACCESSOR,\n    {provide: MAT_SLIDER_THUMB, useExisting: MatSliderThumb},\n  ],\n})\nexport class MatSliderThumb implements _MatSliderThumb, OnDestroy, ControlValueAccessor {\n  @Input()\n  get value(): number {\n    return coerceNumberProperty(this._hostElement.value);\n  }\n  set value(v: NumberInput) {\n    const val = coerceNumberProperty(v).toString();\n    if (!this._hasSetInitialValue) {\n      this._initialValue = val;\n      return;\n    }\n    if (this._isActive) {\n      return;\n    }\n    this._hostElement.value = val;\n    this._updateThumbUIByValue();\n    this._slider._onValueChange(this);\n    this._cdr.detectChanges();\n  }\n  @Output() readonly valueChange: EventEmitter<number> = new EventEmitter<number>();\n\n  /** Event emitted when the slider thumb starts being dragged. */\n  @Output() readonly dragStart: EventEmitter<MatSliderDragEvent> =\n    new EventEmitter<MatSliderDragEvent>();\n\n  /** Event emitted when the slider thumb stops being dragged. */\n  @Output() readonly dragEnd: EventEmitter<MatSliderDragEvent> =\n    new EventEmitter<MatSliderDragEvent>();\n\n  /** The current translateX in px of the slider visual thumb. */\n  get translateX(): number {\n    if (this._slider.min >= this._slider.max) {\n      this._translateX = 0;\n      return this._translateX;\n    }\n    if (this._translateX === undefined) {\n      this._translateX = this._calcTranslateXByValue();\n    }\n    return this._translateX;\n  }\n  set translateX(v: number) {\n    this._translateX = v;\n  }\n  private _translateX: number | undefined;\n\n  /** Indicates whether this thumb is the start or end thumb. */\n  thumbPosition: _MatThumb = _MatThumb.END;\n\n  get min(): number {\n    return coerceNumberProperty(this._hostElement.min);\n  }\n  set min(v: NumberInput) {\n    this._hostElement.min = coerceNumberProperty(v).toString();\n    this._cdr.detectChanges();\n  }\n\n  get max(): number {\n    return coerceNumberProperty(this._hostElement.max);\n  }\n  set max(v: NumberInput) {\n    this._hostElement.max = coerceNumberProperty(v).toString();\n    this._cdr.detectChanges();\n  }\n\n  get step(): number {\n    return coerceNumberProperty(this._hostElement.step);\n  }\n  set step(v: NumberInput) {\n    this._hostElement.step = coerceNumberProperty(v).toString();\n    this._cdr.detectChanges();\n  }\n\n  get disabled(): boolean {\n    return coerceBooleanProperty(this._hostElement.disabled);\n  }\n  set disabled(v: BooleanInput) {\n    this._hostElement.disabled = coerceBooleanProperty(v);\n    this._cdr.detectChanges();\n\n    if (this._slider.disabled !== this.disabled) {\n      this._slider.disabled = this.disabled;\n    }\n  }\n\n  get percentage(): number {\n    if (this._slider.min >= this._slider.max) {\n      return this._slider._isRtl ? 1 : 0;\n    }\n    return (this.value - this._slider.min) / (this._slider.max - this._slider.min);\n  }\n\n  get fillPercentage(): number {\n    if (!this._slider._cachedWidth) {\n      return this._slider._isRtl ? 1 : 0;\n    }\n    if (this._translateX === 0) {\n      return 0;\n    }\n    return this.translateX / this._slider._cachedWidth;\n  }\n\n  /** The host native HTML input element. */\n  _hostElement: HTMLInputElement;\n\n  /** The aria-valuetext string representation of the input's value. */\n  _valuetext: string;\n\n  /** The radius of a native html slider's knob. */\n  _knobRadius: number = 8;\n\n  /** Whether user's cursor is currently in a mouse down state on the input. */\n  _isActive: boolean = false;\n\n  /** Whether the input is currently focused (either by tab or after clicking). */\n  _isFocused: boolean = false;\n\n  /** Used to relay updates to _isFocused to the slider visual thumbs. */\n  private _setIsFocused(v: boolean): void {\n    this._isFocused = v;\n  }\n\n  /**\n   * Whether the initial value has been set.\n   * This exists because the initial value cannot be immediately set because the min and max\n   * must first be relayed from the parent MatSlider component, which can only happen later\n   * in the component lifecycle.\n   */\n  private _hasSetInitialValue: boolean = false;\n\n  /** The stored initial value. */\n  _initialValue: string | undefined;\n\n  /** Defined when a user is using a form control to manage slider value & validation. */\n  private _formControl: FormControl | undefined;\n\n  /** Emits when the component is destroyed. */\n  protected readonly _destroyed = new Subject<void>();\n\n  /**\n   * Indicates whether UI updates should be skipped.\n   *\n   * This flag is used to avoid flickering\n   * when correcting values on pointer up/down.\n   */\n  _skipUIUpdate: boolean = false;\n\n  /** Callback called when the slider input value changes. */\n  private _onChangeFn: (value: any) => void = () => {};\n\n  /** Callback called when the slider input has been touched. */\n  private _onTouchedFn: () => void = () => {};\n\n  constructor(\n    readonly _ngZone: NgZone,\n    readonly _elementRef: ElementRef<HTMLInputElement>,\n    readonly _cdr: ChangeDetectorRef,\n    @Inject(MAT_SLIDER) protected _slider: _MatSlider,\n  ) {\n    this._hostElement = _elementRef.nativeElement;\n    this._ngZone.runOutsideAngular(() => {\n      this._hostElement.addEventListener('pointerdown', this._onPointerDown.bind(this));\n      this._hostElement.addEventListener('pointermove', this._onPointerMove.bind(this));\n      this._hostElement.addEventListener('pointerup', this._onPointerUp.bind(this));\n    });\n  }\n\n  ngOnDestroy(): void {\n    this._hostElement.removeEventListener('pointerdown', this._onPointerDown);\n    this._hostElement.removeEventListener('pointermove', this._onPointerMove);\n    this._hostElement.removeEventListener('pointerup', this._onPointerUp);\n    this._destroyed.next();\n    this._destroyed.complete();\n    this.dragStart.complete();\n    this.dragEnd.complete();\n  }\n\n  initProps(): void {\n    this._updateWidthInactive();\n    this.disabled = this._slider.disabled;\n    this.step = this._slider.step;\n    this.min = this._slider.min;\n    this.max = this._slider.max;\n    this._initValue();\n  }\n\n  initUI(): void {\n    this._updateThumbUIByValue();\n  }\n\n  _initValue(): void {\n    this._hasSetInitialValue = true;\n    if (this._initialValue === undefined) {\n      this.value = this._getDefaultValue();\n    } else {\n      this._hostElement.value = this._initialValue;\n      this._updateThumbUIByValue();\n      this._slider._onValueChange(this);\n      this._cdr.detectChanges();\n    }\n  }\n\n  _getDefaultValue(): number {\n    return this.min;\n  }\n\n  _onBlur(): void {\n    this._setIsFocused(false);\n    this._onTouchedFn();\n  }\n\n  _onFocus(): void {\n    this._setIsFocused(true);\n  }\n\n  _onChange(): void {\n    // only used to handle the edge case where user\n    // mousedown on the slider then uses arrow keys.\n    if (this._isActive) {\n      this._updateThumbUIByValue({withAnimation: true});\n    }\n  }\n\n  _onInput(): void {\n    this.valueChange.emit(this.value);\n    this._onChangeFn(this.value);\n    // handles arrowing and updating the value when\n    // a step is defined.\n    if (this._slider.step || !this._isActive) {\n      this._updateThumbUIByValue({withAnimation: true});\n    }\n    this._slider._onValueChange(this);\n  }\n\n  _onNgControlValueChange(): void {\n    // only used to handle when the value change\n    // originates outside of the slider.\n    if (!this._isActive || !this._isFocused) {\n      this._slider._onValueChange(this);\n      this._updateThumbUIByValue();\n    }\n    this._slider.disabled = this._formControl!.disabled;\n  }\n\n  _onPointerDown(event: PointerEvent): void {\n    if (this.disabled || event.button !== 0) {\n      return;\n    }\n\n    this._isActive = true;\n    this._setIsFocused(true);\n    this._updateWidthActive();\n    this._slider._updateDimensions();\n\n    // Does nothing if a step is defined because we\n    // want the value to snap to the values on input.\n    if (!this._slider.step) {\n      this._updateThumbUIByPointerEvent(event, {withAnimation: true});\n    }\n\n    if (!this.disabled) {\n      this._handleValueCorrection(event);\n    }\n  }\n\n  /**\n   * Corrects the value of the slider on pointer up/down.\n   *\n   * Called on pointer down and up because the value is set based\n   * on the inactive width instead of the active width.\n   */\n  private _handleValueCorrection(event: PointerEvent): void {\n    // Don't update the UI with the current value! The value on pointerdown\n    // and pointerup is calculated in the split second before the input(s)\n    // resize. See _updateWidthInactive() and _updateWidthActive() for more\n    // details.\n    this._skipUIUpdate = true;\n\n    // Note that this function gets triggered before the actual value of the\n    // slider is updated. This means if we were to set the value here, it\n    // would immediately be overwritten. Using setTimeout ensures the setting\n    // of the value happens after the value has been updated by the\n    // pointerdown event.\n    setTimeout(() => {\n      this._skipUIUpdate = false;\n      this._fixValue(event);\n    }, 0);\n  }\n\n  /** Corrects the value of the slider based on the pointer event's position. */\n  _fixValue(event: PointerEvent): void {\n    const xPos = event.clientX - this._slider._cachedLeft;\n    const width = this._slider._cachedWidth;\n    const step = this._slider.step === 0 ? 1 : this._slider.step;\n    const numSteps = Math.floor((this._slider.max - this._slider.min) / step);\n    const percentage = this._slider._isRtl ? 1 - xPos / width : xPos / width;\n\n    // To ensure the percentage is rounded to the necessary number of decimals.\n    const fixedPercentage = Math.round(percentage * numSteps) / numSteps;\n\n    const impreciseValue =\n      fixedPercentage * (this._slider.max - this._slider.min) + this._slider.min;\n    const value = Math.round(impreciseValue / step) * step;\n\n    const prevValue = this.value;\n    const dragEvent = {source: this, parent: this._slider, value: value};\n    this._isActive ? this.dragStart.emit(dragEvent) : this.dragEnd.emit(dragEvent);\n\n    if (value === prevValue) {\n      // Because we prevented UI updates, if it turns out that the race\n      // condition didn't happen and the value is already correct, we\n      // have to apply the ui updates now.\n      this._slider._onValueChange(this);\n      this._slider.step > 0\n        ? this._updateThumbUIByValue()\n        : this._updateThumbUIByPointerEvent(event, {withAnimation: this._slider._hasAnimation});\n      return;\n    }\n\n    this.value = value;\n    this.valueChange.emit(this.value);\n    this._onChangeFn(this.value);\n    this._slider._onValueChange(this);\n    this._slider.step > 0\n      ? this._updateThumbUIByValue()\n      : this._updateThumbUIByPointerEvent(event, {withAnimation: this._slider._hasAnimation});\n  }\n\n  _onPointerMove(event: PointerEvent): void {\n    // Again, does nothing if a step is defined because\n    // we want the value to snap to the values on input.\n    if (!this._slider.step && this._isActive) {\n      this._updateThumbUIByPointerEvent(event);\n    }\n  }\n\n  _onPointerUp(event: PointerEvent): void {\n    this._isActive = false;\n    this._updateWidthInactive();\n    if (!this.disabled) {\n      this._handleValueCorrection(event);\n    }\n  }\n\n  _clamp(v: number): number {\n    return Math.max(Math.min(v, this._slider._cachedWidth), 0);\n  }\n\n  _calcTranslateXByValue(): number {\n    if (this._slider._isRtl) {\n      return (1 - this.percentage) * this._slider._cachedWidth;\n    }\n    return this.percentage * this._slider._cachedWidth;\n  }\n\n  _calcTranslateXByPointerEvent(event: PointerEvent): number {\n    return event.clientX - this._slider._cachedLeft;\n  }\n\n  /**\n   * Used to set the slider width to the correct\n   * dimensions while the user is dragging.\n   */\n  _updateWidthActive(): void {\n    this._hostElement.style.padding = `0 ${this._slider._inputPadding}px`;\n    this._hostElement.style.width = `calc(100% + ${this._slider._inputPadding}px)`;\n  }\n\n  /**\n   * Sets the slider input to disproportionate dimensions to allow for touch\n   * events to be captured on touch devices.\n   */\n  _updateWidthInactive(): void {\n    this._hostElement.style.padding = '0px';\n    this._hostElement.style.width = 'calc(100% + 48px)';\n    this._hostElement.style.left = '-24px';\n  }\n\n  _updateThumbUIByValue(options?: {withAnimation: boolean}): void {\n    this.translateX = this._clamp(this._calcTranslateXByValue());\n    this._updateThumbUI(options);\n  }\n\n  _updateThumbUIByPointerEvent(event: PointerEvent, options?: {withAnimation: boolean}): void {\n    this.translateX = this._clamp(this._calcTranslateXByPointerEvent(event));\n    this._updateThumbUI(options);\n  }\n\n  _updateThumbUI(options?: {withAnimation: boolean}) {\n    this._slider._setTransition(!!options?.withAnimation);\n    this._slider._onTranslateXChange(this);\n  }\n\n  /**\n   * Sets the input's value.\n   * @param value The new value of the input\n   * @docs-private\n   */\n  writeValue(value: any): void {\n    this.value = value;\n  }\n\n  /**\n   * Registers a callback to be invoked when the input's value changes from user input.\n   * @param fn The callback to register\n   * @docs-private\n   */\n  registerOnChange(fn: any): void {\n    this._onChangeFn = fn;\n  }\n\n  /**\n   * Registers a callback to be invoked when the input is blurred by the user.\n   * @param fn The callback to register\n   * @docs-private\n   */\n  registerOnTouched(fn: any): void {\n    this._onTouchedFn = fn;\n  }\n\n  /**\n   * Sets the disabled state of the slider.\n   * @param isDisabled The new disabled state\n   * @docs-private\n   */\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\n\n  focus(): void {\n    this._hostElement.focus();\n  }\n\n  blur(): void {\n    this._hostElement.blur();\n  }\n}\n\n@Directive({\n  selector: 'input[matSliderStartThumb], input[matSliderEndThumb]',\n  exportAs: 'matSliderRangeThumb',\n  providers: [\n    MAT_SLIDER_RANGE_THUMB_VALUE_ACCESSOR,\n    {provide: MAT_SLIDER_RANGE_THUMB, useExisting: MatSliderRangeThumb},\n  ],\n})\nexport class MatSliderRangeThumb extends MatSliderThumb implements _MatSliderRangeThumb {\n  getSibling(): _MatSliderRangeThumb | undefined {\n    if (!this._sibling) {\n      this._sibling = this._slider._getInput(this._isEndThumb ? _MatThumb.START : _MatThumb.END) as\n        | MatSliderRangeThumb\n        | undefined;\n    }\n    return this._sibling;\n  }\n  private _sibling: MatSliderRangeThumb | undefined;\n\n  /** Returns the minimum translateX position allowed for this slider input's visual thumb. */\n  getMinPos(): number {\n    const sibling = this.getSibling();\n    if (!this._isLeftThumb && sibling) {\n      return sibling.translateX;\n    }\n    return 0;\n  }\n\n  /** Returns the maximum translateX position allowed for this slider input's visual thumb. */\n  getMaxPos(): number {\n    const sibling = this.getSibling();\n    if (this._isLeftThumb && sibling) {\n      return sibling.translateX;\n    }\n    return this._slider._cachedWidth;\n  }\n\n  _setIsLeftThumb(): void {\n    this._isLeftThumb =\n      (this._isEndThumb && this._slider._isRtl) || (!this._isEndThumb && !this._slider._isRtl);\n  }\n\n  /** Whether this slider corresponds to the input on the left hand side. */\n  _isLeftThumb: boolean;\n\n  /** Whether this slider corresponds to the input with greater value. */\n  _isEndThumb: boolean;\n\n  constructor(\n    _ngZone: NgZone,\n    @Inject(MAT_SLIDER) _slider: _MatSlider,\n    _elementRef: ElementRef<HTMLInputElement>,\n    override readonly _cdr: ChangeDetectorRef,\n  ) {\n    super(_ngZone, _elementRef, _cdr, _slider);\n    this._isEndThumb = this._hostElement.hasAttribute('matSliderEndThumb');\n    this._setIsLeftThumb();\n    this.thumbPosition = this._isEndThumb ? _MatThumb.END : _MatThumb.START;\n  }\n\n  override _getDefaultValue(): number {\n    return this._isEndThumb && this._slider._isRange ? this.max : this.min;\n  }\n\n  override _onInput(): void {\n    super._onInput();\n    this._updateSibling();\n    if (!this._isActive) {\n      this._updateWidthInactive();\n    }\n  }\n\n  override _onNgControlValueChange(): void {\n    super._onNgControlValueChange();\n    this.getSibling()?._updateMinMax();\n  }\n\n  override _onPointerDown(event: PointerEvent): void {\n    if (this.disabled) {\n      return;\n    }\n    if (this._sibling) {\n      this._sibling._updateWidthActive();\n      this._sibling._hostElement.classList.add('mat-mdc-slider-input-no-pointer-events');\n    }\n    super._onPointerDown(event);\n  }\n\n  override _onPointerUp(event: PointerEvent): void {\n    super._onPointerUp(event);\n    if (this._sibling) {\n      this._sibling._updateWidthInactive();\n      this._sibling._hostElement.classList.remove('mat-mdc-slider-input-no-pointer-events');\n    }\n  }\n\n  override _onPointerMove(event: PointerEvent): void {\n    super._onPointerMove(event);\n    if (!this._slider.step && this._isActive) {\n      this._updateSibling();\n    }\n  }\n\n  override _fixValue(event: PointerEvent): void {\n    super._fixValue(event);\n    this._sibling?._updateMinMax();\n  }\n\n  override _clamp(v: number): number {\n    return Math.max(Math.min(v, this.getMaxPos()), this.getMinPos());\n  }\n\n  _updateMinMax(): void {\n    const sibling = this.getSibling();\n    if (!sibling) {\n      return;\n    }\n    if (this._isEndThumb) {\n      this.min = Math.max(this._slider.min, sibling.value);\n      this.max = this._slider.max;\n    } else {\n      this.min = this._slider.min;\n      this.max = Math.min(this._slider.max, sibling.value);\n    }\n  }\n\n  override _updateWidthActive(): void {\n    const minWidth = this._slider._rippleRadius * 2 - this._slider._inputPadding * 2;\n    const maxWidth = this._slider._cachedWidth + this._slider._inputPadding - minWidth;\n    const percentage =\n      this._slider.min < this._slider.max\n        ? (this.max - this.min) / (this._slider.max - this._slider.min)\n        : 1;\n    const width = maxWidth * percentage + minWidth;\n    this._hostElement.style.width = `${width}px`;\n    this._hostElement.style.padding = `0 ${this._slider._inputPadding}px`;\n  }\n\n  override _updateWidthInactive(): void {\n    const sibling = this.getSibling();\n    if (!sibling) {\n      return;\n    }\n    const maxWidth = this._slider._cachedWidth;\n    const midValue = this._isEndThumb\n      ? this.value - (this.value - sibling.value) / 2\n      : this.value + (sibling.value - this.value) / 2;\n\n    const _percentage = this._isEndThumb\n      ? (this.max - midValue) / (this._slider.max - this._slider.min)\n      : (midValue - this.min) / (this._slider.max - this._slider.min);\n\n    const percentage = this._slider.min < this._slider.max ? _percentage : 1;\n\n    const width = maxWidth * percentage + 24;\n    this._hostElement.style.width = `${width}px`;\n    this._hostElement.style.padding = '0px';\n\n    if (this._isLeftThumb) {\n      this._hostElement.style.left = '-24px';\n      this._hostElement.style.right = 'auto';\n    } else {\n      this._hostElement.style.left = 'auto';\n      this._hostElement.style.right = '-24px';\n    }\n  }\n\n  _updateStaticStyles(): void {\n    this._hostElement.classList.toggle('mat-slider__right-input', !this._isLeftThumb);\n  }\n\n  private _updateSibling(): void {\n    const sibling = this.getSibling();\n    if (!sibling) {\n      return;\n    }\n    sibling._updateMinMax();\n    if (this._isActive) {\n      sibling._updateWidthActive();\n    } else {\n      sibling._updateWidthInactive();\n    }\n  }\n\n  /**\n   * Sets the input's value.\n   * @param value The new value of the input\n   * @docs-private\n   */\n  override writeValue(value: any): void {\n    this.value = value;\n    this._updateWidthInactive();\n    this._updateSibling();\n  }\n}\n"]}