@ngx-formly/material 6.0.4 → 6.1.0

package/esm2020/slider/slider-input.mjs

@@ -0,0 +1,443 @@
+/**
+ * @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 { Directive, EventEmitter, forwardRef, Inject, Input, Output, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { MatSlider } from '@angular/material/slider';
+import { Subject } from 'rxjs';
+import { MAT_SLIDER_THUMB } 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,
+};
+/**
+ * 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;
+        /** Event emitted when the `value` is changed. */
+        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.
+         * @docs-private
+         */
+        this.thumbPosition = 2 /* 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.
+     * @docs-private
+     */
+    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;
+    }
+    /** @docs-private */
+    get min() {
+        return coerceNumberProperty(this._hostElement.min);
+    }
+    set min(v) {
+        this._hostElement.min = coerceNumberProperty(v).toString();
+        this._cdr.detectChanges();
+    }
+    /** @docs-private */
+    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();
+    }
+    /** @docs-private */
+    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;
+        }
+    }
+    /** The percentage of the slider that coincides with the value. */
+    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);
+    }
+    /** @docs-private */
+    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();
+    }
+    /** @docs-private */
+    initProps() {
+        this._updateWidthInactive();
+        // If this or the parent slider is disabled, just make everything disabled.
+        if (this.disabled !== this._slider.disabled) {
+            // The MatSlider setter for disabled will relay this and disable both inputs.
+            this._slider.disabled = true;
+        }
+        this.step = this._slider.step;
+        this.min = this._slider.min;
+        this.max = this._slider.max;
+        this._initValue();
+    }
+    /** @docs-private */
+    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: "13.3.12", ngImport: i0, type: MatSliderThumb, deps: [{ token: i0.NgZone }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: MatSlider }], target: i0.ɵɵFactoryTarget.Directive });
+MatSliderThumb.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.12", 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: "13.3.12", ngImport: i0, type: MatSliderThumb, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line
+                    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: [MatSlider]
+                }] }]; }, propDecorators: { value: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], dragStart: [{
+                type: Output
+            }], dragEnd: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slider-input.js","sourceRoot":"","sources":["../../../../../src/ui/material/slider/src/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 { BooleanInput, coerceBooleanProperty, coerceNumberProperty, NumberInput } 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 { MatSlider } from '@angular/material/slider';\nimport { Subject } from 'rxjs';\nimport { _MatThumb, MatSliderDragEvent, _MatSlider, _MatSliderThumb, MAT_SLIDER_THUMB } 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 * 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  // eslint-disable-next-line\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: [MAT_SLIDER_THUMB_VALUE_ACCESSOR, { provide: MAT_SLIDER_THUMB, useExisting: MatSliderThumb }],\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  /** Event emitted when the `value` is changed. */\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> = new EventEmitter<MatSliderDragEvent>();\n\n  /** Event emitted when the slider thumb stops being dragged. */\n  @Output() readonly dragEnd: EventEmitter<MatSliderDragEvent> = new EventEmitter<MatSliderDragEvent>();\n\n  /**\n   * The current translateX in px of the slider visual thumb.\n   * @docs-private\n   */\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  /**\n   * Indicates whether this thumb is the start or end thumb.\n   * @docs-private\n   */\n  thumbPosition: _MatThumb = _MatThumb.END;\n\n  /** @docs-private */\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  /** @docs-private */\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  /** @docs-private */\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  /** The percentage of the slider that coincides with the value. */\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  /** @docs-private */\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(MatSlider) 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  /** @docs-private */\n  initProps(): void {\n    this._updateWidthInactive();\n\n    // If this or the parent slider is disabled, just make everything disabled.\n    if (this.disabled !== this._slider.disabled) {\n      // The MatSlider setter for disabled will relay this and disable both inputs.\n      this._slider.disabled = true;\n    }\n\n    this.step = this._slider.step;\n    this.min = this._slider.min;\n    this.max = this._slider.max;\n    this._initValue();\n  }\n\n  /** @docs-private */\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 = 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"]}

package/esm2020/slider/slider-interface.mjs

