@raintonic/formaui 0.3.1 → 0.9.0

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

@@ -1,49 +1,29 @@
+import * as _raintonic_formaui_components_select from '@raintonic/formaui/components/select';
 import * as i0 from '@angular/core';
-import { OnDestroy, AfterViewInit, InputSignal, OutputEmitterRef, WritableSignal, InjectionToken, DoCheck, AfterContentInit, Signal, ElementRef } from '@angular/core';
+import { InjectionToken, OnDestroy, InputSignal, OutputEmitterRef, WritableSignal, ElementRef, Signal, AfterContentInit, AfterViewInit } from '@angular/core';
 import { Subject } from 'rxjs';
 import { ControlValueAccessor, NgControl } from '@angular/forms';
 import { FuiFormFieldControl, ErrorStateMatcher } from '@raintonic/formaui/core';
+import * as i1 from '@raintonic/formaui/cdk/form-field';
 
 /**
- * # FuiOption Component
- *
- * Individual option component for use within fui-select.
- * Works like Angular Material's mat-option with full accessibility support.
- *
- * ## Features
- * - Disabled state support
- * - Selection state management
- * - Full accessibility support (ARIA attributes)
- * - Keyboard navigation support
- * - Custom content projection
- * - Smooth hover animations
+ * Injection token for querying all option-like components
+ * via contentChildren from parent components.
  *
- * ## Usage
+ * FuiOptionComponent provides this token so a single
+ * contentChildren(FUI_OPTION) query captures all options.
+ */
+declare const FUI_OPTION: InjectionToken<FuiOptionBase>;
+/**
+ * Abstract base class for FuiOptionComponent.
  *
- * ### Basic Option
- * ```html
- * <fui-select placeholder="Select a status">
- *   <fui-option value="active">Active</fui-option>
- *   <fui-option value="inactive">Inactive</fui-option>
- *   <fui-option value="pending" [disabled]="true">Pending (Disabled)</fui-option>
- * </fui-select>
- * ```
+ * Defines the contract that parent components rely on.
+ * FuiOptionComponent provides FUI_OPTION for DI-based querying.
  *
- * ### Option with Custom Content
- * ```html
- * <fui-select placeholder="Select a country">
- *   <fui-option value="us">
- *     <fui-icon name="flag-us"></fui-icon>
- *     United States
- *   </fui-option>
- *   <fui-option value="ca">
- *     <fui-icon name="flag-ca"></fui-icon>
- *     Canada
- *   </fui-option>
- * </fui-select>
- * ```
+ * Uses @Directive() so Angular recognises input()/output()/signal()/HostListener
+ * calls as valid (they are only valid on @Component or @Directive classes).
  */
-declare class FuiOptionComponent implements OnDestroy, AfterViewInit {
+declare abstract class FuiOptionBase implements OnDestroy {
     static nextId: number;
     /**
      * The value of the option
@@ -58,17 +38,15 @@ declare class FuiOptionComponent implements OnDestroy, AfterViewInit {
      * Event emitted when the option is selected
      */
     readonly selectionChange: OutputEmitterRef<{
-        source: FuiOptionComponent;
+        source: FuiOptionBase;
         value: unknown;
     }>;
     readonly _selected: WritableSignal<boolean>;
     readonly _active: WritableSignal<boolean>;
     readonly stateChanges: Subject<void>;
-    private readonly _element;
-    private readonly _parentSelect;
+    protected readonly _element: ElementRef<HTMLElement>;
+    protected readonly _parentSelect: _raintonic_formaui_components_select.FuiSelectParent | null;
     readonly id: string;
-    readonly _showCheckmark: WritableSignal<boolean>;
-    ngAfterViewInit(): void;
     ngOnDestroy(): void;
     get viewValue(): string;
     _handleClick(event: Event): void;
@@ -102,12 +80,67 @@ declare class FuiOptionComponent implements OnDestroy, AfterViewInit {
      * Gets the host element
      */
     _getHostElement(): HTMLElement;
-    /** Update checkmark visibility based on selection and multiple mode */
-    private _updateCheckmarkVisibility;
     /** Emits the selection change event */
     private _emitSelectionChangeEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiOptionBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FuiOptionBase, never, never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; }, never, never, true, never>;
+}
+
+/**
+ * # FuiOption Component
+ *
+ * Individual option component for use within fui-select.
+ * Works like Angular Material's mat-option with full accessibility support.
+ *
+ * ## Features
+ * - Disabled state support
+ * - Selection state management
+ * - Full accessibility support (ARIA attributes)
+ * - Keyboard navigation support
+ * - Custom content projection
+ * - Smooth hover animations
+ *
+ * ## Usage
+ *
+ * ### Basic Option
+ * ```html
+ * <fui-select placeholder="Select a status">
+ *   <fui-option value="active">Active</fui-option>
+ *   <fui-option value="inactive">Inactive</fui-option>
+ *   <fui-option value="pending" [disabled]="true">Pending (Disabled)</fui-option>
+ * </fui-select>
+ * ```
+ *
+ * ### Option with Custom Content
+ * ```html
+ * <fui-select placeholder="Select a country">
+ *   <fui-option value="us">
+ *     <fui-icon name="flag-us"></fui-icon>
+ *     United States
+ *   </fui-option>
+ *   <fui-option value="ca">
+ *     <fui-icon name="flag-ca"></fui-icon>
+ *     Canada
+ *   </fui-option>
+ * </fui-select>
+ * ```
+ *
+ * ### Multi-Select Options
+ * When `fui-select` has `[multiple]="true"`, `<fui-option>` automatically renders
+ * a checkbox indicator:
+ * ```html
+ * <fui-select [multiple]="true" placeholder="Select skills">
+ *   <fui-option value="js">JavaScript</fui-option>
+ *   <fui-option value="ts">TypeScript</fui-option>
+ *   <fui-option value="py">Python</fui-option>
+ * </fui-select>
+ * ```
+ */
+declare class FuiOptionComponent extends FuiOptionBase {
+    /** Whether the parent select is in multi-select mode */
+    readonly _isMultiParent: Signal<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FuiOptionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FuiOptionComponent, "fui-option", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; }, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiOptionComponent, "fui-option", never, {}, {}, never, ["*"], true, never>;
 }
 
 /**
@@ -197,33 +230,34 @@ interface FuiSelectChange {
  * </fui-form-field>
  * ```
  */
