@radix-ng/primitives 0.10.0 → 0.11.1

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

@@ -1,64 +1,11 @@
-import { CdkAccordionItem } from '@angular/cdk/accordion';
-import { InjectionToken, OnInit } from '@angular/core';
-import { RdxAccordionItemState } from './accordion-item.directive';
-import { RdxAccordionOrientation } from './accordion-root.directive';
+import { RdxAccordionItemDirective } from './accordion-item.directive';
 import * as i0 from "@angular/core";
-import * as i1 from "@angular/cdk/accordion";
-export declare const RdxAccordionContentToken: InjectionToken<RdxAccordionContentDirective>;
-export declare class RdxAccordionContentDirective implements OnInit {
-    /**
-     * @ignore
-     */
-    private readonly elementRef;
-    /**
-     * @ignore
-     */
-    private initialized;
-    /**
-     * Current item state
-     */
-    state: import("@angular/core").WritableSignal<RdxAccordionItemState>;
-    /**
-     * When true, prevents the user from interacting with the accordion and all its items.
-     */
-    disabled: import("@angular/core").InputSignal<boolean>;
-    /**
-     * @ignore
-     */
-    accordionItem: CdkAccordionItem;
-    /**
-     * @ignore
-     */
-    orientation: RdxAccordionOrientation;
-    constructor();
-    /**
-     * @ignore
-     */
-    ngOnInit(): void;
-    /**
-     * @ignore
-     */
-    setOpen(state?: RdxAccordionItemState | undefined): void;
-    /**
-     * @ignore
-     */
-    private initialize;
-    /**
-     * @ignore
-     */
-    private setPresence;
-    /**
-     * @ignore
-     */
-    private togglePresence;
-    /**
-     * @ignore
-     */
-    private show;
-    /**
-     * @ignore
-     */
-    private hide;
+export declare class RdxAccordionContentDirective {
+    protected readonly item: RdxAccordionItemDirective;
+    protected readonly nativeElement: any;
+    protected hidden: boolean;
+    protected onAnimationEnd(): void;
+    onToggle(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionContentDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionContentDirective, "[rdxAccordionContent]", ["rdxAccordionContent"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkAccordionItem; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionContentDirective, "[rdxAccordionContent]", ["rdxAccordionContent"], {}, {}, never, never, true, never>;
 }

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

@@ -1,23 +1,7 @@
-import { RdxAccordionItemState } from './accordion-item.directive';
-import { RdxAccordionOrientation } from './accordion-root.directive';
+import { RdxAccordionItemDirective } from './accordion-item.directive';
 import * as i0 from "@angular/core";
 export declare class RdxAccordionHeaderDirective {
-    /**
-     * @ignore
-     */
-    private readonly accordionItem;
-    /**
-     * @ignore
-     */
-    getState(): RdxAccordionItemState;
-    /**
-     * @ignore
-     */
-    getDisabled(): string | undefined;
-    /**
-     * @ignore
-     */
-    getOrientation(): RdxAccordionOrientation;
+    protected readonly item: RdxAccordionItemDirective;
     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,36 +1,64 @@
-import { InjectionToken } from '@angular/core';
+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 * as i0 from "@angular/core";
-import * as i1 from "@angular/cdk/accordion";
 export type RdxAccordionItemState = 'open' | 'closed';
-export declare const RdxAccordionItemToken: InjectionToken<RdxAccordionItemDirective>;
-export declare function injectAccordionItem(): RdxAccordionItemDirective;
-export declare class RdxAccordionItemDirective {
+export declare class RdxAccordionItemDirective implements FocusableOption, OnDestroy {
+    protected readonly accordion: import("./accordion-root.directive").RdxAccordionRootDirective;
+    protected readonly changeDetectorRef: ChangeDetectorRef;
+    protected readonly expansionDispatcher: UniqueSelectionDispatcher;
+    trigger: RdxAccordionTriggerDirective;
+    content: RdxAccordionContentDirective;
+    get dataState(): RdxAccordionItemState;
     /**
+     * The unique AccordionItem id.
      * @ignore
      */
-    private accordionContent;
+    readonly id: string;
+    get orientation(): RdxAccordionOrientation;
+    /** Whether the AccordionItem is expanded. */
+    set expanded(expanded: boolean);
+    get expanded(): boolean;
+    private _expanded;
+    set value(value: string);
+    get value(): string;
+    private _value?;
+    /** Whether the AccordionItem is disabled. */
+    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. */
+    readonly destroyed: EventEmitter<void>;
     /**
-     * Current item state
+     * Emits whenever the expanded state of the accordion changes.
+     * Primarily used to facilitate two-way binding.
+     * @docs-private
      */
-    state: import("@angular/core").WritableSignal<RdxAccordionItemState>;
-    /**
-     * When true, prevents the user from interacting with the item.
-     */
-    disabled: import("@angular/core").InputSignal<boolean>;
-    /**
-     * @ignore
-     */
-    orientation: RdxAccordionOrientation;
-    value?: string;
-    /**
-     * Changes current item state
-     */
-    setOpen(state?: RdxAccordionItemState): void;
-    /**
-     * @ignore
-     */
-    setOrientation(orientation: RdxAccordionOrientation): void;
+    readonly expandedChange: EventEmitter<boolean>;
+    /** Unregister function for expansionDispatcher. */
+    private removeUniqueSelectionListener;
+    /** Subscription to openAll/closeAll events. */
+    private openCloseAllSubscription;
+    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;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionItemDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionItemDirective, "[rdxAccordionItem]", ["rdxAccordionItem"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; }; }, {}, ["accordionContent"], never, true, [{ directive: typeof i1.CdkAccordion; inputs: {}; outputs: {}; }]>;
+    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;
 }

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

@@ -1,29 +1,36 @@
-import { InjectionToken, OnInit } from '@angular/core';
+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 * as i0 from "@angular/core";
 export type RdxAccordionType = 'single' | 'multiple';
 export type RdxAccordionOrientation = 'horizontal' | 'vertical';
 export declare const RdxAccordionRootToken: InjectionToken<RdxAccordionRootDirective>;
-export declare function injectAccordionRoot(): RdxAccordionRootDirective;
-export declare class RdxAccordionRootDirective implements OnInit {
+export declare class RdxAccordionRootDirective implements AfterContentInit, OnDestroy {
+    protected readonly selectionDispatcher: UniqueSelectionDispatcher;
+    protected readonly dir: Directionality | null;
+    protected keyManager: FocusKeyManager<RdxAccordionItemDirective>;
+    readonly id: string;
+    readonly openCloseAllActions: Subject<boolean>;
+    get isMultiple(): boolean;
+    /** Whether the Accordion is disabled. */
+    disabled: boolean;
     /**
-     * @private
-     * @ignore
-     */
-    private readonly accordionItems;
-    /**
-     * @private
-     * @ignore
+     * The orientation of the accordion.
      */
-    private _orientation;
+    orientation: RdxAccordionOrientation;
     /**
      * @private
      * @ignore
      */
-    private _value;
+    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.
      */
-    defaultValue?: string[];
+    set defaultValue(value: string[] | string);
+    get defaultValue(): string[] | string;
     /**
      * Determines whether one or multiple items can be opened at the same time.
      */
@@ -35,23 +42,37 @@ export declare class RdxAccordionRootDirective implements OnInit {
     /**
      * The controlled value of the item to expand
      */
-    set value(value: string | string[] | undefined);
+    set value(value: string[] | string);
+    get value(): string[] | string;
+    readonly onValueChange: EventEmitter<void>;
+    private _value?;
+    private _defaultValue;
+    private onValueChangeSubscription;
     /**
-     * The orientation of the accordion.
+     * @ignore
      */
-    set orientation(orientation: RdxAccordionOrientation | undefined);
+    ngAfterContentInit(): void;
     /**
      * @ignore
      */
-    ngOnInit(): void;
+    ngOnDestroy(): void;
     /**
      * @ignore
      */
-    onValueChange(value: string[]): void;
+    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
      */
-    getOrientation(): RdxAccordionOrientation;
+    setActiveItem(item: RdxAccordionItemDirective): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionRootDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionRootDirective, "[rdxAccordionRoot]", never, { "defaultValue": { "alias": "defaultValue"; "required": false; }; "type": { "alias": "type"; "required": false; }; "collapsible": { "alias": "collapsible"; "required": false; }; "value": { "alias": "value"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; }, {}, ["accordionItems"], never, true, 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;
 }

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

@@ -1,31 +1,15 @@
-import { RdxAccordionItemState } from './accordion-item.directive';
-import { RdxAccordionOrientation } from './accordion-root.directive';
+import { RdxAccordionItemDirective } from './accordion-item.directive';
+import { RdxAccordionRootDirective } from './accordion-root.directive';
 import * as i0 from "@angular/core";
 export declare class RdxAccordionTriggerDirective {
-    /**
-     * @ignore
-     */
-    private readonly accordionRoot;
-    /**
-     * @ignore
-     */
-    private readonly accordionItem;
+    protected readonly nativeElement: any;
+    protected readonly accordionRoot: RdxAccordionRootDirective;
+    protected readonly item: RdxAccordionItemDirective;
     /**
      * Fires when trigger clicked
      */
     onClick(): void;
-    /**
-     * @ignore
-     */
-    getState(): RdxAccordionItemState;
-    /**
-     * @ignore
-     */
-    getDisabled(): boolean | undefined;
-    /**
-     * @ignore
-     */
-    getOrientation(): RdxAccordionOrientation;
+    focus(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionTriggerDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionTriggerDirective, "[rdxAccordionTrigger]", never, {}, {}, never, never, true, never>;
 }

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

@@ -1,11 +1,17 @@
-import { ElementRef, InjectionToken } from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { RdxCollapsibleRootDirective } from './collapsible-root.directive';
 import * as i0 from "@angular/core";
-export declare const RdxCollapsibleContentToken: InjectionToken<RdxCollapsibleContentDirective>;
 export declare class RdxCollapsibleContentDirective {
+    /**
+     * @ignore
+     */
+    protected readonly collapsible: RdxCollapsibleRootDirective;
     /**
      * Reference to CollapsibleContent host element
+     * @ignore
      */
     elementRef: ElementRef<HTMLElement>;
+    getDisabled(): string | undefined;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxCollapsibleContentDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCollapsibleContentDirective, "[rdxCollapsibleContent]", never, {}, {}, never, never, true, never>;
 }

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

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { RdxCollapsibleContentDirective } from './collapsible-content.directive';
+export declare const RdxCollapsibleContentToken: InjectionToken<RdxCollapsibleContentDirective>;

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

@@ -16,18 +16,21 @@ export declare class RdxCollapsibleRootDirective {
      */
     private _open;
     /**
-     * Determines whether a directive is available for interaction
+     * Determines whether a directive is available for interaction.
+     * When true, prevents the user from interacting with the collapsible.
      */
     disabled: boolean;
     /**
+     * The controlled open state of the collapsible.
      * Sets the state of the directive. `true` - expanded, `false` - collapsed
      * @param {boolean} value
      */
     set open(value: boolean);
     /**
-     * Emitted with new value when directive state changed
+     * Emitted with new value when directive state changed.
+     * Event handler called when the open state of the collapsible changes.
      */
-    openChange: EventEmitter<boolean>;
+    onOpenChange: EventEmitter<boolean>;
     /**
      * Allows to change directive state
      * @param {boolean | undefined} value
@@ -48,5 +51,5 @@ export declare class RdxCollapsibleRootDirective {
      */
     private setPresence;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxCollapsibleRootDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCollapsibleRootDirective, "[rdxCollapsibleRoot]", ["collapsibleRoot"], { "disabled": { "alias": "disabled"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; }, ["contentDirective"], never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCollapsibleRootDirective, "[rdxCollapsibleRoot]", ["collapsibleRoot"], { "disabled": { "alias": "disabled"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "onOpenChange": "onOpenChange"; }, ["contentDirective"], never, true, never>;
 }