@@ -0,0 +1,15 @@
+/**
+ * @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 { InjectionToken } from '@angular/core';
+/**
+ * Injection token that can be used to query for a `MatSliderThumb`.
+ * Used primarily to avoid circular imports.
+ * @docs-private
+ */
+export const MAT_SLIDER_THUMB = new InjectionToken('_MatSliderThumb');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpZGVyLWludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy91aS9tYXRlcmlhbC9zbGlkZXIvc3JjL3NsaWRlci1pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQVkvQzs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsSUFBSSxjQUFjLENBQUssaUJBQWlCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUmlwcGxlR2xvYmFsT3B0aW9ucyB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2NvcmUnO1xuXG4vKipcbiAqIFRodW1iIHR5cGVzOiByYW5nZSBzbGlkZXIgaGFzIHR3byB0aHVtYnMgKFNUQVJULCBFTkQpIHdoZXJlYXMgc2luZ2xlIHBvaW50XG4gKiBzbGlkZXIgb25seSBoYXMgb25lIHRodW1iIChFTkQpLlxuICovXG5leHBvcnQgY29uc3QgZW51bSBfTWF0VGh1bWIge1xuICBTVEFSVCA9IDEsXG4gIEVORCA9IDIsXG59XG5cbi8qKlxuICogSW5qZWN0aW9uIHRva2VuIHRoYXQgY2FuIGJlIHVzZWQgdG8gcXVlcnkgZm9yIGEgYE1hdFNsaWRlclRodW1iYC5cbiAqIFVzZWQgcHJpbWFyaWx5IHRvIGF2b2lkIGNpcmN1bGFyIGltcG9ydHMuXG4gKiBAZG9jcy1wcml2YXRlXG4gKi9cbmV4cG9ydCBjb25zdCBNQVRfU0xJREVSX1RIVU1CID0gbmV3IEluamVjdGlvblRva2VuPHt9PignX01hdFNsaWRlclRodW1iJyk7XG5cbi8qKiBSZXByZXNlbnRzIGEgZHJhZyBldmVudCBlbWl0dGVkIGJ5IHRoZSBNYXRTbGlkZXIgY29tcG9uZW50LiAqL1xuZXhwb3J0IGludGVyZmFjZSBNYXRTbGlkZXJEcmFnRXZlbnQge1xuICAvKiogVGhlIE1hdFNsaWRlclRodW1iIHRoYXQgd2FzIGludGVyYWN0ZWQgd2l0aC4gKi9cbiAgc291cmNlOiBfTWF0U2xpZGVyVGh1bWI7XG5cbiAgLyoqIFRoZSBNYXRTbGlkZXIgdGhhdCB3YXMgaW50ZXJhY3RlZCB3aXRoLiAqL1xuICBwYXJlbnQ6IF9NYXRTbGlkZXI7XG5cbiAgLyoqIFRoZSBjdXJyZW50IHZhbHVlIG9mIHRoZSBzbGlkZXIuICovXG4gIHZhbHVlOiBudW1iZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgX01hdFNsaWRlciB7XG4gIC8qKiBHZXRzIHRoZSBzbGlkZXIgdGh1bWIgaW5wdXQgb2YgdGhlIGdpdmVuIHRodW1iIHBvc2l0aW9uLiAqL1xuICBfZ2V0SW5wdXQodGh1bWJQb3NpdGlvbjogX01hdFRodW1iKTogX01hdFNsaWRlclRodW1iIHwgdW5kZWZpbmVkO1xuXG4gIC8qKiBUaGUgbWluaW11bSB2YWx1ZSB0aGF0IHRoZSBzbGlkZXIgY2FuIGhhdmUuICovXG4gIG1pbjogbnVtYmVyO1xuXG4gIC8qKiBUaGUgbWF4aW11bSB2YWx1ZSB0aGF0IHRoZSBzbGlkZXIgY2FuIGhhdmUuICovXG4gIG1heDogbnVtYmVyO1xuXG4gIC8qKiBUaGUgYW1vdW50IHRoYXQgc2xpZGVyIHZhbHVlcyBjYW4gaW5jcmVtZW50IG9yIGRlY3JlbWVudCBieS4gKi9cbiAgc3RlcDogbnVtYmVyO1xuXG4gIC8qKiBXaGV0aGVyIHRoZSBzbGlkZXIgaXMgZGlzYWJsZWQuICovXG4gIGRpc2FibGVkOiBib29sZWFuO1xuXG4gIC8qKiBXaGV0aGVyIHRoZSBzbGlkZXIgaXMgYSByYW5nZSBzbGlkZXIuICovXG4gIF9pc1JhbmdlOiBib29sZWFuO1xuXG4gIC8qKiBXaGV0aGVyIHRoZSBzbGlkZXIgaXMgcnRsLiAqL1xuICBfaXNSdGw6IGJvb2xlYW47XG5cbiAgLyoqIFRoZSBzdG9yZWQgd2lkdGggb2YgdGhlIGhvc3QgZWxlbWVudCdzIGJvdW5kaW5nIGNsaWVudCByZWN0LiAqL1xuICBfY2FjaGVkV2lkdGg6IG51bWJlcjtcblxuICAvKiogVGhlIHN0b3JlZCB3aWR0aCBvZiB0aGUgaG9zdCBlbGVtZW50J3MgYm91bmRpbmcgY2xpZW50IHJlY3QuICovXG4gIF9jYWNoZWRMZWZ0OiBudW1iZXI7XG5cbiAgLyoqXG4gICAqIFRoZSBwYWRkaW5nIG9mIHRoZSBuYXRpdmUgc2xpZGVyIGlucHV0LiBUaGlzIGlzIGFkZGVkIGluIG9yZGVyIHRvIG1ha2UgdGhlIHJlZ2lvbiB3aGVyZSB0aGVcbiAgICogdGh1bWIgcmlwcGxlIGV4dGVuZHMgcGFzdCB0aGUgZW5kIG9mIHRoZSBzbGlkZXIgdHJhY2sgY2xpY2thYmxlLlxuICAgKi9cbiAgX2lucHV0UGFkZGluZzogbnVtYmVyO1xuXG4gIC8qKlxuICAgKiBUaGUgb2Zmc2V0IHJlcHJlc2VudHMgbGVmdCBtb3N0IHRyYW5zbGF0ZVggb2YgdGhlIHNsaWRlciBrbm9iLiBJbnZlcnNlbHksXG4gICAqIChzbGlkZXIgd2lkdGggLSBvZmZzZXQpID0gdGhlIHJpZ2h0IG1vc3QgdHJhbnNsYXRlWCBvZiB0aGUgc2xpZGVyIGtub2IuXG4gICAqXG4gICAqIE5vdGU6XG4gICAqICAgICogVGhlIG5hdGl2ZSBzbGlkZXIga25vYiBkaWZmZXJzIGZyb20gdGhlIHZpc3VhbCBzbGlkZXIuIEl0J3Mga25vYiBjYW5ub3Qgc2xpZGUgcGFzdFxuICAgKiAgICAgIHRoZSBlbmQgb2YgdGhlIHRyYWNrIEFUIEFMTC5cbiAgICogICAgKiBUaGUgdmlzdWFsIHNsaWRlciBrbm9iIENBTiBzbGlkZSBwYXN0IHRoZSBlbmQgb2YgdGhlIHRyYWNrIHNsaWdodGx5LiBJdCdzIGtub2IgY2FuIHNsaWRlXG4gICAqICAgICAgcGFzdCB0aGUgZW5kIG9mIHRoZSB0cmFjayBzdWNoIHRoYXQgaXQncyBjZW50ZXIgbGluZXMgdXAgd2l0aCB0aGUgZW5kIG9mIHRoZSB0cmFjay5cbiAgICovXG4gIF9pbnB1dE9mZnNldDogbnVtYmVyO1xuXG4gIC8qKiBUaGUgcmFkaXVzIG9mIHRoZSB2aXN1YWwgc2xpZGVyJ3MgcmlwcGxlLiAqL1xuICBfcmlwcGxlUmFkaXVzOiBudW1iZXI7XG5cbiAgLyoqIFRoZSBnbG9iYWwgY29uZmlndXJhdGlvbiBmb3IgYG1hdFJpcHBsZWAgaW5zdGFuY2VzLiAqL1xuICByZWFkb25seSBfZ2xvYmFsUmlwcGxlT3B0aW9ucz86IFJpcHBsZUdsb2JhbE9wdGlvbnM7XG5cbiAgLyoqIFdoZXRoZXIgYW5pbWF0aW9ucyBoYXZlIGJlZW4gZGlzYWJsZWQuICovXG4gIF9ub29wQW5pbWF0aW9uczogYm9vbGVhbjtcblxuICAvKiogV2hldGhlciBvciBub3QgdGhlIHNsaWRlciBzaG91bGQgdXNlIGFuaW1hdGlvbnMuICovXG4gIF9oYXNBbmltYXRpb246IGJvb2xlYW47XG5cbiAgLyoqIFRyaWdnZXJzIFVJIHVwZGF0ZXMgdGhhdCBhcmUgbmVlZGVkIGFmdGVyIGEgc2xpZGVyIGlucHV0IHZhbHVlIGhhcyBjaGFuZ2VkLiAqL1xuICBfb25WYWx1ZUNoYW5nZTogKHNvdXJjZTogX01hdFNsaWRlclRodW1iKSA9PiB2b2lkO1xuXG4gIC8qKiBUcmlnZ2VycyBVSSB1cGRhdGVzIHRoYXQgYXJlIG5lZWRlZCBhZnRlciB0aGUgc2xpZGVyIHRodW1iIHBvc2l0aW9uIGhhcyBjaGFuZ2VkLiAqL1xuICBfb25UcmFuc2xhdGVYQ2hhbmdlOiAoc291cmNlOiBfTWF0U2xpZGVyVGh1bWIpID0+IHZvaWQ7XG5cbiAgLyoqIFVwZGF0ZXMgdGhlIHN0b3JlZCBzbGlkZXIgZGltZW5zaW9ucyB1c2luZyB0aGUgY3VycmVudCBib3VuZGluZyBjbGllbnQgcmVjdC4gKi9cbiAgX3VwZGF0ZURpbWVuc2lvbnM6ICgpID0+IHZvaWQ7XG5cbiAgLyoqIFVzZWQgdG8gc2V0IHRoZSB0cmFuc2l0aW9uIGR1cmF0aW9uIGZvciB0aHVtYiBhbmQgdHJhY2sgYW5pbWF0aW9ucy4gKi9cbiAgX3NldFRyYW5zaXRpb246ICh3aXRoQW5pbWF0aW9uOiBib29sZWFuKSA9PiB2b2lkO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIF9NYXRTbGlkZXJUaHVtYiB7XG4gIC8qKiBUaGUgbWluaW11bSB2YWx1ZSB0aGF0IHRoZSBzbGlkZXIgY2FuIGhhdmUuICovXG4gIG1pbjogbnVtYmVyO1xuXG4gIC8qKiBUaGUgbWF4aW11bSB2YWx1ZSB0aGF0IHRoZSBzbGlkZXIgY2FuIGhhdmUuICovXG4gIG1heDogbnVtYmVyO1xuXG4gIC8qKiBUaGUgYW1vdW50IHRoYXQgc2xpZGVyIHZhbHVlcyBjYW4gaW5jcmVtZW50IG9yIGRlY3JlbWVudCBieS4gKi9cbiAgc3RlcDogbnVtYmVyO1xuXG4gIC8qKiBUaGUgY3VycmVudCB2YWx1ZSBvZiB0aGlzIHNsaWRlciBpbnB1dC4gKi9cbiAgdmFsdWU6IG51bWJlcjtcblxuICAvKiogVGhlIGN1cnJlbnQgdHJhbnNsYXRlWCBpbiBweCBvZiB0aGUgc2xpZGVyIHZpc3VhbCB0aHVtYi4gKi9cbiAgdHJhbnNsYXRlWDogbnVtYmVyO1xuXG4gIC8qKiBJbmRpY2F0ZXMgd2hldGhlciB0aGlzIHRodW1iIGlzIHRoZSBzdGFydCBvciBlbmQgdGh1bWIuICovXG4gIHRodW1iUG9zaXRpb246IF9NYXRUaHVtYjtcblxuICAvKiogU2ltaWxhciB0byBwZXJjZW50YWdlIGJ1dCBjYWxjdWFsdGVkIHVzaW5nIHRyYW5zbGF0ZVggcmVsYXRpdmUgdG8gdGhlIHRvdGFsIHRyYWNrIHdpZHRoLiAqL1xuICBmaWxsUGVyY2VudGFnZTogbnVtYmVyO1xuXG4gIC8qKiBXaGV0aGVyIHRoZSBzbGlkZXIgaXMgZGlzYWJsZWQuICovXG4gIGRpc2FibGVkOiBib29sZWFuO1xuXG4gIC8qKiBUaGUgaG9zdCBuYXRpdmUgSFRNTCBpbnB1dCBlbGVtZW50LiAqL1xuICBfaG9zdEVsZW1lbnQ6IEhUTUxJbnB1dEVsZW1lbnQ7XG5cbiAgLyoqIFdoZXRoZXIgdGhlIGlucHV0IGlzIGN1cnJlbnRseSBmb2N1c2VkIChlaXRoZXIgYnkgdGFiIG9yIGFmdGVyIGNsaWNraW5nKS4gKi9cbiAgX2lzRm9jdXNlZDogYm9vbGVhbjtcblxuICAvKiogVGhlIGFyaWEtdmFsdWV0ZXh0IHN0cmluZyByZXByZXNlbnRhdGlvbiBvZiB0aGUgaW5wdXQncyB2YWx1ZS4gKi9cbiAgX3ZhbHVldGV4dDogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBJbmRpY2F0ZXMgd2hldGhlciBVSSB1cGRhdGVzIHNob3VsZCBiZSBza2lwcGVkLlxuICAgKlxuICAgKiBUaGlzIGZsYWcgaXMgdXNlZCB0byBhdm9pZCBmbGlja2VyaW5nXG4gICAqIHdoZW4gY29ycmVjdGluZyB2YWx1ZXMgb24gcG9pbnRlciB1cC9kb3duLlxuICAgKi9cbiAgX3NraXBVSVVwZGF0ZTogYm9vbGVhbjtcblxuICAvKiogSGFuZGxlcyB0aGUgaW5pdGlhbGl6YXRpb24gb2YgcHJvcGVydGllcyBmb3IgdGhlIHNsaWRlciBpbnB1dC4gKi9cbiAgaW5pdFByb3BzOiAoKSA9PiB2b2lkO1xuXG4gIC8qKiBIYW5kbGVzIFVJIGluaXRpYWxpemF0aW9uIGNvbnRyb2xsZWQgYnkgdGhpcyBzbGlkZXIgaW5wdXQuICovXG4gIGluaXRVSTogKCkgPT4gdm9pZDtcblxuICAvKiogQ2FsY3VsYXRlcyB0aGUgdmlzdWFsIHRodW1iJ3MgdHJhbnNsYXRlWCBiYXNlZCBvbiB0aGUgc2xpZGVyIGlucHV0J3MgY3VycmVudCB2YWx1ZS4gKi9cbiAgX2NhbGNUcmFuc2xhdGVYQnlWYWx1ZTogKCkgPT4gbnVtYmVyO1xuXG4gIC8qKiBVcGRhdGVzIHRoZSB2aXN1YWwgdGh1bWIgYmFzZWQgb24gdGhlIHNsaWRlciBpbnB1dCdzIGN1cnJlbnQgdmFsdWUuICovXG4gIF91cGRhdGVUaHVtYlVJQnlWYWx1ZTogKCkgPT4gdm9pZDtcblxuICAvKipcbiAgICogU2V0cyB0aGUgc2xpZGVyIGlucHV0IHRvIGRpc3Byb3BvcnRpb25hdGUgZGltZW5zaW9ucyB0byBhbGxvdyBmb3IgdG91Y2hcbiAgICogZXZlbnRzIHRvIGJlIGNhcHR1cmVkIG9uIHRvdWNoIGRldmljZXMuXG4gICAqL1xuICBfdXBkYXRlV2lkdGhJbmFjdGl2ZTogKCkgPT4gdm9pZDtcblxuICAvKipcbiAgICogVXNlZCB0byBzZXQgdGhlIHNsaWRlciB3aWR0aCB0byB0aGUgY29ycmVjdFxuICAgKiBkaW1lbnNpb25zIHdoaWxlIHRoZSB1c2VyIGlzIGRyYWdnaW5nLlxuICAgKi9cbiAgX3VwZGF0ZVdpZHRoQWN0aXZlOiAoKSA9PiB2b2lkO1xufVxuIl19

