@radix-ng/primitives 0.43.0 → 0.44.0

package/calendar/index.d.ts

@@ -1,30 +1,311 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/calendar-cell-trigger.directive";
-import * as i2 from "./src/calendar-cell.directive";
-import * as i3 from "./src/calendar-grid-body.directive";
-import * as i4 from "./src/calendar-grid-head.directive";
-import * as i5 from "./src/calendar-grid-row.directive";
-import * as i6 from "./src/calendar-grid.directive";
-import * as i7 from "./src/calendar-head-cell.directive";
-import * as i8 from "./src/calendar-header.directive";
-import * as i9 from "./src/calendar-prev.directive";
-import * as i10 from "./src/calendar-root.directive";
-import * as i11 from "./src/calendar-heading.directive";
-import * as i12 from "./src/calendar-next.directive";
-export { RdxCalendarCellTriggerDirective } from './src/calendar-cell-trigger.directive';
-export { RdxCalendarCellDirective } from './src/calendar-cell.directive';
-export { RdxCalendarGridBodyDirective } from './src/calendar-grid-body.directive';
-export { RdxCalendarGridHeadDirective } from './src/calendar-grid-head.directive';
-export { RdxCalendarGridRowDirective } from './src/calendar-grid-row.directive';
-export { RdxCalendarGridDirective } from './src/calendar-grid.directive';
-export { RdxCalendarHeadCellDirective } from './src/calendar-head-cell.directive';
-export { RdxCalendarHeaderDirective } from './src/calendar-header.directive';
-export { RdxCalendarHeadingDirective } from './src/calendar-heading.directive';
-export { RdxCalendarNextDirective } from './src/calendar-next.directive';
-export { RdxCalendarPrevDirective } from './src/calendar-prev.directive';
-export { RdxCalendarRootDirective } from './src/calendar-root.directive';
-export declare class RdxCalendarModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCalendarModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxCalendarModule, never, [typeof i1.RdxCalendarCellTriggerDirective, typeof i2.RdxCalendarCellDirective, typeof i3.RdxCalendarGridBodyDirective, typeof i4.RdxCalendarGridHeadDirective, typeof i5.RdxCalendarGridRowDirective, typeof i6.RdxCalendarGridDirective, typeof i7.RdxCalendarHeadCellDirective, typeof i8.RdxCalendarHeaderDirective, typeof i9.RdxCalendarPrevDirective, typeof i10.RdxCalendarRootDirective, typeof i11.RdxCalendarHeadingDirective, typeof i12.RdxCalendarNextDirective], [typeof i1.RdxCalendarCellTriggerDirective, typeof i2.RdxCalendarCellDirective, typeof i3.RdxCalendarGridBodyDirective, typeof i4.RdxCalendarGridHeadDirective, typeof i5.RdxCalendarGridRowDirective, typeof i6.RdxCalendarGridDirective, typeof i7.RdxCalendarHeadCellDirective, typeof i8.RdxCalendarHeaderDirective, typeof i9.RdxCalendarPrevDirective, typeof i10.RdxCalendarRootDirective, typeof i11.RdxCalendarHeadingDirective, typeof i12.RdxCalendarNextDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<RdxCalendarModule>;
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, WritableSignal, InputSignal, ModelSignal, Signal } from '@angular/core';
+import { DateValue } from '@internationalized/date';
+import { DateMatcher, Formatter, Month } from '@radix-ng/primitives/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+
+declare class RdxCalendarCellTriggerDirective implements AfterViewInit {
+    private readonly rootContext;
+    private readonly elementRef;
+    /**
+     * The date value provided to the cell trigger
+     */
+    readonly day: _angular_core.InputSignal<DateValue | undefined>;
+    /**
+     * The month in which the cell is rendered
+     */
+    readonly month: _angular_core.InputSignal<DateValue | undefined>;
+    /**
+     * Current day
+     */
+    readonly dayValue: _angular_core.Signal<string | undefined>;
+    /**
+     * Current today state
+     */
+    readonly isDateToday: _angular_core.Signal<boolean>;
+    /**
+     * Current selected state
+     */
+    readonly isSelectedDate: _angular_core.Signal<boolean>;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    readonly isOutsideView: _angular_core.Signal<boolean>;
+    readonly isFocusedDate: _angular_core.Signal<boolean>;
+    readonly isUnavailable: _angular_core.Signal<boolean>;
+    readonly labelText: _angular_core.Signal<string>;
+    /**
+     * @ignore
+     */
+    currentElement: HTMLElement;
+    ngAfterViewInit(): void;
+    protected onClick(): void;
+    protected onArrowKey(event: KeyboardEvent): void;
+    private shiftFocus;
+    /**
+     * @ignore
+     */
+    SELECTOR: string;
+    /**
+     * @ignore
+     */
+    getSelectableCells(calendar: HTMLElement): HTMLElement[];
+    /**
+     * @ignore
+     */
+    changeDate(date: DateValue): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCalendarCellTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCalendarCellTriggerDirective, "[rdxCalendarCellTrigger]", ["rdxCalendarCellTrigger"], { "day": { "alias": "day"; "required": false; "isSignal": true; }; "month": { "alias": "month"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
+
+interface CalendarRootContextToken {
+    nextPage?: (nextPageFunc?: (date: DateValue) => DateValue) => void;
+    prevPage?: (nextPageFunc?: (date: DateValue) => DateValue) => void;
+    isNextButtonDisabled: (nextPageFunc?: (date: DateValue) => DateValue) => boolean;
+    isPrevButtonDisabled: (nextPageFunc?: (date: DateValue) => DateValue) => boolean;
+    headingValue: WritableSignal<string>;
+    dir: InputSignal<'ltr' | 'rtl'>;
+    readonly: boolean;
+    numberOfMonths: InputSignal<number>;
+    placeholder: ModelSignal<DateValue>;
+    pagedNavigation: boolean;
+    disabled: InputSignal<boolean>;
+    isDateSelected?: DateMatcher;
+    isDateDisabled?: DateMatcher;
+    isDateUnavailable: DateMatcher;
+    formatter: Formatter;
+    onDateChange: (date: DateValue) => void;
+    currentElement: HTMLElement;
+    startingWeekNumber: Signal<number[]>;
+}
+
+declare class RdxCalendarCellDirective {
+    protected readonly rootContext: CalendarRootContextToken;
+    /**
+     * The date of the cell
+     */
+    readonly date: _angular_core.InputSignal<DateValue | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCalendarCellDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCalendarCellDirective, "td[rdxCalendarCell]", never, { "date": { "alias": "date"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxCalendarGridBodyDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCalendarGridBodyDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCalendarGridBodyDirective, "tbody[rdxCalendarGridBody]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxCalendarGridHeadDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCalendarGridHeadDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCalendarGridHeadDirective, "thead[rdxCalendarGridHead]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxCalendarGridRowDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCalendarGridRowDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCalendarGridRowDirective, "tr[rdxCalendarGridRow]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxCalendarGridDirective {
+    private readonly rootContext;
+    readonly disabled: _angular_core.Signal<true | undefined>;
+    readonly readonly: _angular_core.Signal<true | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCalendarGridDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCalendarGridDirective, "table[rdxCalendarGrid]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxCalendarHeadCellDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCalendarHeadCellDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCalendarHeadCellDirective, "th[rdxCalendarHeadCell]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxCalendarHeaderDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCalendarHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCalendarHeaderDirective, "div[rdxCalendarHeader]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxCalendarPrevDirective {
+    protected readonly rootContext: CalendarRootContextToken;
+    /**
+     * The function to be used for the `prev page`. Overwrites the prevPage function set on the `CalendarRoot`.
+     */
+    readonly prevPage: _angular_core.InputSignal<((placeholder: DateValue) => DateValue) | undefined>;
+    /**
+     * @ignore
+     */
+    readonly disabled: _angular_core.Signal<boolean>;
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCalendarPrevDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCalendarPrevDirective, "button[rdxCalendarPrev]", ["rdxCalendarPrev"], { "prevPage": { "alias": "prevPage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxCalendarRootDirective implements AfterViewInit {
+    private readonly elementRef;
+    /**
+     * The controlled checked state of the calendar
+     */
+    readonly value: _angular_core.ModelSignal<DateValue | DateValue[] | undefined>;
+    /**
+     * The default placeholder date
+     */
+    readonly defaultPlaceholder: _angular_core.ModelSignal<DateValue | undefined>;
+    readonly locale: _angular_core.InputSignal<string>;
+    readonly defaultDate: DateValue;
+    /**
+     * The placeholder date, which is used to determine what month to display when no date is selected.
+     * This updates as the user navigates the calendar and can be used to programmatically control the calendar view
+     */
+    readonly placeholder: _angular_core.ModelSignal<DateValue>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether to always display 6 weeks in the calendar
+     */
+    readonly fixedWeeks: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the calendar is disabled
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether to prevent the user from deselecting a date without selecting another date first
+     */
+    readonly preventDeselect: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The day of the week to start the calendar on
+     */
+    readonly weekStartsOn: _angular_core.InputSignal<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+    /**
+     * The number of months to display at once
+     */
+    readonly numberOfMonths: _angular_core.InputSignal<number>;
+    /**
+     * The reading direction of the calendar when applicable.
+     */
+    readonly dir: _angular_core.InputSignal<"ltr" | "rtl">;
+    /**
+     * The minimum date that can be selected
+     */
+    readonly minValue: _angular_core.InputSignal<DateValue | undefined>;
+    /**
+     * The maximum date that can be selected
+     */
+    readonly maxValue: _angular_core.InputSignal<DateValue | undefined>;
+    /**
+     * The format to use for the weekday strings provided via the weekdays slot prop
+     */
+    readonly weekdayFormat: _angular_core.InputSignal<"long" | "short" | "narrow" | undefined>;
+    /**
+     * The accessible label for the calendar
+     */
+    readonly calendarLabel: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether the calendar is readonly
+     */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * This property causes the previous and next buttons to navigate by the number of months displayed at once, rather than one month
+     */
+    readonly pagedNavigation: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly propsNextPage: _angular_core.InputSignal<((placeholder: DateValue) => DateValue) | undefined>;
+    readonly propsPrevPage: _angular_core.InputSignal<((placeholder: DateValue) => DateValue) | undefined>;
+    /**
+     * A function that returns whether a date is disabled
+     */
+    readonly isDateDisabled: _angular_core.InputSignal<DateMatcher | undefined>;
+    /**
+     * A function that returns whether a date is unavailable
+     */
+    readonly isDateUnavailable: _angular_core.InputSignal<DateMatcher | undefined>;
+    readonly initialFocus: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly months: _angular_core.ModelSignal<Month<DateValue>[] | undefined>;
+    /**
+     * The days of the week
+     */
+    readonly weekDays: _angular_core.ModelSignal<string[] | undefined>;
+    protected readonly _fixedWeeks: _angular_core.WritableSignal<boolean>;
+    protected readonly _disabled: _angular_core.WritableSignal<boolean>;
+    protected readonly _pagedNavigation: _angular_core.WritableSignal<boolean>;
+    readonly startingWeekNumber: _angular_core.Signal<number[]>;
+    /**
+     * @ignore
+     */
+    readonly headingValue: _angular_core.WritableSignal<string>;
+    /**
+     * @ignore
+     */
+    readonly fullCalendarLabel: _angular_core.WritableSignal<string>;
+    /**
+     * @ignore
+     */
+    nextPage: (nextPageFunc?: (date: DateValue) => DateValue) => void;
+    /**
+     * @ignore
+     */
+    prevPage: (nextPageFunc?: (date: DateValue) => DateValue) => void;
+    /**
+     * @ignore
+     */
+    isNextButtonDisabled: (nextPageFunc?: (date: DateValue) => DateValue) => boolean;
+    /**
+     * @ignore
+     */
+    isPrevButtonDisabled: (nextPageFunc?: (date: DateValue) => DateValue) => boolean;
+    /**
+     * @ignore
+     */
+    isDateSelected: DateMatcher;
+    /**
+     * @ignore
+     */
+    isInvalid: boolean;
+    /**
+     * @ignore
+     */
+    isOutsideVisibleView: (date: DateValue) => boolean;
+    /**
+     * @ignore
+     */
+    formatter: Formatter;
+    /**
+     * @ignore
+     */
+    currentElement: HTMLElement;
+    private readonly calendar;
+    constructor();
+    ngAfterViewInit(): void;
+    /**
+     * @ignore
+     */
+    onPlaceholderChange(value: DateValue): void;
+    /**
+     * @ignore
+     */
+    onDateChange(date: DateValue): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCalendarRootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCalendarRootDirective, "[rdxCalendarRoot]", ["rdxCalendarRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultPlaceholder": { "alias": "defaultPlaceholder"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "fixedWeeks": { "alias": "fixedWeeks"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "preventDeselect": { "alias": "preventDeselect"; "required": false; "isSignal": true; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; "isSignal": true; }; "numberOfMonths": { "alias": "numberOfMonths"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "weekdayFormat": { "alias": "weekdayFormat"; "required": false; "isSignal": true; }; "calendarLabel": { "alias": "calendarLabel"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "pagedNavigation": { "alias": "pagedNavigation"; "required": false; "isSignal": true; }; "propsNextPage": { "alias": "propsNextPage"; "required": false; "isSignal": true; }; "propsPrevPage": { "alias": "propsPrevPage"; "required": false; "isSignal": true; }; "isDateDisabled": { "alias": "isDateDisabled"; "required": false; "isSignal": true; }; "isDateUnavailable": { "alias": "isDateUnavailable"; "required": false; "isSignal": true; }; "initialFocus": { "alias": "initialFocus"; "required": false; "isSignal": true; }; "months": { "alias": "months"; "required": false; "isSignal": true; }; "weekDays": { "alias": "weekDays"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "defaultPlaceholder": "defaultPlaceholderChange"; "placeholder": "placeholderChange"; "months": "monthsChange"; "weekDays": "weekDaysChange"; }, never, never, true, never>;
+}
+
+declare class RdxCalendarHeadingDirective {
+    protected readonly rootContext: CalendarRootContextToken;
+    readonly headingValue: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCalendarHeadingDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCalendarHeadingDirective, "div[rdxCalendarHeading]", ["rdxCalendarHeading"], {}, {}, never, never, true, never>;
+}
+
+declare class RdxCalendarNextDirective {
+    protected readonly rootContext: CalendarRootContextToken;
+    /**
+     * The function to be used for the `next page`. Overwrites the nextPage function set on the `CalendarRoot`.
+     */
+    readonly nextPage: _angular_core.InputSignal<((placeholder: DateValue) => DateValue) | undefined>;
+    /**
+     * @ignore
+     */
+    readonly disabled: _angular_core.Signal<boolean>;
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCalendarNextDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCalendarNextDirective, "button[rdxCalendarNext]", ["rdxCalendarNext"], { "nextPage": { "alias": "nextPage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxCalendarModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCalendarModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxCalendarModule, never, [typeof RdxCalendarCellTriggerDirective, typeof RdxCalendarCellDirective, typeof RdxCalendarGridBodyDirective, typeof RdxCalendarGridHeadDirective, typeof RdxCalendarGridRowDirective, typeof RdxCalendarGridDirective, typeof RdxCalendarHeadCellDirective, typeof RdxCalendarHeaderDirective, typeof RdxCalendarPrevDirective, typeof RdxCalendarRootDirective, typeof RdxCalendarHeadingDirective, typeof RdxCalendarNextDirective], [typeof RdxCalendarCellTriggerDirective, typeof RdxCalendarCellDirective, typeof RdxCalendarGridBodyDirective, typeof RdxCalendarGridHeadDirective, typeof RdxCalendarGridRowDirective, typeof RdxCalendarGridDirective, typeof RdxCalendarHeadCellDirective, typeof RdxCalendarHeaderDirective, typeof RdxCalendarPrevDirective, typeof RdxCalendarRootDirective, typeof RdxCalendarHeadingDirective, typeof RdxCalendarNextDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxCalendarModule>;
+}
+
+export { RdxCalendarCellDirective, RdxCalendarCellTriggerDirective, RdxCalendarGridBodyDirective, RdxCalendarGridDirective, RdxCalendarGridHeadDirective, RdxCalendarGridRowDirective, RdxCalendarHeadCellDirective, RdxCalendarHeaderDirective, RdxCalendarHeadingDirective, RdxCalendarModule, RdxCalendarNextDirective, RdxCalendarPrevDirective, RdxCalendarRootDirective };

package/checkbox/index.d.ts

@@ -1,16 +1,164 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/checkbox-input.directive";
-import * as i2 from "./src/checkbox.directive";
-import * as i3 from "./src/checkbox-button.directive";
-import * as i4 from "./src/checkbox-indicator.directive";
-export * from './src/checkbox-button.directive';
-export * from './src/checkbox-indicator.directive';
-export * from './src/checkbox-input.directive';
-export * from './src/checkbox.directive';
-export type { CheckboxState } from './src/checkbox.directive';
-export * from './src/checkbox.token';
-export declare class RdxCheckboxModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCheckboxModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxCheckboxModule, never, [typeof i1.RdxCheckboxInputDirective, typeof i2.RdxCheckboxRootDirective, typeof i3.RdxCheckboxButtonDirective, typeof i4.RdxCheckboxIndicatorDirective], [typeof i1.RdxCheckboxInputDirective, typeof i2.RdxCheckboxRootDirective, typeof i3.RdxCheckboxButtonDirective, typeof i4.RdxCheckboxIndicatorDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<RdxCheckboxModule>;
+import * as _angular_core from '@angular/core';
+import * as i1 from '@radix-ng/primitives/presence';
+import * as _angular_cdk_coercion from '@angular/cdk/coercion';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1$1 from '@radix-ng/primitives/core';
+
+declare class RdxCheckboxIndicatorPresenceDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCheckboxIndicatorPresenceDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCheckboxIndicatorPresenceDirective, "ng-template[rdxCheckboxIndicatorPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxPresenceDirective; inputs: {}; outputs: {}; }]>;
 }
+
+type CheckedState = boolean | 'indeterminate';
+declare const rootContext: () => {
+    checked: _angular_core.Signal<CheckedState | undefined>;
+    disabled: _angular_core.Signal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    value: _angular_core.InputSignal<string>;
+    name: _angular_core.InputSignal<string | undefined>;
+    form: _angular_core.InputSignal<string | undefined>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    state: _angular_core.Signal<"indeterminate" | "checked" | "unchecked">;
+    toggle(): void;
+};
+type CheckboxRootContext = ReturnType<typeof rootContext>;
+declare const injectCheckboxRootContext: (optional?: boolean) => {
+    checked: _angular_core.Signal<CheckedState | undefined>;
+    disabled: _angular_core.Signal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    value: _angular_core.InputSignal<string>;
+    name: _angular_core.InputSignal<string | undefined>;
+    form: _angular_core.InputSignal<string | undefined>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    state: _angular_core.Signal<"indeterminate" | "checked" | "unchecked">;
+    toggle(): void;
+} | null;
+declare const provideCheckboxRootContext: (useFactory: () => {
+    checked: _angular_core.Signal<CheckedState | undefined>;
+    disabled: _angular_core.Signal<boolean>;
+    required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    value: _angular_core.InputSignal<string>;
+    name: _angular_core.InputSignal<string | undefined>;
+    form: _angular_core.InputSignal<string | undefined>;
+    readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    state: _angular_core.Signal<"indeterminate" | "checked" | "unchecked">;
+    toggle(): void;
+}) => _angular_core.Provider;
+/**
+ * @group Components
+ */
+declare class RdxCheckboxRootDirective {
+    private readonly controlValueAccessor;
+    /**
+     * The controlled checked state of the checkbox. Must be used in conjunction with onCheckedChange.
+     * @group Props
+     */
+    readonly checked: _angular_core.InputSignalWithTransform<CheckedState, BooleanInput>;
+    /**
+     * The value of the checkbox. This is what is submitted with the form when the checkbox is checked.
+     * @group Props
+     */
+    readonly value: _angular_core.InputSignal<string>;
+    /**
+     * Whether or not the checkbox button is disabled. This prevents the user from interacting with it.
+     * @group Props
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the user should be unable to tick or untick the checkbox.
+     * @group Props
+     */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether or not the checkbox is required.
+     * @group Props
+     */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Name of the form control. Submitted with the form as part of a name/value pair.
+     * @group Props
+     */
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Associates the control with a form element.
+     * @group Props
+     */
+    readonly form: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Event emitted when the checkbox checked state changes.
+     * @group Emits
+     */
+    readonly onCheckedChange: _angular_core.OutputRef<any>;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCheckboxRootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCheckboxRootDirective, "[rdxCheckboxRoot]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; }, { "onCheckedChange": "onCheckedChange"; }, never, never, true, [{ directive: typeof i1$1.RdxControlValueAccessor; inputs: { "value": "checked"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+declare class RdxCheckboxInputDirective {
+    protected readonly rootContext: {
+        checked: _angular_core.Signal<CheckedState | undefined>;
+        disabled: _angular_core.Signal<boolean>;
+        required: _angular_core.InputSignalWithTransform<boolean, _angular_cdk_coercion.BooleanInput>;
+        value: _angular_core.InputSignal<string>;
+        name: _angular_core.InputSignal<string | undefined>;
+        form: _angular_core.InputSignal<string | undefined>;
+        readonly: _angular_core.InputSignalWithTransform<boolean, _angular_cdk_coercion.BooleanInput>;
+        state: _angular_core.Signal<"indeterminate" | "checked" | "unchecked">;
+        toggle(): void;
+    };
+    private readonly elementRef;
+    private readonly destroyRef;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCheckboxInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCheckboxInputDirective, "input[rdxCheckboxInput]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive: rdxCheckboxButton
+ * Purpose: Turns a native <button> into an accessible checkbox control bound to the Radix Checkbox context.
+ * It mirrors the checkbox state via ARIA/data attributes, toggles on click, and prevents Enter activation per WAI-ARIA.
+ * In forms, it stops the button's click from bubbling so only the hidden input emits the native event used for form/validator integration.
+ */
+declare class RdxCheckboxButtonDirective {
+    protected readonly rootContext: {
+        checked: _angular_core.Signal<CheckedState | undefined>;
+        disabled: _angular_core.Signal<boolean>;
+        required: _angular_core.InputSignalWithTransform<boolean, _angular_cdk_coercion.BooleanInput>;
+        value: _angular_core.InputSignal<string>;
+        name: _angular_core.InputSignal<string | undefined>;
+        form: _angular_core.InputSignal<string | undefined>;
+        readonly: _angular_core.InputSignalWithTransform<boolean, _angular_cdk_coercion.BooleanInput>;
+        state: _angular_core.Signal<"indeterminate" | "checked" | "unchecked">;
+        toggle(): void;
+    };
+    private readonly elementRef;
+    protected clicked(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCheckboxButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCheckboxButtonDirective, "button[rdxCheckboxButton]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxCheckboxIndicatorDirective {
+    protected readonly rootContext: {
+        checked: _angular_core.Signal<CheckedState | undefined>;
+        disabled: _angular_core.Signal<boolean>;
+        required: _angular_core.InputSignalWithTransform<boolean, _angular_cdk_coercion.BooleanInput>;
+        value: _angular_core.InputSignal<string>;
+        name: _angular_core.InputSignal<string | undefined>;
+        form: _angular_core.InputSignal<string | undefined>;
+        readonly: _angular_core.InputSignalWithTransform<boolean, _angular_cdk_coercion.BooleanInput>;
+        state: _angular_core.Signal<"indeterminate" | "checked" | "unchecked">;
+        toggle(): void;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCheckboxIndicatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCheckboxIndicatorDirective, "[rdxCheckboxIndicator]", never, {}, {}, never, never, true, never>;
+}
+
+declare const checkboxImports: (typeof RdxCheckboxIndicatorPresenceDirective)[];
+declare class RdxCheckboxModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCheckboxModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxCheckboxModule, never, [typeof RdxCheckboxInputDirective, typeof RdxCheckboxRootDirective, typeof RdxCheckboxButtonDirective, typeof RdxCheckboxIndicatorDirective, typeof RdxCheckboxIndicatorPresenceDirective], [typeof RdxCheckboxInputDirective, typeof RdxCheckboxRootDirective, typeof RdxCheckboxButtonDirective, typeof RdxCheckboxIndicatorDirective, typeof RdxCheckboxIndicatorPresenceDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxCheckboxModule>;
+}
+
+export { RdxCheckboxButtonDirective, RdxCheckboxIndicatorDirective, RdxCheckboxIndicatorPresenceDirective, RdxCheckboxInputDirective, RdxCheckboxModule, RdxCheckboxRootDirective, checkboxImports, injectCheckboxRootContext, provideCheckboxRootContext };
+export type { CheckboxRootContext, CheckedState };

package/collapsible/index.d.ts

@@ -1,14 +1,85 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/collapsible-content.directive";
-import * as i2 from "./src/collapsible-root.directive";
-import * as i3 from "./src/collapsible-trigger.directive";
-import * as i4 from "./src/collapsible-content-presence.directive";
-export * from './src/collapsible-content-presence.directive';
-export * from './src/collapsible-content.directive';
-export * from './src/collapsible-root.directive';
-export * from './src/collapsible-trigger.directive';
-export declare class RdxCollapsibleModule {
+import * as i0 from '@angular/core';
+import { InputSignal, ModelSignal, Signal } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1 from '@radix-ng/primitives/presence';
+
+type RdxCollapsibleState = 'open' | 'closed';
+interface CollapsibleRootContext {
+    contentId: InputSignal<string>;
+    open: ModelSignal<boolean>;
+    toggle: () => void;
+    disabled: Signal<boolean>;
+}
+declare const injectCollapsibleRootContext: (optional?: boolean) => CollapsibleRootContext | null;
+declare const provideCollapsibleRootContext: (useFactory: () => CollapsibleRootContext) => i0.Provider;
+/**
+ * @group Components
+ */
+declare class RdxCollapsibleRootDirective {
+    /**
+     * The controlled open state of the collapsible.
+     * Sets the state of the directive. `true` - expanded, `false` - collapsed
+     *
+     * @group Props
+     * @defaultValue false
+     */
+    readonly open: ModelSignal<boolean>;
+    readonly contentId: InputSignal<string>;
+    /**
+     * Determines whether a directive is available for interaction.
+     * When true, prevents the user from interacting with the collapsible.
+     *
+     * @group Props
+     */
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly _disabled: i0.WritableSignal<boolean>;
+    readonly isDisabled: Signal<boolean>;
+    readonly isOpen: Signal<boolean>;
+    /**
+     * Emitted with new value when directive state changed.
+     * Event handler called when the open state of the collapsible changes.
+     *
+     * @group Emits
+     */
+    readonly onOpenChange: i0.OutputEmitterRef<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCollapsibleRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCollapsibleRootDirective, "[rdxCollapsibleRoot]", ["rdxCollapsibleRoot"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "contentId": { "alias": "contentId"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "onOpenChange": "onOpenChange"; }, never, never, true, never>;
+}
+
+declare class RdxCollapsibleContentDirective {
+    private readonly elementRef;
+    private readonly platformId;
+    protected readonly rootContext: CollapsibleRootContext;
+    readonly isOpen: i0.Signal<boolean>;
+    readonly height: i0.WritableSignal<number | null>;
+    readonly width: i0.WritableSignal<number | null>;
+    readonly shouldHide: i0.WritableSignal<boolean>;
+    private isMountAnimationPrevented;
+    private currentStyle;
+    private firstRender;
+    constructor();
+    onAnimationEnd(): void;
+    private updateDimensions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCollapsibleContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCollapsibleContentDirective, "[rdxCollapsibleContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxCollapsibleTriggerDirective {
+    protected readonly rootContext: CollapsibleRootContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCollapsibleTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCollapsibleTriggerDirective, "[rdxCollapsibleTrigger]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxCollapsibleContentPresenceDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCollapsibleContentPresenceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCollapsibleContentPresenceDirective, "ng-template[rdxCollapsibleContentPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxPresenceDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class RdxCollapsibleModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxCollapsibleModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxCollapsibleModule, never, [typeof i1.RdxCollapsibleContentDirective, typeof i2.RdxCollapsibleRootDirective, typeof i3.RdxCollapsibleTriggerDirective, typeof i4.RdxCollapsibleContentPresenceDirective], [typeof i1.RdxCollapsibleContentDirective, typeof i2.RdxCollapsibleRootDirective, typeof i3.RdxCollapsibleTriggerDirective, typeof i4.RdxCollapsibleContentPresenceDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxCollapsibleModule, never, [typeof RdxCollapsibleContentDirective, typeof RdxCollapsibleRootDirective, typeof RdxCollapsibleTriggerDirective, typeof RdxCollapsibleContentPresenceDirective], [typeof RdxCollapsibleContentDirective, typeof RdxCollapsibleRootDirective, typeof RdxCollapsibleTriggerDirective, typeof RdxCollapsibleContentPresenceDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxCollapsibleModule>;
 }
+
+export { RdxCollapsibleContentDirective, RdxCollapsibleContentPresenceDirective, RdxCollapsibleModule, RdxCollapsibleRootDirective, RdxCollapsibleTriggerDirective, injectCollapsibleRootContext, provideCollapsibleRootContext };
+export type { CollapsibleRootContext, RdxCollapsibleState };