@ardium-ui/ui 1.0.0

package/esm2022/lib/slider/abstract-slider.mjs

@@ -0,0 +1,330 @@
+import { DOCUMENT } from '@angular/common';
+import { ContentChild, Directive, EventEmitter, HostListener, Inject, Input, Output, TemplateRef, ViewChild, } from '@angular/core';
+import { coerceBooleanProperty, coerceNumberProperty } from '@ardium-ui/devkit';
+import { roundToMultiple, roundToPrecision } from 'more-rounding';
+import { isDefined, isObject } from 'simple-bool';
+import { _NgModelComponentBase } from '../_internal/ngmodel-component';
+import { SimpleComponentColor } from '../types/colors.types';
+import { ArdSliderTooltipDirective } from './slider.directive';
+import { SliderDecorationPosition, SliderTooltipBehavior } from './slider.types';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export class _AbstractSlider extends _NgModelComponentBase {
+    constructor(document, renderer, overlay, scrollStrategyOpts, viewContainerRef) {
+        super();
+        this.document = document;
+        this.renderer = renderer;
+        this.overlay = overlay;
+        this.scrollStrategyOpts = scrollStrategyOpts;
+        this.viewContainerRef = viewContainerRef;
+        this._noTooltip = false;
+        //! min, max, step sizes
+        this._min = 0;
+        this._max = 100;
+        this._step = 1;
+        this._shiftMultiplier = 5;
+        this._stepSizeComputed = this._updateComputedStepSizes();
+        //! value ticks
+        this._showValueTicks = false;
+        this._tickArray = this._updateTickArray();
+        //! labels
+        this.labelPosition = SliderDecorationPosition.Bottom;
+        this.labelObjects = [];
+        //! appearance
+        this.color = SimpleComponentColor.Primary;
+        this._compact = false;
+        this.valueChange = new EventEmitter();
+        this.tooltipPosition = SliderDecorationPosition.Top;
+        this._tooltipBehavior = SliderTooltipBehavior.Auto;
+        //! event handlers
+        this._isGrabbed = 0;
+        this._shouldCheckForMovement = false;
+        this._bodyHasClass = false;
+        //! position calculators
+        this._positionPercent = [0];
+    }
+    get noTooltip() {
+        return this._noTooltip;
+    }
+    set noTooltip(v) {
+        this._noTooltip = coerceBooleanProperty(v);
+    }
+    get min() {
+        return this._min;
+    }
+    set min(v) {
+        this._min = coerceNumberProperty(v, 0);
+        this._updateComputedStepSizes();
+        this._updateTickArray();
+    }
+    get max() {
+        return this._max;
+    }
+    set max(v) {
+        this._max = coerceNumberProperty(v, 100);
+        this._updateComputedStepSizes();
+        this._updateTickArray();
+    }
+    get step() {
+        return this._step;
+    }
+    set step(v) {
+        this._step = coerceNumberProperty(v, 0.5);
+        if (this._step <= 0) {
+            throw new Error('Cannot use negative or zero step size for a slider.');
+        }
+        this._updateComputedStepSizes();
+        this._updateTickArray();
+    }
+    get shiftMultiplier() {
+        return this._shiftMultiplier;
+    }
+    set shiftMultiplier(v) {
+        this._shiftMultiplier = coerceNumberProperty(v, 1);
+    }
+    _updateComputedStepSizes() {
+        const minMaxDifference = Math.abs(this._min - this._max);
+        this._stepSizeComputed = this._step / minMaxDifference;
+        return this._stepSizeComputed;
+    }
+    get showValueTicks() {
+        return this._showValueTicks;
+    }
+    set showValueTicks(v) {
+        this._showValueTicks = coerceBooleanProperty(v);
+    }
+    get percentStepSize() {
+        return this._stepSizeComputed * 100;
+    }
+    _updateTickArray() {
+        let newArr = [];
+        let positionPercentCumulative = 0;
+        while (positionPercentCumulative < 100) {
+            newArr.push(positionPercentCumulative);
+            positionPercentCumulative += this._stepSizeComputed * 100;
+            positionPercentCumulative = roundToPrecision(positionPercentCumulative, 6);
+        }
+        newArr.push(100);
+        let stringArr = newArr.map(v => `${v}%`);
+        this._tickArray = stringArr;
+        return stringArr;
+    }
+    get tickArray() {
+        return this._tickArray;
+    }
+    set labels(val) {
+        if (!isDefined(val) || val.length == 0) {
+            this.labelObjects = [];
+            return;
+        }
+        this.labelObjects = val.map(this._numberLabelArrayMapFn).map(label => {
+            let v = this._clampValue(label.for);
+            return {
+                label: String(label.label),
+                positionPercent: `${this._valueToPercent(v) * 100}%`,
+            };
+        });
+    }
+    _numberLabelArrayMapFn(val) {
+        if (isObject(val))
+            return val;
+        return {
+            label: val,
+            for: val,
+        };
+    }
+    get compact() {
+        return this._compact;
+    }
+    set compact(v) {
+        this._compact = coerceBooleanProperty(v);
+    }
+    get ngClasses() {
+        return [`ard-color-${this.color}`, `ard-labels-${this.labelPosition}`, `ard-tooltip-${this.tooltipPosition}`, this.compact ? 'ard-compact' : ''].join(' ');
+    }
+    //! determining transition
+    get sliderTransition() {
+        const x = this._totalSteps;
+        //this is determined using this graph: https://www.geogebra.org/calculator/nqgnhpap
+        //capped at y=80
+        const formulaResult = (20 * (x + 200)) / (x + 20) - 80;
+        const formulaResultRounded = roundToPrecision(formulaResult, 3);
+        if (formulaResultRounded < 0)
+            return '0';
+        const transitionDuration = Math.min(80, formulaResultRounded);
+        return transitionDuration + 'ms';
+    }
+    get _totalSteps() {
+        return (this.max - this.min) / this.step;
+    }
+    set value(newValue) {
+        this.writeValue(newValue);
+    }
+    get value() {
+        return this._value;
+    }
+    _offset(offset, hasShift, handleId = 1) {
+        let stepSize = this._stepSizeComputed * (hasShift ? this._shiftMultiplier : 1);
+        let newPercent = this._positionPercent[handleId - 1] + stepSize * offset;
+        newPercent = this._clampPercentValue(newPercent);
+        this._setValueFromPercent(newPercent);
+    }
+    //! helper methods
+    _clampValue(v) {
+        //clamp between min and max
+        v = Math.min(v, this._max);
+        v = Math.max(v, this._min);
+        //round to the nearest step
+        v -= this._min;
+        v = roundToMultiple(v, this._step);
+        v += this._min;
+        return v;
+    }
+    _valueToPercent(v) {
+        const minMaxDifference = Math.abs(this._min - this._max);
+        return (v - this._min) / minMaxDifference;
+    }
+    _emitChange() {
+        let v = this.value;
+        this._onChangeRegistered?.(v);
+        this.valueChange.emit(v);
+    }
+    set tooltipBehavior(v) {
+        this._tooltipBehavior = v;
+    }
+    get tooltipBehavior() {
+        return this._tooltipBehavior;
+    }
+    get isSliderHandleGrabbed() {
+        return this._isGrabbed != 0;
+    }
+    onPointerDownOnHandle(event, handleId = 1) {
+        this._isGrabbed = handleId;
+        this._shouldCheckForMovement = true;
+        if (!this._bodyHasClass) {
+            this._bodyHasClass = true;
+            this.renderer.addClass(this.document.body, 'ard-prevent-touch-actions');
+        }
+    }
+    onPointerUp(event) {
+        if (!this._shouldCheckForMovement)
+            return;
+        this._isGrabbed = 0;
+        this._shouldCheckForMovement = false;
+        if (this._bodyHasClass) {
+            this._bodyHasClass = false;
+            this.renderer.removeClass(this.document.body, 'ard-prevent-touch-actions');
+        }
+    }
+    getHandlePosition(handleId = 1) {
+        return this._positionPercent[handleId - 1] * 100 + '%';
+    }
+    _setValueFromPercent(percent, handleId = 1) {
+        if (this._positionPercent[handleId - 1] == percent)
+            return;
+        this._positionPercent[handleId - 1] = percent;
+        this._value = this._percentValueToValue(percent, handleId);
+        this._updateTooltipValue();
+        this._emitChange();
+    }
+    _writeValueFromEvent(event, handleId) {
+        let percent = this._getPercentValueFromEvent(event);
+        this._setValueFromPercent(percent, handleId);
+    }
+    _getElementRect() {
+        return this.element.nativeElement.getBoundingClientRect();
+    }
+    _clampPercentValue(percent) {
+        //clamp between 0 and 1
+        percent = Math.min(percent, 1);
+        percent = Math.max(percent, 0);
+        //round to the nearest step
+        percent = roundToMultiple(percent, this._stepSizeComputed);
+        return percent;
+    }
+    _getPercentValueFromEvent(event) {
+        const rect = this._getElementRect();
+        let position;
+        if (event instanceof MouseEvent) {
+            position = event.clientX;
+        }
+        else {
+            position = event.targetTouches[0].clientX;
+        }
+        let percent = (position - rect.left) / rect.width;
+        return this._clampPercentValue(percent);
+    }
+    //! key press handlers
+    onKeyPress(event) {
+        switch (event.code) {
+            case 'ArrowLeft': {
+                this._decrement(event);
+                return;
+            }
+            case 'ArrowRight': {
+                this._increment(event);
+                return;
+            }
+        }
+    }
+    _decrement(event, steps = 1) {
+        this._offset(-steps, event.shiftKey);
+    }
+    _increment(event, steps = 1) {
+        this._offset(+steps, event.shiftKey);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: _AbstractSlider, deps: [{ token: DOCUMENT }, { token: i0.Renderer2 }, { token: i1.Overlay }, { token: i1.ScrollStrategyOptions }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.7", type: _AbstractSlider, inputs: { noTooltip: "noTooltip", tooltipFormat: "tooltipFormat", min: "min", max: "max", step: "step", shiftMultiplier: "shiftMultiplier", showValueTicks: "showValueTicks", labelPosition: "labelPosition", labels: "labels", color: "color", compact: "compact", value: "value", tooltipPosition: "tooltipPosition", tooltipBehavior: "tooltipBehavior" }, outputs: { valueChange: "valueChange" }, host: { listeners: { "document:pointerup": "onPointerUp($event)", "document:touchend": "onPointerUp($event)", "keydown": "onKeyPress($event)" } }, queries: [{ propertyName: "tooltipTemplate", first: true, predicate: ArdSliderTooltipDirective, descendants: true, read: TemplateRef }], viewQueries: [{ propertyName: "element", first: true, predicate: ["track"], descendants: true }], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: _AbstractSlider, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.Renderer2 }, { type: i1.Overlay }, { type: i1.ScrollStrategyOptions }, { type: i0.ViewContainerRef }], propDecorators: { element: [{
+                type: ViewChild,
+                args: ['track']
+            }], noTooltip: [{
+                type: Input
+            }], tooltipFormat: [{
+                type: Input
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], step: [{
+                type: Input
+            }], shiftMultiplier: [{
+                type: Input
+            }], showValueTicks: [{
+                type: Input
+            }], labelPosition: [{
+                type: Input
+            }], labels: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], compact: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], tooltipTemplate: [{
+                type: ContentChild,
+                args: [ArdSliderTooltipDirective, { read: TemplateRef }]
+            }], tooltipPosition: [{
+                type: Input
+            }], tooltipBehavior: [{
+                type: Input
+            }], onPointerUp: [{
+                type: HostListener,
+                args: ['document:pointerup', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['document:touchend', ['$event']]
+            }], onKeyPress: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-slider.js","sourceRoot":"","sources":["../../../../../projects/ui/src/lib/slider/abstract-slider.ts"],"names":[],"mappings":"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","sourcesContent":["import { Overlay, ScrollStrategyOptions } from '@angular/cdk/overlay';\nimport { DOCUMENT } from '@angular/common';\nimport {\n    ContentChild,\n    Directive,\n    ElementRef,\n    EventEmitter,\n    HostListener,\n    Inject,\n    Input,\n    Output,\n    Renderer2,\n    TemplateRef,\n    ViewChild,\n    ViewContainerRef,\n} from '@angular/core';\nimport { coerceBooleanProperty, coerceNumberProperty } from '@ardium-ui/devkit';\nimport { roundToMultiple, roundToPrecision } from 'more-rounding';\nimport { isDefined, isObject } from 'simple-bool';\nimport { _NgModelComponentBase } from '../_internal/ngmodel-component';\nimport { SimpleComponentColor } from '../types/colors.types';\nimport { ArdSliderTooltipDirective } from './slider.directive';\nimport { SliderDecorationPosition, SliderLabelObject, SliderTooltipBehavior, SliderTooltipFormatFn, _InternalSliderLabelObject } from './slider.types';\n\n@Directive()\nexport abstract class _AbstractSlider<T> extends _NgModelComponentBase {\n    @ViewChild('track')\n    public readonly element!: ElementRef<HTMLElement>;\n\n    constructor(\n        @Inject(DOCUMENT) protected document: Document,\n        protected renderer: Renderer2,\n        protected overlay: Overlay,\n        protected scrollStrategyOpts: ScrollStrategyOptions,\n        protected viewContainerRef: ViewContainerRef\n    ) {\n        super();\n    }\n\n    private _noTooltip: boolean = false;\n    @Input()\n    get noTooltip(): boolean {\n        return this._noTooltip;\n    }\n    set noTooltip(v: any) {\n        this._noTooltip = coerceBooleanProperty(v);\n    }\n\n    @Input() tooltipFormat?: SliderTooltipFormatFn;\n\n    protected abstract _updateTooltipValue(): void;\n\n    //! min, max, step sizes\n    protected _min: number = 0;\n    @Input()\n    get min(): number {\n        return this._min;\n    }\n    set min(v: any) {\n        this._min = coerceNumberProperty(v, 0);\n        this._updateComputedStepSizes();\n        this._updateTickArray();\n    }\n    protected _max: number = 100;\n    @Input()\n    get max(): number {\n        return this._max;\n    }\n    set max(v: any) {\n        this._max = coerceNumberProperty(v, 100);\n        this._updateComputedStepSizes();\n        this._updateTickArray();\n    }\n    protected _step: number = 1;\n    @Input()\n    get step(): number {\n        return this._step;\n    }\n    set step(v: any) {\n        this._step = coerceNumberProperty(v, 0.5);\n        if (this._step <= 0) {\n            throw new Error('Cannot use negative or zero step size for a slider.');\n        }\n        this._updateComputedStepSizes();\n        this._updateTickArray();\n    }\n    protected _shiftMultiplier: number = 5;\n    @Input()\n    get shiftMultiplier(): number {\n        return this._shiftMultiplier;\n    }\n    set shiftMultiplier(v: any) {\n        this._shiftMultiplier = coerceNumberProperty(v, 1);\n    }\n\n    protected _stepSizeComputed: number = this._updateComputedStepSizes();\n    protected _updateComputedStepSizes(): number {\n        const minMaxDifference = Math.abs(this._min - this._max);\n        this._stepSizeComputed = this._step / minMaxDifference;\n        return this._stepSizeComputed;\n    }\n\n    //! value ticks\n    protected _showValueTicks: boolean = false;\n    @Input()\n    get showValueTicks(): boolean {\n        return this._showValueTicks;\n    }\n    set showValueTicks(v: any) {\n        this._showValueTicks = coerceBooleanProperty(v);\n    }\n\n    get percentStepSize(): number {\n        return this._stepSizeComputed * 100;\n    }\n    protected _tickArray: string[] = this._updateTickArray();\n    protected _updateTickArray(): string[] {\n        let newArr: number[] = [];\n        let positionPercentCumulative: number = 0;\n\n        while (positionPercentCumulative < 100) {\n            newArr.push(positionPercentCumulative);\n            positionPercentCumulative += this._stepSizeComputed * 100;\n            positionPercentCumulative = roundToPrecision(positionPercentCumulative, 6);\n        }\n        newArr.push(100);\n\n        let stringArr = newArr.map(v => `${v}%`);\n\n        this._tickArray = stringArr;\n        return stringArr;\n    }\n    get tickArray(): string[] {\n        return this._tickArray;\n    }\n\n    //! labels\n    @Input() labelPosition: SliderDecorationPosition = SliderDecorationPosition.Bottom;\n    public labelObjects: _InternalSliderLabelObject[] = [];\n    @Input()\n    set labels(val: SliderLabelObject[] | number[] | null) {\n        if (!isDefined(val) || val.length == 0) {\n            this.labelObjects = [];\n            return;\n        }\n        this.labelObjects = val.map(this._numberLabelArrayMapFn).map(label => {\n            let v = this._clampValue(label.for);\n            return {\n                label: String(label.label),\n                positionPercent: `${this._valueToPercent(v) * 100}%`,\n            };\n        });\n    }\n    protected _numberLabelArrayMapFn(val: SliderLabelObject | number): SliderLabelObject {\n        if (isObject(val)) return val;\n        return {\n            label: val,\n            for: val,\n        };\n    }\n\n    //! appearance\n    @Input() color: SimpleComponentColor = SimpleComponentColor.Primary;\n\n    private _compact: boolean = false;\n    @Input()\n    get compact(): boolean {\n        return this._compact;\n    }\n    set compact(v: any) {\n        this._compact = coerceBooleanProperty(v);\n    }\n\n    get ngClasses(): string {\n        return [`ard-color-${this.color}`, `ard-labels-${this.labelPosition}`, `ard-tooltip-${this.tooltipPosition}`, this.compact ? 'ard-compact' : ''].join(\n            ' '\n        );\n    }\n\n    //! determining transition\n    get sliderTransition(): string {\n        const x = this._totalSteps;\n        //this is determined using this graph: https://www.geogebra.org/calculator/nqgnhpap\n        //capped at y=80\n        const formulaResult = (20 * (x + 200)) / (x + 20) - 80;\n        const formulaResultRounded = roundToPrecision(formulaResult, 3);\n\n        if (formulaResultRounded < 0) return '0';\n\n        const transitionDuration = Math.min(80, formulaResultRounded);\n        return transitionDuration + 'ms';\n    }\n    private get _totalSteps(): number {\n        return (this.max - this.min) / this.step;\n    }\n\n    //! value input & output\n    //! abstract here\n    protected abstract _value: T;\n    @Input()\n    set value(newValue: T) {\n        this.writeValue(newValue);\n    }\n    get value(): T {\n        return this._value;\n    }\n    @Output() valueChange = new EventEmitter<T>();\n\n    //! writeValue\n    //! abstract here\n    abstract override writeValue(v: any): void; //* abstact\n    //! methods for programmatic manipulation\n    abstract reset(): void;\n\n    protected _offset(offset: number, hasShift: boolean, handleId: number = 1): void {\n        let stepSize = this._stepSizeComputed * (hasShift ? this._shiftMultiplier : 1);\n        let newPercent = this._positionPercent[handleId - 1] + stepSize * offset;\n        newPercent = this._clampPercentValue(newPercent);\n        this._setValueFromPercent(newPercent);\n    }\n\n    //! helper methods\n    protected _clampValue(v: number): number {\n        //clamp between min and max\n        v = Math.min(v, this._max);\n        v = Math.max(v, this._min);\n        //round to the nearest step\n        v -= this._min;\n        v = roundToMultiple(v, this._step);\n        v += this._min;\n        return v;\n    }\n    protected _valueToPercent(v: number): number {\n        const minMaxDifference = Math.abs(this._min - this._max);\n        return (v - this._min) / minMaxDifference;\n    }\n    protected _emitChange(): void {\n        let v = this.value;\n        this._onChangeRegistered?.(v);\n        this.valueChange.emit(v);\n    }\n\n    //! tooltip\n    @ContentChild(ArdSliderTooltipDirective, { read: TemplateRef })\n    tooltipTemplate?: TemplateRef<any>;\n\n    @Input() tooltipPosition: SliderDecorationPosition = SliderDecorationPosition.Top;\n\n    private _tooltipBehavior: SliderTooltipBehavior = SliderTooltipBehavior.Auto;\n    @Input()\n    set tooltipBehavior(v: SliderTooltipBehavior) {\n        this._tooltipBehavior = v;\n    }\n    get tooltipBehavior(): SliderTooltipBehavior {\n        return this._tooltipBehavior;\n    }\n\n    //! event handlers\n    protected _isGrabbed: number = 0;\n    protected _shouldCheckForMovement: boolean = false;\n    protected _bodyHasClass: boolean = false;\n\n    get isSliderHandleGrabbed(): boolean {\n        return this._isGrabbed != 0;\n    }\n    abstract onTrackHitboxPointerDown(event: MouseEvent | TouchEvent): void; //* abstact\n\n    onPointerDownOnHandle(event: MouseEvent | TouchEvent, handleId: number = 1): void {\n        this._isGrabbed = handleId;\n        this._shouldCheckForMovement = true;\n        if (!this._bodyHasClass) {\n            this._bodyHasClass = true;\n            this.renderer.addClass(this.document.body, 'ard-prevent-touch-actions');\n        }\n    }\n\n    abstract onPointerMove(event: MouseEvent | TouchEvent): void; //* abstact\n\n    @HostListener('document:pointerup', ['$event'])\n    @HostListener('document:touchend', ['$event'])\n    onPointerUp(event: MouseEvent | TouchEvent): void {\n        if (!this._shouldCheckForMovement) return;\n        this._isGrabbed = 0;\n        this._shouldCheckForMovement = false;\n        if (this._bodyHasClass) {\n            this._bodyHasClass = false;\n            this.renderer.removeClass(this.document.body, 'ard-prevent-touch-actions');\n        }\n    }\n\n    //! position calculators\n    protected _positionPercent: [number] | [number, number] = [0];\n    getHandlePosition(handleId: number = 1): string {\n        return this._positionPercent[handleId - 1] * 100 + '%';\n    }\n    protected _setValueFromPercent(percent: number, handleId: number = 1): void {\n        if (this._positionPercent[handleId - 1] == percent) return;\n        this._positionPercent[handleId - 1] = percent;\n        this._value = this._percentValueToValue(percent, handleId);\n\n        this._updateTooltipValue();\n\n        this._emitChange();\n    }\n    protected _writeValueFromEvent(event: MouseEvent | TouchEvent, handleId?: number): void {\n        let percent = this._getPercentValueFromEvent(event);\n        this._setValueFromPercent(percent, handleId);\n    }\n    protected abstract _percentValueToValue(percent: number, handleId?: number): T; //* abstact\n\n    protected _getElementRect(): DOMRect {\n        return this.element.nativeElement.getBoundingClientRect();\n    }\n    protected _clampPercentValue(percent: number): number {\n        //clamp between 0 and 1\n        percent = Math.min(percent, 1);\n        percent = Math.max(percent, 0);\n        //round to the nearest step\n        percent = roundToMultiple(percent, this._stepSizeComputed);\n        return percent;\n    }\n    protected _getPercentValueFromEvent(event: MouseEvent | TouchEvent): number {\n        const rect = this._getElementRect();\n        let position: number;\n        if (event instanceof MouseEvent) {\n            position = event.clientX;\n        } else {\n            position = event.targetTouches[0].clientX;\n        }\n        let percent = (position - rect.left) / rect.width;\n        return this._clampPercentValue(percent);\n    }\n    //! key press handlers\n    @HostListener('keydown', ['$event'])\n    onKeyPress(event: KeyboardEvent): void {\n        switch (event.code) {\n            case 'ArrowLeft': {\n                this._decrement(event);\n                return;\n            }\n            case 'ArrowRight': {\n                this._increment(event);\n                return;\n            }\n        }\n    }\n    protected _decrement(event: KeyboardEvent, steps: number = 1): void {\n        this._offset(-steps, event.shiftKey);\n    }\n    protected _increment(event: KeyboardEvent, steps: number = 1): void {\n        this._offset(+steps, event.shiftKey);\n    }\n}\n"]}

package/esm2022/lib/slider/range-slider/range-slider.component.mjs

@@ -0,0 +1,143 @@
+import { ChangeDetectionStrategy, Component, HostListener, ViewEncapsulation } from '@angular/core';
+import { roundToPrecision } from 'more-rounding';
+import { isNumber, isObject } from 'simple-bool';
+import { _AbstractSlider } from '../abstract-slider';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class ArdiumRangeSliderComponent extends _AbstractSlider {
+    constructor() {
+        super(...arguments);
+        this._value = { low: -Infinity, high: Infinity };
+        //! tooltip updater
+        this._tooltipValue = this.value;
+        //! handle focus monitors
+        this.currentHandle = null;
+    }
+    ngOnInit() {
+        if (this._value.low != -Infinity && this._value.high != Infinity)
+            return;
+        this.writeValue({ low: this._min, high: this._max });
+    }
+    //! writeValue
+    _isValidObject(v) {
+        return isObject(v) && isNumber(v['low']) && isNumber(v['high']);
+    }
+    _isValidTuple(v) {
+        return Array.isArray(v) && isNumber(v[0]) && isNumber(v[1]) && v.length == 2;
+    }
+    _arrayValueToObjectValue(v) {
+        return { low: v[0], high: v[1] };
+    }
+    _normalizeSliderRange(v) {
+        if (v.low <= v.high)
+            return v;
+        return { low: v.high, high: v.low };
+    }
+    writeValue(v) {
+        if (!this._isValidObject(v) && !this._isValidTuple(v)) {
+            this.reset();
+            return;
+        }
+        let low = -Infinity;
+        let high = Infinity;
+        if (this._isValidObject(v)) {
+            low = v.low;
+            high = v.high;
+        }
+        else if (this._isValidTuple(v)) {
+            low = v[0];
+            high = v[1];
+        }
+        let lowClamped = this._clampValue(low);
+        let highClamped = this._clampValue(high);
+        let value = this._arrayValueToObjectValue([lowClamped, highClamped]);
+        this._value = value;
+        this._positionPercent[0] = this._valueToPercent(lowClamped);
+        this._positionPercent[1] = this._valueToPercent(highClamped);
+        this._updateTooltipValue();
+    }
+    get value() {
+        return this._normalizeSliderRange(this._value);
+    }
+    set value(v) {
+        this.writeValue(v);
+    }
+    _updateTooltipValue() {
+        let v = Object.create(this._value);
+        if (this.tooltipFormat) {
+            v.low = this.tooltipFormat(v.low);
+            v.high = this.tooltipFormat(v.high);
+        }
+        this._tooltipValue = v;
+    }
+    getTooltipContext(type) {
+        return {
+            value: this._tooltipValue[type],
+            $implicit: this._tooltipValue[type],
+        };
+    }
+    //! methods for programmatic manipulation
+    reset() {
+        this._value = { low: -Infinity, high: Infinity };
+        this._positionPercent[0] = 0;
+        this._positionPercent[1] = 1;
+    }
+    //! track overlay getters
+    get trackOverlayLeft() {
+        return Math.min(...this._positionPercent) * 100 + '%';
+    }
+    get trackOverlayWidth() {
+        return Math.abs(this._positionPercent[0] - this._positionPercent[1]) * 100 + '%';
+    }
+    //! event handlers
+    onTrackHitboxPointerDown(event) {
+        this._writeValueFromEvent(event);
+        this.onPointerDownOnHandle(event);
+    }
+    onPointerMove(event) {
+        if (!this._shouldCheckForMovement)
+            return;
+        if (!this._bodyHasClass) {
+            this._bodyHasClass = true;
+            this.renderer.addClass(this.document.body, 'ard-prevent-touch-actions');
+        }
+        this._writeValueFromEvent(event, this._isGrabbed);
+    }
+    //! position calculators
+    _percentValueToValue(percent, handleId) {
+        const minMaxDifference = Math.abs(this._min - this._max);
+        let newVal = percent * minMaxDifference + this._min;
+        //round to 9 decimal places to avoid floating point arithmetic errors
+        //9 is an arbitrary number that just works well. ¯\_(ツ)_/¯
+        newVal = roundToPrecision(newVal, 9);
+        const newValObj = { low: this._value.low, high: this._value.high };
+        if (handleId == 1) {
+            newValObj.low = newVal;
+        }
+        else {
+            newValObj.high = newVal;
+        }
+        return newValObj;
+    }
+    onHandleFocus(event, handleId) {
+        this.onFocus(event);
+        this.currentHandle = handleId;
+    }
+    onBlur(event) {
+        super.onBlur(event);
+        this.currentHandle = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumRangeSliderComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.7", type: ArdiumRangeSliderComponent, selector: "ard-range-slider", host: { listeners: { "document:mousemove": "onPointerMove($event)", "document:touchmove": "onPointerMove($event)" } }, usesInheritance: true, ngImport: i0, template: "<div class=\"ard-range-slider-container-master\"\r\n    [ngClass]=\"ngClasses\"\r\n    [class.ard-slider-handle-grabbed]=\"isSliderHandleGrabbed\"\r\n    [style]=\"{'--_ard-slider-transition': sliderTransition }\"\r\n>\r\n    <div class=\"ard-slider-container\">\r\n        <div #track\r\n            class=\"ard-slider-track\"\r\n            (pointerdown)=\"onTrackHitboxPointerDown($event)\"\r\n        >\r\n            <div class=\"ard-hitbox\"></div>\r\n            <div class=\"ard-slider-track-overlay ard-slider-track-inactive\"></div>\r\n            <div \r\n                class=\"ard-slider-track-overlay ard-slider-track-active\"\r\n                [style]=\"{\r\n                    left: trackOverlayLeft,\r\n                    width: trackOverlayWidth\r\n                }\"\r\n            ></div>\r\n            <div class=\"ard-value-tick-container\" *ngIf=\"showValueTicks\">\r\n                <div class=\"ard-value-tick\" *ngFor=\"let left of tickArray\" [style]=\"{left: left}\"></div>\r\n            </div>\r\n        </div>\r\n        <button #focusableElement\r\n            class=\"ard-slider-handle\"\r\n            [tabindex]=\"tabIndex\"\r\n            [class.ard-grabbed]=\"isSliderHandleGrabbed && currentHandle == 1\"\r\n            (pointerdown)=\"onPointerDownOnHandle($event, 1)\"\r\n            (focus)=\"onHandleFocus($event, 1)\"\r\n            (blur)=\"onBlur($event)\"\r\n            [style]=\"{left: getHandlePosition(1)}\"\r\n        >\r\n            <div class=\"ard-focus-overlay\"></div>\r\n            <div class=\"ard-hitbox\"></div>\r\n        </button>\r\n        <div class=\"ard-slider-tooltip-wrapper\"\r\n            *ngIf=\"tooltipBehavior != 'never'\"\r\n            [class.ard-tooltip-always]=\"tooltipBehavior == 'always'\"\r\n            [style]=\"{left: getHandlePosition(1)}\"\r\n        >\r\n            <ng-template #defaultTooltipTemplate let-value>\r\n                <div class=\"ard-slider-tooltip\">{{ value }}</div>\r\n            </ng-template>\r\n        \r\n            <ng-template [ngTemplateOutlet]=\"tooltipTemplate || defaultTooltipTemplate\"\r\n                [ngTemplateOutletContext]=\"getTooltipContext('low')\">\r\n            </ng-template>\r\n        </div>\r\n        <button\r\n            class=\"ard-slider-handle\"\r\n            [tabindex]=\"tabIndex\"\r\n            [class.ard-grabbed]=\"isSliderHandleGrabbed && currentHandle == 2\"\r\n            (pointerdown)=\"onPointerDownOnHandle($event, 2)\"\r\n            (focus)=\"onHandleFocus($event, 2)\"\r\n            (blur)=\"onBlur($event)\"\r\n            [style]=\"{left: getHandlePosition(2)}\"\r\n        >\r\n            <div class=\"ard-focus-overlay\"></div>\r\n            <div class=\"ard-hitbox\"></div>\r\n        </button>\r\n        <div class=\"ard-slider-tooltip-wrapper\"\r\n            *ngIf=\"tooltipBehavior != 'never'\"\r\n            [class.ard-tooltip-always]=\"tooltipBehavior == 'always'\"\r\n            [style]=\"{left: getHandlePosition(2)}\"\r\n        >\r\n            <ng-template #defaultTooltipTemplate let-value>\r\n                <div class=\"ard-slider-tooltip\">{{ value }}</div>\r\n            </ng-template>\r\n        \r\n            <ng-template [ngTemplateOutlet]=\"tooltipTemplate || defaultTooltipTemplate\"\r\n                [ngTemplateOutletContext]=\"getTooltipContext('high')\">\r\n            </ng-template>\r\n        </div>\r\n    </div>\r\n    <div class=\"ard-slider-label-container\" *ngIf=\"labelObjects.length\">\r\n        <div\r\n            *ngFor=\"let label of labelObjects\"\r\n            class=\"ard-slider-label\"\r\n            [style]=\"{left: label.positionPercent}\"\r\n        >{{ label.label }}</div>\r\n    </div>\r\n</div>\r\n\r\n<ng-template #handleThumbBase>\r\n    <div class=\"ard-slide-thumb\">Test</div>\r\n</ng-template>", styles: ["body.ard-prevent-touch-actions,body.ard-prevent-touch-actions *{touch-action:none}.ard-range-slider-container-master{display:flex;flex-direction:column}.ard-range-slider-container-master.ard-labels-top{flex-direction:column-reverse}.ard-range-slider-container-master .ard-slider-tooltip-wrapper{position:absolute;transform:translate(-50%);pointer-events:none}.ard-range-slider-container-master.ard-tooltip-top .ard-slider-tooltip-wrapper{bottom:100%}.ard-range-slider-container-master.ard-tooltip-bottom .ard-slider-tooltip-wrapper{top:100%}.ard-range-slider-container-master .ard-slider-handle{position:absolute;left:0;transform:translate(-50%)}.ard-range-slider-container-master .ard-slider-tooltip,.ard-range-slider-container-master .ard-slider-track,.ard-range-slider-container-master .ard-value-tick-container{position:relative}.ard-range-slider-container-master .ard-value-tick{position:absolute}.ard-range-slider-container-master .ard-slider-label-container{position:relative;width:100%;height:1em}.ard-range-slider-container-master .ard-slider-label{position:absolute;line-height:1em}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumRangeSliderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ard-range-slider', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"ard-range-slider-container-master\"\r\n    [ngClass]=\"ngClasses\"\r\n    [class.ard-slider-handle-grabbed]=\"isSliderHandleGrabbed\"\r\n    [style]=\"{'--_ard-slider-transition': sliderTransition }\"\r\n>\r\n    <div class=\"ard-slider-container\">\r\n        <div #track\r\n            class=\"ard-slider-track\"\r\n            (pointerdown)=\"onTrackHitboxPointerDown($event)\"\r\n        >\r\n            <div class=\"ard-hitbox\"></div>\r\n            <div class=\"ard-slider-track-overlay ard-slider-track-inactive\"></div>\r\n            <div \r\n                class=\"ard-slider-track-overlay ard-slider-track-active\"\r\n                [style]=\"{\r\n                    left: trackOverlayLeft,\r\n                    width: trackOverlayWidth\r\n                }\"\r\n            ></div>\r\n            <div class=\"ard-value-tick-container\" *ngIf=\"showValueTicks\">\r\n                <div class=\"ard-value-tick\" *ngFor=\"let left of tickArray\" [style]=\"{left: left}\"></div>\r\n            </div>\r\n        </div>\r\n        <button #focusableElement\r\n            class=\"ard-slider-handle\"\r\n            [tabindex]=\"tabIndex\"\r\n            [class.ard-grabbed]=\"isSliderHandleGrabbed && currentHandle == 1\"\r\n            (pointerdown)=\"onPointerDownOnHandle($event, 1)\"\r\n            (focus)=\"onHandleFocus($event, 1)\"\r\n            (blur)=\"onBlur($event)\"\r\n            [style]=\"{left: getHandlePosition(1)}\"\r\n        >\r\n            <div class=\"ard-focus-overlay\"></div>\r\n            <div class=\"ard-hitbox\"></div>\r\n        </button>\r\n        <div class=\"ard-slider-tooltip-wrapper\"\r\n            *ngIf=\"tooltipBehavior != 'never'\"\r\n            [class.ard-tooltip-always]=\"tooltipBehavior == 'always'\"\r\n            [style]=\"{left: getHandlePosition(1)}\"\r\n        >\r\n            <ng-template #defaultTooltipTemplate let-value>\r\n                <div class=\"ard-slider-tooltip\">{{ value }}</div>\r\n            </ng-template>\r\n        \r\n            <ng-template [ngTemplateOutlet]=\"tooltipTemplate || defaultTooltipTemplate\"\r\n                [ngTemplateOutletContext]=\"getTooltipContext('low')\">\r\n            </ng-template>\r\n        </div>\r\n        <button\r\n            class=\"ard-slider-handle\"\r\n            [tabindex]=\"tabIndex\"\r\n            [class.ard-grabbed]=\"isSliderHandleGrabbed && currentHandle == 2\"\r\n            (pointerdown)=\"onPointerDownOnHandle($event, 2)\"\r\n            (focus)=\"onHandleFocus($event, 2)\"\r\n            (blur)=\"onBlur($event)\"\r\n            [style]=\"{left: getHandlePosition(2)}\"\r\n        >\r\n            <div class=\"ard-focus-overlay\"></div>\r\n            <div class=\"ard-hitbox\"></div>\r\n        </button>\r\n        <div class=\"ard-slider-tooltip-wrapper\"\r\n            *ngIf=\"tooltipBehavior != 'never'\"\r\n            [class.ard-tooltip-always]=\"tooltipBehavior == 'always'\"\r\n            [style]=\"{left: getHandlePosition(2)}\"\r\n        >\r\n            <ng-template #defaultTooltipTemplate let-value>\r\n                <div class=\"ard-slider-tooltip\">{{ value }}</div>\r\n            </ng-template>\r\n        \r\n            <ng-template [ngTemplateOutlet]=\"tooltipTemplate || defaultTooltipTemplate\"\r\n                [ngTemplateOutletContext]=\"getTooltipContext('high')\">\r\n            </ng-template>\r\n        </div>\r\n    </div>\r\n    <div class=\"ard-slider-label-container\" *ngIf=\"labelObjects.length\">\r\n        <div\r\n            *ngFor=\"let label of labelObjects\"\r\n            class=\"ard-slider-label\"\r\n            [style]=\"{left: label.positionPercent}\"\r\n        >{{ label.label }}</div>\r\n    </div>\r\n</div>\r\n\r\n<ng-template #handleThumbBase>\r\n    <div class=\"ard-slide-thumb\">Test</div>\r\n</ng-template>", styles: ["body.ard-prevent-touch-actions,body.ard-prevent-touch-actions *{touch-action:none}.ard-range-slider-container-master{display:flex;flex-direction:column}.ard-range-slider-container-master.ard-labels-top{flex-direction:column-reverse}.ard-range-slider-container-master .ard-slider-tooltip-wrapper{position:absolute;transform:translate(-50%);pointer-events:none}.ard-range-slider-container-master.ard-tooltip-top .ard-slider-tooltip-wrapper{bottom:100%}.ard-range-slider-container-master.ard-tooltip-bottom .ard-slider-tooltip-wrapper{top:100%}.ard-range-slider-container-master .ard-slider-handle{position:absolute;left:0;transform:translate(-50%)}.ard-range-slider-container-master .ard-slider-tooltip,.ard-range-slider-container-master .ard-slider-track,.ard-range-slider-container-master .ard-value-tick-container{position:relative}.ard-range-slider-container-master .ard-value-tick{position:absolute}.ard-range-slider-container-master .ard-slider-label-container{position:relative;width:100%;height:1em}.ard-range-slider-container-master .ard-slider-label{position:absolute;line-height:1em}\n"] }]
+        }], propDecorators: { onPointerMove: [{
+                type: HostListener,
+                args: ['document:mousemove', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['document:touchmove', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"range-slider.component.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/slider/range-slider/range-slider.component.ts","../../../../../../projects/ui/src/lib/slider/range-slider/range-slider.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,YAAY,EAAU,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAC5G,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;;;AAWrD,MAAM,OAAO,0BAA2B,SAAQ,eAA4B;IAP5E;;QAQc,WAAM,GAAgB,EAAE,GAAG,EAAE,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;QAmDnE,mBAAmB;QACnB,kBAAa,GAAiC,IAAI,CAAC,KAAK,CAAC;QAkEzD,yBAAyB;QACzB,kBAAa,GAAiB,IAAI,CAAC;KAUtC;IA/HG,QAAQ;QACJ,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,QAAQ;YAAE,OAAO;QAEzE,IAAI,CAAC,UAAU,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;IACzD,CAAC;IAED,cAAc;IACN,cAAc,CAAC,CAAM;QACzB,OAAO,QAAQ,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IACpE,CAAC;IACO,aAAa,CAAC,CAAM;QACxB,OAAO,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC;IACjF,CAAC;IACO,wBAAwB,CAAC,CAAmB;QAChD,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACrC,CAAC;IACO,qBAAqB,CAAC,CAAc;QACxC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI;YAAE,OAAO,CAAC,CAAC;QAC9B,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC;IACxC,CAAC;IACD,UAAU,CAAC,CAAM;QACb,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE;YACnD,IAAI,CAAC,KAAK,EAAE,CAAC;YACb,OAAO;SACV;QACD,IAAI,GAAG,GAAW,CAAC,QAAQ,CAAC;QAC5B,IAAI,IAAI,GAAW,QAAQ,CAAC;QAC5B,IAAI,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE;YACxB,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC;YACZ,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC;SACjB;aAAM,IAAI,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE;YAC9B,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YACX,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;SACf;QACD,IAAI,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACvC,IAAI,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QACzC,IAAI,KAAK,GAAgB,IAAI,CAAC,wBAAwB,CAAC,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC,CAAC;QAClF,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;QAC5D,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;QAC7D,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC/B,CAAC;IACD,IAAa,KAAK;QACd,OAAO,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnD,CAAC;IACD,IAAa,KAAK,CAAC,CAAM;QACrB,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IACvB,CAAC;IAKS,mBAAmB;QACzB,IAAI,CAAC,GAAiC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACjE,IAAI,IAAI,CAAC,aAAa,EAAE;YACpB,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,GAAa,CAAC,CAAC;YAC5C,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAc,CAAC,CAAC;SACjD;QACD,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;IAC3B,CAAC;IAED,iBAAiB,CAAC,IAAoB;QAClC,OAAO;YACH,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;YAC/B,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;SACtC,CAAC;IACN,CAAC;IAED,yCAAyC;IACzC,KAAK;QACD,IAAI,CAAC,MAAM,GAAG,EAAE,GAAG,EAAE,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;QACjD,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC7B,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;IAED,yBAAyB;IACzB,IAAI,gBAAgB;QAChB,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC;IAC1D,CAAC;IACD,IAAI,iBAAiB;QACjB,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAE,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC;IACtF,CAAC;IAED,kBAAkB;IAClB,wBAAwB,CAAC,KAA8B;QACnD,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IAGD,aAAa,CAAC,KAA8B;QACxC,IAAI,CAAC,IAAI,CAAC,uBAAuB;YAAE,OAAO;QAC1C,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACrB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;YAC1B,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,2BAA2B,CAAC,CAAC;SAC3E;QACD,IAAI,CAAC,oBAAoB,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IACtD,CAAC;IAED,wBAAwB;IACd,oBAAoB,CAAC,OAAe,EAAE,QAAgB;QAC5D,MAAM,gBAAgB,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;QACzD,IAAI,MAAM,GAAG,OAAO,GAAG,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC;QACpD,qEAAqE;QACrE,0DAA0D;QAC1D,MAAM,GAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QAErC,MAAM,SAAS,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QACnE,IAAI,QAAQ,IAAI,CAAC,EAAE;YACf,SAAS,CAAC,GAAG,GAAG,MAAM,CAAC;SAC1B;aAAM;YACH,SAAS,CAAC,IAAI,GAAG,MAAM,CAAC;SAC3B;QACD,OAAO,SAAS,CAAC;IACrB,CAAC;IAID,aAAa,CAAC,KAAiB,EAAE,QAAe;QAC5C,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAEpB,IAAI,CAAC,aAAa,GAAG,QAAQ,CAAC;IAClC,CAAC;IACQ,MAAM,CAAC,KAAiB;QAC7B,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACpB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;IAC9B,CAAC;8GAjIQ,0BAA0B;kGAA1B,0BAA0B,sMCdvC,uwHAqFc;;2FDvED,0BAA0B;kBAPtC,SAAS;+BACI,kBAAkB,iBAGb,iBAAiB,CAAC,IAAI,mBACpB,uBAAuB,CAAC,MAAM;8BA+F/C,aAAa;sBAFZ,YAAY;uBAAC,oBAAoB,EAAE,CAAC,QAAQ,CAAC;;sBAC7C,YAAY;uBAAC,oBAAoB,EAAE,CAAC,QAAQ,CAAC","sourcesContent":["import { ChangeDetectionStrategy, Component, HostListener, OnInit, ViewEncapsulation } from '@angular/core';\nimport { roundToPrecision } from 'more-rounding';\nimport { isNumber, isObject } from 'simple-bool';\nimport { _AbstractSlider } from '../abstract-slider';\nimport { SliderRange, SliderTooltipContext } from '../slider.types';\nimport { isDefined } from 'simple-bool';\n\n@Component({\n    selector: 'ard-range-slider',\n    templateUrl: './range-slider.component.html',\n    styleUrls: ['./range-slider.component.scss'],\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ArdiumRangeSliderComponent extends _AbstractSlider<SliderRange> implements OnInit {\n    protected _value: SliderRange = { low: -Infinity, high: Infinity };\n\n    ngOnInit(): void {\n        if (this._value.low != -Infinity && this._value.high != Infinity) return;\n\n        this.writeValue({ low: this._min, high: this._max });\n    }\n\n    //! writeValue\n    private _isValidObject(v: any): v is SliderRange {\n        return isObject(v) && isNumber(v['low']) && isNumber(v['high']);\n    }\n    private _isValidTuple(v: any): v is [number, number] {\n        return Array.isArray(v) && isNumber(v[0]) && isNumber(v[1]) && v.length == 2;\n    }\n    private _arrayValueToObjectValue(v: [number, number]): SliderRange {\n        return { low: v[0], high: v[1] };\n    }\n    private _normalizeSliderRange(v: SliderRange): SliderRange {\n        if (v.low <= v.high) return v;\n        return { low: v.high, high: v.low };\n    }\n    writeValue(v: any): void {\n        if (!this._isValidObject(v) && !this._isValidTuple(v)) {\n            this.reset();\n            return;\n        }\n        let low: number = -Infinity;\n        let high: number = Infinity;\n        if (this._isValidObject(v)) {\n            low = v.low;\n            high = v.high;\n        } else if (this._isValidTuple(v)) {\n            low = v[0];\n            high = v[1];\n        }\n        let lowClamped = this._clampValue(low);\n        let highClamped = this._clampValue(high);\n        let value: SliderRange = this._arrayValueToObjectValue([lowClamped, highClamped]);\n        this._value = value;\n        this._positionPercent[0] = this._valueToPercent(lowClamped);\n        this._positionPercent[1] = this._valueToPercent(highClamped);\n        this._updateTooltipValue();\n    }\n    override get value(): SliderRange {\n        return this._normalizeSliderRange(this._value);\n    }\n    override set value(v: any) {\n        this.writeValue(v);\n    }\n\n    //! tooltip updater\n    _tooltipValue: SliderRange<string | number> = this.value;\n\n    protected _updateTooltipValue(): void {\n        let v: SliderRange<string | number> = Object.create(this._value);\n        if (this.tooltipFormat) {\n            v.low = this.tooltipFormat(v.low as number);\n            v.high = this.tooltipFormat(v.high as number);\n        }\n        this._tooltipValue = v;\n    }\n\n    getTooltipContext(type: 'low' | 'high'): SliderTooltipContext {\n        return {\n            value: this._tooltipValue[type],\n            $implicit: this._tooltipValue[type],\n        };\n    }\n\n    //! methods for programmatic manipulation\n    reset(): void {\n        this._value = { low: -Infinity, high: Infinity };\n        this._positionPercent[0] = 0;\n        this._positionPercent[1] = 1;\n    }\n\n    //! track overlay getters\n    get trackOverlayLeft(): string {\n        return Math.min(...this._positionPercent) * 100 + '%';\n    }\n    get trackOverlayWidth(): string {\n        return Math.abs(this._positionPercent[0] - this._positionPercent[1]!) * 100 + '%';\n    }\n\n    //! event handlers\n    onTrackHitboxPointerDown(event: MouseEvent | TouchEvent): void {\n        this._writeValueFromEvent(event);\n        this.onPointerDownOnHandle(event);\n    }\n    @HostListener('document:mousemove', ['$event'])\n    @HostListener('document:touchmove', ['$event'])\n    onPointerMove(event: MouseEvent | TouchEvent): void {\n        if (!this._shouldCheckForMovement) return;\n        if (!this._bodyHasClass) {\n            this._bodyHasClass = true;\n            this.renderer.addClass(this.document.body, 'ard-prevent-touch-actions');\n        }\n        this._writeValueFromEvent(event, this._isGrabbed);\n    }\n\n    //! position calculators\n    protected _percentValueToValue(percent: number, handleId: number): SliderRange {\n        const minMaxDifference = Math.abs(this._min - this._max);\n        let newVal = percent * minMaxDifference + this._min;\n        //round to 9 decimal places to avoid floating point arithmetic errors\n        //9 is an arbitrary number that just works well. ¯\\_(ツ)_/¯\n        newVal = roundToPrecision(newVal, 9);\n\n        const newValObj = { low: this._value.low, high: this._value.high };\n        if (handleId == 1) {\n            newValObj.low = newVal;\n        } else {\n            newValObj.high = newVal;\n        }\n        return newValObj;\n    }\n\n    //! handle focus monitors\n    currentHandle: 1 | 2 | null = null;\n    onHandleFocus(event: FocusEvent, handleId: 1 | 2) {\n        this.onFocus(event);\n\n        this.currentHandle = handleId;\n    }\n    override onBlur(event: FocusEvent) {\n        super.onBlur(event);\n        this.currentHandle = null;\n    }\n}\n","<div class=\"ard-range-slider-container-master\"\r\n    [ngClass]=\"ngClasses\"\r\n    [class.ard-slider-handle-grabbed]=\"isSliderHandleGrabbed\"\r\n    [style]=\"{'--_ard-slider-transition': sliderTransition }\"\r\n>\r\n    <div class=\"ard-slider-container\">\r\n        <div #track\r\n            class=\"ard-slider-track\"\r\n            (pointerdown)=\"onTrackHitboxPointerDown($event)\"\r\n        >\r\n            <div class=\"ard-hitbox\"></div>\r\n            <div class=\"ard-slider-track-overlay ard-slider-track-inactive\"></div>\r\n            <div \r\n                class=\"ard-slider-track-overlay ard-slider-track-active\"\r\n                [style]=\"{\r\n                    left: trackOverlayLeft,\r\n                    width: trackOverlayWidth\r\n                }\"\r\n            ></div>\r\n            <div class=\"ard-value-tick-container\" *ngIf=\"showValueTicks\">\r\n                <div class=\"ard-value-tick\" *ngFor=\"let left of tickArray\" [style]=\"{left: left}\"></div>\r\n            </div>\r\n        </div>\r\n        <button #focusableElement\r\n            class=\"ard-slider-handle\"\r\n            [tabindex]=\"tabIndex\"\r\n            [class.ard-grabbed]=\"isSliderHandleGrabbed && currentHandle == 1\"\r\n            (pointerdown)=\"onPointerDownOnHandle($event, 1)\"\r\n            (focus)=\"onHandleFocus($event, 1)\"\r\n            (blur)=\"onBlur($event)\"\r\n            [style]=\"{left: getHandlePosition(1)}\"\r\n        >\r\n            <div class=\"ard-focus-overlay\"></div>\r\n            <div class=\"ard-hitbox\"></div>\r\n        </button>\r\n        <div class=\"ard-slider-tooltip-wrapper\"\r\n            *ngIf=\"tooltipBehavior != 'never'\"\r\n            [class.ard-tooltip-always]=\"tooltipBehavior == 'always'\"\r\n            [style]=\"{left: getHandlePosition(1)}\"\r\n        >\r\n            <ng-template #defaultTooltipTemplate let-value>\r\n                <div class=\"ard-slider-tooltip\">{{ value }}</div>\r\n            </ng-template>\r\n        \r\n            <ng-template [ngTemplateOutlet]=\"tooltipTemplate || defaultTooltipTemplate\"\r\n                [ngTemplateOutletContext]=\"getTooltipContext('low')\">\r\n            </ng-template>\r\n        </div>\r\n        <button\r\n            class=\"ard-slider-handle\"\r\n            [tabindex]=\"tabIndex\"\r\n            [class.ard-grabbed]=\"isSliderHandleGrabbed && currentHandle == 2\"\r\n            (pointerdown)=\"onPointerDownOnHandle($event, 2)\"\r\n            (focus)=\"onHandleFocus($event, 2)\"\r\n            (blur)=\"onBlur($event)\"\r\n            [style]=\"{left: getHandlePosition(2)}\"\r\n        >\r\n            <div class=\"ard-focus-overlay\"></div>\r\n            <div class=\"ard-hitbox\"></div>\r\n        </button>\r\n        <div class=\"ard-slider-tooltip-wrapper\"\r\n            *ngIf=\"tooltipBehavior != 'never'\"\r\n            [class.ard-tooltip-always]=\"tooltipBehavior == 'always'\"\r\n            [style]=\"{left: getHandlePosition(2)}\"\r\n        >\r\n            <ng-template #defaultTooltipTemplate let-value>\r\n                <div class=\"ard-slider-tooltip\">{{ value }}</div>\r\n            </ng-template>\r\n        \r\n            <ng-template [ngTemplateOutlet]=\"tooltipTemplate || defaultTooltipTemplate\"\r\n                [ngTemplateOutletContext]=\"getTooltipContext('high')\">\r\n            </ng-template>\r\n        </div>\r\n    </div>\r\n    <div class=\"ard-slider-label-container\" *ngIf=\"labelObjects.length\">\r\n        <div\r\n            *ngFor=\"let label of labelObjects\"\r\n            class=\"ard-slider-label\"\r\n            [style]=\"{left: label.positionPercent}\"\r\n        >{{ label.label }}</div>\r\n    </div>\r\n</div>\r\n\r\n<ng-template #handleThumbBase>\r\n    <div class=\"ard-slide-thumb\">Test</div>\r\n</ng-template>"]}

package/esm2022/lib/slider/range-slider/range-slider.module.mjs

@@ -0,0 +1,18 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ArdiumRangeSliderComponent } from './range-slider.component';
+import * as i0 from "@angular/core";
+export class ArdiumRangeSliderModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumRangeSliderModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.7", ngImport: i0, type: ArdiumRangeSliderModule, declarations: [ArdiumRangeSliderComponent], imports: [CommonModule], exports: [ArdiumRangeSliderComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumRangeSliderModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumRangeSliderModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ArdiumRangeSliderComponent],
+                    imports: [CommonModule],
+                    exports: [ArdiumRangeSliderComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFuZ2Utc2xpZGVyLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpL3NyYy9saWIvc2xpZGVyL3JhbmdlLXNsaWRlci9yYW5nZS1zbGlkZXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLDBCQUEwQixDQUFDOztBQU90RSxNQUFNLE9BQU8sdUJBQXVCOzhHQUF2Qix1QkFBdUI7K0dBQXZCLHVCQUF1QixpQkFKakIsMEJBQTBCLGFBQy9CLFlBQVksYUFDWiwwQkFBMEI7K0dBRTNCLHVCQUF1QixZQUh0QixZQUFZOzsyRkFHYix1QkFBdUI7a0JBTG5DLFFBQVE7bUJBQUM7b0JBQ04sWUFBWSxFQUFFLENBQUMsMEJBQTBCLENBQUM7b0JBQzFDLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsT0FBTyxFQUFFLENBQUMsMEJBQTBCLENBQUM7aUJBQ3hDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBcmRpdW1SYW5nZVNsaWRlckNvbXBvbmVudCB9IGZyb20gJy4vcmFuZ2Utc2xpZGVyLmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gICAgZGVjbGFyYXRpb25zOiBbQXJkaXVtUmFuZ2VTbGlkZXJDb21wb25lbnRdLFxuICAgIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICAgIGV4cG9ydHM6IFtBcmRpdW1SYW5nZVNsaWRlckNvbXBvbmVudF0sXG59KVxuZXhwb3J0IGNsYXNzIEFyZGl1bVJhbmdlU2xpZGVyTW9kdWxlIHt9XG4iXX0=