@raintonic/formaui 0.2.0

package/types/raintonic-formaui-components-tree.d.ts

@@ -0,0 +1,104 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, TemplateRef } from '@angular/core';
+import { Observable } from 'rxjs';
+
+/** Tree node data model (hierarchical) */
+interface FuiTreeNode<T = any> {
+    data: T;
+    children?: FuiTreeNode<T>[];
+    expanded?: boolean;
+    selected?: boolean;
+    disabled?: boolean;
+    leaf?: boolean;
+}
+/** Flat node (internal representation for flat rendering) */
+interface FuiFlatTreeNode<T = any> {
+    origin: FuiTreeNode<T>;
+    level: number;
+    expandable: boolean;
+    expanded: boolean;
+    selected: boolean;
+    disabled: boolean;
+    visible: boolean;
+    loading: boolean;
+    _flatIndex: number;
+}
+/** Selection mode for the tree */
+type FuiTreeSelectionMode = 'none' | 'single' | 'multi' | 'checkbox';
+/** Event emitted when a node is selected or unselected */
+interface FuiTreeNodeEvent<T = any> {
+    node: FuiTreeNode<T>;
+    flatNode: FuiFlatTreeNode<T>;
+}
+/** Event emitted when a node is dragged and dropped */
+interface FuiTreeDragDropEvent<T = any> {
+    dragNode: FuiTreeNode<T>;
+    dropNode: FuiTreeNode<T> | null;
+    dropPosition: 'before' | 'after' | 'inside';
+    dragIndex: number;
+    dropIndex: number;
+}
+
+declare class FuiTreeComponent<T = any> implements OnDestroy {
+    readonly nodes: _angular_core.InputSignal<FuiTreeNode<T>[]>;
+    readonly selectionMode: _angular_core.InputSignal<FuiTreeSelectionMode>;
+    readonly loadChildren: _angular_core.InputSignal<((node: FuiTreeNode<T>) => Observable<FuiTreeNode<T>[]>) | null>;
+    readonly nodeTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
+    readonly draggable: _angular_core.InputSignal<boolean>;
+    readonly virtualScroll: _angular_core.InputSignal<boolean>;
+    readonly virtualItemSize: _angular_core.InputSignal<number>;
+    readonly filter: _angular_core.InputSignal<string>;
+    readonly nodeSelect: _angular_core.OutputEmitterRef<FuiTreeNodeEvent<T>>;
+    readonly nodeUnselect: _angular_core.OutputEmitterRef<FuiTreeNodeEvent<T>>;
+    readonly nodeExpand: _angular_core.OutputEmitterRef<FuiTreeNodeEvent<T>>;
+    readonly nodeCollapse: _angular_core.OutputEmitterRef<FuiTreeNodeEvent<T>>;
+    readonly nodeDrop: _angular_core.OutputEmitterRef<FuiTreeDragDropEvent<T>>;
+    readonly filterChange: _angular_core.OutputEmitterRef<string>;
+    private readonly _flattener;
+    private readonly _subscriptions;
+    /** Refresh counter to trigger re-flatten after mutations */
+    private readonly _refreshCounter;
+    readonly flatNodes: _angular_core.Signal<FuiFlatTreeNode<T>[]>;
+    readonly checkboxStates: _angular_core.Signal<Map<FuiTreeNode<T>, "checked" | "unchecked" | "indeterminate">>;
+    readonly focusedIndex: _angular_core.WritableSignal<number>;
+    ngOnDestroy(): void;
+    expandAll(): void;
+    collapseAll(): void;
+    selectNode(node: FuiTreeNode<T>): void;
+    getSelectedNodes(): FuiTreeNode<T>[];
+    onNodeToggle(flatNode: FuiFlatTreeNode<T>): void;
+    onNodeSelect(flatNode: FuiFlatTreeNode<T>): void;
+    onCheckboxChange(flatNode: FuiFlatTreeNode<T>): void;
+    _onKeydown(event: KeyboardEvent): void;
+    private _filterNodes;
+    private _nodeMatchesFilter;
+    private _setExpandedRecursive;
+    private _clearSelectionRecursive;
+    private _setSelectedRecursive;
+    private _collectSelectedRecursive;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiTreeComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiTreeComponent<any>, "fui-tree", never, { "nodes": { "alias": "nodes"; "required": true; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "loadChildren": { "alias": "loadChildren"; "required": false; "isSignal": true; }; "nodeTemplate": { "alias": "nodeTemplate"; "required": false; "isSignal": true; }; "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; "isSignal": true; }; "virtualItemSize": { "alias": "virtualItemSize"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; }, { "nodeSelect": "nodeSelect"; "nodeUnselect": "nodeUnselect"; "nodeExpand": "nodeExpand"; "nodeCollapse": "nodeCollapse"; "nodeDrop": "nodeDrop"; "filterChange": "filterChange"; }, never, never, true, never>;
+}
+
+declare class FuiTreeNodeComponent {
+    readonly flatNode: _angular_core.InputSignal<FuiFlatTreeNode<any>>;
+    readonly selectionMode: _angular_core.InputSignal<FuiTreeSelectionMode>;
+    readonly nodeTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
+    readonly checkboxState: _angular_core.InputSignal<"checked" | "unchecked" | "indeterminate">;
+    readonly focused: _angular_core.InputSignal<boolean>;
+    readonly toggle: _angular_core.OutputEmitterRef<void>;
+    readonly select: _angular_core.OutputEmitterRef<void>;
+    readonly checkboxChange: _angular_core.OutputEmitterRef<void>;
+    readonly indentPx = 24;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiTreeNodeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiTreeNodeComponent, "fui-tree-node", never, { "flatNode": { "alias": "flatNode"; "required": true; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "nodeTemplate": { "alias": "nodeTemplate"; "required": false; "isSignal": true; }; "checkboxState": { "alias": "checkboxState"; "required": false; "isSignal": true; }; "focused": { "alias": "focused"; "required": false; "isSignal": true; }; }, { "toggle": "toggle"; "select": "select"; "checkboxChange": "checkboxChange"; }, never, never, true, never>;
+}
+
+declare class FuiTreeFlattener<T = any> {
+    flatten(nodes: FuiTreeNode<T>[], hasLoadChildren?: boolean): FuiFlatTreeNode<T>[];
+    calculateCheckboxStates(nodes: FuiTreeNode<T>[]): Map<FuiTreeNode<T>, 'checked' | 'unchecked' | 'indeterminate'>;
+}
+
+export { FuiTreeComponent, FuiTreeFlattener, FuiTreeNodeComponent };
+export type { FuiFlatTreeNode, FuiTreeDragDropEvent, FuiTreeNode, FuiTreeNodeEvent, FuiTreeSelectionMode };
+//# sourceMappingURL=raintonic-formaui-components-tree.d.ts.map

package/types/raintonic-formaui-components-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-tree.d.ts","sources":["../../../lib/components/tree/tree.types.ts","../../../lib/components/tree/fui-tree.component.ts","../../../lib/components/tree/fui-tree-node.component.ts","../../../lib/components/tree/tree-flattener.ts"],"mappings":";;;;AAAA;AACM,UAAW,WAAW;;AAE1B,eAAW,WAAW;;;;;AAKvB;AAED;AACM,UAAW,eAAe;AAC9B,YAAQ,WAAW;;;;;;;;;AASpB;AAED;AACM,KAAM,oBAAoB;AAEhC;AACM,UAAW,gBAAgB;AAC/B,UAAM,WAAW;AACjB,cAAU,eAAe;AAC1B;AAED;AACM,UAAW,oBAAoB;AACnC,cAAU,WAAW;AACrB,cAAU,WAAW;AACrB;;;AAGD;;AChBD,cAea,gBAAgB,qBAAqB,SAAS;oBAC3C,aAAA,CAAA,WAAA,CAAA,WAAA;4BACQ,aAAA,CAAA,WAAA,CAAA,oBAAA;AACtB,2BAAqB,aAAA,CAAA,WAAA,SAAiB,WAAW,QAAQ,UAAU,CAAC,WAAW;2BAC1D,aAAA,CAAA,WAAA,CAAA,WAAA;wBACH,aAAA,CAAA,WAAA;4BACI,aAAA,CAAA,WAAA;8BACE,aAAA,CAAA,WAAA;qBACT,aAAA,CAAA,WAAA;yBAEI,aAAA,CAAA,gBAAA,CAAA,gBAAA;2BACE,aAAA,CAAA,gBAAA,CAAA,gBAAA;yBACF,aAAA,CAAA,gBAAA,CAAA,gBAAA;2BACE,aAAA,CAAA,gBAAA,CAAA,gBAAA;uBACJ,aAAA,CAAA,gBAAA,CAAA,oBAAA;2BACI,aAAA,CAAA,gBAAA;AAErB;AACA;;AAGA;wBAEkB,aAAA,CAAA,MAAA,CAAA,eAAA;6BAWK,aAAA,CAAA,MAAA,CAAA,GAAA,CAAA,WAAA;2BAQF,aAAA,CAAA,cAAA;AAErB;AAQA;AAKA;qBAKiB,WAAW;AAa5B,wBAAoB,WAAW;2BAQR,eAAe;2BAmCf,eAAe;+BA2BX,eAAe;AAsB1C,sBAAkB,aAAa;AAyG/B;AAqBA;AAgBA;AASA;AASA;AASA;oDAhVW,gBAAgB;sDAAhB,gBAAgB;AA0V5B;;AC1XD,cAoBa,oBAAoB;uBACd,aAAA,CAAA,WAAA,CAAA,eAAA;4BACK,aAAA,CAAA,WAAA,CAAA,oBAAA;2BACD,aAAA,CAAA,WAAA,CAAA,WAAA;4BACC,aAAA,CAAA,WAAA;sBACN,aAAA,CAAA,WAAA;qBAED,aAAA,CAAA,gBAAA;qBACA,aAAA,CAAA,gBAAA;6BACQ,aAAA,CAAA,gBAAA;;oDATZ,oBAAoB;sDAApB,oBAAoB;AAYhC;;ACpCD,cAAa,gBAAgB;AAC3B,mBAAe,WAAW,mCAAiC,eAAe;mCAgC3C,WAAW,QAAQ,GAAG,CAAC,WAAW;AAiClE;;;;","names":[]}

package/types/raintonic-formaui-core.d.ts

@@ -0,0 +1,115 @@
+import { Observable, Subject } from 'rxjs';
+import { NgControl, FormControl, FormGroupDirective, NgForm } from '@angular/forms';
+import * as i0 from '@angular/core';
+import { InjectionToken, Signal } from '@angular/core';
+
+/**
+ * Interface for form field controls following Angular Material patterns
+ * This interface should be implemented by any component that can be used inside fui-form-field
+ */
+interface FuiFormFieldControl<T = unknown> {
+    /**
+     * Stream that emits whenever the state of the control changes
+     */
+    readonly stateChanges: Observable<void>;
+    /**
+     * The value of the control
+     */
+    readonly value: Signal<T | null>;
+    /**
+     * The placeholder for this control
+     */
+    readonly placeholder: Signal<string>;
+    /**
+     * The NgControl for this control (non-reactive)
+     */
+    readonly ngControl: NgControl | null;
+    /**
+     * Whether the control is focused
+     */
+    readonly focused: Signal<boolean>;
+    /**
+     * Whether the control is empty
+     */
+    readonly empty: Signal<boolean>;
+    /**
+     * Whether the control is required
+     */
+    readonly required: Signal<boolean>;
+    /**
+     * Whether the control is disabled
+     */
+    readonly disabled: Signal<boolean>;
+    /**
+     * Whether the control is in an error state
+     */
+    readonly errorState: Signal<boolean>;
+    /**
+     * The aria-describedby attribute on the control
+     */
+    readonly controlType?: string;
+    /**
+     * The element ID for the control
+     */
+    readonly id: string;
+    /**
+     * Handles a click on the control's container
+     */
+    onContainerClick(event: MouseEvent): void;
+    /**
+     * Sets the list of element IDs that describe the control
+     */
+    setDescribedByIds(ids: string[]): void;
+    /**
+     * Sets the read-only state of the control (propagated from form-field)
+     */
+    setReadOnly?(readOnly: boolean): void;
+}
+/**
+ * Injection token used to provide the form field control to the form field
+ */
+declare const FUI_FORM_FIELD_CONTROL: InjectionToken<FuiFormFieldControl<unknown>>;
+
+/**
+ * Error state matcher that follows Angular Material patterns
+ * Determines when to show error messages
+ */
+interface ErrorStateMatcher {
+    isErrorState(control: FormControl | null, form: FormGroupDirective | NgForm | null): boolean;
+}
+/**
+ * Default error state matcher implementation
+ * Shows errors when control is invalid and either touched or form is submitted
+ */
+declare class DefaultErrorStateMatcher implements ErrorStateMatcher {
+    isErrorState(control: FormControl | null, form: FormGroupDirective | NgForm | null): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultErrorStateMatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultErrorStateMatcher>;
+}
+/**
+ * Interface for components that can display error state
+ */
+interface CanUpdateErrorState {
+    readonly stateChanges: Subject<void>;
+    errorState: boolean;
+    errorStateMatcher: ErrorStateMatcher | null;
+    updateErrorState(): void;
+}
+/**
+ * Mixin to add error state handling to a component
+ */
+type Constructor<T = object> = new (...args: any[]) => T;
+interface HasErrorState {
+    _defaultErrorStateMatcher: ErrorStateMatcher;
+    _parentForm: NgForm | FormGroupDirective | null;
+    _parentFormGroup: FormGroupDirective | null;
+    ngControl: NgControl | null;
+}
+/**
+ * Mixin that adds error state handling
+ */
+declare function mixinErrorState<T extends Constructor<HasErrorState>>(base: T): Constructor<CanUpdateErrorState> & T;
+
+export { DefaultErrorStateMatcher, FUI_FORM_FIELD_CONTROL, mixinErrorState };
+export type { CanUpdateErrorState, Constructor, ErrorStateMatcher, FuiFormFieldControl, HasErrorState };
+//# sourceMappingURL=raintonic-formaui-core.d.ts.map

package/types/raintonic-formaui-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-core.d.ts","sources":["../../../lib/core/form-field-control.ts","../../../lib/core/error-state.ts"],"mappings":";;;;;AAIA;;;AAGG;AACG,UAAW,mBAAmB;AAClC;;AAEG;AACH,2BAAuB,UAAU;AAEjC;;AAEG;oBACa,MAAM;AAEtB;;AAEG;AACH,0BAAsB,MAAM;AAE5B;;AAEG;AACH,wBAAoB,SAAS;AAE7B;;AAEG;AACH,sBAAkB,MAAM;AAExB;;AAEG;AACH,oBAAgB,MAAM;AAEtB;;AAEG;AACH,uBAAmB,MAAM;AAEzB;;AAEG;AACH,uBAAmB,MAAM;AAEzB;;AAEG;AACH,yBAAqB,MAAM;AAE3B;;AAEG;AACH;AAEA;;AAEG;AACH;AAEA;;AAEG;AACH,4BAAwB,UAAU;AAElC;;AAEG;AACH;AAEA;;AAEG;AACH;AACD;AAED;;AAEG;AACH,cAAa,sBAAsB,EAAA,cAAA,CAAA,mBAAA;;AC/EnC;;;AAGG;UACc,iBAAiB;AAChC,0BAAsB,WAAW,eAAe,kBAAkB,GAAG,MAAM;AAC5E;AAED;;;AAGG;AACH,cACa,wBAAyB,YAAW,iBAAiB;AAChE,0BAAsB,WAAW,eAAe,kBAAkB,GAAG,MAAM;yCADhE,wBAAwB;6CAAxB,wBAAwB;AAKpC;AAED;;AAEG;UACc,mBAAmB;AAClC,2BAAuB,OAAO;;AAE9B,uBAAmB,iBAAiB;;AAErC;AAED;;AAEG;AAEG,KAAM,WAAW;UAEN,aAAa;+BACD,iBAAiB;AAC5C,iBAAa,MAAM,GAAG,kBAAkB;AACxC,sBAAkB,kBAAkB;AACpC,eAAW,SAAS;AACrB;AAED;;AAEG;AACH,iBAAgB,eAAe,WAAW,WAAW,CAAC,aAAa,aAAa,WAAW,CAAC,mBAAmB;;;;","names":[]}

package/types/raintonic-formaui-services-dialog.d.ts

@@ -0,0 +1,451 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, ViewContainerRef, Injector, Type, TemplateRef, AfterViewInit, OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+import { FuiOverlayRef } from '@raintonic/formaui/cdk/overlay';
+import * as _raintonic_formaui_services_dialog from '@raintonic/formaui/services/dialog';
+
+/**
+ * Injection token for dialog data passed to the dialog component
+ */
+declare const FUI_DIALOG_DATA: InjectionToken<unknown>;
+/**
+ * Injection token for the dialog scroll strategy
+ */
+declare const FUI_DIALOG_DEFAULT_OPTIONS: InjectionToken<FuiDialogConfig<unknown>>;
+/**
+ * Role attribute for the dialog
+ */
+type FuiDialogRole = 'dialog' | 'alertdialog';
+/**
+ * Configuration for opening a dialog
+ */
+interface FuiDialogConfig<D = unknown> {
+    /** ID for the dialog. If omitted, a unique one will be generated */
+    id?: string;
+    /** Role attribute for the dialog element */
+    role?: FuiDialogRole;
+    /** CSS class(es) to apply to the overlay pane */
+    panelClass?: string | string[];
+    /** Whether the dialog has a backdrop */
+    hasBackdrop?: boolean;
+    /** CSS class(es) to apply to the backdrop */
+    backdropClass?: string | string[];
+    /** Whether the user can close the dialog by clicking on the backdrop */
+    disableClose?: boolean;
+    /** Width of the dialog */
+    width?: string;
+    /** Height of the dialog */
+    height?: string;
+    /** Min-width of the dialog */
+    minWidth?: string | number;
+    /** Min-height of the dialog */
+    minHeight?: string | number;
+    /** Max-width of the dialog. Defaults to 80vw */
+    maxWidth?: string | number;
+    /** Max-height of the dialog */
+    maxHeight?: string | number;
+    /** Position of the dialog */
+    position?: FuiDialogPosition;
+    /** Data to pass to the dialog component */
+    data?: D | null;
+    /** Layout direction for the dialog content */
+    direction?: 'ltr' | 'rtl';
+    /** ARIA label for the dialog */
+    ariaLabel?: string | null;
+    /** ID of the element that labels the dialog */
+    ariaLabelledBy?: string | null;
+    /** ID of the element that describes the dialog */
+    ariaDescribedBy?: string | null;
+    /** Whether to focus the first focusable element on open */
+    autoFocus?: FuiAutoFocusTarget | string | boolean;
+    /** Whether to restore focus to the previously focused element on close */
+    restoreFocus?: boolean;
+    /** Whether the dialog should close when the user goes backwards/forwards in history */
+    closeOnNavigation?: boolean;
+    /** Duration of the enter animation in ms */
+    enterAnimationDuration?: string | number;
+    /** Duration of the exit animation in ms */
+    exitAnimationDuration?: string | number;
+    /** Alternate ViewContainerRef to use for creating the dialog */
+    viewContainerRef?: ViewContainerRef;
+    /** Injector used for the dialog component */
+    injector?: Injector;
+    /** Component to instantiate as the dialog container (internal use) */
+    containerComponent?: Type<FuiDialogContainerBase>;
+    /** Whether to delay the focus trap */
+    delayFocusTrap?: boolean;
+}
+/**
+ * Target for auto focus within the dialog
+ */
+type FuiAutoFocusTarget = 'dialog' | 'first-tabbable' | 'first-heading';
+/**
+ * Position of the dialog
+ */
+interface FuiDialogPosition {
+    /** Override for the dialog's top position */
+    top?: string;
+    /** Override for the dialog's bottom position */
+    bottom?: string;
+    /** Override for the dialog's left position */
+    left?: string;
+    /** Override for the dialog's right position */
+    right?: string;
+}
+/**
+ * State of the dialog animation
+ */
+type FuiDialogState = 'void' | 'enter' | 'exit';
+/**
+ * Base interface for dialog container
+ */
+interface FuiDialogContainerBase {
+    /** Starts the dialog exit animation */
+    _startExitAnimation(): void;
+}
+/**
+ * Reference to an opened dialog
+ */
+interface IFuiDialogRef<T = unknown, R = unknown> {
+    /** Unique ID for this dialog instance */
+    readonly id: string;
+    /** The component instance if the dialog was created with a component */
+    readonly componentInstance: T | null;
+    /** Whether the user is allowed to close the dialog */
+    disableClose: boolean;
+    /** Observable that emits when the dialog has been opened */
+    readonly afterOpened: Observable<void>;
+    /** Observable that emits when the dialog has started closing */
+    readonly beforeClosed: Observable<R | undefined>;
+    /** Observable that emits when the dialog has finished closing */
+    readonly afterClosed: Observable<R | undefined>;
+    /** Observable that emits when the backdrop is clicked */
+    readonly backdropClick: Observable<MouseEvent>;
+    /** Observable that emits when a keydown event occurs on the overlay */
+    readonly keydownEvents: Observable<KeyboardEvent>;
+    /**
+     * Closes the dialog with an optional result
+     * @param dialogResult Result to return to the dialog opener
+     */
+    close(dialogResult?: R): void;
+    /**
+     * Updates the dialog's position
+     * @param position New position configuration
+     */
+    updatePosition(position?: FuiDialogPosition): void;
+    /**
+     * Updates the dialog's dimensions
+     * @param width New width
+     * @param height New height
+     */
+    updateSize(width?: string, height?: string): void;
+    /**
+     * Adds CSS classes to the dialog panel
+     * @param classes Classes to add
+     */
+    addPanelClass(classes: string | string[]): void;
+    /**
+     * Removes CSS classes from the dialog panel
+     * @param classes Classes to remove
+     */
+    removePanelClass(classes: string | string[]): void;
+    /**
+     * Gets the current state of the dialog's lifecycle
+     */
+    getState(): FuiDialogState;
+}
+/**
+ * Result from opening a dialog
+ */
+interface FuiDialogOpenResult<T, R> {
+    /** Reference to the opened dialog */
+    dialogRef: IFuiDialogRef<T, R>;
+    /** Reference to the component instance if dialog was created with a component */
+    componentRef?: T;
+}
+type FuiConfirmDialogVariant = 'info' | 'warning' | 'danger';
+interface FuiConfirmDialogConfig {
+    title: string;
+    message: string;
+    confirmText?: string;
+    cancelText?: string;
+    variant?: FuiConfirmDialogVariant;
+}
+
+/**
+ * # FuiDialogRefImpl
+ *
+ * Implementation of the FuiDialogRef interface. This class manages the lifecycle
+ * of an individual dialog instance, providing methods to close, update position/size,
+ * and observe dialog events.
+ *
+ * ## Features
+ * - Dialog result handling
+ * - Position and size updates
+ * - Event observables (backdrop click, keydown, lifecycle)
+ * - CSS class management
+ * - Focus management integration
+ */
+declare class FuiDialogRef<T = unknown, R = unknown> implements IFuiDialogRef<T, R> {
+    private readonly _overlayRef;
+    private _config;
+    private readonly _id;
+    private _componentInstance;
+    private _result;
+    private _state;
+    private readonly _afterOpened;
+    private readonly _beforeClosed;
+    private readonly _afterClosed;
+    disableClose: boolean;
+    constructor(_overlayRef: FuiOverlayRef, _config: FuiDialogConfig, id?: string);
+    /** Unique ID for this dialog instance */
+    get id(): string;
+    /** The component instance if the dialog was created with a component */
+    get componentInstance(): T | null;
+    /** Sets the component instance (internal use) */
+    set componentInstance(instance: T | null);
+    /** Observable that emits when the dialog has been opened */
+    get afterOpened(): Observable<void>;
+    /** Observable that emits when the dialog has started closing */
+    get beforeClosed(): Observable<R | undefined>;
+    /** Observable that emits when the dialog has finished closing */
+    get afterClosed(): Observable<R | undefined>;
+    /** Observable that emits when the backdrop is clicked */
+    get backdropClick(): Observable<MouseEvent>;
+    /** Observable that emits when a keydown event occurs on the overlay */
+    get keydownEvents(): Observable<KeyboardEvent>;
+    /**
+     * Closes the dialog with an optional result
+     */
+    close(dialogResult?: R): void;
+    /**
+     * Updates the dialog's position
+     */
+    updatePosition(position?: FuiDialogPosition): void;
+    /**
+     * Updates the dialog's dimensions
+     */
+    updateSize(width?: string, height?: string): void;
+    /**
+     * Adds CSS classes to the dialog panel
+     */
+    addPanelClass(classes: string | string[]): void;
+    /**
+     * Removes CSS classes from the dialog panel
+     */
+    removePanelClass(classes: string | string[]): void;
+    /**
+     * Gets the current state of the dialog's lifecycle
+     */
+    getState(): FuiDialogState;
+    /**
+     * Notifies that the dialog has been opened (internal use)
+     */
+    _notifyOpened(): void;
+    private _setupEventHandlers;
+    private _finishDialogClose;
+    private _parseAnimationDuration;
+    private _generateId;
+}
+
+/**
+ * # FuiDialogService
+ *
+ * Service for opening modal dialogs. This service provides a comprehensive
+ * dialog system similar to Angular Material's MatDialog, built on top of
+ * the FuiOverlayService.
+ *
+ * ## Features
+ * - Open dialogs with components or templates
+ * - Pass data to dialog components
+ * - Configure positioning, sizing, and behavior
+ * - Get results from dialogs via observables
+ * - Manage multiple open dialogs
+ * - Automatic focus management and accessibility
+ *
+ * ## Usage
+ *
+ * ### Opening a Component Dialog
+ * ```typescript
+ * const dialogRef = this.dialog.open(MyDialogComponent, {
+ *   width: '400px',
+ *   data: { name: 'John' }
+ * });
+ *
+ * dialogRef.afterClosed().subscribe(result => {
+ *   console.log('Dialog result:', result);
+ * });
+ * ```
+ *
+ * ### Opening a Template Dialog
+ * ```typescript
+ * const dialogRef = this.dialog.open(myTemplateRef, {
+ *   width: '300px',
+ *   hasBackdrop: true
+ * });
+ * ```
+ *
+ * ### Accessing Data in Dialog Component
+ * ```typescript
+ * export class MyDialogComponent {
+ *   private readonly data = inject(FUI_DIALOG_DATA);
+ *   private readonly dialogRef = inject(FuiDialogRef);
+ *
+ *   onClose() {
+ *     this.dialogRef.close('result');
+ *   }
+ * }
+ * ```
+ */
+declare class FuiDialogService {
+    private readonly _overlayService;
+    private readonly _environmentInjector;
+    private readonly _injector;
+    private readonly _appRef;
+    private readonly _openDialogs;
+    private readonly _afterOpenedSubject;
+    private readonly _afterAllClosedSubject;
+    private _nextUniqueId;
+    /**
+     * Observable that emits when a dialog is opened
+     */
+    readonly afterOpened: Observable<IFuiDialogRef>;
+    /**
+     * Observable that emits when all dialogs are closed
+     */
+    readonly afterAllClosed: Observable<void>;
+    /**
+     * Gets all currently open dialogs
+     */
+    get openDialogs(): IFuiDialogRef[];
+    /**
+     * Opens a dialog containing the given component or template
+     * @param componentOrTemplateRef Component type or TemplateRef to display
+     * @param config Configuration options for the dialog
+     * @returns Reference to the opened dialog
+     */
+    open<T, D = unknown, R = unknown>(componentOrTemplateRef: Type<T> | TemplateRef<T>, config?: FuiDialogConfig<D>): FuiDialogRef<T, R>;
+    /**
+     * Closes all open dialogs
+     */
+    closeAll(): void;
+    /**
+     * Gets a dialog by its ID
+     * @param id Dialog ID
+     * @returns The dialog reference or undefined
+     */
+    getDialogById(id: string): IFuiDialogRef | undefined;
+    private _createOverlay;
+    private _getOverlayConfig;
+    private _getBackdropClass;
+    private _getPanelClass;
+    private _attachDialogContainer;
+    private _createDialogRef;
+    private _attachComponentContent;
+    private _attachTemplateContent;
+    private _removeOpenDialog;
+    private _getAfterAllClosed;
+    /**
+     * Opens a confirmation dialog and returns an Observable<boolean>.
+     * Resolves to `true` when confirmed, `false` when cancelled, ESC, or backdrop click.
+     */
+    confirm(config: FuiConfirmDialogConfig): Observable<boolean>;
+    private _applyConfigDefaults;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FuiDialogService>;
+}
+
+/**
+ * # FuiDialogContainerComponent
+ *
+ * Internal container component that hosts the dialog content. This component
+ * handles focus trapping, animations, and accessibility attributes.
+ *
+ * ## Features
+ * - Focus trapping within the dialog
+ * - Configurable ARIA attributes
+ * - Enter/exit animations
+ * - Focus restoration on close
+ */
+declare class FuiDialogContainerComponent implements FuiDialogContainerBase, AfterViewInit, OnDestroy {
+    private readonly _document;
+    private readonly _elementRef;
+    private _dialogContainer;
+    /** Configuration for the dialog */
+    config: FuiDialogConfig;
+    /** The previously focused element before the dialog was opened */
+    private _elementFocusedBeforeDialogWasOpened;
+    /** Animation state of the dialog */
+    readonly animationState: i0.WritableSignal<"void" | "enter" | "exit">;
+    /** Whether the dialog is currently animating */
+    readonly isAnimating: i0.Signal<boolean>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Handles keydown events for focus trap cycling within the dialog.
+     * Tab loops from last to first focusable element, Shift+Tab from first to last.
+     */
+    _onKeydown(event: KeyboardEvent): void;
+    /**
+     * Initializes the dialog container with the given configuration
+     */
+    _initializeWithConfig(config: FuiDialogConfig): void;
+    /**
+     * Starts the enter animation
+     */
+    _startEnterAnimation(): void;
+    /**
+     * Starts the exit animation
+     */
+    _startExitAnimation(): void;
+    /**
+     * Gets the native element of the container
+     */
+    _getHostElement(): HTMLElement;
+    /**
+     * Saves the element that was focused before the dialog opened and traps focus
+     */
+    private _trapFocus;
+    /**
+     * Focuses the first tabbable element within the dialog
+     */
+    private _focusFirstTabbableElement;
+    /**
+     * Focuses the first heading element within the dialog
+     */
+    private _focusFirstHeading;
+    /**
+     * Focuses an element matching the given selector
+     */
+    private _focusBySelector;
+    /**
+     * Gets all focusable elements within the dialog
+     */
+    private _getFocusableElements;
+    /**
+     * Restores focus to the element that was focused before the dialog opened
+     */
+    private _restoreFocus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiDialogContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiDialogContainerComponent, "fui-dialog-container", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class FuiConfirmDialogComponent {
+    private readonly data;
+    private readonly dialogRef;
+    readonly title: string;
+    readonly message: string;
+    readonly confirmText: string;
+    readonly cancelText: string;
+    readonly variant: _raintonic_formaui_services_dialog.FuiConfirmDialogVariant;
+    readonly icon: i0.Signal<"info" | "warning-diamond" | "warning-octagon">;
+    readonly confirmButtonVariant: i0.Signal<"danger" | "primary">;
+    onConfirm(): void;
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiConfirmDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiConfirmDialogComponent, "fui-confirm-dialog", never, {}, {}, never, never, true, never>;
+}
+
+export { FUI_DIALOG_DATA, FUI_DIALOG_DEFAULT_OPTIONS, FuiConfirmDialogComponent, FuiDialogContainerComponent, FuiDialogRef, FuiDialogService };
+export type { FuiAutoFocusTarget, FuiConfirmDialogConfig, FuiConfirmDialogVariant, FuiDialogConfig, FuiDialogContainerBase, FuiDialogOpenResult, FuiDialogPosition, FuiDialogRole, FuiDialogState, IFuiDialogRef };
+//# sourceMappingURL=raintonic-formaui-services-dialog.d.ts.map

package/types/raintonic-formaui-services-dialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-services-dialog.d.ts","sources":["../../../lib/services/dialog/dialog.types.ts","../../../lib/services/dialog/dialog-ref.ts","../../../lib/services/dialog/dialog.service.ts","../../../lib/services/dialog/dialog-container.component.ts","../../../lib/services/dialog/confirm-dialog.component.ts"],"mappings":"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","names":["_angular_core"]}