@radix-ng/primitives 0.7.2 → 0.8.1

package/accordion/README.md

@@ -0,0 +1 @@
+# @radix-ng/primitives/accordion

package/accordion/index.d.ts

@@ -0,0 +1,5 @@
+export * from './src/accordion-root.directive';
+export * from './src/accordion-item.directive';
+export * from './src/accordion-header.directive';
+export * from './src/accordion-trigger.directive';
+export * from './src/accordion-content.directive';

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

@@ -0,0 +1,64 @@
+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 * 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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionContentDirective, "[AccordionContent]", ["AccordionContent"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkAccordionItem; inputs: {}; outputs: {}; }]>;
+}

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

@@ -0,0 +1,23 @@
+import { RdxAccordionItemState } from './accordion-item.directive';
+import { RdxAccordionOrientation } from './accordion-root.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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionHeaderDirective, "[AccordionHeader]", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,36 @@
+import { InjectionToken } from '@angular/core';
+import { RdxAccordionOrientation } from './accordion-root.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 {
+    /**
+     * @ignore
+     */
+    private accordionContent;
+    /**
+     * Current item state
+     */
+    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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionItemDirective, "[AccordionItem]", ["AccordionItem"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; }; }, {}, ["accordionContent"], never, true, [{ directive: typeof i1.CdkAccordion; inputs: {}; outputs: {}; }]>;
+}

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

@@ -0,0 +1,57 @@
+import { InjectionToken, OnInit } from '@angular/core';
+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 {
+    /**
+     * @private
+     * @ignore
+     */
+    private readonly accordionItems;
+    /**
+     * @private
+     * @ignore
+     */
+    private _orientation;
+    /**
+     * @private
+     * @ignore
+     */
+    private _value;
+    /**
+     * 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[];
+    /**
+     * Determines whether one or multiple items can be opened at the same time.
+     */
+    type: RdxAccordionType;
+    /**
+     * @ignore
+     */
+    collapsible: boolean;
+    /**
+     * The controlled value of the item to expand
+     */
+    set value(value: string | string[] | undefined);
+    /**
+     * The orientation of the accordion.
+     */
+    set orientation(orientation: RdxAccordionOrientation | undefined);
+    /**
+     * @ignore
+     */
+    ngOnInit(): void;
+    /**
+     * @ignore
+     */
+    onValueChange(value: string[]): void;
+    /**
+     * @ignore
+     */
+    getOrientation(): RdxAccordionOrientation;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionRootDirective, "[AccordionRoot]", 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>;
+}

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

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

package/dropdown-menu/README.md

@@ -0,0 +1 @@
+# @radix-ng/primitives/dropdown-menu

package/dropdown-menu/index.d.ts

@@ -0,0 +1,5 @@
+export * from './src/dropdown-menu-trigger.directive';
+export * from './src/dropdown-menu-item.directive';
+export * from './src/dropdown-menu-separator.directive';
+export * from './src/dropdown-menu-content.directive';
+export * from './src/dropdown-menu-label.directive';

package/dropdown-menu/src/dropdown-menu-content.directive.d.ts

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

package/dropdown-menu/src/dropdown-menu-item.directive.d.ts

