@radix-ng/primitives 0.21.0 → 0.23.0

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

@@ -6,18 +6,12 @@ import { RdxAccordionOrientation } from './accordion-root.directive';
 import { RdxAccordionTriggerDirective } from './accordion-trigger.directive';
 import * as i0 from "@angular/core";
 export type RdxAccordionItemState = 'open' | 'closed';
+/**
+ * @group Components
+ */
 export declare class RdxAccordionItemDirective implements FocusableOption, OnDestroy {
-    /**
-     * @ignore
-     */
     protected readonly accordion: import("./accordion-root.directive").RdxAccordionRootDirective;
-    /**
-     * @ignore
-     */
     protected readonly changeDetectorRef: ChangeDetectorRef;
-    /**
-     * @ignore
-     */
     protected readonly expansionDispatcher: UniqueSelectionDispatcher;
     /**
      * @ignore
@@ -34,18 +28,33 @@ export declare class RdxAccordionItemDirective implements FocusableOption, OnDes
      */
     readonly id: string;
     get orientation(): RdxAccordionOrientation;
-    /** Whether the AccordionItem is expanded. */
+    /**
+     * @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. */
+    /**
+     * 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. */
+    /**
+     * Event emitted every time the AccordionItem is closed.
+     */
     readonly closed: EventEmitter<void>;
     /** Event emitted every time the AccordionItem is opened. */
     readonly opened: EventEmitter<void>;
@@ -57,7 +66,7 @@ export declare class RdxAccordionItemDirective implements FocusableOption, OnDes
     /**
      * Emits whenever the expanded state of the accordion changes.
      * Primarily used to facilitate two-way binding.
-     * @docs-private
+     * @group Emits
      */
     readonly expandedChange: EventEmitter<boolean>;
     /** Unregister function for expansionDispatcher. */

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

@@ -8,6 +8,9 @@ import * as i0 from "@angular/core";
 export type RdxAccordionType = 'single' | 'multiple';
 export type RdxAccordionOrientation = 'horizontal' | 'vertical';
 export declare const RdxAccordionRootToken: InjectionToken<RdxAccordionRootDirective>;
+/**
+ * @group Components
+ */
 export declare class RdxAccordionRootDirective implements AfterContentInit, OnDestroy {
     /**
      * @ignore
@@ -30,10 +33,16 @@ export declare class RdxAccordionRootDirective implements AfterContentInit, OnDe
      */
     readonly openCloseAllActions: Subject<boolean>;
     get isMultiple(): boolean;
-    /** Whether the Accordion is disabled. */
+    /** Whether the Accordion is disabled.
+     * @defaultValue false
+     * @group Props
+     */
     disabled: boolean;
     /**
      * The orientation of the accordion.
+     *
+     * @defaultValue 'vertical'
+     * @group Props
      */
     orientation: RdxAccordionOrientation;
     /**
@@ -42,12 +51,16 @@ export declare class RdxAccordionRootDirective implements AfterContentInit, OnDe
      */
     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.
+     * 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;
     /**
@@ -55,10 +68,16 @@ export declare class RdxAccordionRootDirective implements AfterContentInit, OnDe
      */
     collapsible: boolean;
     /**
-     * The controlled value of the item to expand
+     * The controlled value of the item to expand.
+     *
+     * @group Props
      */
     set value(value: string[] | string);
     get value(): string[] | string;
+    /**
+     * 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;

package/aspect-ratio/src/aspect-ratio.directive.d.ts

@@ -6,13 +6,16 @@ import * as i0 from "@angular/core";
  * The element will have its `padding-bottom` dynamically calculated
  * based on the provided aspect ratio to maintain the desired ratio.
  * The content inside the element will be positioned absolutely.
+ * @group Components
  */
 export declare class RdxAspectRatioDirective implements AfterViewInit {
-    private element;
-    private renderer;
+    private readonly element;
+    private readonly renderer;
     /**
      * The desired aspect ratio (e.g., 16/9).
      * By default, it is set to 1 (which results in a square, 1:1).
+     * @group Props
+     * @defaultValue 1
      */
     readonly ratio: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
     /**
@@ -21,7 +24,6 @@ export declare class RdxAspectRatioDirective implements AfterViewInit {
      *
      * If the ratio is zero, it defaults to `0%` to avoid division by zero.
      *
-     * @ignore
      */
     protected readonly paddingBottom: import("@angular/core").Signal<string>;
     ngAfterViewInit(): void;

package/avatar/index.d.ts

@@ -1,5 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./src/avatar-root.directive";
+import * as i2 from "./src/avatar-fallback.directive";
+import * as i3 from "./src/avatar-image.directive";
 export * from './src/avatar-fallback.directive';
 export * from './src/avatar-image.directive';
 export * from './src/avatar-root.directive';
 export type { RdxImageLoadingStatus } from './src/avatar-root.directive';
 export * from './src/avatar.config';
+export declare class RdxCheckboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxCheckboxModule, never, [typeof i1.RdxAvatarRootDirective, typeof i2.RdxAvatarFallbackDirective, typeof i3.RdxAvatarImageDirective], [typeof i1.RdxAvatarRootDirective, typeof i2.RdxAvatarFallbackDirective, typeof i3.RdxAvatarImageDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RdxCheckboxModule>;
+}

package/avatar/src/avatar-fallback.directive.d.ts

@@ -1,9 +1,18 @@
 import { OnDestroy } from '@angular/core';
 import { RdxAvatarRootContext } from './avatar-root.directive';
 import * as i0 from "@angular/core";
+/**
+ * @group Components
+ */
 export declare class RdxAvatarFallbackDirective implements OnDestroy {
     protected readonly avatarRoot: RdxAvatarRootContext;
     private readonly config;
+    /**
+     * Useful for delaying rendering so it only appears for those with slower connections.
+     *
+     * @group Props
+     * @defaultValue 0
+     */
     readonly delayMs: import("@angular/core").InputSignal<number>;
     protected readonly shouldRender: import("@angular/core").Signal<boolean>;
     protected readonly canRender: import("@angular/core").WritableSignal<boolean>;

package/avatar/src/avatar-image.directive.d.ts

@@ -1,10 +1,22 @@
 import { OnInit } from '@angular/core';
 import { RdxImageLoadingStatus } from './avatar-root.directive';
 import * as i0 from "@angular/core";
+/**
+ * @group Components
+ */
 export declare class RdxAvatarImageDirective implements OnInit {
     private readonly avatarRoot;
     private readonly elementRef;
+    /**
+     * @group Props
+     */
     readonly src: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * A callback providing information about the loading status of the image.
+     * This is useful in case you want to control more precisely what to render as the image is loading.
+     *
+     * @group Emits
+     */
     readonly onLoadingStatusChange: import("@angular/core").OutputEmitterRef<RdxImageLoadingStatus>;
     protected readonly imageLoadingStatus: import("@angular/core").Signal<RdxImageLoadingStatus>;
     ngOnInit(): void;

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

@@ -2,9 +2,6 @@ import { ElementRef } from '@angular/core';
 import { RdxCollapsibleRootDirective } from './collapsible-root.directive';
 import * as i0 from "@angular/core";
 export declare class RdxCollapsibleContentDirective {
-    /**
-     * @ignore
-     */
     protected readonly collapsible: RdxCollapsibleRootDirective;
     /**
      * Reference to CollapsibleContent host element

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

@@ -2,33 +2,40 @@ import { EventEmitter } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare function injectCollapsible(): RdxCollapsibleRootDirective;
 export type RdxCollapsibleState = 'open' | 'closed';
+/**
+ * @group Components
+ */
 export declare class RdxCollapsibleRootDirective {
     /**
      * Reference to RdxCollapsibleContent directive
      * @private
-     * @ignore
      */
     private readonly contentDirective;
     /**
      * Stores collapsible state
-     * @private
-     * @ignore
      */
     private _open;
     /**
      * Determines whether a directive is available for interaction.
      * When true, prevents the user from interacting with the collapsible.
+     *
+     * @group Props
      */
     disabled: boolean;
     /**
      * The controlled open state of the collapsible.
      * Sets the state of the directive. `true` - expanded, `false` - collapsed
-     * @param {boolean} value
+     *
+     * @group Props
+     * @defaultValue false
      */
     set open(value: boolean);
+    get open(): boolean;
     /**
      * Emitted with new value when directive state changed.
      * Event handler called when the open state of the collapsible changes.
+     *
+     * @group Emits
      */
     onOpenChange: EventEmitter<boolean>;
     /**