@radix-ng/primitives 0.37.0 → 0.38.0

package/accordion/index.d.ts

@@ -4,6 +4,8 @@ import * as i2 from "./src/accordion-header.directive";
 import * as i3 from "./src/accordion-item.directive";
 import * as i4 from "./src/accordion-root.directive";
 import * as i5 from "./src/accordion-trigger.directive";
+import * as i6 from "./src/accordion-content-presence.directive";
+export * from './src/accordion-content-presence.directive';
 export * from './src/accordion-content.directive';
 export * from './src/accordion-header.directive';
 export * from './src/accordion-item.directive';
@@ -11,6 +13,6 @@ export * from './src/accordion-root.directive';
 export * from './src/accordion-trigger.directive';
 export declare class RdxAccordionModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxAccordionModule, never, [typeof i1.RdxAccordionContentDirective, typeof i2.RdxAccordionHeaderDirective, typeof i3.RdxAccordionItemDirective, typeof i4.RdxAccordionRootDirective, typeof i5.RdxAccordionTriggerDirective], [typeof i1.RdxAccordionContentDirective, typeof i2.RdxAccordionHeaderDirective, typeof i3.RdxAccordionItemDirective, typeof i4.RdxAccordionRootDirective, typeof i5.RdxAccordionTriggerDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxAccordionModule, never, [typeof i1.RdxAccordionContentDirective, typeof i2.RdxAccordionHeaderDirective, typeof i3.RdxAccordionItemDirective, typeof i4.RdxAccordionRootDirective, typeof i5.RdxAccordionTriggerDirective, typeof i6.RdxAccordionContentPresenceDirective], [typeof i1.RdxAccordionContentDirective, typeof i2.RdxAccordionHeaderDirective, typeof i3.RdxAccordionItemDirective, typeof i4.RdxAccordionRootDirective, typeof i5.RdxAccordionTriggerDirective, typeof i6.RdxAccordionContentPresenceDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxAccordionModule>;
 }

package/accordion/src/accordion-content-presence.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@radix-ng/primitives/collapsible";
+export declare class RdxAccordionContentPresenceDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionContentPresenceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionContentPresenceDirective, "ng-template[rdxAccordionContentPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxCollapsibleContentPresenceDirective; inputs: {}; outputs: {}; }]>;
+}

package/accordion/src/accordion-content.directive.d.ts

@@ -1,11 +1,8 @@
-import { RdxAccordionItemDirective } from './accordion-item.directive';
 import * as i0 from "@angular/core";
+import * as i1 from "@radix-ng/primitives/collapsible";
 export declare class RdxAccordionContentDirective {
-    protected readonly item: RdxAccordionItemDirective;
-    protected readonly nativeElement: any;
-    protected hidden: boolean;
-    protected onAnimationEnd(): void;
-    onToggle(): void;
+    protected readonly rootContext: import("./accordion-root.directive").AccordionRootContext;
+    protected readonly itemContext: import("./accordion-item.directive").AccordionItemContext;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionContentDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionContentDirective, "[rdxAccordionContent]", ["rdxAccordionContent"], {}, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionContentDirective, "[rdxAccordionContent]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxCollapsibleContentDirective; inputs: {}; outputs: {}; }]>;
 }

package/accordion/src/accordion-header.directive.d.ts

@@ -1,7 +1,7 @@
-import { RdxAccordionItemDirective } from './accordion-item.directive';
 import * as i0 from "@angular/core";
 export declare class RdxAccordionHeaderDirective {
-    protected readonly item: RdxAccordionItemDirective;
+    protected readonly rootContext: import("./accordion-root.directive").AccordionRootContext;
+    protected readonly itemContext: import("./accordion-item.directive").AccordionItemContext;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionHeaderDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionHeaderDirective, "[rdxAccordionHeader]", never, {}, {}, never, never, true, never>;
 }

package/accordion/src/accordion-item.directive.d.ts

@@ -1,91 +1,32 @@
-import { FocusableOption } from '@angular/cdk/a11y';
-import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
-import { ChangeDetectorRef, EventEmitter, OnDestroy } from '@angular/core';
-import { RdxAccordionContentDirective } from './accordion-content.directive';
-import { RdxAccordionOrientation } from './accordion-root.directive';
-import { RdxAccordionTriggerDirective } from './accordion-trigger.directive';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ElementRef, Signal } from '@angular/core';
 import * as i0 from "@angular/core";
+import * as i1 from "@radix-ng/primitives/collapsible";
 export type RdxAccordionItemState = 'open' | 'closed';