@@ -0,0 +1,8 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+import * as i1 from "@radix-ng/primitives/menu";
+export declare class RdxDropdownMenuItemDirective {
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDropdownMenuItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDropdownMenuItemDirective, "[DropdownMenuItem]", never, { "disabled": { "alias": "rdxDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxMenuItemDirective; inputs: { "rdxDisabled": "disabled"; }; outputs: {}; }]>;
+}

package/dropdown-menu/src/dropdown-menu-label.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class RdxDropdownMenuLabelDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDropdownMenuLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDropdownMenuLabelDirective, "div[DropdownMenuLabel]", never, {}, {}, never, never, true, never>;
+}

package/dropdown-menu/src/dropdown-menu-separator.directive.d.ts

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

package/dropdown-menu/src/dropdown-menu-trigger.directive.d.ts

@@ -0,0 +1,11 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import { CdkMenuTrigger } from '@angular/cdk/menu';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/menu";
+export declare class RdxDropdownMenuTriggerDirective {
+    protected readonly cdkTrigger: CdkMenuTrigger;
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    onPointerDown($event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDropdownMenuTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDropdownMenuTriggerDirective, "[DropdownMenuTrigger]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkMenuTrigger; inputs: { "cdkMenuTriggerFor": "DropdownMenuTrigger"; }; outputs: {}; }]>;
+}

package/esm2022/accordion/index.mjs

@@ -0,0 +1,6 @@
+export * from './src/accordion-root.directive';
+export * from './src/accordion-item.directive';
+export * from './src/accordion-header.directive';
+export * from './src/accordion-trigger.directive';
+export * from './src/accordion-content.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9wcmltaXRpdmVzL2FjY29yZGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsbUNBQW1DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NyYy9hY2NvcmRpb24tcm9vdC5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvYWNjb3JkaW9uLWl0ZW0uZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL2FjY29yZGlvbi1oZWFkZXIuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL2FjY29yZGlvbi10cmlnZ2VyLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9hY2NvcmRpb24tY29udGVudC5kaXJlY3RpdmUnO1xuIl19

package/esm2022/accordion/radix-ng-primitives-accordion.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFkaXgtbmctcHJpbWl0aXZlcy1hY2NvcmRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9wcmltaXRpdmVzL2FjY29yZGlvbi9yYWRpeC1uZy1wcmltaXRpdmVzLWFjY29yZGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/accordion/src/accordion-content.directive.mjs

@@ -0,0 +1,139 @@
+import { CdkAccordionItem } from '@angular/cdk/accordion';
+import { Directive, effect, ElementRef, inject, InjectionToken, input, signal } from '@angular/core';
+import { animationFrameScheduler } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/accordion";
+export const RdxAccordionContentToken = new InjectionToken('RdxAccordionContentToken');
+export class RdxAccordionContentDirective {
+    constructor() {
+        /**
+         * @ignore
+         */
+        this.elementRef = inject(ElementRef);
+        /**
+         * @ignore
+         */
+        this.initialized = signal(false);
+        /**
+         * Current item state
+         */
+        this.state = signal('closed');
+        /**
+         * When true, prevents the user from interacting with the accordion and all its items.
+         */
+        this.disabled = input(false);
+        /**
+         * @ignore
+         */
+        this.accordionItem = inject(CdkAccordionItem);
+        /**
+         * @ignore
+         */
+        this.orientation = 'vertical';
+        effect(() => {
+            if (this.state()) {
+                this.setPresence();
+            }
+        });
+    }
+    /**
+     * @ignore
+     */
+    ngOnInit() {
+        this.togglePresence();
+    }
+    /**
+     * @ignore
+     */
+    setOpen(state) {
+        if (this.disabled()) {
+            return;
+        }
+        if (state === undefined) {
+            this.state.update(() => (this.state() === 'open' ? 'closed' : 'open'));
+        }
+        else {
+            this.state.update(() => state);
+        }
+    }
+    /**
+     * @ignore
+     */
+    initialize() {
+        if (!this.initialized()) {
+            this.togglePresence();
+            animationFrameScheduler.schedule(() => {
+                this.elementRef.nativeElement
+                    .getAnimations()
+                    .forEach((animation) => animation.cancel());
+                this.initialized.set(true);
+            });
+        }
+    }
+    /**
+     * @ignore
+     */
+    setPresence() {
+        if (!this.initialized()) {
+            this.initialize();
+            return;
+        }
+        animationFrameScheduler.schedule(() => {
+            const animations = this.elementRef.nativeElement.getAnimations();
+            const hidden = this.elementRef.nativeElement.hasAttribute('hidden');
+            if (hidden) {
+                this.show();
+                const rect = this.elementRef.nativeElement.getBoundingClientRect();
+                const height = `${this.elementRef.nativeElement.scrollHeight /*rect.height*/}px`;
+                const width = `${rect.width}px`;
+                this.elementRef.nativeElement.style.setProperty('--radix-accordion-content-height', height);
+                this.elementRef.nativeElement.style.setProperty('--radix-accordion-content-width', width);
+                this.hide();
+            }
+            Promise.all(animations.map((animation) => animation.finished)).then(() => {
+                this.togglePresence();
+            });
+        });
+    }
+    /**
+     * @ignore
+     */
+    togglePresence() {
+        if (this.state() === 'open') {
+            this.show();
+        }
+        else {
+            this.hide();
+        }
+    }
+    /**
+     * @ignore
+     */
+    show() {
+        this.elementRef.nativeElement.removeAttribute('hidden');
+    }
+    /**
+     * @ignore
+     */
+    hide() {
+        this.elementRef.nativeElement.setAttribute('hidden', '');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: RdxAccordionContentDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.0.4", type: RdxAccordionContentDirective, isStandalone: true, selector: "[AccordionContent]", inputs: { disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "attr.data-state": "state()", "attr.data-disabled": "disabled() ? \"\" : undefined", "attr.data-orientation": "orientation" } }, providers: [{ provide: RdxAccordionContentToken, useExisting: RdxAccordionContentDirective }], exportAs: ["AccordionContent"], hostDirectives: [{ directive: i1.CdkAccordionItem }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: RdxAccordionContentDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[AccordionContent]',
+                    standalone: true,
+                    exportAs: 'AccordionContent',
+                    providers: [{ provide: RdxAccordionContentToken, useExisting: RdxAccordionContentDirective }],
+                    host: {
+                        '[attr.data-state]': 'state()',
+                        '[attr.data-disabled]': 'disabled() ? "" : undefined',
+                        '[attr.data-orientation]': 'orientation'
+                    },
+                    hostDirectives: [CdkAccordionItem]
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"accordion-content.directive.js","sourceRoot":"","sources":["../../../../../packages/primitives/accordion/src/accordion-content.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { CdkAccordionItem } from '@angular/cdk/accordion';\nimport {\n    Directive,\n    effect,\n    ElementRef,\n    inject,\n    InjectionToken,\n    input,\n    OnInit,\n    signal\n} from '@angular/core';\nimport { animationFrameScheduler } from 'rxjs';\n\nimport { RdxAccordionItemState } from './accordion-item.directive';\nimport { RdxAccordionOrientation } from './accordion-root.directive';\n\nexport const RdxAccordionContentToken = new InjectionToken<RdxAccordionContentDirective>(\n    'RdxAccordionContentToken'\n);\n\n@Directive({\n    selector: '[AccordionContent]',\n    standalone: true,\n    exportAs: 'AccordionContent',\n    providers: [{ provide: RdxAccordionContentToken, useExisting: RdxAccordionContentDirective }],\n    host: {\n        '[attr.data-state]': 'state()',\n        '[attr.data-disabled]': 'disabled() ? \"\" : undefined',\n        '[attr.data-orientation]': 'orientation'\n    },\n    hostDirectives: [CdkAccordionItem]\n})\nexport class RdxAccordionContentDirective implements OnInit {\n    /**\n     * @ignore\n     */\n    private readonly elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\n    /**\n     * @ignore\n     */\n    private initialized = signal(false);\n    /**\n     * Current item state\n     */\n    state = signal<RdxAccordionItemState>('closed');\n    /**\n     * When true, prevents the user from interacting with the accordion and all its items.\n     */\n    disabled = input(false);\n    /**\n     * @ignore\n     */\n    accordionItem = inject(CdkAccordionItem);\n    /**\n     * @ignore\n     */\n    orientation: RdxAccordionOrientation = 'vertical';\n\n    constructor() {\n        effect(() => {\n            if (this.state()) {\n                this.setPresence();\n            }\n        });\n    }\n\n    /**\n     * @ignore\n     */\n    ngOnInit(): void {\n        this.togglePresence();\n    }\n\n    /**\n     * @ignore\n     */\n    setOpen(state?: RdxAccordionItemState | undefined): void {\n        if (this.disabled()) {\n            return;\n        }\n\n        if (state === undefined) {\n            this.state.update(() => (this.state() === 'open' ? 'closed' : 'open'));\n        } else {\n            this.state.update(() => state);\n        }\n    }\n\n    /**\n     * @ignore\n     */\n    private initialize(): void {\n        if (!this.initialized()) {\n            this.togglePresence();\n\n            animationFrameScheduler.schedule(() => {\n                this.elementRef.nativeElement\n                    .getAnimations()\n                    .forEach((animation) => animation.cancel());\n\n                this.initialized.set(true);\n            });\n        }\n    }\n\n    /**\n     * @ignore\n     */\n    private setPresence(): void {\n        if (!this.initialized()) {\n            this.initialize();\n\n            return;\n        }\n\n        animationFrameScheduler.schedule(() => {\n            const animations = this.elementRef.nativeElement.getAnimations();\n\n            const hidden = this.elementRef.nativeElement.hasAttribute('hidden');\n\n            if (hidden) {\n                this.show();\n\n                const rect = this.elementRef.nativeElement.getBoundingClientRect();\n                const height = `${this.elementRef.nativeElement.scrollHeight /*rect.height*/}px`;\n                const width = `${rect.width}px`;\n\n                this.elementRef.nativeElement.style.setProperty(\n                    '--radix-accordion-content-height',\n                    height\n                );\n\n                this.elementRef.nativeElement.style.setProperty(\n                    '--radix-accordion-content-width',\n                    width\n                );\n\n                this.hide();\n            }\n\n            Promise.all(animations.map((animation) => animation.finished)).then(() => {\n                this.togglePresence();\n            });\n        });\n    }\n\n    /**\n     * @ignore\n     */\n    private togglePresence(): void {\n        if (this.state() === 'open') {\n            this.show();\n        } else {\n            this.hide();\n        }\n    }\n\n    /**\n     * @ignore\n     */\n    private show(): void {\n        this.elementRef.nativeElement.removeAttribute('hidden');\n    }\n\n    /**\n     * @ignore\n     */\n    private hide(): void {\n        this.elementRef.nativeElement.setAttribute('hidden', '');\n    }\n}\n"]}

package/esm2022/accordion/src/accordion-header.directive.mjs

@@ -0,0 +1,44 @@
+import { Directive } from '@angular/core';
+import { injectAccordionItem } from './accordion-item.directive';
+import * as i0 from "@angular/core";
+export class RdxAccordionHeaderDirective {
+    constructor() {
+        /**
+         * @ignore
+         */
+        this.accordionItem = injectAccordionItem();
+    }
+    /**
+     * @ignore
+     */
+    getState() {
+        return this.accordionItem.state();
+    }
+    /**
+     * @ignore
+     */
+    getDisabled() {
+        return this.accordionItem.disabled() ? '' : undefined;
+    }
+    /**
+     * @ignore
+     */
+    getOrientation() {
+        return this.accordionItem.orientation;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: RdxAccordionHeaderDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.4", type: RdxAccordionHeaderDirective, isStandalone: true, selector: "[AccordionHeader]", host: { properties: { "attr.data-state": "getState()", "attr.data-disabled": "getDisabled()", "attr.data-orientation": "getOrientation()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: RdxAccordionHeaderDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[AccordionHeader]',
+                    standalone: true,
+                    host: {
+                        '[attr.data-state]': 'getState()',
+                        '[attr.data-disabled]': 'getDisabled()',
+                        '[attr.data-orientation]': 'getOrientation()'
+                    }
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3JkaW9uLWhlYWRlci5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9wcmltaXRpdmVzL2FjY29yZGlvbi9zcmMvYWNjb3JkaW9uLWhlYWRlci5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUxQyxPQUFPLEVBQUUsbUJBQW1CLEVBQXlCLE1BQU0sNEJBQTRCLENBQUM7O0FBWXhGLE1BQU0sT0FBTywyQkFBMkI7SUFUeEM7UUFVSTs7V0FFRztRQUNjLGtCQUFhLEdBQUcsbUJBQW1CLEVBQUUsQ0FBQztLQXNCMUQ7SUFwQkc7O09BRUc7SUFDSCxRQUFRO1FBQ0osT0FBTyxJQUFJLENBQUMsYUFBYSxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ3RDLENBQUM7SUFFRDs7T0FFRztJQUNILFdBQVc7UUFDUCxPQUFPLElBQUksQ0FBQyxhQUFhLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDO0lBQzFELENBQUM7SUFFRDs7T0FFRztJQUNILGNBQWM7UUFDVixPQUFPLElBQUksQ0FBQyxhQUFhLENBQUMsV0FBVyxDQUFDO0lBQzFDLENBQUM7OEdBekJRLDJCQUEyQjtrR0FBM0IsMkJBQTJCOzsyRkFBM0IsMkJBQTJCO2tCQVR2QyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSxtQkFBbUI7b0JBQzdCLFVBQVUsRUFBRSxJQUFJO29CQUNoQixJQUFJLEVBQUU7d0JBQ0YsbUJBQW1CLEVBQUUsWUFBWTt3QkFDakMsc0JBQXNCLEVBQUUsZUFBZTt3QkFDdkMseUJBQXlCLEVBQUUsa0JBQWtCO3FCQUNoRDtpQkFDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBpbmplY3RBY2NvcmRpb25JdGVtLCBSZHhBY2NvcmRpb25JdGVtU3RhdGUgfSBmcm9tICcuL2FjY29yZGlvbi1pdGVtLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBSZHhBY2NvcmRpb25PcmllbnRhdGlvbiB9IGZyb20gJy4vYWNjb3JkaW9uLXJvb3QuZGlyZWN0aXZlJztcblxuQERpcmVjdGl2ZSh7XG4gICAgc2VsZWN0b3I6ICdbQWNjb3JkaW9uSGVhZGVyXScsXG4gICAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgICBob3N0OiB7XG4gICAgICAgICdbYXR0ci5kYXRhLXN0YXRlXSc6ICdnZXRTdGF0ZSgpJyxcbiAgICAgICAgJ1thdHRyLmRhdGEtZGlzYWJsZWRdJzogJ2dldERpc2FibGVkKCknLFxuICAgICAgICAnW2F0dHIuZGF0YS1vcmllbnRhdGlvbl0nOiAnZ2V0T3JpZW50YXRpb24oKSdcbiAgICB9XG59KVxuZXhwb3J0IGNsYXNzIFJkeEFjY29yZGlvbkhlYWRlckRpcmVjdGl2ZSB7XG4gICAgLyoqXG4gICAgICogQGlnbm9yZVxuICAgICAqL1xuICAgIHByaXZhdGUgcmVhZG9ubHkgYWNjb3JkaW9uSXRlbSA9IGluamVjdEFjY29yZGlvbkl0ZW0oKTtcblxuICAgIC8qKlxuICAgICAqIEBpZ25vcmVcbiAgICAgKi9cbiAgICBnZXRTdGF0ZSgpOiBSZHhBY2NvcmRpb25JdGVtU3RhdGUge1xuICAgICAgICByZXR1cm4gdGhpcy5hY2NvcmRpb25JdGVtLnN0YXRlKCk7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogQGlnbm9yZVxuICAgICAqL1xuICAgIGdldERpc2FibGVkKCk6IHN0cmluZyB8IHVuZGVmaW5lZCB7XG4gICAgICAgIHJldHVybiB0aGlzLmFjY29yZGlvbkl0ZW0uZGlzYWJsZWQoKSA/ICcnIDogdW5kZWZpbmVkO1xuICAgIH1cblxuICAgIC8qKlxuICAgICAqIEBpZ25vcmVcbiAgICAgKi9cbiAgICBnZXRPcmllbnRhdGlvbigpOiBSZHhBY2NvcmRpb25PcmllbnRhdGlvbiB7XG4gICAgICAgIHJldHVybiB0aGlzLmFjY29yZGlvbkl0ZW0ub3JpZW50YXRpb247XG4gICAgfVxufVxuIl19

package/esm2022/accordion/src/accordion-item.directive.mjs

@@ -0,0 +1,75 @@
+import { CdkAccordion } from '@angular/cdk/accordion';
+import { contentChild, Directive, inject, InjectionToken, Input, input, signal } from '@angular/core';
+import { RdxAccordionContentToken } from './accordion-content.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/accordion";
+export const RdxAccordionItemToken = new InjectionToken('RdxAccordionItemToken');
+export function injectAccordionItem() {
+    return inject(RdxAccordionItemDirective);
+}
+export class RdxAccordionItemDirective {
+    constructor() {
+        /**
+         * @ignore
+         */
+        this.accordionContent = contentChild.required(RdxAccordionContentToken);
+        /**
+         * Current item state
+         */
+        this.state = signal('closed');
+        /**
+         * When true, prevents the user from interacting with the item.
+         */
+        this.disabled = input(false);
+        /**
+         * @ignore
+         */
+        this.orientation = 'vertical';
+    }
+    /**
+     * Changes current item state
+     */
+    setOpen(state) {
+        if (this.disabled()) {
+            return;
+        }
+        if (state === undefined) {
+            this.state.update(() => (this.state() === 'open' ? 'closed' : 'open'));
+        }
+        else {
+            this.state.update(() => state);
+        }
+        this.accordionContent().setOpen(this.state());
+    }
+    /**
+     * @ignore
+     */
+    setOrientation(orientation) {
+        this.orientation = orientation;
+        this.accordionContent().orientation = orientation;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: RdxAccordionItemDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "18.0.4", type: RdxAccordionItemDirective, isStandalone: true, selector: "[AccordionItem]", inputs: { disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: false, isRequired: false, transformFunction: null } }, host: { properties: { "attr.data-state": "state()", "attr.data-disabled": "disabled() ? \"\" : undefined", "attr.data-orientation": "orientation" } }, providers: [
+            { provide: RdxAccordionItemToken, useExisting: RdxAccordionItemDirective, multi: true }
+        ], queries: [{ propertyName: "accordionContent", first: true, predicate: RdxAccordionContentToken, descendants: true, isSignal: true }], exportAs: ["AccordionItem"], hostDirectives: [{ directive: i1.CdkAccordion }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: RdxAccordionItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[AccordionItem]',
+                    standalone: true,
+                    exportAs: 'AccordionItem',
+                    providers: [
+                        { provide: RdxAccordionItemToken, useExisting: RdxAccordionItemDirective, multi: true }
+                    ],
+                    host: {
+                        '[attr.data-state]': 'state()',
+                        '[attr.data-disabled]': 'disabled() ? "" : undefined',
+                        '[attr.data-orientation]': 'orientation'
+                    },
+                    hostDirectives: [CdkAccordion]
+                }]
+        }], propDecorators: { value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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