-declare class FuiSelectComponent implements ControlValueAccessor, FuiFormFieldControl, DoCheck, OnDestroy, AfterContentInit {
+declare class FuiSelectComponent implements ControlValueAccessor, FuiFormFieldControl, OnDestroy, AfterContentInit, AfterViewInit {
     static nextId: number;
     readonly controlType = "fui-select";
+    private readonly _popup;
+    private readonly _formSync;
+    private readonly _parentFormField;
     readonly placeholderInput: InputSignal<string>;
     readonly disabledInput: InputSignal<boolean>;
-    readonly readonly: InputSignal<boolean>;
+    readonly readonlyInput: InputSignal<boolean>;
     readonly multiple: InputSignal<boolean>;
-    readonly errorStateMatcher: InputSignal<ErrorStateMatcher | null>;
     /**
-     * Whether to compare option values using object identity or deep equality
+     * Comparison function for option values.
+     * Defaults to strict equality (`===`). Override when options use object
+     * values and you need to match by a property (e.g. comparing by `id`).
      */
     readonly compareWith: InputSignal<(o1: unknown, o2: unknown) => boolean>;
+    readonly errorStateMatcher: InputSignal<ErrorStateMatcher | null>;
     readonly valueChange: OutputEmitterRef<unknown>;
     readonly selectionChange: OutputEmitterRef<FuiSelectChange>;
     readonly openedChange: OutputEmitterRef<boolean>;
     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>;
@@ -233,49 +267,52 @@ declare class FuiSelectComponent implements ControlValueAccessor, FuiFormFieldCo
     readonly focused: WritableSignal<boolean>;
     private readonly _ngControlDisabled;
     readonly disabled: Signal<boolean>;
+    readonly readonly: Signal<boolean>;
     readonly empty: Signal<boolean>;
     readonly id: string;
     trigger?: ElementRef<HTMLDivElement>;
     panel?: ElementRef<HTMLDivElement>;
-    readonly options: Signal<readonly FuiOptionComponent[]>;
-    readonly panelOpen: WritableSignal<boolean>;
+    readonly options: Signal<readonly FuiOptionBase[]>;
+    readonly panelOpen: Signal<boolean>;
     private readonly _activeOptionIndex;
     readonly activeOptionIndex: Signal<number>;
     readonly _liveAnnouncement: WritableSignal<string>;
-    private _overlayRef;
-    private _overlaySubscriptions;
-    private readonly _overlayService;
-    private readonly _elementRef;
-    private readonly _document;
-    private readonly _ngZone;
-    private _outsideClickSub?;
-    private _typeaheadBuffer;
-    private _typeaheadTimeout;
+    private readonly _typeaheadBuffer;
+    private _typeaheadResetTimer;
     private readonly TYPE_AHEAD_DEBOUNCE;
     private _onChange;
     private _onTouched;
     readonly displayValue: Signal<string>;
     constructor();
-    ngDoCheck(): void;
     ngOnDestroy(): void;
     ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    /** Sets the select value from the form model. Null/undefined coerces to null. */
     writeValue(value: unknown): void;
+    /** Registers the callback Angular calls when the value should propagate to the model. */
     registerOnChange(fn: (value: unknown) => void): void;
+    /** Registers the callback Angular calls when the control should be marked as touched. */
     registerOnTouched(fn: () => void): void;
+    /** Enables or disables the control programmatically; mirrors the `disabled` form-control state. */
     setDisabledState(isDisabled: boolean): void;
+    /** Opens the panel when the form-field container is clicked, unless disabled or readonly. */
     onContainerClick(_event: MouseEvent): void;
+    /** Stores the space-separated list of IDs for the aria-describedby attribute. */
     setDescribedByIds(ids: string[]): void;
-    setReadOnly(readOnly: boolean): void;
     private _syncOptionsSelection;
     _onFocus(): void;
     _onBlur(event?: FocusEvent): void;
+    /** Focuses the select trigger element. */
     focus(): void;
+    /** Blurs the select trigger element. */
     blur(): void;
+    /** Toggles the select panel. No-op if disabled. */
     toggle(): void;
+    /** Opens the select panel. No-op if disabled, readonly, or already open. */
     open(): void;
+    /** Closes the select panel and restores focus to the trigger unless `restoreFocus` is false. No-op if already closed. */
     close(restoreFocus?: boolean): void;
-    _onOptionSelected(option: FuiOptionComponent): void;
-    _getDisplayValue(): string;
+    _onOptionSelected(option: FuiOptionBase): void;
     _handleKeydown(event: KeyboardEvent): void;
     private _handleClosedKeydown;
     private _handleOpenKeydown;
@@ -287,21 +324,15 @@ declare class FuiSelectComponent implements ControlValueAccessor, FuiFormFieldCo
     private _selectFirstOption;
     private _selectLastOption;
     private _getEnabledOptions;
-    private _listenForOutsideClicks;
-    private _createOverlay;
-    private _disposeOverlay;
     _getActiveDescendant(): string | null;
-    /**
-     * Announces a message to screen readers via the aria-live region.
-     * Clears the message after a brief delay to allow repeated announcements.
-     */
     private _announce;
     get selected(): Signal<unknown>;
+    /** @internal Helper to check if a value is an array. Used by tests. */
     isArray(value: unknown): value is unknown[];
     static ɵfac: i0.ɵɵFactoryDeclaration<FuiSelectComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FuiSelectComponent, "fui-select", never, { "placeholderInput": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "selectionChange": "selectionChange"; "openedChange": "openedChange"; }, ["options"], ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiSelectComponent, "fui-select", never, { "placeholderInput": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonlyInput": { "alias": "readonly"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "selectionChange": "selectionChange"; "openedChange": "openedChange"; }, ["options"], ["*"], true, [{ directive: typeof i1.FuiPopupOverlayDirective; inputs: { "positions": "positions"; "panelClass": "panelClass"; "backdropClass": "backdropClass"; "scrollStrategy": "scrollStrategy"; "minWidthFromTrigger": "minWidthFromTrigger"; }; outputs: { "openedChange": "openedChange"; "escapeKey": "escapeKey"; }; }, { directive: typeof i1.FuiFormControlSyncDirective; inputs: {}; outputs: {}; }]>;
 }
 
-export { FUI_SELECT, FuiOptionComponent, FuiSelectComponent };
+export { FUI_OPTION, FUI_SELECT, FuiOptionBase, FuiOptionComponent, FuiSelectComponent };
 export type { FuiSelectChange, FuiSelectParent, FuiSelectSize, FuiSelectVariant };
 //# sourceMappingURL=raintonic-formaui-components-select.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"raintonic-formaui-components-select.d.ts","sources":["../../../lib/components/select/option.component.ts","../../../lib/components/select/select-tokens.ts","../../../lib/components/select/select.component.ts"],"mappings":";;;;;;AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCG;AACH,cA+Ba,kBAAmB,YAAW,SAAS,EAAE,aAAa;;AAGjE;;AAEG;AACH,oBAAgB,WAAW;AAE3B;;;AAGG;AACH,uBAAmB,WAAW;AAE9B;;AAEG;AACH,8BAA0B,gBAAgB;gBAAW,kBAAkB;;AAAkB;AAGzF,wBAAoB,cAAc;AAClC,sBAAkB,cAAc;2BACX,OAAA;AAGrB;AAGA;;6BAMuB,cAAA;AAEvB;AAKA;;AAUA,wBAAoB,KAAK;AAgBzB;AAOA;AAIA;;AAEG;AACH;AAQA;;AAEG;AACH;AAQA;;AAEG;AACH;AAOA;;AAEG;AACH;AAOA;;AAEG;AACH;AAOA;;AAEG;AACH;AAIA;;AAEG;AACH,uBAAmB,WAAW;;AAK9B;;AAMA;yCAvJW,kBAAkB;2CAAlB,kBAAkB;AA0J9B;;AClPD;;;AAGG;UACc,eAAe;;AAE9B;AACD;AAED;;AAEG;AACH,cAAa,UAAU,EAAA,cAAA,CAAA,eAAA;;AC2BvB;;AAEG;AACG,KAAM,aAAa;AAEzB;;AAEG;KACS,gBAAgB;AAE5B;;AAEG;UACc,eAAe;YACtB,kBAAkB;;AAE3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DG;AACH,cAgCa,kBACX,YAAW,oBAAoB,EAAE,mBAAmB,EAAE,OAAO,EAAE,SAAS,EAAE,gBAAgB;;;AAO1F,+BAA2B,WAAW;AACtC,4BAAwB,WAAW;AACnC,uBAAmB,WAAW;AAC9B,uBAAmB,WAAW;gCACF,WAAW,CAAC,iBAAiB;AAEzD;;AAEG;AACH,0BAAsB,WAAW;AAKjC,0BAAsB,gBAAgB;AACtC,8BAA0B,gBAAgB,CAAC,eAAe;AAC1D,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;sBAEE,cAAA;AAEhB;uBACiB,MAAA;oBAEH,MAAA;;AAQ2B,cAAU,UAAU,CAAC,cAAc;AACrC,YAAQ,UAAU,CAAC,cAAc;sBAGxD,MAAA,UAAA,kBAAA;wBAGE,cAAA;AAGlB;gCAC0B,MAAA;AAG1B,gCAA4B,cAAc;;;AAO1C;AACA;AACA;AACA;;;;AAMA;;;AAWA,2BAAuB,MAAM;;AAqF7B;AAgBA;AASA;AAMA;;AAUA;AAIA;AAMA,6BAAyB,UAAU;AAMnC;AAIA;AAKA;AA6BA;AAKA,oBAAgB,UAAU;AAkB1B;AAIA;AAKA;AAUA;AAsBA;AAoBA,8BAA0B,kBAAkB;AAkD5C;AAKA,0BAAsB,aAAa;AAanC;AA6BA;AA+DA;AAkBA;AAwBA;AAuBA;AAyBA;AA2BA;AAQA;AAQA;AAKA;AAgCA;AAsDA;;AAkBA;;;AAGG;AACH;AASA,oBAAgB,MAAM;;yCAtxBX,kBAAkB;2CAAlB,kBAAkB;AA8xB9B;;;;","names":[]}
+{"version":3,"file":"raintonic-formaui-components-select.d.ts","sources":["../../../lib/components/select/option-base.ts","../../../lib/components/select/option.component.ts","../../../lib/components/select/select-tokens.ts","../../../lib/components/select/select.component.ts"],"mappings":";;;;;;;;AAkBA;;;;;;AAMG;AACH,cAAa,UAAU,EAAA,cAAA,CAAA,aAAA;AAEvB;;;;;;;;AAQG;AACH,uBACsB,aAAc,YAAW,SAAS;;AAGtD;;AAEG;AACH,oBAAgB,WAAW;AAE3B;;;AAGG;AACH,uBAAmB,WAAW;AAE9B;;AAEG;AACH,8BAA0B,gBAAgB;gBAAW,aAAa;;AAAkB;AAGpF,wBAAoB,cAAc;AAClC,sBAAkB,cAAc;2BACX,OAAA;iCAGQ,UAAU,CAAC,WAAW;AAGnD,sCAAgC,oCAAA,CAAA,eAAA;;AAKhC;;AAUA,wBAAoB,KAAK;AAgBzB;AAOA;AAIA;;AAEG;AACH;AAOA;;AAEG;AACH;AAOA;;AAEG;AACH;AAOA;;AAEG;AACH;AAOA;;AAEG;AACH;AAOA;;AAEG;AACH;AAIA;;AAEG;AACH,uBAAmB,WAAW;;AAK9B;yCAvIoB,aAAa;2CAAb,aAAa;AA0IlC;;AC1KD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDG;AACH,cAuCa,kBAAmB,SAAQ,aAAa;;AAEnD,6BAAyB,MAAM;yCAFpB,kBAAkB;2CAAlB,kBAAkB;AAG9B;;AC/FD;;;AAGG;UACc,eAAe;;AAE9B;AACD;AAED;;AAEG;AACH,cAAa,UAAU,EAAA,cAAA,CAAA,eAAA;;ACkCvB;;AAEG;AACG,KAAM,aAAa;AAEzB;;AAEG;KACS,gBAAgB;AAE5B;;AAEG;UACc,eAAe;YACtB,kBAAkB;;AAE3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DG;AACH,cAyCa,kBACX,YAAW,oBAAoB,EAAE,mBAAmB,EAAE,SAAS,EAAE,gBAAgB,EAAE,aAAa;;;AAOhG;AACA;AAGA;AAGA,+BAA2B,WAAW;AACtC,4BAAwB,WAAW;AACnC,4BAAwB,WAAW;AACnC,uBAAmB,WAAW;AAE9B;;;;AAIG;AACH,0BAAsB,WAAW;gCAIL,WAAW,CAAC,iBAAiB;AAGzD,0BAAsB,gBAAgB;AACtC,8BAA0B,gBAAgB,CAAC,eAAe;AAC1D,2BAAuB,gBAAgB;AAGvC;AACA;AACA;2BAEqB,OAAA;;AAErB;AAGA;yBACmB,cAAA;AAGnB;AACA,qBAAiB,SAAS;0BAKN,MAAA;AACpB;uBACiB,cAAA;oBAEH,cAAA;sBAEE,cAAA;AAEhB;uBACiB,MAAA;uBACA,MAAA;oBAEH,MAAA;;AAK0B,cAAU,UAAU,CAAC,cAAc;AACrC,YAAQ,UAAU,CAAC,cAAc;sBAGvD,MAAA,UAAA,aAAA;wBAGE,MAAA;AAGlB;gCAC0B,MAAA;AAG1B,gCAA4B,cAAc;AAG1C;;AAEA;;;AAWA,2BAAuB,MAAM;;AAqC7B;AAOA;AAKA;;AAoCA;;;;AAWA;;AAKA;;AAOA,6BAAyB,UAAU;;AAOnC;AAKA;AAKA;AAKA,oBAAgB,UAAU;;AAmB1B;;AAKA;;AAKA;;AAUA;;AAcA;AAiBA,8BAA0B,aAAa;AAqBvC,0BAAsB,aAAa;AAanC;AA6BA;AA6DA;AAOA;AAwBA;AAYA;AAQA;AA2BA;AAQA;AAQA;;AASA;AAKA,oBAAgB,MAAM;;;yCAvhBX,kBAAkB;2CAAlB,kBAAkB,mqBAAA,EAAA,CAAA,wBAAA,wRAAA,EAAA,CAAA,2BAAA;AA+hB9B;;;;","names":[]}

package/types/raintonic-formaui-components-sidebar-nav-menu.d.ts

@@ -0,0 +1,223 @@
+import * as _angular_core from '@angular/core';
+import { MenuItem, FuiIntlBase } from '@raintonic/formaui/core';
+
+/**
+ * # FuiSidebarNavMenuComponent
+ *
+ * A standalone sidebar navigation menu component with recursive,
+ * multi-level submenus. Inspired by PrimeNG's TieredMenu model
+ * with a minimal, structural approach.
+ *
+ * ## Features
+ * - Unlimited nesting depth via recursive submenu template
+ * - Inline expand/collapse submenus
+ * - Built-in search input with clear button
+ * - Routing integration via `routerLink` with automatic active detection
+ * - Keyboard navigation (Arrow keys, Enter/Space, Home/End)
+ * - Full ARIA support (`role="navigation"`, `aria-expanded`, `aria-haspopup`)
+ *
+ * ## Usage
+ *
+ * ```html
+ * <fui-sidebar-nav-menu
+ *   [items]="menuItems"
+ *   [(filterString)]="myFilter"
+ *   (itemClick)="onMenuItemClick($event)"
+ * />
+ * ```
+ *
+ * ```typescript
+ * import { FuiSidebarNavMenuComponent, MenuItem } from '@raintonic/formaui/components/sidebar-nav-menu';
+ *
+ * @Component({
+ *   standalone: true,
+ *   imports: [FuiSidebarNavMenuComponent],
+ *   template: `...`,
+ * })
+ * export class MyLayout {
+ *   menuItems: MenuItem[] = [
+ *     { label: 'Dashboard', icon: 'house', routerLink: '/dashboard' },
+ *     {
+ *       label: 'Products',
+ *       icon: 'package',
+ *       items: [
+ *         { label: 'List', routerLink: '/products' },
+ *         { label: 'Categories', routerLink: '/categories' },
+ *       ],
+ *     },
+ *     { separator: true },
+ *     { label: 'Logout', command: () => this.logout() },
+ *   ];
+ *
+ *   onMenuItemClick(item: MenuItem): void {
+ *     console.log('Menu item:', item.label);
+ *   }
+ * }
+ * ```
+ */
+declare class FuiSidebarNavMenuComponent {
+    /**
+     * Array of menu items to render.
+     */
+    readonly items: _angular_core.InputSignal<MenuItem[]>;
+    /**
+     * Accessible label for the navigation region.
+     * @default 'Sidebar menu'
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Optional filter string. When set, the menu displays only items whose label
+     * contains the filter text (case-insensitive, substring match). Parent items
+     * with matching descendants remain visible so the filtered child can be reached.
+     * Separators and section headers are hidden during filtering.
+     *
+     * This is a two-way bindable model signal — set it programmatically or wire it
+     * to the built-in search component.
+     */
+    readonly filterString: _angular_core.ModelSignal<string>;
+    /**
+     * Emitted when any clickable menu item is activated.
+     */
+    readonly itemClick: _angular_core.OutputEmitterRef<MenuItem>;
+    /**
+     * Pure derivation that assigns unique IDs without mutating consumer data.
+     * Each item is shallow-copied; the tree is walked recursively.
+     */
+    readonly _readyItems: _angular_core.Signal<MenuItem[]>;
+    /**
+     * Filtered items based on `filterString`. When the filter is non-empty,
+     * items are kept if their label matches (case-insensitive substring) or
+     * if any descendant matches. Separators and section headers are hidden
+     * during filtering.
+     */
+    readonly _filteredItems: _angular_core.Signal<MenuItem[]>;
+    /** @internal Pass-through handler from submenu */
+    _onItemClick(item: MenuItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiSidebarNavMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiSidebarNavMenuComponent, "fui-sidebar-nav-menu", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "filterString": { "alias": "filterString"; "required": false; "isSignal": true; }; }, { "filterString": "filterStringChange"; "itemClick": "itemClick"; }, never, ["[fuiSidebarNavHeader]", "[fuiSidebarNavFooter]"], true, never>;
+}
+
+/**
+ * Recursive submenu component for rendering nested menu items.
+ *
+ * Used internally by FuiSidebarNavMenuComponent. Renders a flat list
+ * of items and recurses via &lt;sidebar-nav-submenu&gt; in the template
+ * when an item has children.
+ *
+ * Keyboard navigation follows WAI-ARIA menu patterns:
+ * - ArrowDown / ArrowUp: navigate between siblings
+ * - ArrowRight: expand submenu
+ * - ArrowLeft: collapse submenu / move focus to parent
+ * - Enter / Space: activate item
+ * - Home / End: first / last item
+ */
+declare class SidebarNavSubmenuComponent {
+    /** Menu items to render (IDs already assigned by parent) */
+    readonly items: _angular_core.InputSignal<MenuItem[]>;
+    /** Accessible label for this submenu group */
+    readonly submenuLabel: _angular_core.InputSignal<string>;
+    /** Whether this is the root level (applies root-level styles) */
+    readonly isRoot: _angular_core.InputSignal<boolean>;
+    /** Nesting depth (0 = root). Used to compute aria-level on section headers. */
+    readonly depth: _angular_core.InputSignal<number>;
+    /** Emitted when any clickable item is activated */
+    readonly itemClick: _angular_core.OutputEmitterRef<MenuItem>;
+    readonly _expanded: _angular_core.WritableSignal<Set<string>>;
+    constructor();
+    /** @internal Whether the item has child submenu items */
+    hasChildren(item: MenuItem): boolean;
+    /** @internal Whether the item's submenu is currently expanded */
+    isExpanded(item: MenuItem): boolean;
+    /** @internal Toggle submenu open/closed */
+    toggleExpand(event: Event, item: MenuItem): void;
+    /** @internal Handle click on a leaf (non-parent) item */
+    onLeafClick(event: Event, item: MenuItem): void;
+    /** @internal Keyboard event handler */
+    onKeydown(event: KeyboardEvent, item: MenuItem): void;
+    private _focusItemAt;
+    private _hasParentSubmenu;
+    private _focusParent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidebarNavSubmenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidebarNavSubmenuComponent, "fui-sidebar-nav-submenu", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "submenuLabel": { "alias": "submenuLabel"; "required": false; "isSignal": true; }; "isRoot": { "alias": "isRoot"; "required": false; "isSignal": true; }; "depth": { "alias": "depth"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
+}
+
+declare class FuiSidebarNavSearchIntl extends FuiIntlBase {
+    /** Placeholder text for the search input. */
+    searchPlaceholder: string;
+    /** aria-label for the search input. */
+    searchInputAriaLabel: string;
+    /** aria-label for the clear-search button. */
+    clearSearchAriaLabel: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiSidebarNavSearchIntl, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FuiSidebarNavSearchIntl>;
+}
+
+/**
+ * # FuiSidebarNavSearchComponent
+ *
+ * A standalone search input component designed to be placed inside the sidebar
+ * navigation menu. Emits the current filter string so the parent component can
+ * reactively filter menu items.
+ *
+ * ## Features
+ * - Search input with magnifying-glass icon
+ * - Clear button that appears when a query is entered
+ * - Configurable placeholder text (falls back to `FuiSidebarNavSearchIntl` default)
+ * - Two-way binding via `filterString` model
+ * - Aria labels via `FuiSidebarNavSearchIntl` (overridable via DI)
+ *
+ * ## Usage
+ *
+ * ```html
+ * <fui-sidebar-nav-search
+ *   [(filterString)]="myFilter"
+ *   placeholder="Search…"
+ * />
+ * ```
+ */
+declare class FuiSidebarNavSearchComponent {
+    readonly intl: FuiSidebarNavSearchIntl;
+    private readonly _cdr;
+    constructor();
+    /**
+     * The current filter string. Two-way bindable.
+     */
+    readonly filterString: _angular_core.ModelSignal<string>;
+    /**
+     * Placeholder text for the search input.
+     * Falls back to the Intl default when not set.
+     */
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    /** Resolved placeholder: input override -> Intl default. */
+    readonly resolvedPlaceholder: _angular_core.Signal<string>;
+    /** Resolved search-input aria-label: Intl default. */
+    readonly resolvedSearchInputAriaLabel: _angular_core.Signal<string>;
+    /** Resolved clear-button aria-label: Intl default. */
+    readonly resolvedClearSearchAriaLabel: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiSidebarNavSearchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiSidebarNavSearchComponent, "fui-sidebar-nav-search", never, { "filterString": { "alias": "filterString"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "filterString": "filterStringChange"; }, never, never, true, never>;
+}
+
+/**
+ * Walk a menu item tree and set `expanded: true` on every parent whose
+ * descendant chain contains a `routerLink` that matches the current URL.
+ *
+ * The function is **immutable** — it clones items only when it needs to mutate
+ * them, returning the same reference for untouched subtrees.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { expandMenuItems } from '@raintonic/formaui/components/sidebar-nav-menu';
+ *
+ * const items = expandMenuItems(myMenuItems, '/products/categories');
+ * ```
+ *
+ * @param items - Menu item tree
+ * @param currentUrl - The current URL path (e.g. `'/products/categories'`)
+ * @returns A new tree with `expanded` set on matching parent items
+ */
+declare function expandMenuItems(items: readonly MenuItem[], currentUrl: string): MenuItem[];
+
+export { FuiSidebarNavMenuComponent, FuiSidebarNavSearchComponent, SidebarNavSubmenuComponent, expandMenuItems };
+//# sourceMappingURL=raintonic-formaui-components-sidebar-nav-menu.d.ts.map

package/types/raintonic-formaui-components-sidebar-nav-menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-sidebar-nav-menu.d.ts","sources":["../../../lib/components/sidebar-nav-menu/sidebar-nav-menu.component.ts","../../../lib/components/sidebar-nav-menu/sidebar-nav-submenu.component.ts","../../../lib/components/sidebar-nav-menu/sidebar-nav-search.intl.ts","../../../lib/components/sidebar-nav-menu/sidebar-nav-search.component.ts","../../../lib/components/sidebar-nav-menu/expand-menu-items.ts"],"mappings":";;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDG;AACH,cAaa,0BAA0B;AACrC;;AAEG;oBACW,aAAA,CAAA,WAAA,CAAA,QAAA;AAEd;;;AAGG;wBACe,aAAA,CAAA,WAAA;AAElB;;;;;;;;AAQG;2BACkB,aAAA,CAAA,WAAA;AAErB;;AAEG;wBACe,aAAA,CAAA,gBAAA,CAAA,QAAA;AAElB;;;AAGG;0BACiB,aAAA,CAAA,MAAA,CAAA,QAAA;AAWpB;;;;;AAKG;6BACoB,aAAA,CAAA,MAAA,CAAA,QAAA;;AAsBvB,uBAAmB,QAAQ;oDAvEhB,0BAA0B;sDAA1B,0BAA0B;AA0EtC;;AC7ID;;;;;;;;;;;;;AAaG;AACH,cAOa,0BAA0B;;oBAEvB,aAAA,CAAA,WAAA,CAAA,QAAA;;2BAGO,aAAA,CAAA,WAAA;;qBAGN,aAAA,CAAA,WAAA;;oBAGD,aAAA,CAAA,WAAA;;wBAGI,aAAA,CAAA,gBAAA,CAAA,QAAA;wBAGA,aAAA,CAAA,cAAA,CAAA,GAAA;;;AA4BlB,sBAAkB,QAAQ;;AAK1B,qBAAiB,QAAQ;;wBAML,KAAK,QAAQ,QAAQ;;uBAiCtB,KAAK,QAAQ,QAAQ;;qBAcvB,aAAa,QAAQ,QAAQ;AAwE9C;AAWA;AAIA;oDA9LW,0BAA0B;sDAA1B,0BAA0B;AAsMtC;;AC7ND,cACa,uBAAwB,SAAQ,WAAW;;AAEtD;;AAEA;;AAEA;oDANW,uBAAuB;wDAAvB,uBAAuB;AAOnC;;ACJD;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACH,cA8Ba,4BAA4B;mBAC1B,uBAAA;AACb;;AAQA;;AAEG;2BACkB,aAAA,CAAA,WAAA;AAErB;;;AAGG;0BACiB,aAAA,CAAA,WAAA;;kCAGQ,aAAA,CAAA,MAAA;;2CAGS,aAAA,CAAA,MAAA;;2CAGA,aAAA,CAAA,MAAA;oDA5B1B,4BAA4B;sDAA5B,4BAA4B;AA6BxC;;ACvFD;;;;;;;;;;;;;;;;;;AAkBG;AACH,iBAAgB,eAAe,iBAAiB,QAAQ,yBAAyB,QAAQ;;;;","names":[]}

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

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, WritableSignal, Signal, TemplateRef } from '@angular/core';
+import { InjectionToken, WritableSignal, Signal, TemplateRef, ElementRef } from '@angular/core';
 import { AbstractControl } from '@angular/forms';
 
 type StepperOrientation = 'horizontal' | 'vertical';
@@ -40,6 +40,7 @@ declare class FuiStepComponent {
     readonly errorMessage: _angular_core.InputSignal<string>;
     readonly stepControl: _angular_core.InputSignal<AbstractControl<any, any, any> | null>;
     readonly optional: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly _interacted: WritableSignal<boolean>;
     readonly contentTemplate: Signal<TemplateRef<unknown> | undefined>;
     readonly hasError: Signal<boolean>;
@@ -49,7 +50,7 @@ declare class FuiStepComponent {
     /** Reset the step to its initial state. */
     reset(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiStepComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiStepComponent, "fui-step", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "completed": { "alias": "completed"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "stepControl": { "alias": "stepControl"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiStepComponent, "fui-step", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "completed": { "alias": "completed"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "stepControl": { "alias": "stepControl"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 /**
@@ -97,6 +98,7 @@ declare class FuiStepperComponent {
     readonly selectionChange: _angular_core.OutputEmitterRef<StepSelectionChange>;
     readonly animationDone: _angular_core.OutputEmitterRef<void>;
     readonly steps: _angular_core.Signal<readonly FuiStepComponent[]>;
+    readonly stepHeaderButtons: _angular_core.Signal<readonly ElementRef<any>[]>;
     readonly _selectedIndex: WritableSignal<number>;
     readonly _uniqueId: number;
     readonly _selectedStep: _angular_core.Signal<FuiStepComponent>;

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

@@ -1 +1 @@
-{"version":3,"file":"raintonic-formaui-components-stepper.d.ts","sources":["../../../lib/components/stepper/stepper.types.ts","../../../lib/components/stepper/step.component.ts","../../../lib/components/stepper/stepper.component.ts"],"mappings":";;;;KAEY,kBAAkB;AACxB,KAAM,SAAS;UAEJ,mBAAmB;;;;;AAKnC;AAED,cAAa,eAAe,EAAA,cAAA;;ACI5B;;;;;;;;;;;;;;;;;;AAkBG;AACH,cAOa,gBAAgB;oBAEb,aAAA,CAAA,WAAA;0BACM,aAAA,CAAA,WAAA;mBACP,aAAA,CAAA,WAAA;wBACK,aAAA,CAAA,wBAAA;uBACD,aAAA,CAAA,wBAAA;2BACI,aAAA,CAAA,WAAA;0BACD,aAAA,CAAA,WAAA,CAAA,eAAA;uBACH,aAAA,CAAA,wBAAA;AAGjB,0BAAsB,cAAc;AAGpC,8BAA0B,MAAM,CAAC,WAAW;AAG5C,uBAAmB,MAAM;AASzB,oBAAgB,MAAM,CAAC,SAAS;;AAWhC;;AAKA;oDA3CW,gBAAgB;sDAAhB,gBAAgB;AAkD5B;;ACxED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCG;AACH,cAgBa,mBAAmB;0BAEV,aAAA,CAAA,WAAA,CAAA,kBAAA;qBACL,aAAA,CAAA,wBAAA;4BACO,aAAA,CAAA,WAAA;8BAGE,aAAA,CAAA,gBAAA,CAAA,mBAAA;4BACF,aAAA,CAAA,gBAAA;oBAGR,aAAA,CAAA,MAAA,UAAA,gBAAA;AAGd,6BAAyB,cAAc;;4BAMjB,aAAA,CAAA,MAAA,CAAA,gBAAA;;;AAetB;;AAuBA;;AAQA;;AAwBA;;AAQA;;AAKA;;4BA+BwB,aAAa;;AA8CrC;oDApLW,mBAAmB;sDAAnB,mBAAmB;AA6M/B;;;;","names":[]}
+{"version":3,"file":"raintonic-formaui-components-stepper.d.ts","sources":["../../../lib/components/stepper/stepper.types.ts","../../../lib/components/stepper/step.component.ts","../../../lib/components/stepper/stepper.component.ts"],"mappings":";;;;KAEY,kBAAkB;AACxB,KAAM,SAAS;UAEJ,mBAAmB;;;;;AAKnC;AAED,cAAa,eAAe,EAAA,cAAA;;ACI5B;;;;;;;;;;;;;;;;;;AAkBG;AACH,cAOa,gBAAgB;oBAEb,aAAA,CAAA,WAAA;0BACM,aAAA,CAAA,WAAA;mBACP,aAAA,CAAA,WAAA;wBACK,aAAA,CAAA,wBAAA;uBACD,aAAA,CAAA,wBAAA;2BACI,aAAA,CAAA,WAAA;0BACD,aAAA,CAAA,WAAA,CAAA,eAAA;uBACH,aAAA,CAAA,wBAAA;uBACA,aAAA,CAAA,wBAAA;AAGjB,0BAAsB,cAAc;AAGpC,8BAA0B,MAAM,CAAC,WAAW;AAG5C,uBAAmB,MAAM;AASzB,oBAAgB,MAAM,CAAC,SAAS;;AAchC;;AAKA;oDA/CW,gBAAgB;sDAAhB,gBAAgB;AAsD5B;;AC1ED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCG;AACH,cAgBa,mBAAmB;0BAEV,aAAA,CAAA,WAAA,CAAA,kBAAA;qBACL,aAAA,CAAA,wBAAA;4BACO,aAAA,CAAA,WAAA;8BAGE,aAAA,CAAA,gBAAA,CAAA,mBAAA;4BACF,aAAA,CAAA,gBAAA;oBAGR,aAAA,CAAA,MAAA,UAAA,gBAAA;gCAGY,aAAA,CAAA,MAAA,UAAA,UAAA;AAG1B,6BAAyB,cAAc;;4BAMjB,aAAA,CAAA,MAAA,CAAA,gBAAA;;;AAsBtB;;AAMA;;AAMA;;AAuBA;;AAQA;;AAKA;;4BA2CwB,aAAa;;AA8CrC;oDAtLW,mBAAmB;sDAAnB,mBAAmB;AA+M/B;;;;","names":[]}