@raintonic/formaui 0.2.0

package/types/raintonic-formaui-cdk-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-cdk-overlay.d.ts","sources":["../../../lib/cdk/overlay/overlay.types.ts","../../../lib/cdk/overlay/position/global-position-strategy.ts","../../../lib/cdk/overlay/position/connected-position-strategy.ts","../../../lib/cdk/overlay/scroll/scroll-strategies.ts","../../../lib/cdk/overlay/overlay.service.ts","../../../lib/cdk/overlay/overlay-ref.ts","../../../lib/cdk/overlay/overlay-container.component.ts","../../../lib/cdk/overlay/portal.service.ts"],"mappings":"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","names":[]}

package/types/raintonic-formaui-cdk-virtual-scroll.d.ts

@@ -0,0 +1,112 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy, AfterViewInit, ElementRef, DoCheck, TrackByFunction } from '@angular/core';
+
+/** Range of items currently rendered in the DOM */
+interface FuiListRange {
+    start: number;
+    end: number;
+}
+/** Virtual scroll item context passed to templates */
+interface FuiVirtualForContext<T> {
+    $implicit: T;
+    index: number;
+    count: number;
+    first: boolean;
+    last: boolean;
+    even: boolean;
+    odd: boolean;
+}
+/** Scroll event info emitted by the viewport */
+interface FuiVirtualScrollEvent {
+    firstVisibleIndex: number;
+    lastVisibleIndex: number;
+    scrollOffset: number;
+}
+/** Orientation of the virtual scroll */
+type FuiVirtualScrollOrientation = 'vertical' | 'horizontal';
+
+declare class FuiVirtualScrollViewportComponent implements OnInit, OnDestroy, AfterViewInit {
+    /** Fixed size of each item in pixels */
+    readonly itemSize: _angular_core.InputSignal<number>;
+    /** Minimum buffer in pixels to render before the visible area */
+    readonly minBufferPx: _angular_core.InputSignal<number>;
+    /** Maximum buffer in pixels to render after the visible area */
+    readonly maxBufferPx: _angular_core.InputSignal<number>;
+    /** Scroll orientation */
+    readonly orientation: _angular_core.InputSignal<FuiVirtualScrollOrientation>;
+    /** Emits the first visible index on scroll */
+    readonly scrolledIndexChange: _angular_core.OutputEmitterRef<number>;
+    /** Emits the rendered range when it changes */
+    readonly renderedRangeChange: _angular_core.OutputEmitterRef<FuiListRange>;
+    /** Current rendered range (shared with fuiVirtualFor directive) */
+    readonly _renderedRange: _angular_core.WritableSignal<{
+        start: number;
+        end: number;
+    }>;
+    /** Total number of items in the data source */
+    readonly _totalItems: _angular_core.WritableSignal<number>;
+    /** Total content size in pixels */
+    readonly _totalContentSize: _angular_core.Signal<number>;
+    _contentWrapper: ElementRef<HTMLElement>;
+    private readonly _elementRef;
+    private readonly _ngZone;
+    private _rafId;
+    private _lastScrollOffset;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** Scroll event handler - throttled via requestAnimationFrame */
+    _onScroll(): void;
+    /** Scrolls the viewport to bring the given index into view */
+    scrollToIndex(index: number, behavior?: ScrollBehavior): void;
+    /** Scrolls the viewport to a specific pixel offset */
+    scrollToOffset(offset: number, behavior?: ScrollBehavior): void;
+    /** Returns the current rendered range */
+    getRenderedRange(): FuiListRange;
+    /** Measures and returns the viewport size (height or width depending on orientation) */
+    measureViewportSize(): number;
+    /** Called by fuiVirtualFor to set the total item count */
+    _setTotalItems(count: number): void;
+    /** Recalculates which items should be rendered based on current scroll position */
+    private _updateRenderedRange;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiVirtualScrollViewportComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiVirtualScrollViewportComponent, "fui-virtual-scroll-viewport", never, { "itemSize": { "alias": "itemSize"; "required": true; "isSignal": true; }; "minBufferPx": { "alias": "minBufferPx"; "required": false; "isSignal": true; }; "maxBufferPx": { "alias": "maxBufferPx"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, { "scrolledIndexChange": "scrolledIndexChange"; "renderedRangeChange": "renderedRangeChange"; }, never, ["*"], true, never>;
+}
+
+declare class FuiVirtualForDirective<T> implements OnDestroy, DoCheck {
+    /** The data array to iterate over */
+    readonly fuiVirtualForOf: _angular_core.InputSignal<T[]>;
+    /** Optional trackBy function for identity tracking */
+    readonly fuiVirtualForTrackBy: _angular_core.InputSignal<TrackByFunction<T> | undefined>;
+    private readonly _viewport;
+    private readonly _viewContainerRef;
+    private readonly _templateRef;
+    /** Pool of detached views available for reuse */
+    private _viewCache;
+    /** Currently attached views in the container */
+    private _renderedViews;
+    /** Previous data reference for change detection */
+    private _previousData;
+    constructor();
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    /**
+     * Renders items within the given range [start, end).
+     * Recycles views from the cache when possible.
+     */
+    private _renderRange;
+    /** Updates the context of an existing embedded view */
+    private _updateContext;
+    /** Detaches all rendered views and moves them to the cache */
+    private _detachAllViews;
+    /** Destroys all cached views */
+    private _destroyCache;
+    /** Static method for Angular's type inference in templates */
+    static ngTemplateContextGuard<T>(_dir: FuiVirtualForDirective<T>, _ctx: unknown): _ctx is FuiVirtualForContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiVirtualForDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FuiVirtualForDirective<any>, "[fuiVirtualFor][fuiVirtualForOf]", never, { "fuiVirtualForOf": { "alias": "fuiVirtualForOf"; "required": true; "isSignal": true; }; "fuiVirtualForTrackBy": { "alias": "fuiVirtualForTrackBy"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { FuiVirtualForDirective, FuiVirtualScrollViewportComponent };
+export type { FuiListRange, FuiVirtualForContext, FuiVirtualScrollEvent, FuiVirtualScrollOrientation };
+//# sourceMappingURL=raintonic-formaui-cdk-virtual-scroll.d.ts.map

package/types/raintonic-formaui-cdk-virtual-scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-cdk-virtual-scroll.d.ts","sources":["../../../lib/cdk/virtual-scroll/virtual-scroll.types.ts","../../../lib/cdk/virtual-scroll/fui-virtual-scroll-viewport.component.ts","../../../lib/cdk/virtual-scroll/fui-virtual-for.directive.ts"],"mappings":";;;AAAA;UACiB,YAAY;;;AAG5B;AAED;AACM,UAAW,oBAAoB;;;;;;;;AAQpC;AAED;UACiB,qBAAqB;;;;AAIrC;AAED;KACY,2BAA2B;;ACNvC,cAca,iCAAkC,YAAW,MAAM,EAAE,SAAS,EAAE,aAAa;;uBAEvE,aAAA,CAAA,WAAA;;0BAGG,aAAA,CAAA,WAAA;;0BAGA,aAAA,CAAA,WAAA;;0BAGA,aAAA,CAAA,WAAA,CAAA,2BAAA;;kCAGQ,aAAA,CAAA,gBAAA;;kCAGA,aAAA,CAAA,gBAAA,CAAA,YAAA;;AAG5B,6BAAuB,aAAA,CAAA,cAAA;;;AAAgC;;0BAGnC,aAAA,CAAA,cAAA;;gCAGM,aAAA,CAAA,MAAA;AAEqB,qBAAkB,UAAU,CAAC,WAAW;AAEvF;AACA;;;AAKA;AAMA;AAIA;;AAQA;;4CAWuC,cAAuB;;8CAMrB,cAAuB;;AAYhE,wBAAoB,YAAY;;AAKhC;;AAMA;;AAMA;oDApGW,iCAAiC;sDAAjC,iCAAiC;AA4I7C;;AC3JD,cAIa,sBAAsB,eAAe,SAAS,EAAE,OAAO;;8BAE1C,aAAA,CAAA,WAAA;;mCAGK,aAAA,CAAA,WAAA,CAAA,eAAA;AAE7B;AACA;AACA;;;;;;;;AAyBA;AASA;AAKA;;;AAGG;AACH;;AAkDA;;AAYA;;AAWA;;2CAQuC,sBAAsB,6BAA6B,oBAAoB;oDArInG,sBAAsB;sDAAtB,sBAAsB;AAwIlC;;;;","names":[]}

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

@@ -0,0 +1,124 @@
+import * as _angular_core from '@angular/core';
+import { WritableSignal, InjectionToken } from '@angular/core';
+
+/**
+ * # ExpansionPanel Component
+ *
+ * A collapsible panel that can be used standalone or within an `fui-accordion`.
+ * Supports lazy rendering of content (only rendered after first open).
+ *
+ * ## Usage
+ *
+ * ### Standalone
+ * ```html
+ * <fui-expansion-panel>
+ *   <span panelTitle>Panel Title</span>
+ *   <p>Panel content here</p>
+ * </fui-expansion-panel>
+ * ```
+ *
+ * ### Inside Accordion
+ * ```html
+ * <fui-accordion>
+ *   <fui-expansion-panel>
+ *     <span panelTitle>First</span>
+ *     Content 1
+ *   </fui-expansion-panel>
+ *   <fui-expansion-panel>
+ *     <span panelTitle>Second</span>
+ *     Content 2
+ *   </fui-expansion-panel>
+ * </fui-accordion>
+ * ```
+ */
+declare class FuiExpansionPanelComponent {
+    readonly expanded: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly hideToggle: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly expandedChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly afterExpand: _angular_core.OutputEmitterRef<void>;
+    readonly afterCollapse: _angular_core.OutputEmitterRef<void>;
+    readonly _expanded: WritableSignal<boolean>;
+    readonly _animating: WritableSignal<boolean>;
+    readonly _hasBeenOpened: WritableSignal<boolean>;
+    private readonly _panelId;
+    readonly _headerId: string;
+    readonly _contentId: string;
+    private readonly _accordion;
+    private readonly _elementRef;
+    constructor();
+    /** Toggles the expanded state of the panel. */
+    toggle(): void;
+    /** Opens the panel. */
+    open(): void;
+    /** Closes the panel. */
+    close(): void;
+    /** Called when the body transition ends. */
+    _onBodyTransitionEnd(event: TransitionEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiExpansionPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiExpansionPanelComponent, "fui-expansion-panel", never, { "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "hideToggle": { "alias": "hideToggle"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; "expandedChange": "expandedChange"; "afterExpand": "afterExpand"; "afterCollapse": "afterCollapse"; }, never, ["[panelTitle]", "[panelDescription]", "*"], true, never>;
+}
+
+type AccordionDisplayMode = 'default' | 'flat';
+interface AccordionExpandedChange {
+    source: unknown;
+    expanded: boolean;
+}
+declare const FUI_ACCORDION: InjectionToken<unknown>;
+
+/**
+ * # Accordion Component
+ *
+ * Groups multiple `fui-expansion-panel` components.
+ * In single mode (default), only one panel can be expanded at a time.
+ * In multi mode, multiple panels can be expanded simultaneously.
+ *
+ * ## Usage
+ *
+ * ### Single mode (default)
+ * ```html
+ * <fui-accordion>
+ *   <fui-expansion-panel>
+ *     <span panelTitle>Panel 1</span>
+ *     Content 1
+ *   </fui-expansion-panel>
+ *   <fui-expansion-panel>
+ *     <span panelTitle>Panel 2</span>
+ *     Content 2
+ *   </fui-expansion-panel>
+ * </fui-accordion>
+ * ```
+ *
+ * ### Multi mode
+ * ```html
+ * <fui-accordion [multi]="true">
+ *   ...
+ * </fui-accordion>
+ * ```
+ *
+ * ### Flat display mode
+ * ```html
+ * <fui-accordion displayMode="flat">
+ *   ...
+ * </fui-accordion>
+ * ```
+ */
+declare class FuiAccordionComponent {
+    readonly multi: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly displayMode: _angular_core.InputSignal<AccordionDisplayMode>;
+    readonly panels: _angular_core.Signal<readonly FuiExpansionPanelComponent[]>;
+    /** Opens all panels. Only effective in multi mode. */
+    openAll(): void;
+    /** Closes all panels. */
+    closeAll(): void;
+    /** Closes all panels except the specified one. Used internally by panels. */
+    _closeOtherPanels(openedPanel: FuiExpansionPanelComponent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiAccordionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiAccordionComponent, "fui-accordion", never, { "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "displayMode": { "alias": "displayMode"; "required": false; "isSignal": true; }; }, {}, ["panels"], ["*"], true, never>;
+}
+
+export { FUI_ACCORDION, FuiAccordionComponent, FuiExpansionPanelComponent };
+export type { AccordionDisplayMode, AccordionExpandedChange };
+//# sourceMappingURL=raintonic-formaui-components-accordion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-accordion.d.ts","sources":["../../../lib/components/accordion/expansion-panel.component.ts","../../../lib/components/accordion/accordion.types.ts","../../../lib/components/accordion/accordion.component.ts"],"mappings":";;;AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;AACH,cAea,0BAA0B;uBAEpB,aAAA,CAAA,wBAAA;uBACA,aAAA,CAAA,wBAAA;yBACE,aAAA,CAAA,wBAAA;qBAGJ,aAAA,CAAA,gBAAA;qBACA,aAAA,CAAA,gBAAA;6BACQ,aAAA,CAAA,gBAAA;0BACH,aAAA,CAAA,gBAAA;4BACE,aAAA,CAAA,gBAAA;AAGtB,wBAAoB,cAAc;AAClC,yBAAqB,cAAc;AACnC,6BAAyB,cAAc;AAGvC;;;AAKA;AAMA;;;AAcA;;AAYA;;AAkBA;;AAYA,gCAA4B,eAAe;oDAtFhC,0BAA0B;sDAA1B,0BAA0B;AAgGtC;;KC7JW,oBAAoB;UAEf,uBAAuB;;;AAGvC;AAED,cAAa,aAAa,EAAA,cAAA;;ACE1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCG;AACH,cAaa,qBAAqB;oBAElB,aAAA,CAAA,wBAAA;0BACM,aAAA,CAAA,WAAA,CAAA,oBAAA;qBAGL,aAAA,CAAA,MAAA,UAAA,0BAAA;;AAGf;;AAUA;;AAOA,mCAA+B,0BAA0B;oDA1B9C,qBAAqB;sDAArB,qBAAqB;AAoCjC;;;;","names":[]}

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

@@ -0,0 +1,143 @@
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+
+type FuiAlertVariant = 'primary' | 'success' | 'info' | 'warning' | 'error' | 'generic';
+declare const FUI_ALERT_VARIANTS: readonly FuiAlertVariant[];
+/**
+ * Configuration for notification display
+ */
+interface FuiNotificationConfig {
+    /**
+     * Notification variant (determines color scheme and icon)
+     */
+    variant: FuiAlertVariant;
+    /**
+     * Title of the notification
+     */
+    title: string;
+    /**
+     * Description/message of the notification
+     */
+    description?: string;
+    /**
+     * Duration in milliseconds before auto-dismiss (default: 5000)
+     * Set to 0 to disable auto-dismiss
+     */
+    duration?: number;
+    /**
+     * Whether to show the close button (default: true)
+     */
+    closeable?: boolean;
+    /**
+     * Custom icon name (overrides default variant icon)
+     */
+    icon?: string;
+}
+/**
+ * Position for notification display
+ */
+type FuiNotificationPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+declare const FUI_NOTIFICATION_POSITIONS: readonly FuiNotificationPosition[];
+
+/**
+ * # FuiAlertComponent
+ *
+ * A flexible alert component for displaying informational messages, warnings, errors, and success notifications.
+ * Can be used inline in pages or as part of the notification system.
+ *
+ * ## Features
+ * - Multiple variants: primary, success, info, warning, error, generic
+ * - Title and description support
+ * - Optional close button
+ * - Custom or default icons per variant
+ * - Accessible with ARIA attributes
+ *
+ * ## Usage
+ *
+ * ### Basic Alert
+ * ```html
+ * <fui-alert
+ *   variant="success"
+ *   title="Success!"
+ *   description="Your changes have been saved."
+ * ></fui-alert>
+ * ```
+ *
+ * ### Closeable Alert
+ * ```html
+ * <fui-alert
+ *   variant="warning"
+ *   title="Warning"
+ *   description="Please review before continuing."
+ *   [closeable]="true"
+ *   (closed)="onAlertClosed()"
+ * ></fui-alert>
+ * ```
+ *
+ * ### Custom Icon
+ * ```html
+ * <fui-alert
+ *   variant="info"
+ *   title="Custom Icon"
+ *   icon="custom-icon-name"
+ * ></fui-alert>
+ * ```
+ */
+declare class FuiAlertComponent {
+    /**
+     * Alert variant (determines color scheme and default icon)
+     */
+    readonly variant: _angular_core.InputSignalWithTransform<FuiAlertVariant, string>;
+    /**
+     * Alert title (required)
+     */
+    readonly title: _angular_core.InputSignal<string>;
+    /**
+     * Progress (optional)
+     * 0 = turned off
+     * -1 = indeterminate
+     */
+    readonly progress: _angular_core.InputSignal<number>;
+    /**
+     * Alert description (optional)
+     */
+    readonly description: _angular_core.InputSignal<string | null>;
+    /**
+     * Whether to show the close button
+     */
+    readonly closeable: _angular_core.InputSignal<boolean>;
+    /**
+     * Custom icon name (overrides default variant icon)
+     */
+    readonly icon: _angular_core.InputSignal<string | null>;
+    /**
+     * Emits when the close button is clicked
+     */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Computed CSS classes for the alert
+     */
+    readonly computedClasses: Signal<string>;
+    /**
+     * Computed ARIA role: "alert" for error/warning, "status" for info/success/primary/generic
+     */
+    readonly computedRole: Signal<string>;
+    /**
+     * Computed aria-live: "assertive" for errors, "polite" for everything else
+     */
+    readonly computedAriaLive: Signal<string>;
+    /**
+     * Computed icon name based on variant or custom icon
+     */
+    readonly computedIcon: Signal<string>;
+    /**
+     * Handle close button click
+     */
+    onClose(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiAlertComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiAlertComponent, "fui-alert", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": true; "isSignal": true; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "closeable": { "alias": "closeable"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, never, true, never>;
+}
+
+export { FUI_ALERT_VARIANTS, FUI_NOTIFICATION_POSITIONS, FuiAlertComponent };
+export type { FuiAlertVariant, FuiNotificationConfig, FuiNotificationPosition };
+//# sourceMappingURL=raintonic-formaui-components-alert.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-alert.d.ts","sources":["../../../lib/components/alert/alert.types.ts","../../../lib/components/alert/alert.component.ts"],"mappings":";;;AAAM,KAAM,eAAe;AAE3B,cAAa,kBAAkB,WAAW,eAAe;AASzD;;AAEG;UACc,qBAAqB;AACpC;;AAEG;aACM,eAAe;AAExB;;AAEG;;AAGH;;AAEG;;AAGH;;;AAGG;;AAGH;;AAEG;;AAGH;;AAEG;;AAEJ;AAED;;AAEG;AACG,KAAM,uBAAuB;AAQnC,cAAa,0BAA0B,WAAW,uBAAuB;;ACrDzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CG;AACH,cAca,iBAAiB;AAC5B;;AAEG;sBACa,aAAA,CAAA,wBAAA,CAAA,eAAA;AAIhB;;AAEG;oBACW,aAAA,CAAA,WAAA;AAEd;;;;AAIG;uBACc,aAAA,CAAA,WAAA;AAEjB;;AAEG;0BACiB,aAAA,CAAA,WAAA;AAEpB;;AAEG;wBACe,aAAA,CAAA,WAAA;AAElB;;AAEG;mBACU,aAAA,CAAA,WAAA;AAEb;;AAEG;qBACY,aAAA,CAAA,gBAAA;AAEf;;AAEG;AACH,8BAA0B,MAAM;AAMhC;;AAEG;AACH,2BAAuB,MAAM;AAK7B;;AAEG;AACH,+BAA2B,MAAM;AAIjC;;AAEG;AACH,2BAAuB,MAAM;AAmB7B;;AAEG;AACH;oDAzFW,iBAAiB;sDAAjB,iBAAiB;AA4F7B;;;;","names":[]}

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

@@ -0,0 +1,193 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, DoCheck, OnDestroy, InputSignal, OutputEmitterRef, WritableSignal, Signal, ElementRef } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { FuiFormFieldControl, ErrorStateMatcher } from '@raintonic/formaui/core';
+import { FuiOptionComponent } from '@raintonic/formaui/components/select';
+
+/**
+ * Injection token used to provide the parent autocomplete to options
+ */
+declare const FUI_AUTOCOMPLETE: InjectionToken<FuiAutocompleteComponent>;
+/**
+ * Selection change event object emitted when the autocomplete's selection changes
+ */
+interface FuiAutocompleteChange {
+    source: FuiAutocompleteComponent;
+    value: unknown;
+}
+/**
+ * # fui-autocomplete Component
+ *
+ * An autocomplete component designed to work seamlessly with fui-form-field.
+ * Similar to Angular Material's mat-autocomplete integration with mat-form-field.
+ * Provides full Reactive Forms support with validation, filtering, and optional
+ * add/refresh actions.
+ *
+ * ## Features
+ * - Works inside fui-form-field like mat-autocomplete
+ * - Full Reactive Forms integration (ControlValueAccessor)
+ * - Options via projected content (fui-option)
+ * - Built-in search/filter input in the panel
+ * - Optional "Add New" and "Refresh" action buttons
+ * - Disabled and readonly states
+ * - Full accessibility support
+ * - Full keyboard navigation (Arrow keys, Enter, Escape, Home, End, PageUp, PageDown)
+ * - Uses overlay service for proper positioning
+ *
+ * ## Usage
+ *
+ * ### Basic Autocomplete with Form Field
+ * ```html
+ * <fui-form-field>
+ *   <label>Country</label>
+ *   <fui-autocomplete placeholder="Search countries...">
+ *     <fui-option value="us">United States</fui-option>
+ *     <fui-option value="ca">Canada</fui-option>
+ *     <fui-option value="mx">Mexico</fui-option>
+ *   </fui-autocomplete>
+ * </fui-form-field>
+ * ```
+ *
+ * ### With Reactive Forms and Validation
+ * ```html
+ * <form [formGroup]="form">
+ *   <fui-form-field>
+ *     <label>Country</label>
+ *     <fui-autocomplete formControlName="country" placeholder="Select a country">
+ *       <fui-option value="us">United States</fui-option>
+ *       <fui-option value="ca">Canada</fui-option>
+ *     </fui-autocomplete>
+ *     <fui-error *ngIf="form.get('country')?.hasError('required')">
+ *       Country is required
+ *     </fui-error>
+ *   </fui-form-field>
+ * </form>
+ * ```
+ *
+ * ### With Add/Refresh Buttons
+ * ```html
+ * <fui-form-field>
+ *   <label>Category</label>
+ *   <fui-autocomplete
+ *     placeholder="Search categories..."
+ *     [showAddButton]="true"
+ *     [showRefreshButton]="true"
+ *     (addNew)="openAddCategoryDialog()"
+ *     (refresh)="refreshCategories()">
+ *     @for (category of categories; track category.id) {
+ *       <fui-option [value]="category.id">{{ category.name }}</fui-option>
+ *     }
+ *   </fui-autocomplete>
+ * </fui-form-field>
+ * ```
+ */
+declare class FuiAutocompleteComponent implements ControlValueAccessor, FuiFormFieldControl, DoCheck, OnDestroy {
+    static nextId: number;
+    readonly controlType = "fui-autocomplete";
+    readonly placeholderInput: InputSignal<string>;
+    readonly disabledInput: InputSignal<boolean>;
+    readonly readonly: InputSignal<boolean>;
+    readonly showAddButton: InputSignal<boolean>;
+    readonly showRefreshButton: InputSignal<boolean>;
+    readonly addButtonLabel: InputSignal<string>;
+    readonly refreshButtonLabel: InputSignal<string>;
+    readonly noOptionsText: InputSignal<string>;
+    readonly searchPlaceholder: InputSignal<string>;
+    readonly errorStateMatcher: InputSignal<ErrorStateMatcher | null>;
+    /**
+     * Whether to compare option values using object identity or deep equality
+     */
+    readonly compareWith: InputSignal<(o1: unknown, o2: unknown) => boolean>;
+    readonly valueChange: OutputEmitterRef<unknown>;
+    readonly selectionChange: OutputEmitterRef<FuiAutocompleteChange>;
+    readonly openedChange: OutputEmitterRef<boolean>;
+    readonly addNew: OutputEmitterRef<void>;
+    readonly refresh: OutputEmitterRef<void>;
+    readonly searchChange: OutputEmitterRef<string>;
+    private readonly _value;
+    private readonly _focused;
+    private readonly _disabled;
+    readonly _readOnly: WritableSignal<boolean>;
+    readonly stateChanges: Subject<void>;
+    private _uid;
+    _ariaDescribedby: string | null;
+    private readonly _errorState;
+    readonly errorState: WritableSignal<boolean>;
+    private _parentForm;
+    private _parentFormGroup;
+    private _defaultErrorStateMatcher;
+    private readonly _ngControlRef;
+    get ngControl(): NgControl | null;
+    readonly placeholder: Signal<string>;
+    private readonly _required;
+    readonly required: WritableSignal<boolean>;
+    readonly value: WritableSignal<unknown>;
+    readonly focused: WritableSignal<boolean>;
+    private readonly _ngControlDisabled;
+    readonly disabled: Signal<boolean>;
+    readonly empty: Signal<boolean>;
+    readonly id: string;
+    trigger?: ElementRef<HTMLDivElement>;
+    panel?: ElementRef<HTMLDivElement>;
+    searchInput?: ElementRef<HTMLInputElement>;
+    readonly options: Signal<readonly FuiOptionComponent[]>;
+    readonly panelOpen: WritableSignal<boolean>;
+    readonly searchTerm: WritableSignal<string>;
+    readonly activeOptionIndex: WritableSignal<number>;
+    readonly _liveAnnouncement: WritableSignal<string>;
+    _announce(message: string): void;
+    private _overlayRef;
+    private _overlaySubscriptions;
+    private readonly _overlayService;
+    private readonly _elementRef;
+    private readonly _document;
+    private readonly _ngZone;
+    private _outsideClickSub?;
+    private _onChange;
+    private _onTouched;
+    readonly displayValue: Signal<string>;
+    readonly filteredOptions: Signal<FuiOptionComponent[]>;
+    readonly hasFilteredOptions: Signal<boolean>;
+    constructor();
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onContainerClick(_event: MouseEvent): void;
+    setDescribedByIds(ids: string[]): void;
+    setReadOnly(readOnly: boolean): void;
+    clear(event: Event): void;
+    focus(): void;
+    blur(): void;
+    toggle(): void;
+    open(): void;
+    close(): void;
+    _onOptionSelected(option: FuiOptionComponent): void;
+    onSearchInput(event: Event): void;
+    onAddNew(): void;
+    onRefresh(): void;
+    _getDisplayValue(): string;
+    _handleKeydown(event: KeyboardEvent): void;
+    private _handleClosedKeydown;
+    _handlePanelKeydown(event: KeyboardEvent): void;
+    private _handleOpenKeydown;
+    private _setNextActiveOption;
+    private _setActiveOptionIndex;
+    private _setInitialActiveOption;
+    private _scrollToActiveOption;
+    private _listenForOutsideClicks;
+    private _createOverlay;
+    private _disposeOverlay;
+    _getActiveDescendant(): string | null;
+    setActiveOption(index: number, option: FuiOptionComponent): void;
+    get selected(): unknown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiAutocompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiAutocompleteComponent, "fui-autocomplete", never, { "placeholderInput": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "showAddButton": { "alias": "showAddButton"; "required": false; "isSignal": true; }; "showRefreshButton": { "alias": "showRefreshButton"; "required": false; "isSignal": true; }; "addButtonLabel": { "alias": "addButtonLabel"; "required": false; "isSignal": true; }; "refreshButtonLabel": { "alias": "refreshButtonLabel"; "required": false; "isSignal": true; }; "noOptionsText": { "alias": "noOptionsText"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "selectionChange": "selectionChange"; "openedChange": "openedChange"; "addNew": "addNew"; "refresh": "refresh"; "searchChange": "searchChange"; }, ["options"], ["*"], true, never>;
+}
+
+export { FUI_AUTOCOMPLETE, FuiAutocompleteComponent };
+export type { FuiAutocompleteChange };
+//# sourceMappingURL=raintonic-formaui-components-autocomplete.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-autocomplete.d.ts","sources":["../../../lib/components/autocomplete/autocomplete.component.ts"],"mappings":";;;;;;;AA0CA;;AAEG;AACH,cAAa,gBAAgB,EAAA,cAAA,CAAA,wBAAA;AAE7B;;AAEG;UACc,qBAAqB;YAC5B,wBAAwB;;AAEjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiEG;AACH,cAiCa,wBAAyB,YAAW,oBAAoB,EAAE,mBAAmB,EAAE,OAAO,EAAE,SAAS;;;AAM5G,+BAA2B,WAAW;AAGtC,4BAAwB,WAAW;AAGnC,uBAAmB,WAAW;AAC9B,4BAAwB,WAAW;AACnC,gCAA4B,WAAW;AACvC,6BAAyB,WAAW;AACpC,iCAA6B,WAAW;AACxC,4BAAwB,WAAW;AACnC,gCAA4B,WAAW;gCACX,WAAW,CAAC,iBAAiB;AAEzD;;AAEG;AACH,0BAAsB,WAAW;AAKjC,0BAAsB,gBAAgB;AACtC,8BAA0B,gBAAgB,CAAC,qBAAqB;AAChE,2BAAuB,gBAAgB;AACvC,qBAAiB,gBAAgB;AACjC,sBAAkB,gBAAgB;AAClC,2BAAuB,gBAAgB;AAGvC;AACA;AACA;AACA,wBAAoB,cAAc;2BAGb,OAAA;;AAErB;AAGA;yBACmB,cAAA;;;;AAMnB;AACA,qBAAiB,SAAS;0BAKN,MAAA;AACpB;uBACiB,cAAA;oBAEH,cAAA;sBACE,cAAA;AAEhB;uBACiB,MAAA;oBAEH,MAAA;;AAQ2B,cAAU,UAAU,CAAC,cAAc;AACrC,YAAQ,UAAU,CAAC,cAAc;AAExE,kBAAc,UAAU,CAAC,gBAAgB;sBAGzB,MAAA,UAAA,kBAAA;wBAGE,cAAA;AAGlB,yBAAqB,cAAc;AAGnC,gCAA4B,cAAc;gCAGhB,cAAA;AAE1B;;;AAYA;AACA;AACA;AACA;;;;AAYA,2BAAuB,MAAM;8BAaH,MAAM,CAAC,kBAAkB;AAWnD,iCAA6B,MAAM;;AAoDnC;AAgBA;AAOA;;AASA;AAIA;AAMA,6BAAyB,UAAU;AAMnC;AAIA;AAKA,iBAAa,KAAK;AASlB;AAIA;AAKA;AAUA;AAsBA;AAwBA,8BAA0B,kBAAkB;AAuB5C,yBAAqB,KAAK;AAgB1B;AAMA;AAOA;AAKA,0BAAsB,aAAa;AAanC;AAeA,+BAA2B,aAAa;AA8DxC;AAMA;AAsBA;AAkBA;AAqBA;AA4BA;AA8BA;AA+DA;;2CAmBuC,kBAAkB;;yCA/qB9C,wBAAwB;2CAAxB,wBAAwB;AA4rBpC;;;;","names":[]}

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

@@ -0,0 +1,52 @@
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+
+type FuiAvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/**
+ * @component FuiAvatarComponent
+ * @selector fui-avatar
+ * @description Displays a user avatar with image, initials fallback, and configurable shape/size.
+ * Automatically computes initials from name fields and generates a background color from an identity key.
+ *
+ * @input size - Avatar size: 'xs' | 'sm' | 'md' | 'lg' | 'xl' or a numeric pixel value. Default 'md'.
+ * @input shape - Avatar shape: 'circle' | 'rounded' | 'square'. Default 'circle'.
+ * @input src - Image URL or data URI for the avatar.
+ * @input avatarUrl - Backward-compatible alias for src.
+ * @input srcSet - HTML srcset attribute for responsive images.
+ * @input sizesAttr - HTML sizes attribute for responsive images.
+ * @input name - First name used to compute initials.
+ * @input surname - Last name used to compute initials.
+ * @input fullName - Full name (overrides name + surname for initials).
+ * @input alt - Alt text for the image element.
+ * @input identityKey - Key (e.g. email) used to deterministically pick a background color.
+ *
+ * @example
+ * <fui-avatar [src]="user.photoUrl" [fullName]="user.displayName" size="lg"></fui-avatar>
+ */
+declare class FuiAvatarComponent {
+    readonly size: _angular_core.InputSignal<number | FuiAvatarSize>;
+    readonly shape: _angular_core.InputSignal<"circle" | "rounded" | "square">;
+    readonly src: _angular_core.InputSignal<string | null>;
+    readonly avatarUrl: _angular_core.InputSignal<string | null>;
+    readonly srcSet: _angular_core.InputSignal<string | null>;
+    readonly sizesAttr: _angular_core.InputSignal<string | null>;
+    readonly name: _angular_core.InputSignal<string | null>;
+    readonly surname: _angular_core.InputSignal<string | null>;
+    readonly fullName: _angular_core.InputSignal<string | null>;
+    readonly alt: _angular_core.InputSignal<string | null>;
+    readonly identityKey: _angular_core.InputSignal<string | null>;
+    private readonly imageFailed;
+    readonly normalizedName: Signal<string>;
+    readonly initials: Signal<string>;
+    readonly pixelSize: Signal<number>;
+    readonly displayImage: Signal<string | null>;
+    readonly bgColor: Signal<string>;
+    readonly ariaLabel: Signal<string>;
+    onImgError(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiAvatarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiAvatarComponent, "fui-avatar", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "src": { "alias": "src"; "required": false; "isSignal": true; }; "avatarUrl": { "alias": "avatarUrl"; "required": false; "isSignal": true; }; "srcSet": { "alias": "srcSet"; "required": false; "isSignal": true; }; "sizesAttr": { "alias": "sizesAttr"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "surname": { "alias": "surname"; "required": false; "isSignal": true; }; "fullName": { "alias": "fullName"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "identityKey": { "alias": "identityKey"; "required": false; "isSignal": true; }; }, {}, never, ["[avatar-badge]"], true, never>;
+}
+
+export { FuiAvatarComponent };
+export type { FuiAvatarSize };
+//# sourceMappingURL=raintonic-formaui-components-avatar.d.ts.map