+export type AccordionItemContext = {
+    open: Signal<boolean>;
+    disabled: Signal<boolean>;
+    triggerId: string;
+    dataState: Signal<RdxAccordionItemState>;
+    dataDisabled: Signal<boolean>;
+    currentElement: ElementRef<HTMLElement>;
+    value: Signal<string | undefined>;
+};
+export declare const injectAccordionItemContext: (optional?: boolean) => AccordionItemContext | null, provideAccordionItemContext: (useFactory: () => AccordionItemContext) => import("@angular/core").Provider;
 /**
  * @group Components
  */
-export declare class RdxAccordionItemDirective implements FocusableOption, OnDestroy {
-    protected readonly accordion: import("./accordion-root.directive").RdxAccordionRootDirective;
-    protected readonly changeDetectorRef: ChangeDetectorRef;
-    protected readonly expansionDispatcher: UniqueSelectionDispatcher;
-    /**
-     * @ignore
-     */
-    trigger: RdxAccordionTriggerDirective;
-    /**
-     * @ignore
-     */
-    content: RdxAccordionContentDirective;
-    get dataState(): RdxAccordionItemState;
-    /**
-     * The unique AccordionItem id.
-     * @ignore
-     */
-    readonly id: string;
-    get orientation(): RdxAccordionOrientation;
-    /**
-     * @defaultValue false
-     * @group Props
-     */
-    set expanded(expanded: boolean);
-    get expanded(): boolean;
-    private _expanded;
-    /**
-     * Accordion value.
-     *
-     * @group Props
-     */
-    set value(value: string);
-    get value(): string;
-    private _value?;
-    /**
-     * Whether the AccordionItem is disabled.
-     *
-     * @defaultValue false
-     * @group Props
-     */
-    set disabled(value: boolean);
-    get disabled(): boolean;
-    private _disabled;
-    /**
-     * Event emitted every time the AccordionItem is closed.
-     */
-    readonly closed: EventEmitter<void>;
-    /** Event emitted every time the AccordionItem is opened. */
-    readonly opened: EventEmitter<void>;
-    /**
-     * Event emitted when the AccordionItem is destroyed.
-     * @ignore
-     */
-    readonly destroyed: EventEmitter<void>;
-    /**
-     * Emits whenever the expanded state of the accordion changes.
-     * Primarily used to facilitate two-way binding.
-     * @group Emits
-     */
-    readonly expandedChange: EventEmitter<boolean>;
-    /** Unregister function for expansionDispatcher. */
-    private removeUniqueSelectionListener;
-    /** Subscription to openAll/closeAll events. */
-    private openCloseAllSubscription;
+export declare class RdxAccordionItemDirective {
+    readonly elementRef: ElementRef<HTMLElement>;
+    private readonly collapsibleContext;
+    protected readonly rootContext: import("./accordion-root.directive").AccordionRootContext;
+    readonly value: import("@angular/core").InputSignal<string | undefined>;
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    readonly isDisabled: Signal<boolean>;
+    readonly open: Signal<boolean>;
+    readonly dataState: Signal<RdxAccordionItemState>;
     constructor();
-    /** Emits an event for the accordion item being destroyed. */
-    ngOnDestroy(): void;
-    focus(): void;
-    /** Toggles the expanded state of the accordion item. */
-    toggle(): void;
-    /** Sets the expanded state of the accordion item to false. */
-    close(): void;
-    /** Sets the expanded state of the accordion item to true. */
-    open(): void;
-    private subscribeToOpenCloseAllActions;
+    handleArrowKey(event: KeyboardEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionItemDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionItemDirective, "[rdxAccordionItem]", ["rdxAccordionItem"], { "expanded": { "alias": "expanded"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "closed": "closed"; "opened": "opened"; "expandedChange": "expandedChange"; }, ["trigger", "content"], never, true, never>;
-    static ngAcceptInputType_expanded: unknown;
-    static ngAcceptInputType_disabled: unknown;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionItemDirective, "[rdxAccordionItem]", ["rdxAccordionItem"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxCollapsibleRootDirective; inputs: { "disabled": "disabled"; }; outputs: {}; }]>;
 }

package/accordion/src/accordion-root.directive.d.ts

@@ -1,112 +1,58 @@
-import { FocusKeyManager } from '@angular/cdk/a11y';
-import { Directionality } from '@angular/cdk/bidi';
-import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
-import { AfterContentInit, EventEmitter, InjectionToken, OnDestroy, QueryList } from '@angular/core';
-import { Subject } from 'rxjs';
-import { RdxAccordionItemDirective } from './accordion-item.directive';
+import { Direction } from '@angular/cdk/bidi';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ElementRef, InputSignal, InputSignalWithTransform, ModelSignal, Signal } from '@angular/core';
+import { DataOrientation } from '@radix-ng/primitives/core';
 import * as i0 from "@angular/core";
-export type RdxAccordionType = 'single' | 'multiple';
-export type RdxAccordionOrientation = 'horizontal' | 'vertical';
-export declare const RdxAccordionRootToken: InjectionToken<RdxAccordionRootDirective>;
+export type AccordionRootContext = {
+    disabled: InputSignalWithTransform<boolean, BooleanInput>;
+    direction: InputSignal<Direction>;
+    orientation: InputSignal<DataOrientation>;
+    value: ModelSignal<string | string[] | undefined>;
+    collapsible: Signal<boolean>;
+    isSingle: Signal<boolean>;
+    elementRef: ElementRef<HTMLElement>;
+    changeModelValue: (value: string, isOpen: boolean) => void;
+    isItemOpen: (value: string) => boolean;
+};
+export declare const injectAccordionRootContext: (optional?: boolean) => AccordionRootContext | null, provideAccordionRootContext: (useFactory: () => AccordionRootContext) => import("@angular/core").Provider;
 /**
  * @group Components
  */
-export declare class RdxAccordionRootDirective implements AfterContentInit, OnDestroy {
-    /**
-     * @ignore
-     */
-    protected readonly selectionDispatcher: UniqueSelectionDispatcher;
-    /**
-     * @ignore
-     */
-    protected readonly dir: Directionality | null;
-    /**
-     * @ignore
-     */
-    protected keyManager: FocusKeyManager<RdxAccordionItemDirective>;
-    /**
-     * @ignore
-     */
-    readonly id: string;
-    /**
-     * @ignore
-     */
-    readonly openCloseAllActions: Subject<boolean>;
-    get isMultiple(): boolean;
+export declare class RdxAccordionRootDirective {
+    readonly elementRef: ElementRef<HTMLElement>;
+    readonly id: InputSignal<string>;
+    readonly dir: InputSignal<Direction>;
     /** Whether the Accordion is disabled.
      * @defaultValue false
      * @group Props
      */
-    disabled: boolean;
+    readonly disabled: InputSignalWithTransform<boolean, BooleanInput>;
     /**
      * The orientation of the accordion.
      *
      * @defaultValue 'vertical'
      * @group Props
      */
-    orientation: RdxAccordionOrientation;
-    /**
-     * @private
-     * @ignore
-     */
-    items: QueryList<RdxAccordionItemDirective>;
-    /**
-     * The value of the item to expand when initially rendered and type is "single".
-     * Use when you do not need to control the state of the items.
-     * @group Props
-     */
-    set defaultValue(value: string[] | string);
-    get defaultValue(): string[] | string;
-    /**
-     * Determines whether one or multiple items can be opened at the same time.
-     * @group Props
-     * @defaultValue 'single'
-     */
-    type: RdxAccordionType;
-    /**
-     * @ignore
-     */
-    collapsible: boolean;
+    readonly orientation: InputSignal<DataOrientation>;
+    readonly defaultValue: InputSignal<string | string[] | undefined>;
     /**
      * The controlled value of the item to expand.
      *
      * @group Props
      */
-    set value(value: string[] | string);
-    get value(): string[] | string;
+    readonly value: ModelSignal<string | string[] | undefined>;
+    readonly collapsible: InputSignalWithTransform<boolean, BooleanInput>;
+    readonly type: InputSignal<"multiple" | "single">;
     /**
      * Event handler called when the expanded state of an item changes and type is "multiple".
      * @group Emits
      */
-    readonly onValueChange: EventEmitter<void>;
-    private _value?;
-    private _defaultValue;
-    private onValueChangeSubscription;
-    /**
-     * @ignore
-     */
-    ngAfterContentInit(): void;
-    /**
-     * @ignore
-     */
-    ngOnDestroy(): void;
-    /**
-     * @ignore
-     */
-    handleKeydown(event: KeyboardEvent): void;
-    /** Opens all enabled accordion items in an accordion where multi is enabled.
-     * @ignore
-     */
-    openAll(): void;
-    /** Closes all enabled accordion items.
-     * @ignore
-     */
-    closeAll(): void;
-    /**
-     * @ignore
-     */
-    setActiveItem(item: RdxAccordionItemDirective): void;
+    readonly onValueChange: import("@angular/core").OutputEmitterRef<void>;
+    readonly isCollapsible: Signal<boolean>;
+    readonly isSingle: Signal<boolean>;
+    constructor();
+    changeModelValue: (value: string, isOpen: boolean) => void;
+    isItemOpen: (value: string) => boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionRootDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionRootDirective, "[rdxAccordionRoot]", never, { "disabled": { "alias": "disabled"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; "type": { "alias": "type"; "required": false; }; "collapsible": { "alias": "collapsible"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "onValueChange": "onValueChange"; }, ["items"], never, true, never>;
-    static ngAcceptInputType_disabled: unknown;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionRootDirective, "[rdxAccordionRoot]", ["rdxAccordionRoot"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, never>;
 }

package/accordion/src/accordion-trigger.directive.d.ts

@@ -1,15 +1,9 @@
-import { RdxAccordionItemDirective } from './accordion-item.directive';
-import { RdxAccordionRootDirective } from './accordion-root.directive';
 import * as i0 from "@angular/core";
+import * as i1 from "@radix-ng/primitives/collapsible";
 export declare class RdxAccordionTriggerDirective {
-    protected readonly nativeElement: any;
-    protected readonly accordionRoot: RdxAccordionRootDirective;
-    protected readonly item: RdxAccordionItemDirective;
-    /**
-     * Fires when trigger clicked
-     */
-    onClick(): void;
-    focus(): void;
+    protected readonly rootContext: import("./accordion-root.directive").AccordionRootContext;
+    protected readonly itemContext: import("./accordion-item.directive").AccordionItemContext;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionTriggerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionTriggerDirective, "[rdxAccordionTrigger]", never, {}, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionTriggerDirective, "[rdxAccordionTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxCollapsibleTriggerDirective; inputs: {}; outputs: {}; }]>;
 }

package/collapsible/index.d.ts

@@ -1,3 +1,14 @@
+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 {
+    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 ɵinj: i0.ɵɵInjectorDeclaration<RdxCollapsibleModule>;
+}

package/collapsible/src/collapsible-content-presence.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@radix-ng/primitives/presence";
+export 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: {}; }]>;
+}

package/collapsible/src/collapsible-content.directive.d.ts

@@ -1,14 +1,15 @@
-import { ElementRef } from '@angular/core';
-import { RdxCollapsibleRootDirective } from './collapsible-root.directive';
 import * as i0 from "@angular/core";
 export declare class RdxCollapsibleContentDirective {
-    protected readonly collapsible: RdxCollapsibleRootDirective;
-    /**
-     * Reference to CollapsibleContent host element
-     * @ignore
-     */
-    readonly elementRef: ElementRef<HTMLElement>;
-    getDisabled(): string | undefined;
+    private readonly elementRef;
+    protected readonly rootContext: import("./collapsible-root.directive").CollapsibleRootContext;
+    readonly isOpen: import("@angular/core").Signal<boolean>;
+    readonly height: import("@angular/core").WritableSignal<number>;
+    readonly width: import("@angular/core").WritableSignal<number>;
+    readonly isMountAnimationPrevented: import("@angular/core").WritableSignal<boolean>;
+    private originalStyles;
+    protected readonly hiddenSignal: import("@angular/core").WritableSignal<boolean>;
+    constructor();
+    onAnimationEnd(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxCollapsibleContentDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCollapsibleContentDirective, "[rdxCollapsibleContent]", never, {}, {}, never, never, true, never>;
 }

package/collapsible/src/collapsible-root.directive.d.ts

@@ -1,22 +1,18 @@
 import { BooleanInput } from '@angular/cdk/coercion';
+import { InputSignal, ModelSignal, Signal } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare function injectCollapsible(): RdxCollapsibleRootDirective;
 export type RdxCollapsibleState = 'open' | 'closed';
+export interface CollapsibleRootContext {
+    contentId: InputSignal<string>;
+    open: ModelSignal<boolean>;
+    toggle: () => void;
+    disabled: Signal<boolean>;
+}
+export declare const injectCollapsibleRootContext: (optional?: boolean) => CollapsibleRootContext | null, provideCollapsibleRootContext: (useFactory: () => CollapsibleRootContext) => import("@angular/core").Provider;
 /**
  * @group Components
  */
 export declare class RdxCollapsibleRootDirective {
-    /**
-     * Reference to RdxCollapsibleContent directive
-     */
-    private readonly contentDirective;
-    /**
-     * Determines whether a directive is available for interaction.
-     * When true, prevents the user from interacting with the collapsible.
-     *
-     * @group Props
-     */
-    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
     /**
      * The controlled open state of the collapsible.
      * Sets the state of the directive. `true` - expanded, `false` - collapsed
@@ -24,12 +20,18 @@ export declare class RdxCollapsibleRootDirective {
      * @group Props
      * @defaultValue false
      */
-    set open(value: boolean);
-    get open(): boolean;
+    readonly open: ModelSignal<boolean>;
+    readonly contentId: InputSignal<string>;
     /**
-     * Stores collapsible state
+     * Determines whether a directive is available for interaction.
+     * When true, prevents the user from interacting with the collapsible.
+     *
+     * @group Props
      */
-    private _open;
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    readonly _disabled: import("@angular/core").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.
@@ -37,26 +39,6 @@ export declare class RdxCollapsibleRootDirective {
      * @group Emits
      */
     readonly onOpenChange: import("@angular/core").OutputEmitterRef<boolean>;
-    /**
-     * Allows to change directive state
-     * @param {boolean | undefined} value
-     * @ignore
-     */
-    setOpen(value?: boolean): void;
-    /**
-     * Returns directive state (open | closed)
-     * @ignore
-     */
-    getState(): RdxCollapsibleState;
-    /**
-     * Returns current directive state
-     * @ignore
-     */
-    isOpen(): boolean;
-    /**
-     * Controls visibility of content
-     */
-    private setPresence;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxCollapsibleRootDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCollapsibleRootDirective, "[rdxCollapsibleRoot]", ["collapsibleRoot"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; }; }, { "onOpenChange": "onOpenChange"; }, ["contentDirective"], never, true, 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>;
 }

package/collapsible/src/collapsible-trigger.directive.d.ts

@@ -1,26 +1,6 @@
-import { RdxCollapsibleState } from './collapsible-root.directive';
 import * as i0 from "@angular/core";
 export declare class RdxCollapsibleTriggerDirective {
-    /**
-     * Reference to CollapsibleRoot
-     * @private
-     * @ignore
-     */
-    private readonly collapsible;
-    /**
-     * Called on trigger clicked
-     */
-    onOpenToggle(): void;
-    /**
-     * Returns current directive state (open | closed)
-     * @ignore
-     */
-    getState(): RdxCollapsibleState;
-    /**
-     * Returns current trigger state
-     * @ignore
-     */
-    getDisabled(): string | undefined;
+    protected readonly rootContext: import("./collapsible-root.directive").CollapsibleRootContext;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxCollapsibleTriggerDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCollapsibleTriggerDirective, "[rdxCollapsibleTrigger]", never, {}, {}, never, never, true, never>;
 }

package/core/index.d.ts

@@ -1,3 +1,4 @@
+export * from './src/accessor/control-value-accessor';
 export * from './src/accessor/provide-value-accessor';
 export * from './src/auto-focus.directive';
 export * from './src/clamp';
@@ -13,8 +14,12 @@ export * from './src/is-number';
 export * from './src/kbd-constants';
 export * from './src/provide-token';
 export * from './src/window';
+export * from './src/create-context';
 export * from './src/date-time';
 export * from './src/positioning/constants';
 export * from './src/positioning/types';
 export * from './src/positioning/utils';
+export * from './src/types';
+export * from './src/useArrowNavigation';
+export * from './src/useResizeObserver';
 export * from './src/watch';

package/core/src/accessor/control-value-accessor.d.ts

@@ -0,0 +1,67 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * A reusable ControlValueAccessor implementation for form controls
+ * @template T The type of the control's value
+ */
+export declare class RdxControlValueAccessor<T> implements ControlValueAccessor {
+    /**
+     * Input for the control's value with alias 'value'
+     * @default undefined
+     */
+    readonly valueInput: import("@angular/core").InputSignal<T | undefined>;
+    /**
+     * Input for the disabled state with alias 'disabled'
+     * Uses booleanAttribute transform to convert string attributes to booleans
+     * @default false
+     */
+    readonly disabledInput: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    readonly valueChange: import("@angular/core").OutputEmitterRef<T>;
+    private readonly _value;
+    /**
+     * Readonly access to the current value
+     */
+    readonly value: import("@angular/core").Signal<T | undefined>;
+    private readonly _disabled;
+    /**
+     * Readonly access to the disabled state
+     */
+    readonly disabled: import("@angular/core").Signal<boolean>;
+    private onChange?;
+    private onTouched?;
+    /**
+     * Writes a new value to the control (ControlValueAccessor interface)
+     * @param value The new value for the control
+     */
+    writeValue(value: T | undefined): void;
+    /**
+     * Registers a callback for when the control value changes (ControlValueAccessor interface)
+     * @param fn The callback function
+     */
+    registerOnChange(fn: (value: T | undefined) => void): void;
+    /**
+     * Registers a callback for when the control is touched (ControlValueAccessor interface)
+     * @param fn The callback function
+     */
+    registerOnTouched(fn: () => void): void;
+    /**
+     * Sets the disabled state of the control (ControlValueAccessor interface)
+     * @param isDisabled Whether the control should be disabled
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Updates the control's value and triggers change detection
+     * @param value The new value
+     */
+    setValue(value: T): void;
+    markAsTouched(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxControlValueAccessor<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxControlValueAccessor<any>, never, ["rdxControlValueAccessor"], { "valueInput": { "alias": "value"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+/**
+ * Provides a type-safe way to inject the RdxControlValueAccessor
+ * @template T The type of the control's value
+ * @returns An instance of RdxControlValueAccessor<T>
+ */
+export declare function injectControlValueAccessor<T>(): RdxControlValueAccessor<T>;

package/core/src/create-context.d.ts

@@ -0,0 +1,10 @@
+import { Provider } from '@angular/core';
+/**
+ * Creates a context with injector and provider functions for a given type
+ * @template T The type of the context value
+ * @param description Descriptive string for the context (used in token creation)
+ * @returns A tuple containing:
+ *   - injectContext: Function to retrieve the context value
+ *   - provideContext: Function to create a provider for the context
+ */
+export declare function createContext<T>(description: string): readonly [injectContext: (optional?: boolean) => T | null, provideContext: (useFactory: () => T) => Provider];

package/core/src/date-time/comparators.d.ts

@@ -1,4 +1,4 @@
-import { CalendarDateTime, type DateValue, ZonedDateTime } from '@internationalized/date';
+import { CalendarDateTime, type DateValue, Time, ZonedDateTime } from '@internationalized/date';
 import type { DateMatcher } from './types';
 /**
  * Given a `DateValue` object, convert it to a native `Date` object.
@@ -70,6 +70,7 @@ export declare function isBetween(date: DateValue, start: DateValue, end: DateVa
 export declare function getLastFirstDayOfWeek<T extends DateValue = DateValue>(date: T, firstDayOfWeek: number, locale: string): T;
 export declare function getNextLastDayOfWeek<T extends DateValue = DateValue>(date: T, firstDayOfWeek: number, locale: string): T;
 export declare function areAllDaysBetweenValid(start: DateValue, end: DateValue, isUnavailable: DateMatcher | undefined, isDisabled: DateMatcher | undefined): boolean;
+export type TimeValue = Time | CalendarDateTime | ZonedDateTime;
 export type Granularity = 'day' | 'hour' | 'minute' | 'second';
 export type TimeGranularity = 'hour' | 'minute' | 'second';
 type GetDefaultDateProps = {
@@ -89,4 +90,9 @@ type GetDefaultDateProps = {
  *
  */
 export declare function getDefaultDate(props: GetDefaultDateProps): DateValue;
+type GetDefaultTimeProps = {
+    defaultValue?: TimeValue | undefined;
+    defaultPlaceholder?: TimeValue | undefined;
+};
+export declare function getDefaultTime(props: GetDefaultTimeProps): TimeValue;
 export {};

package/core/src/date-time/useDateField.d.ts

@@ -5,14 +5,14 @@ import { HourCycle, SegmentPart, SegmentValueObj } from './types';
 export type UseDateFieldProps = {
     hasLeftFocus: WritableSignal<boolean>;
     lastKeyZero: WritableSignal<boolean>;
-    placeholder: ModelSignal<DateValue>;
+    placeholder: ModelSignal<DateValue> | WritableSignal<DateValue>;
     hourCycle: HourCycle;
     formatter: Formatter;
     segmentValues: WritableSignal<SegmentValueObj>;
     disabled: InputSignal<boolean>;
     readonly: InputSignal<boolean>;
     part: SegmentPart;
-    modelValue: ModelSignal<DateValue | undefined>;
+    modelValue: ModelSignal<DateValue | undefined> | WritableSignal<DateValue | undefined>;
     focusNext: () => void;
 };
 type SegmentAttrProps = {