@radix-ng/primitives 0.42.0 → 0.44.0

package/slider/index.d.ts

@@ -1,18 +1,263 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/slider-root.component";
-import * as i2 from "./src/slider-track.component";
-import * as i3 from "./src/slider-range.component";
-import * as i4 from "./src/slider-thumb.component";
-export * from './src/slider-horizontal.component';
-export * from './src/slider-impl.directive';
-export * from './src/slider-range.component';
-export * from './src/slider-root.component';
-export * from './src/slider-thumb-impl.directive';
-export * from './src/slider-thumb.component';
-export * from './src/slider-track.component';
-export * from './src/slider-vertical.component';
-export declare class RdxSliderModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSliderModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxSliderModule, never, [typeof i1.RdxSliderRootComponent, typeof i2.RdxSliderTrackComponent, typeof i3.RdxSliderRangeComponent, typeof i4.RdxSliderThumbComponent], [typeof i1.RdxSliderRootComponent, typeof i2.RdxSliderTrackComponent, typeof i3.RdxSliderRangeComponent, typeof i4.RdxSliderThumbComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<RdxSliderModule>;
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy } from '@angular/core';
+import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
+
+interface OrientationContext {
+    startEdge: string;
+    endEdge: string;
+    direction: number;
+    size: string;
 }
