@radix-ng/primitives 0.16.0 → 0.18.0

package/esm2022/slider/src/slider-horizontal.component.mjs

@@ -0,0 +1,117 @@
+import { booleanAttribute, Component, EventEmitter, inject, input, Input, Output, signal, viewChild } from '@angular/core';
+import { RdxSliderImplDirective } from './slider-impl.directive';
+import { RdxSliderRootComponent } from './slider-root.component';
+import { BACK_KEYS, linearScale } from './utils';
+import * as i0 from "@angular/core";
+export class RdxSliderHorizontalComponent {
+    constructor() {
+        this.rootContext = inject(RdxSliderRootComponent);
+        this.dir = 'ltr';
+        this.inverted = input(false, { transform: booleanAttribute });
+        this.min = 0;
+        this.max = 100;
+        this.className = '';
+        this.slideStart = new EventEmitter();
+        this.slideMove = new EventEmitter();
+        this.slideEnd = new EventEmitter();
+        this.stepKeyDown = new EventEmitter();
+        this.endKeyDown = new EventEmitter();
+        this.homeKeyDown = new EventEmitter();
+        this.sliderElement = viewChild('sliderElement');
+        this.rect = signal(undefined);
+    }
+    onSlideStart(event) {
+        const value = this.getValueFromPointer(event.clientX);
+        this.slideStart.emit(value);
+    }
+    onSlideMove(event) {
+        const value = this.getValueFromPointer(event.clientX);
+        this.slideMove.emit(value);
+    }
+    onSlideEnd() {
+        this.rect.set(undefined);
+        this.slideEnd.emit();
+    }
+    onStepKeyDown(event) {
+        const slideDirection = this.rootContext.isSlidingFromLeft() ? 'from-left' : 'from-right';
+        const isBackKey = BACK_KEYS[slideDirection].includes(event.key);
+        this.stepKeyDown.emit({ event, direction: isBackKey ? -1 : 1 });
+    }
+    getValueFromPointer(pointerPosition) {
+        this.rect.set(this.sliderElement()?.nativeElement.getBoundingClientRect());
+        const rect = this.rect();
+        if (!rect)
+            return 0;
+        const input = [0, rect.width];
+        const output = this.rootContext.isSlidingFromLeft()
+            ? [this.min, this.max]
+            : [this.max, this.min];
+        const value = linearScale(input, output);
+        this.rect.set(rect);
+        return value(pointerPosition - rect.left);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxSliderHorizontalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.11", type: RdxSliderHorizontalComponent, isStandalone: true, selector: "rdx-slider-horizontal", inputs: { dir: { classPropertyName: "dir", publicName: "dir", isSignal: false, isRequired: false, transformFunction: null }, inverted: { classPropertyName: "inverted", publicName: "inverted", isSignal: true, isRequired: false, transformFunction: null }, min: { classPropertyName: "min", publicName: "min", isSignal: false, isRequired: false, transformFunction: null }, max: { classPropertyName: "max", publicName: "max", isSignal: false, isRequired: false, transformFunction: null }, className: { classPropertyName: "className", publicName: "className", isSignal: false, isRequired: false, transformFunction: null } }, outputs: { slideStart: "slideStart", slideMove: "slideMove", slideEnd: "slideEnd", stepKeyDown: "stepKeyDown", endKeyDown: "endKeyDown", homeKeyDown: "homeKeyDown" }, viewQueries: [{ propertyName: "sliderElement", first: true, predicate: ["sliderElement"], descendants: true, isSignal: true }], ngImport: i0, template: `
+        <span
+            #sliderElement
+            [class]="className"
+            [attr.data-orientation]="'horizontal'"
+            [style]="{ '--rdx-slider-thumb-transform': 'translateX(-50%)' }"
+            (slideStart)="onSlideStart($event)"
+            (slideMove)="onSlideMove($event)"
+            (slideEnd)="onSlideEnd()"
+            (stepKeyDown)="onStepKeyDown($event)"
+            (endKeyDown)="endKeyDown.emit($event)"
+            (homeKeyDown)="homeKeyDown.emit($event)"
+            rdxSliderImpl
+        >
+            <ng-content />
+        </span>
+    `, isInline: true, dependencies: [{ kind: "directive", type: RdxSliderImplDirective, selector: "[rdxSliderImpl]", outputs: ["slideStart", "slideMove", "slideEnd", "homeKeyDown", "endKeyDown", "stepKeyDown"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxSliderHorizontalComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'rdx-slider-horizontal',
+                    standalone: true,
+                    imports: [RdxSliderImplDirective],
+                    template: `
+        <span
+            #sliderElement
+            [class]="className"
+            [attr.data-orientation]="'horizontal'"
+            [style]="{ '--rdx-slider-thumb-transform': 'translateX(-50%)' }"
+            (slideStart)="onSlideStart($event)"
+            (slideMove)="onSlideMove($event)"
+            (slideEnd)="onSlideEnd()"
+            (stepKeyDown)="onStepKeyDown($event)"
+            (endKeyDown)="endKeyDown.emit($event)"
+            (homeKeyDown)="homeKeyDown.emit($event)"
+            rdxSliderImpl
+        >
+            <ng-content />
+        </span>
+    `
+                }]
+        }], propDecorators: { dir: [{
+                type: Input
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }], slideStart: [{
+                type: Output
+            }], slideMove: [{
+                type: Output
+            }], slideEnd: [{
+                type: Output
+            }], stepKeyDown: [{
+                type: Output
+            }], endKeyDown: [{
+                type: Output
+            }], homeKeyDown: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slider-horizontal.component.js","sourceRoot":"","sources":["../../../../../packages/primitives/slider/src/slider-horizontal.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput } from '@angular/cdk/coercion';\nimport {\n    booleanAttribute,\n    Component,\n    ElementRef,\n    EventEmitter,\n    inject,\n    input,\n    Input,\n    Output,\n    signal,\n    viewChild\n} from '@angular/core';\nimport { RdxSliderImplDirective } from './slider-impl.directive';\nimport { RdxSliderRootComponent } from './slider-root.component';\nimport { BACK_KEYS, linearScale } from './utils';\n\n@Component({\n    selector: 'rdx-slider-horizontal',\n    standalone: true,\n    imports: [RdxSliderImplDirective],\n    template: `\n        <span\n            #sliderElement\n            [class]=\"className\"\n            [attr.data-orientation]=\"'horizontal'\"\n            [style]=\"{ '--rdx-slider-thumb-transform': 'translateX(-50%)' }\"\n            (slideStart)=\"onSlideStart($event)\"\n            (slideMove)=\"onSlideMove($event)\"\n            (slideEnd)=\"onSlideEnd()\"\n            (stepKeyDown)=\"onStepKeyDown($event)\"\n            (endKeyDown)=\"endKeyDown.emit($event)\"\n            (homeKeyDown)=\"homeKeyDown.emit($event)\"\n            rdxSliderImpl\n        >\n            <ng-content />\n        </span>\n    `\n})\nexport class RdxSliderHorizontalComponent {\n    private readonly rootContext = inject(RdxSliderRootComponent);\n\n    @Input() dir: 'ltr' | 'rtl' = 'ltr';\n\n    readonly inverted = input<boolean, BooleanInput>(false, { transform: booleanAttribute });\n\n    @Input() min = 0;\n    @Input() max = 100;\n\n    @Input() className = '';\n\n    @Output() slideStart = new EventEmitter<number>();\n    @Output() slideMove = new EventEmitter<number>();\n    @Output() slideEnd = new EventEmitter<void>();\n    @Output() stepKeyDown = new EventEmitter<{ event: KeyboardEvent; direction: number }>();\n    @Output() endKeyDown = new EventEmitter<KeyboardEvent>();\n    @Output() homeKeyDown = new EventEmitter<KeyboardEvent>();\n\n    private readonly sliderElement = viewChild<ElementRef>('sliderElement');\n\n    private readonly rect = signal<DOMRect | undefined>(undefined);\n\n    onSlideStart(event: PointerEvent) {\n        const value = this.getValueFromPointer(event.clientX);\n        this.slideStart.emit(value);\n    }\n\n    onSlideMove(event: PointerEvent) {\n        const value = this.getValueFromPointer(event.clientX);\n        this.slideMove.emit(value);\n    }\n\n    onSlideEnd() {\n        this.rect.set(undefined);\n        this.slideEnd.emit();\n    }\n\n    onStepKeyDown(event: KeyboardEvent) {\n        const slideDirection = this.rootContext.isSlidingFromLeft() ? 'from-left' : 'from-right';\n        const isBackKey = BACK_KEYS[slideDirection].includes(event.key);\n\n        this.stepKeyDown.emit({ event, direction: isBackKey ? -1 : 1 });\n    }\n\n    private getValueFromPointer(pointerPosition: number): number {\n        this.rect.set(this.sliderElement()?.nativeElement.getBoundingClientRect());\n        const rect = this.rect();\n        if (!rect) return 0;\n\n        const input: [number, number] = [0, rect.width];\n        const output: [number, number] = this.rootContext.isSlidingFromLeft()\n            ? [this.min, this.max]\n            : [this.max, this.min];\n\n        const value = linearScale(input, output);\n        this.rect.set(rect);\n\n        return value(pointerPosition - rect.left);\n    }\n}\n"]}

package/esm2022/slider/src/slider-impl.directive.mjs

@@ -0,0 +1,89 @@
+import { Directive, EventEmitter, inject, Output } from '@angular/core';
+import { RdxSliderRootComponent } from './slider-root.component';
+import { ARROW_KEYS, PAGE_KEYS } from './utils';
+import * as i0 from "@angular/core";
+export class RdxSliderImplDirective {
+    constructor() {
+        this.rootContext = inject(RdxSliderRootComponent);
+        this.slideStart = new EventEmitter();
+        this.slideMove = new EventEmitter();
+        this.slideEnd = new EventEmitter();
+        this.homeKeyDown = new EventEmitter();
+        this.endKeyDown = new EventEmitter();
+        this.stepKeyDown = new EventEmitter();
+    }
+    onKeyDown(event) {
+        if (event.key === 'Home') {
+            this.homeKeyDown.emit(event);
+            // Prevent scrolling to page start
+            event.preventDefault();
+        }
+        else if (event.key === 'End') {
+            this.endKeyDown.emit(event);
+            // Prevent scrolling to page end
+            event.preventDefault();
+        }
+        else if (PAGE_KEYS.concat(ARROW_KEYS).includes(event.key)) {
+            this.stepKeyDown.emit(event);
+            // Prevent scrolling for directional key presses
+            event.preventDefault();
+        }
+    }
+    onPointerDown(event) {
+        const target = event.target;
+        target.setPointerCapture(event.pointerId);
+        // Prevent browser focus behaviour because we focus a thumb manually when values change.
+        event.preventDefault();
+        // Touch devices have a delay before focusing so won't focus if touch immediately moves
+        // away from target (sliding). We want thumb to focus regardless.
+        if (this.rootContext.thumbElements.includes(target)) {
+            target.focus();
+        }
+        else {
+            this.slideStart.emit(event);
+        }
+    }
+    onPointerMove(event) {
+        const target = event.target;
+        if (target.hasPointerCapture(event.pointerId)) {
+            this.slideMove.emit(event);
+        }
+    }
+    onPointerUp(event) {
+        const target = event.target;
+        if (target.hasPointerCapture(event.pointerId)) {
+            target.releasePointerCapture(event.pointerId);
+            this.slideEnd.emit(event);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxSliderImplDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.11", type: RdxSliderImplDirective, isStandalone: true, selector: "[rdxSliderImpl]", outputs: { slideStart: "slideStart", slideMove: "slideMove", slideEnd: "slideEnd", homeKeyDown: "homeKeyDown", endKeyDown: "endKeyDown", stepKeyDown: "stepKeyDown" }, host: { attributes: { "role": "slider", "tabindex": "0" }, listeners: { "keydown": "onKeyDown($event)", "pointerdown": "onPointerDown($event)", "pointermove": "onPointerMove($event)", "pointerup": "onPointerUp($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxSliderImplDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdxSliderImpl]',
+                    standalone: true,
+                    host: {
+                        role: 'slider',
+                        tabindex: '0',
+                        '(keydown)': 'onKeyDown($event)',
+                        '(pointerdown)': 'onPointerDown($event)',
+                        '(pointermove)': 'onPointerMove($event)',
+                        '(pointerup)': 'onPointerUp($event)'
+                    }
+                }]
+        }], propDecorators: { slideStart: [{
+                type: Output
+            }], slideMove: [{
+                type: Output
+            }], slideEnd: [{
+                type: Output
+            }], homeKeyDown: [{
+                type: Output
+            }], endKeyDown: [{
+                type: Output
+            }], stepKeyDown: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/slider/src/slider-orientation-context.service.mjs

@@ -0,0 +1,28 @@
+import { Injectable, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+export class RdxSliderOrientationContextService {
+    constructor() {
+        this.contextSignal = signal({
+            startEdge: 'left',
+            endEdge: 'right',
+            direction: 1,
+            size: 'width'
+        });
+    }
+    get context() {
+        return this.contextSignal();
+    }
+    updateContext(context) {
+        this.contextSignal.update((current) => ({
+            ...current,
+            ...context
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxSliderOrientationContextService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxSliderOrientationContextService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxSliderOrientationContextService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpZGVyLW9yaWVudGF0aW9uLWNvbnRleHQuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3ByaW1pdGl2ZXMvc2xpZGVyL3NyYy9zbGlkZXItb3JpZW50YXRpb24tY29udGV4dC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQVVuRCxNQUFNLE9BQU8sa0NBQWtDO0lBRC9DO1FBRVksa0JBQWEsR0FBRyxNQUFNLENBQXFCO1lBQy9DLFNBQVMsRUFBRSxNQUFNO1lBQ2pCLE9BQU8sRUFBRSxPQUFPO1lBQ2hCLFNBQVMsRUFBRSxDQUFDO1lBQ1osSUFBSSxFQUFFLE9BQU87U0FDaEIsQ0FBQyxDQUFDO0tBWU47SUFWRyxJQUFJLE9BQU87UUFDUCxPQUFPLElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQztJQUNoQyxDQUFDO0lBRUQsYUFBYSxDQUFDLE9BQW9DO1FBQzlDLElBQUksQ0FBQyxhQUFhLENBQUMsTUFBTSxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1lBQ3BDLEdBQUcsT0FBTztZQUNWLEdBQUcsT0FBTztTQUNiLENBQUMsQ0FBQyxDQUFDO0lBQ1IsQ0FBQzsrR0FqQlEsa0NBQWtDO21IQUFsQyxrQ0FBa0MsY0FEckIsTUFBTTs7NEZBQ25CLGtDQUFrQztrQkFEOUMsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlLCBzaWduYWwgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IGludGVyZmFjZSBPcmllbnRhdGlvbkNvbnRleHQge1xuICAgIHN0YXJ0RWRnZTogc3RyaW5nO1xuICAgIGVuZEVkZ2U6IHN0cmluZztcbiAgICBkaXJlY3Rpb246IG51bWJlcjtcbiAgICBzaXplOiBzdHJpbmc7XG59XG5cbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXG5leHBvcnQgY2xhc3MgUmR4U2xpZGVyT3JpZW50YXRpb25Db250ZXh0U2VydmljZSB7XG4gICAgcHJpdmF0ZSBjb250ZXh0U2lnbmFsID0gc2lnbmFsPE9yaWVudGF0aW9uQ29udGV4dD4oe1xuICAgICAgICBzdGFydEVkZ2U6ICdsZWZ0JyxcbiAgICAgICAgZW5kRWRnZTogJ3JpZ2h0JyxcbiAgICAgICAgZGlyZWN0aW9uOiAxLFxuICAgICAgICBzaXplOiAnd2lkdGgnXG4gICAgfSk7XG5cbiAgICBnZXQgY29udGV4dCgpIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuY29udGV4dFNpZ25hbCgpO1xuICAgIH1cblxuICAgIHVwZGF0ZUNvbnRleHQoY29udGV4dDogUGFydGlhbDxPcmllbnRhdGlvbkNvbnRleHQ+KSB7XG4gICAgICAgIHRoaXMuY29udGV4dFNpZ25hbC51cGRhdGUoKGN1cnJlbnQpID0+ICh7XG4gICAgICAgICAgICAuLi5jdXJyZW50LFxuICAgICAgICAgICAgLi4uY29udGV4dFxuICAgICAgICB9KSk7XG4gICAgfVxufVxuIl19

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

@@ -0,0 +1,41 @@
+import { Component, computed, inject } from '@angular/core';
+import { RdxSliderRootComponent } from './slider-root.component';
+import { convertValueToPercentage } from './utils';
+import * as i0 from "@angular/core";
+export class RdxSliderRangeComponent {
+    constructor() {
+        this.rootContext = inject(RdxSliderRootComponent);
+        this.percentages = computed(() => this.rootContext
+            .modelValue()
+            ?.map((value) => convertValueToPercentage(value, this.rootContext.min(), this.rootContext.max())));
+        this.offsetStart = computed(() => (this.rootContext.modelValue().length > 1 ? Math.min(...this.percentages()) : 0));
+        this.offsetEnd = computed(() => 100 - Math.max(...this.percentages()));
+        this.rangeStyles = computed(() => {
+            const context = this.rootContext.orientationContext.context;
+            return {
+                [context.startEdge]: `${this.offsetStart()}%`,
+                [context.endEdge]: `${this.offsetEnd()}%`
+            };
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxSliderRangeComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.11", type: RdxSliderRangeComponent, isStandalone: true, selector: "rdx-slider-range", host: { properties: { "attr.data-disabled": "rootContext.disabled() ? \"\" : undefined", "attr.data-orientation": "rootContext.orientation()", "style": "rangeStyles()" } }, ngImport: i0, template: `
+        <ng-content />
+    `, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxSliderRangeComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'rdx-slider-range',
+                    standalone: true,
+                    host: {
+                        '[attr.data-disabled]': 'rootContext.disabled() ? "" : undefined',
+                        '[attr.data-orientation]': 'rootContext.orientation()',
+                        '[style]': 'rangeStyles()'
+                    },
+                    template: `
+        <ng-content />
+    `
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/slider/src/slider-root.component.mjs

@@ -0,0 +1,207 @@
+import { NgIf, NgTemplateOutlet } from '@angular/common';
+import { booleanAttribute, Component, computed, EventEmitter, inject, input, Input, model, numberAttribute, Output } from '@angular/core';
+import { RdxSliderHorizontalComponent } from './slider-horizontal.component';
+import { RdxSliderOrientationContextService } from './slider-orientation-context.service';
+import { RdxSliderVerticalComponent } from './slider-vertical.component';
+import { clamp, getClosestValueIndex, getDecimalCount, getNextSortedValues, hasMinStepsBetweenValues, roundValue } from './utils';
+import * as i0 from "@angular/core";
+export class RdxSliderRootComponent {
+    constructor() {
+        /** @ignore */
+        this.orientationContext = inject(RdxSliderOrientationContextService);
+        this.min = input(0, { transform: numberAttribute });
+        this.max = input(100, { transform: numberAttribute });
+        this.step = input(1, { transform: numberAttribute });
+        this.minStepsBetweenThumbs = input(0, { transform: numberAttribute });
+        this.orientation = input('horizontal');
+        this.disabled = input(false, { transform: booleanAttribute });
+        this.inverted = input(false, { transform: booleanAttribute });
+        this.dir = input('ltr');
+        this.className = '';
+        this.valueChange = new EventEmitter();
+        this.valueCommit = new EventEmitter();
+        this.modelValue = model([0]);
+        /** @ignore */
+        this.valueIndexToChange = model(0);
+        /** @ignore */
+        this.valuesBeforeSlideStart = model([]);
+        this.isSlidingFromLeft = computed(() => (this.dir() === 'ltr' && !this.inverted()) || (this.dir() !== 'ltr' && this.inverted()));
+        this.isSlidingFromBottom = computed(() => !this.inverted());
+        /** @ignore */
+        this.thumbElements = [];
+    }
+    /** @ignore */
+    ngOnInit() {
+        const isHorizontal = this.orientation() === 'horizontal';
+        if (isHorizontal) {
+            this.orientationContext.updateContext({
+                direction: this.isSlidingFromLeft() ? 1 : -1,
+                size: 'width',
+                startEdge: this.isSlidingFromLeft() ? 'left' : 'right',
+                endEdge: this.isSlidingFromLeft() ? 'right' : 'left'
+            });
+        }
+        else {
+            this.orientationContext.updateContext({
+                direction: this.isSlidingFromBottom() ? -1 : 1,
+                size: 'height',
+                startEdge: this.isSlidingFromBottom() ? 'bottom' : 'top',
+                endEdge: this.isSlidingFromBottom() ? 'top' : 'bottom'
+            });
+        }
+    }
+    /** @ignore */
+    onPointerDown() {
+        this.valuesBeforeSlideStart.set([...this.modelValue()]);
+    }
+    /** @ignore */
+    handleSlideStart(value) {
+        const closestIndex = getClosestValueIndex(this.modelValue(), value);
+        this.updateValues(value, closestIndex);
+    }
+    /** @ignore */
+    handleSlideMove(value) {
+        this.updateValues(value, this.valueIndexToChange());
+    }
+    /** @ignore */
+    handleSlideEnd() {
+        const prevValue = this.valuesBeforeSlideStart()[this.valueIndexToChange()];
+        const nextValue = this.modelValue()[this.valueIndexToChange()];
+        const hasChanged = nextValue !== prevValue;
+        if (hasChanged) {
+            this.valueCommit.emit([...this.modelValue()]);
+        }
+    }
+    /** @ignore */
+    handleStepKeyDown(event) {
+        const stepInDirection = this.step() * event.direction;
+        const atIndex = this.valueIndexToChange();
+        const currentValue = this.modelValue()[atIndex];
+        this.updateValues(currentValue + stepInDirection, atIndex, true);
+    }
+    /** @ignore */
+    updateValues(value, atIndex, commit = false) {
+        const decimalCount = getDecimalCount(this.step());
+        const snapToStep = roundValue(Math.round((value - this.min()) / this.step()) * this.step() + this.min(), decimalCount);
+        const nextValue = clamp(snapToStep, this.min(), this.max());
+        const nextValues = getNextSortedValues(this.modelValue(), nextValue, atIndex);
+        if (hasMinStepsBetweenValues(nextValues, this.minStepsBetweenThumbs() * this.step())) {
+            this.valueIndexToChange.set(nextValues.indexOf(nextValue));
+            const hasChanged = String(nextValues) !== String(this.modelValue());
+            if (hasChanged) {
+                this.modelValue.set(nextValues);
+                this.valueChange.emit([...this.modelValue()]);
+                this.thumbElements[this.valueIndexToChange()]?.focus();
+                if (commit) {
+                    this.valueCommit.emit([...this.modelValue()]);
+                }
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxSliderRootComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.11", type: RdxSliderRootComponent, isStandalone: true, selector: "rdx-slider", inputs: { min: { classPropertyName: "min", publicName: "min", isSignal: true, isRequired: false, transformFunction: null }, max: { classPropertyName: "max", publicName: "max", isSignal: true, isRequired: false, transformFunction: null }, step: { classPropertyName: "step", publicName: "step", isSignal: true, isRequired: false, transformFunction: null }, minStepsBetweenThumbs: { classPropertyName: "minStepsBetweenThumbs", publicName: "minStepsBetweenThumbs", isSignal: true, isRequired: false, transformFunction: null }, orientation: { classPropertyName: "orientation", publicName: "orientation", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, inverted: { classPropertyName: "inverted", publicName: "inverted", isSignal: true, isRequired: false, transformFunction: null }, dir: { classPropertyName: "dir", publicName: "dir", isSignal: true, isRequired: false, transformFunction: null }, className: { classPropertyName: "className", publicName: "className", isSignal: false, isRequired: false, transformFunction: null }, modelValue: { classPropertyName: "modelValue", publicName: "modelValue", isSignal: true, isRequired: false, transformFunction: null }, valueIndexToChange: { classPropertyName: "valueIndexToChange", publicName: "valueIndexToChange", isSignal: true, isRequired: false, transformFunction: null }, valuesBeforeSlideStart: { classPropertyName: "valuesBeforeSlideStart", publicName: "valuesBeforeSlideStart", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { valueChange: "valueChange", valueCommit: "valueCommit", modelValue: "modelValueChange", valueIndexToChange: "valueIndexToChangeChange", valuesBeforeSlideStart: "valuesBeforeSlideStartChange" }, ngImport: i0, template: `
+        <ng-template #transclude><ng-content /></ng-template>
+
+        <ng-container *ngIf="orientation() === 'horizontal'">
+            <rdx-slider-horizontal
+                [className]="className"
+                [min]="min()"
+                [max]="max()"
+                [dir]="dir()"
+                [inverted]="inverted()"
+                [attr.aria-disabled]="disabled()"
+                [attr.data-disabled]="disabled() ? '' : undefined"
+                (pointerdown)="onPointerDown()"
+                (slideStart)="handleSlideStart($event)"
+                (slideMove)="handleSlideMove($event)"
+                (slideEnd)="handleSlideEnd()"
+                (homeKeyDown)="updateValues(min(), 0, true)"
+                (endKeyDown)="updateValues(max(), modelValue().length - 1, true)"
+                (stepKeyDown)="handleStepKeyDown($event)"
+            >
+                <ng-container *ngTemplateOutlet="transclude" />
+            </rdx-slider-horizontal>
+        </ng-container>
+
+        <ng-container *ngIf="orientation() === 'vertical'">
+            <rdx-slider-vertical
+                [className]="className"
+                [min]="min()"
+                [max]="max()"
+                [dir]="dir()"
+                [inverted]="inverted()"
+                [attr.aria-disabled]="disabled()"
+                [attr.data-disabled]="disabled() ? '' : undefined"
+                (pointerdown)="onPointerDown()"
+                (slideStart)="handleSlideStart($event)"
+                (slideMove)="handleSlideMove($event)"
+                (slideEnd)="handleSlideEnd()"
+                (homeKeyDown)="updateValues(min(), 0, true)"
+                (endKeyDown)="updateValues(max(), modelValue().length - 1, true)"
+                (stepKeyDown)="handleStepKeyDown($event)"
+            >
+                <ng-container *ngTemplateOutlet="transclude" />
+            </rdx-slider-vertical>
+        </ng-container>
+    `, isInline: true, dependencies: [{ kind: "component", type: RdxSliderHorizontalComponent, selector: "rdx-slider-horizontal", inputs: ["dir", "inverted", "min", "max", "className"], outputs: ["slideStart", "slideMove", "slideEnd", "stepKeyDown", "endKeyDown", "homeKeyDown"] }, { kind: "component", type: RdxSliderVerticalComponent, selector: "rdx-slider-vertical", inputs: ["dir", "inverted", "min", "max", "className"], outputs: ["slideStart", "slideMove", "slideEnd", "stepKeyDown", "endKeyDown", "homeKeyDown"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxSliderRootComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'rdx-slider',
+                    standalone: true,
+                    imports: [RdxSliderHorizontalComponent, RdxSliderVerticalComponent, NgIf, NgTemplateOutlet],
+                    template: `
+        <ng-template #transclude><ng-content /></ng-template>
+
+        <ng-container *ngIf="orientation() === 'horizontal'">
+            <rdx-slider-horizontal
+                [className]="className"
+                [min]="min()"
+                [max]="max()"
+                [dir]="dir()"
+                [inverted]="inverted()"
+                [attr.aria-disabled]="disabled()"
+                [attr.data-disabled]="disabled() ? '' : undefined"
+                (pointerdown)="onPointerDown()"
+                (slideStart)="handleSlideStart($event)"
+                (slideMove)="handleSlideMove($event)"
+                (slideEnd)="handleSlideEnd()"
+                (homeKeyDown)="updateValues(min(), 0, true)"
+                (endKeyDown)="updateValues(max(), modelValue().length - 1, true)"
+                (stepKeyDown)="handleStepKeyDown($event)"
+            >
+                <ng-container *ngTemplateOutlet="transclude" />
+            </rdx-slider-horizontal>
+        </ng-container>
+
+        <ng-container *ngIf="orientation() === 'vertical'">
+            <rdx-slider-vertical
+                [className]="className"
+                [min]="min()"
+                [max]="max()"
+                [dir]="dir()"
+                [inverted]="inverted()"
+                [attr.aria-disabled]="disabled()"
+                [attr.data-disabled]="disabled() ? '' : undefined"
+                (pointerdown)="onPointerDown()"
+                (slideStart)="handleSlideStart($event)"
+                (slideMove)="handleSlideMove($event)"
+                (slideEnd)="handleSlideEnd()"
+                (homeKeyDown)="updateValues(min(), 0, true)"
+                (endKeyDown)="updateValues(max(), modelValue().length - 1, true)"
+                (stepKeyDown)="handleStepKeyDown($event)"
+            >
+                <ng-container *ngTemplateOutlet="transclude" />
+            </rdx-slider-vertical>
+        </ng-container>
+    `
+                }]
+        }], propDecorators: { className: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], valueCommit: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slider-root.component.js","sourceRoot":"","sources":["../../../../../packages/primitives/slider/src/slider-root.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput, NumberInput } from '@angular/cdk/coercion';\nimport { NgIf, NgTemplateOutlet } from '@angular/common';\nimport {\n    booleanAttribute,\n    Component,\n    computed,\n    EventEmitter,\n    inject,\n    input,\n    Input,\n    model,\n    numberAttribute,\n    OnInit,\n    Output\n} from '@angular/core';\nimport { RdxSliderHorizontalComponent } from './slider-horizontal.component';\nimport { RdxSliderOrientationContextService } from './slider-orientation-context.service';\nimport { RdxSliderVerticalComponent } from './slider-vertical.component';\nimport {\n    clamp,\n    getClosestValueIndex,\n    getDecimalCount,\n    getNextSortedValues,\n    hasMinStepsBetweenValues,\n    roundValue\n} from './utils';\n\n@Component({\n    selector: 'rdx-slider',\n    standalone: true,\n    imports: [RdxSliderHorizontalComponent, RdxSliderVerticalComponent, NgIf, NgTemplateOutlet],\n    template: `\n        <ng-template #transclude><ng-content /></ng-template>\n\n        <ng-container *ngIf=\"orientation() === 'horizontal'\">\n            <rdx-slider-horizontal\n                [className]=\"className\"\n                [min]=\"min()\"\n                [max]=\"max()\"\n                [dir]=\"dir()\"\n                [inverted]=\"inverted()\"\n                [attr.aria-disabled]=\"disabled()\"\n                [attr.data-disabled]=\"disabled() ? '' : undefined\"\n                (pointerdown)=\"onPointerDown()\"\n                (slideStart)=\"handleSlideStart($event)\"\n                (slideMove)=\"handleSlideMove($event)\"\n                (slideEnd)=\"handleSlideEnd()\"\n                (homeKeyDown)=\"updateValues(min(), 0, true)\"\n                (endKeyDown)=\"updateValues(max(), modelValue().length - 1, true)\"\n                (stepKeyDown)=\"handleStepKeyDown($event)\"\n            >\n                <ng-container *ngTemplateOutlet=\"transclude\" />\n            </rdx-slider-horizontal>\n        </ng-container>\n\n        <ng-container *ngIf=\"orientation() === 'vertical'\">\n            <rdx-slider-vertical\n                [className]=\"className\"\n                [min]=\"min()\"\n                [max]=\"max()\"\n                [dir]=\"dir()\"\n                [inverted]=\"inverted()\"\n                [attr.aria-disabled]=\"disabled()\"\n                [attr.data-disabled]=\"disabled() ? '' : undefined\"\n                (pointerdown)=\"onPointerDown()\"\n                (slideStart)=\"handleSlideStart($event)\"\n                (slideMove)=\"handleSlideMove($event)\"\n                (slideEnd)=\"handleSlideEnd()\"\n                (homeKeyDown)=\"updateValues(min(), 0, true)\"\n                (endKeyDown)=\"updateValues(max(), modelValue().length - 1, true)\"\n                (stepKeyDown)=\"handleStepKeyDown($event)\"\n            >\n                <ng-container *ngTemplateOutlet=\"transclude\" />\n            </rdx-slider-vertical>\n        </ng-container>\n    `\n})\nexport class RdxSliderRootComponent implements OnInit {\n    /** @ignore */\n    readonly orientationContext = inject(RdxSliderOrientationContextService);\n\n    readonly min = input<number, NumberInput>(0, { transform: numberAttribute });\n\n    readonly max = input<number, NumberInput>(100, { transform: numberAttribute });\n\n    readonly step = input<number, NumberInput>(1, { transform: numberAttribute });\n\n    readonly minStepsBetweenThumbs = input<number, NumberInput>(0, { transform: numberAttribute });\n\n    readonly orientation = input<'horizontal' | 'vertical'>('horizontal');\n\n    readonly disabled = input<boolean, BooleanInput>(false, { transform: booleanAttribute });\n\n    readonly inverted = input<boolean, BooleanInput>(false, { transform: booleanAttribute });\n\n    readonly dir = input<'ltr' | 'rtl'>('ltr');\n\n    @Input() className: string = '';\n\n    @Output() valueChange = new EventEmitter<number[]>();\n    @Output() valueCommit = new EventEmitter<number[]>();\n\n    readonly modelValue = model<number[]>([0]);\n\n    /** @ignore */\n    readonly valueIndexToChange = model(0);\n\n    /** @ignore */\n    readonly valuesBeforeSlideStart = model<number[]>([]);\n\n    readonly isSlidingFromLeft = computed(\n        () => (this.dir() === 'ltr' && !this.inverted()) || (this.dir() !== 'ltr' && this.inverted())\n    );\n\n    readonly isSlidingFromBottom = computed(() => !this.inverted());\n\n    /** @ignore */\n    thumbElements: HTMLElement[] = [];\n\n    /** @ignore */\n    ngOnInit() {\n        const isHorizontal = this.orientation() === 'horizontal';\n\n        if (isHorizontal) {\n            this.orientationContext.updateContext({\n                direction: this.isSlidingFromLeft() ? 1 : -1,\n                size: 'width',\n                startEdge: this.isSlidingFromLeft() ? 'left' : 'right',\n                endEdge: this.isSlidingFromLeft() ? 'right' : 'left'\n            });\n        } else {\n            this.orientationContext.updateContext({\n                direction: this.isSlidingFromBottom() ? -1 : 1,\n                size: 'height',\n                startEdge: this.isSlidingFromBottom() ? 'bottom' : 'top',\n                endEdge: this.isSlidingFromBottom() ? 'top' : 'bottom'\n            });\n        }\n    }\n\n    /** @ignore */\n    onPointerDown() {\n        this.valuesBeforeSlideStart.set([...this.modelValue()]);\n    }\n\n    /** @ignore */\n    handleSlideStart(value: number): void {\n        const closestIndex = getClosestValueIndex(this.modelValue(), value);\n        this.updateValues(value, closestIndex);\n    }\n\n    /** @ignore */\n    handleSlideMove(value: number): void {\n        this.updateValues(value, this.valueIndexToChange());\n    }\n\n    /** @ignore */\n    handleSlideEnd(): void {\n        const prevValue = this.valuesBeforeSlideStart()[this.valueIndexToChange()];\n        const nextValue = this.modelValue()[this.valueIndexToChange()];\n        const hasChanged = nextValue !== prevValue;\n\n        if (hasChanged) {\n            this.valueCommit.emit([...this.modelValue()]);\n        }\n    }\n\n    /** @ignore */\n    handleStepKeyDown(event: { event: KeyboardEvent; direction: number }): void {\n        const stepInDirection = this.step() * event.direction;\n        const atIndex = this.valueIndexToChange();\n        const currentValue = this.modelValue()[atIndex];\n        this.updateValues(currentValue + stepInDirection, atIndex, true);\n    }\n\n    /** @ignore */\n    updateValues(value: number, atIndex: number, commit = false): void {\n        const decimalCount = getDecimalCount(this.step());\n        const snapToStep = roundValue(\n            Math.round((value - this.min()) / this.step()) * this.step() + this.min(),\n            decimalCount\n        );\n        const nextValue = clamp(snapToStep, this.min(), this.max());\n\n        const nextValues = getNextSortedValues(this.modelValue(), nextValue, atIndex);\n\n        if (hasMinStepsBetweenValues(nextValues, this.minStepsBetweenThumbs() * this.step())) {\n            this.valueIndexToChange.set(nextValues.indexOf(nextValue));\n            const hasChanged = String(nextValues) !== String(this.modelValue());\n\n            if (hasChanged) {\n                this.modelValue.set(nextValues);\n                this.valueChange.emit([...this.modelValue()]);\n                this.thumbElements[this.valueIndexToChange()]?.focus();\n\n                if (commit) {\n                    this.valueCommit.emit([...this.modelValue()]);\n                }\n            }\n        }\n    }\n}\n"]}