package/esm2020/slider/slider-mdc.type.mjs

@@ -0,0 +1,80 @@
+import { Component, ChangeDetectionStrategy, ViewChild } from '@angular/core';
+import { MatSlider } from '@angular/material/slider';
+import { MAT_SLIDER_THUMB } from './slider-interface';
+import { FormlyFieldSlider } from './slider.type';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/slider";
+import * as i2 from "@ngx-formly/core";
+import * as i3 from "./slider-input";
+import * as i4 from "@angular/forms";
+export class FormlyFieldMDCSlider extends FormlyFieldSlider {
+    set mdcSlider(slider) {
+        Object.defineProperty(slider, '_input', {
+            set: () => { },
+            get: () => this.sliderThumb,
+        });
+    }
+    onContainerClick(event) {
+        this.sliderThumb?._hostElement.focus();
+        super.onContainerClick(event);
+    }
+}
+FormlyFieldMDCSlider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: FormlyFieldMDCSlider, deps: null, target: i0.ɵɵFactoryTarget.Component });
+FormlyFieldMDCSlider.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: FormlyFieldMDCSlider, selector: "formly-field-mat-slider", viewQueries: [{ propertyName: "sliderThumb", first: true, predicate: MAT_SLIDER_THUMB, descendants: true, static: true }, { propertyName: "mdcSlider", first: true, predicate: MatSlider, descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: `
+    <mat-slider
+      [id]="id"
+      [style.width]="'100%'"
+      [formlyAttributes]="field"
+      [tabIndex]="props.tabindex"
+      [color]="props.color"
+      [displayWith]="displayWith"
+      [invert]="props.invert"
+      [max]="props.max"
+      [min]="props.min"
+      [step]="props.step"
+      [thumbLabel]="props.thumbLabel"
+      [tickInterval]="props.tickInterval"
+      [valueText]="props.valueText"
+      [vertical]="props.vertical"
+      (input)="props.input && props.input(field, $event)"
+      (change)="props.change && props.change(field, $event)"
+    >
+      <input matSliderThumb [formControl]="formControl" [formlyAttributes]="field" />
+    </mat-slider>
+  `, isInline: true, components: [{ type: i1.MatSlider, selector: "mat-slider", inputs: ["disabled", "color", "tabIndex", "invert", "max", "min", "step", "thumbLabel", "tickInterval", "value", "displayWith", "valueText", "vertical"], outputs: ["change", "input", "valueChange"], exportAs: ["matSlider"] }], directives: [{ type: i2.ɵFormlyAttributes, selector: "[formlyAttributes]", inputs: ["formlyAttributes", "id"] }, { type: i3.MatSliderThumb, selector: "input[matSliderThumb]", inputs: ["value"], outputs: ["valueChange", "dragStart", "dragEnd"], exportAs: ["matSliderThumb"] }, { type: i4.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i4.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: FormlyFieldMDCSlider, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'formly-field-mat-slider',
+                    template: `
+    <mat-slider
+      [id]="id"
+      [style.width]="'100%'"
+      [formlyAttributes]="field"
+      [tabIndex]="props.tabindex"
+      [color]="props.color"
+      [displayWith]="displayWith"
+      [invert]="props.invert"
+      [max]="props.max"
+      [min]="props.min"
+      [step]="props.step"
+      [thumbLabel]="props.thumbLabel"
+      [tickInterval]="props.tickInterval"
+      [valueText]="props.valueText"
+      [vertical]="props.vertical"
+      (input)="props.input && props.input(field, $event)"
+      (change)="props.change && props.change(field, $event)"
+    >
+      <input matSliderThumb [formControl]="formControl" [formlyAttributes]="field" />
+    </mat-slider>
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { sliderThumb: [{
+                type: ViewChild,
+                args: [MAT_SLIDER_THUMB, { static: true }]
+            }], mdcSlider: [{
+                type: ViewChild,
+                args: [MatSlider, { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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