+declare class RdxSliderOrientationContextService {
+    private contextSignal;
+    get context(): OrientationContext;
+    updateContext(context: Partial<OrientationContext>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSliderOrientationContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RdxSliderOrientationContextService>;
+}
+
+/**
+ * @group Components
+ */
+declare class RdxSliderRootComponent implements OnInit {
+    /** @ignore */
+    readonly orientationContext: RdxSliderOrientationContextService;
+    /**
+     * The minimum value for the range.
+     *
+     * @group Props
+     * @defaultValue 0
+     */
+    readonly min: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The maximum value for the range.
+     *
+     * @group Props
+     * @defaultValue 100
+     */
+    readonly max: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The stepping interval.
+     *
+     * @group Props
+     * @defaultValue 1
+     */
+    readonly step: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The minimum permitted steps between multiple thumbs.
+     *
+     * @group Props
+     * @defaultValue 0
+     */
+    readonly minStepsBetweenThumbs: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The orientation of the slider.
+     *
+     * @group Props
+     * @defaultValue 'horizontal'
+     */
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    /**
+     * When true, prevents the user from interacting with the slider.
+     *
+     * @group Props
+     * @defaultValue false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the slider is visually inverted.
+     *
+     * @group Props
+     * @defaultValue false
+     */
+    readonly inverted: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The reading direction of the combobox when applicable.
+     *
+     * @group Props
+     * @defaultValue 'ltr'
+     */
+    readonly dir: _angular_core.InputSignal<"ltr" | "rtl">;
+    className: string;
+    /**
+     * Style class of the component.
+     *
+     * @group Props
+     */
+    readonly styleClass: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The controlled value of the slider.
+     *
+     * @group Props
+     */
+    readonly modelValue: _angular_core.ModelSignal<number[]>;
+    /**
+     * Event handler called when the slider value changes.
+     *
+     * @group Emits
+     */
+    readonly valueChange: _angular_core.OutputEmitterRef<number[]>;
+    /**
+     * Event handler called when the value changes at the end of an interaction.
+     *
+     * Useful when you only need to capture a final value e.g. to update a backend service.
+     *
+     * @group Emits
+     */
+    readonly valueCommit: _angular_core.OutputEmitterRef<number[]>;
+    /** @ignore */
+    readonly valueIndexToChange: _angular_core.ModelSignal<number>;
+    /** @ignore */
+    readonly valuesBeforeSlideStart: _angular_core.ModelSignal<number[]>;
+    /** @ignore */
+    readonly isSlidingFromLeft: _angular_core.Signal<boolean>;
+    /** @ignore */
+    readonly isSlidingFromBottom: _angular_core.Signal<boolean>;
+    /** @ignore */
+    thumbElements: HTMLElement[];
+    /** @ignore */
+    ngOnInit(): void;
+    /** @ignore */
+    onPointerDown(): void;
+    /** @ignore */
+    handleSlideStart(value: number): void;
+    /** @ignore */
+    handleSlideMove(value: number): void;
+    /** @ignore */
+    handleSlideEnd(): void;
+    /** @ignore */
+    handleStepKeyDown(event: {
+        event: KeyboardEvent;
+        direction: number;
+    }): void;
+    /** @ignore */
+    updateValues(value: number, atIndex: number, commit?: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSliderRootComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RdxSliderRootComponent, "rdx-slider", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "minStepsBetweenThumbs": { "alias": "minStepsBetweenThumbs"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "modelValue": { "alias": "modelValue"; "required": false; "isSignal": true; }; "valueIndexToChange": { "alias": "valueIndexToChange"; "required": false; "isSignal": true; }; "valuesBeforeSlideStart": { "alias": "valuesBeforeSlideStart"; "required": false; "isSignal": true; }; }, { "modelValue": "modelValueChange"; "valueChange": "valueChange"; "valueCommit": "valueCommit"; "valueIndexToChange": "valueIndexToChangeChange"; "valuesBeforeSlideStart": "valuesBeforeSlideStartChange"; }, never, ["*"], true, never>;
+}
+
+declare class RdxSliderTrackComponent {
+    protected readonly rootContext: RdxSliderRootComponent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSliderTrackComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RdxSliderTrackComponent, "rdx-slider-track", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class RdxSliderRangeComponent {
+    protected readonly rootContext: RdxSliderRootComponent;
+    percentages: _angular_core.Signal<number[]>;
+    offsetStart: _angular_core.Signal<number>;
+    offsetEnd: _angular_core.Signal<number>;
+    rangeStyles: _angular_core.Signal<{
+        [x: string]: string;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSliderRangeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RdxSliderRangeComponent, "rdx-slider-range", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class RdxSliderThumbImplDirective implements OnInit, OnDestroy {
+    protected readonly rootContext: RdxSliderRootComponent;
+    private readonly elementRef;
+    private readonly platformId;
+    private resizeObserver;
+    isMounted: _angular_core.WritableSignal<boolean>;
+    thumbIndex: _angular_core.Signal<number | null>;
+    value: _angular_core.Signal<number | undefined>;
+    percent: _angular_core.Signal<number>;
+    transform: _angular_core.Signal<string>;
+    orientationSize: _angular_core.WritableSignal<number>;
+    thumbInBoundsOffset: _angular_core.Signal<number>;
+    combinedStyles: _angular_core.Signal<{
+        [x: string]: string | undefined;
+        position: string;
+        transform: string;
+        display: string | undefined;
+    }>;
+    onFocus(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSliderThumbImplDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSliderThumbImplDirective, "[rdxSliderThumbImpl]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxSliderThumbComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSliderThumbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RdxSliderThumbComponent, "rdx-slider-thumb", never, {}, {}, never, ["*"], true, [{ directive: typeof RdxSliderThumbImplDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class RdxSliderHorizontalComponent {
+    private readonly rootContext;
+    dir: 'ltr' | 'rtl';
+    readonly inverted: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    min: number;
+    max: number;
+    className: string;
+    readonly slideStart: _angular_core.OutputEmitterRef<number>;
+    readonly slideMove: _angular_core.OutputEmitterRef<number>;
+    readonly slideEnd: _angular_core.OutputEmitterRef<void>;
+    readonly stepKeyDown: _angular_core.OutputEmitterRef<{
+        event: KeyboardEvent;
+        direction: number;
+    }>;
+    readonly endKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    readonly homeKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    private readonly sliderElement;
+    private readonly rect;
+    onSlideStart(event: PointerEvent): void;
+    onSlideMove(event: PointerEvent): void;
+    onSlideEnd(): void;
+    onStepKeyDown(event: KeyboardEvent): void;
+    private getValueFromPointer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSliderHorizontalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RdxSliderHorizontalComponent, "rdx-slider-horizontal", never, { "dir": { "alias": "dir"; "required": false; }; "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "className": { "alias": "className"; "required": false; }; }, { "slideStart": "slideStart"; "slideMove": "slideMove"; "slideEnd": "slideEnd"; "stepKeyDown": "stepKeyDown"; "endKeyDown": "endKeyDown"; "homeKeyDown": "homeKeyDown"; }, never, ["*"], true, never>;
+}
+
+declare class RdxSliderImplDirective {
+    protected readonly rootContext: RdxSliderRootComponent;
+    readonly slideStart: _angular_core.OutputEmitterRef<PointerEvent>;
+    readonly slideMove: _angular_core.OutputEmitterRef<PointerEvent>;
+    readonly slideEnd: _angular_core.OutputEmitterRef<PointerEvent>;
+    readonly homeKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    readonly endKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    readonly stepKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    onKeyDown(event: KeyboardEvent): void;
+    onPointerDown(event: PointerEvent): void;
+    onPointerMove(event: PointerEvent): void;
+    onPointerUp(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSliderImplDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSliderImplDirective, "[rdxSliderImpl]", never, {}, { "slideStart": "slideStart"; "slideMove": "slideMove"; "slideEnd": "slideEnd"; "homeKeyDown": "homeKeyDown"; "endKeyDown": "endKeyDown"; "stepKeyDown": "stepKeyDown"; }, never, never, true, never>;
+}
+
+declare class RdxSliderVerticalComponent {
+    private readonly rootContext;
+    dir: 'ltr' | 'rtl';
+    readonly inverted: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    min: number;
+    max: number;
+    className: string;
+    readonly slideStart: _angular_core.OutputEmitterRef<number>;
+    readonly slideMove: _angular_core.OutputEmitterRef<number>;
+    readonly slideEnd: _angular_core.OutputEmitterRef<void>;
+    readonly stepKeyDown: _angular_core.OutputEmitterRef<{
+        event: KeyboardEvent;
+        direction: number;
+    }>;
+    readonly endKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    readonly homeKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    private readonly sliderElement;
+    private readonly rect;
+    onSlideStart(event: PointerEvent): void;
+    onSlideMove(event: PointerEvent): void;
+    onSlideEnd(): void;
+    onStepKeyDown(event: KeyboardEvent): void;
+    private getValueFromPointer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSliderVerticalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RdxSliderVerticalComponent, "rdx-slider-vertical", never, { "dir": { "alias": "dir"; "required": false; }; "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "className": { "alias": "className"; "required": false; }; }, { "slideStart": "slideStart"; "slideMove": "slideMove"; "slideEnd": "slideEnd"; "stepKeyDown": "stepKeyDown"; "endKeyDown": "endKeyDown"; "homeKeyDown": "homeKeyDown"; }, never, ["*"], true, never>;
+}
+
+declare class RdxSliderModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSliderModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxSliderModule, never, [typeof RdxSliderRootComponent, typeof RdxSliderTrackComponent, typeof RdxSliderRangeComponent, typeof RdxSliderThumbComponent], [typeof RdxSliderRootComponent, typeof RdxSliderTrackComponent, typeof RdxSliderRangeComponent, typeof RdxSliderThumbComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxSliderModule>;
+}
+
+export { RdxSliderHorizontalComponent, RdxSliderImplDirective, RdxSliderModule, RdxSliderRangeComponent, RdxSliderRootComponent, RdxSliderThumbComponent, RdxSliderThumbImplDirective, RdxSliderTrackComponent, RdxSliderVerticalComponent };

package/stepper/index.d.ts

@@ -1,22 +1,123 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/stepper-description.directive";
-import * as i2 from "./src/stepper-title.directive";
-import * as i3 from "./src/stepper-separator.directive";
-import * as i4 from "./src/stepper-item.directive";
-import * as i5 from "./src/stepper-indicator.directive";
-import * as i6 from "./src/stepper-root.directive";
-import * as i7 from "./src/stepper-trigger.directive";
-export * from './src/stepper-description.directive';
-export * from './src/stepper-indicator.directive';
-export * from './src/stepper-item.directive';
-export * from './src/stepper-root-context.token';
-export * from './src/stepper-root.directive';
-export * from './src/stepper-separator.directive';
-export * from './src/stepper-title.directive';
-export * from './src/stepper-trigger.directive';
-export * from './src/types';
-export declare class RdxStepperModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxStepperModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxStepperModule, never, [typeof i1.RdxStepperDescriptionDirective, typeof i2.RdxStepperTitleDirective, typeof i3.RdxStepperSeparatorDirective, typeof i4.RdxStepperItemDirective, typeof i5.RdxStepperIndicatorDirective, typeof i6.RdxStepperRootDirective, typeof i7.RdxStepperTriggerDirective], [typeof i1.RdxStepperDescriptionDirective, typeof i2.RdxStepperTitleDirective, typeof i3.RdxStepperSeparatorDirective, typeof i4.RdxStepperItemDirective, typeof i5.RdxStepperIndicatorDirective, typeof i6.RdxStepperRootDirective, typeof i7.RdxStepperTriggerDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<RdxStepperModule>;
+import * as _angular_core from '@angular/core';
+import { InputSignalWithTransform, Signal, ModelSignal, InputSignal, WritableSignal, InjectionToken, OnInit, OnDestroy } from '@angular/core';
+import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
+import { Direction } from '@angular/cdk/bidi';
+import * as i1 from '@radix-ng/primitives/separator';
+
+type StepperState = 'completed' | 'active' | 'inactive';
+
+interface StepperItemContext {
+    titleId: string;
+    descriptionId: string;
+    step: InputSignalWithTransform<number, NumberInput>;
+    disabled: InputSignalWithTransform<boolean, BooleanInput>;
+    isFocusable: Signal<boolean>;
+    itemState: Signal<StepperState>;
 }
+
+declare class RdxStepperDescriptionDirective {
+    readonly itemContext: StepperItemContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxStepperDescriptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxStepperDescriptionDirective, "[rdxStepperDescription]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxStepperTitleDirective {
+    readonly itemContext: StepperItemContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxStepperTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxStepperTitleDirective, "[rdxStepperTitle]", never, {}, {}, never, never, true, never>;
+}
+
+interface StepperRootContext {
+    value: ModelSignal<number | undefined>;
+    orientation: InputSignal<'vertical' | 'horizontal'>;
+    dir: InputSignal<Direction>;
+    linear: InputSignalWithTransform<boolean, BooleanInput>;
+    totalStepperItems: WritableSignal<HTMLElement[]>;
+}
+declare const STEPPER_ROOT_CONTEXT: InjectionToken<StepperRootContext>;
+declare function injectStepperRootContext(): StepperRootContext;
+
+declare class RdxStepperSeparatorDirective {
+    protected readonly rootContext: StepperRootContext;
+    protected readonly itemContext: StepperItemContext;
+    private readonly rdxSeparator;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxStepperSeparatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxStepperSeparatorDirective, "[rdxStepperSeparator]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxSeparatorRootDirective; inputs: { "orientation": "orientation"; "decorative": "decorative"; }; outputs: {}; }]>;
+}
+
+declare class RdxStepperItemDirective implements StepperItemContext {
+    protected readonly rootContext: StepperRootContext;
+    /** @ignore */
+    readonly titleId: string;
+    /** @ignore */
+    readonly descriptionId: string;
+    readonly step: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** @ignore */
+    readonly completed: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** @ignore */
+    readonly itemState: _angular_core.Signal<StepperState>;
+    /** @ignore */
+    readonly isFocusable: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxStepperItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxStepperItemDirective, "[rdxStepperItem]", never, { "step": { "alias": "step"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "completed": { "alias": "completed"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxStepperIndicatorDirective {
+    readonly itemContext: StepperItemContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxStepperIndicatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxStepperIndicatorDirective, "[rdxStepperIndicator]", ["rdxStepperIndicator"], {}, {}, never, never, true, never>;
+}
+
+declare class RdxStepperRootDirective implements StepperRootContext {
+    private readonly liveAnnouncer;
+    readonly defaultValue: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    readonly value: _angular_core.ModelSignal<number | undefined>;
+    readonly linear: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly dir: _angular_core.InputSignal<Direction>;
+    readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    /** @ignore */
+    readonly totalStepperItemsArray: _angular_core.Signal<HTMLElement[]>;
+    readonly onValueChange: _angular_core.OutputEmitterRef<number>;
+    /** @ignore */
+    readonly isFirstStep: _angular_core.Signal<boolean>;
+    /** @ignore */
+    readonly isLastStep: _angular_core.Signal<boolean>;
+    /** @ignore */
+    readonly totalSteps: _angular_core.Signal<number>;
+    /** @ignore */
+    readonly isNextDisabled: _angular_core.Signal<boolean>;
+    /** @ignore */
+    readonly isPrevDisabled: _angular_core.Signal<boolean>;
+    /** @ignore */
+    readonly totalStepperItems: _angular_core.WritableSignal<HTMLElement[]>;
+    private readonly nextStepperItem;
+    private readonly prevStepperItem;
+    constructor();
+    goToStep(step: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxStepperRootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxStepperRootDirective, "[rdxStepperRoot]", ["rdxStepperRoot"], { "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "linear": { "alias": "linear"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, never>;
+}
+
+declare class RdxStepperTriggerDirective implements OnInit, OnDestroy {
+    protected readonly rootContext: StepperRootContext;
+    protected readonly itemContext: StepperItemContext;
+    private readonly elementRef;
+    readonly stepperItems: _angular_core.Signal<HTMLElement[]>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    handleMouseDown(event: MouseEvent): void;
+    handleKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxStepperTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxStepperTriggerDirective, "button[rdxStepperTrigger]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxStepperModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxStepperModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxStepperModule, never, [typeof RdxStepperDescriptionDirective, typeof RdxStepperTitleDirective, typeof RdxStepperSeparatorDirective, typeof RdxStepperItemDirective, typeof RdxStepperIndicatorDirective, typeof RdxStepperRootDirective, typeof RdxStepperTriggerDirective], [typeof RdxStepperDescriptionDirective, typeof RdxStepperTitleDirective, typeof RdxStepperSeparatorDirective, typeof RdxStepperItemDirective, typeof RdxStepperIndicatorDirective, typeof RdxStepperRootDirective, typeof RdxStepperTriggerDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxStepperModule>;
+}
+
+export { RdxStepperDescriptionDirective, RdxStepperIndicatorDirective, RdxStepperItemDirective, RdxStepperModule, RdxStepperRootDirective, RdxStepperSeparatorDirective, RdxStepperTitleDirective, RdxStepperTriggerDirective, STEPPER_ROOT_CONTEXT, injectStepperRootContext };
+export type { StepperRootContext, StepperState };

package/switch/index.d.ts

@@ -1,12 +1,105 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/switch-root.directive";
-import * as i2 from "./src/switch-input.directive";
-import * as i3 from "./src/switch-thumb.directive";
-export * from './src/switch-input.directive';
-export * from './src/switch-root.directive';
-export * from './src/switch-thumb.directive';
-export declare class RdxSwitchModule {
+import * as i0 from '@angular/core';
+import { InputSignalWithTransform, Signal, InputSignal } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1 from '@radix-ng/primitives/core';
+import { RdxControlValueAccessor } from '@radix-ng/primitives/core';
+
+interface SwitchContext {
+    required: InputSignalWithTransform<boolean, BooleanInput>;
+    checked: Signal<boolean | undefined>;
+    disabled: Signal<boolean | undefined>;
+    ariaLabel: InputSignal<string | undefined>;
+    ariaLabelledBy: InputSignal<string | undefined>;
+    markAsTouched: () => void;
+    toggle: () => void;
+}
+declare const injectSwitchRootContext: (optional?: boolean) => SwitchContext | null;
+declare const provideSwitchRootContext: (useFactory: () => SwitchContext) => i0.Provider;
+/**
+ * @group Components
+ */
+declare class RdxSwitchRootDirective {
+    protected readonly cva: RdxControlValueAccessor<boolean | undefined>;
+    readonly id: InputSignal<string>;
+    /**
+     * When true, indicates that the user must check the switch before the owning form can be submitted.
+     *
+     * @default false
+     * @group Props
+     */
+    readonly required: InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Establishes relationships between the component and label(s) where its value should be one or more element IDs.
+     * @default null
+     * @group Props
+     */
+    readonly ariaLabelledBy: InputSignal<string | undefined>;
+    /**
+     * Used to define a string that autocomplete attribute the current element.
+     * @default null
+     * @group Props
+     */
+    readonly ariaLabel: InputSignal<string | undefined>;
+    /**
+     * The state of the switch when it is initially rendered. Use when you do not need to control its state.
+     * @default false
+     * @group Props
+     */
+    readonly defaultChecked: InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The controlled state of the switch. Must be used in conjunction with onCheckedChange.
+     * @defaultValue false
+     * @group Props
+     */
+    readonly checked: i0.ModelSignal<boolean>;
+    /**
+     * When `true`, prevents the user from interacting with the switch.
+     * @default false
+     * @group Props
+     */
+    readonly disabled: InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Event handler called when the state of the switch changes.
+     *
+     * @param {boolean} value - Boolean value indicates that the option is changed.
+     * @group Emits
+     */
+    readonly onCheckedChange: i0.OutputRef<boolean | undefined>;
+    /**
+     * Toggles the checked state of the switch.
+     * If the switch is disabled, the function returns early.
+     * @ignore
+     */
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSwitchRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSwitchRootDirective, "button[rdxSwitchRoot]", ["rdxSwitchRoot"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "defaultChecked": { "alias": "defaultChecked"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "onCheckedChange": "onCheckedChange"; }, never, never, true, [{ directive: typeof i1.RdxControlValueAccessor; inputs: { "value": "checked"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+/**
+ * @group Components
+ */
+declare class RdxSwitchInputDirective {
+    protected readonly rootContext: SwitchContext;
+    /** @ignore */
+    protected onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSwitchInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSwitchInputDirective, "input[rdxSwitchInput]", ["rdxSwitchInput"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * @group Components
+ */
+declare class RdxSwitchThumbDirective {
+    protected readonly rootContext: SwitchContext | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSwitchThumbDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSwitchThumbDirective, "span[rdxSwitchThumb]", ["rdxSwitchThumb"], {}, {}, never, never, true, never>;
+}
+
+declare class RdxSwitchModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxSwitchModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxSwitchModule, never, [typeof i1.RdxSwitchRootDirective, typeof i2.RdxSwitchInputDirective, typeof i3.RdxSwitchThumbDirective], [typeof i1.RdxSwitchRootDirective, typeof i2.RdxSwitchInputDirective, typeof i3.RdxSwitchThumbDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxSwitchModule, never, [typeof RdxSwitchRootDirective, typeof RdxSwitchInputDirective, typeof RdxSwitchThumbDirective], [typeof RdxSwitchRootDirective, typeof RdxSwitchInputDirective, typeof RdxSwitchThumbDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxSwitchModule>;
 }
+
+export { RdxSwitchInputDirective, RdxSwitchModule, RdxSwitchRootDirective, RdxSwitchThumbDirective, injectSwitchRootContext, provideSwitchRootContext };
+export type { SwitchContext };