@raintonic/formaui 0.3.1 → 0.9.0

package/types/raintonic-formaui-components-dropdown-menu.d.ts

@@ -0,0 +1,394 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, ElementRef, AfterViewInit } from '@angular/core';
+import * as i1 from '@raintonic/formaui/cdk/form-field';
+import { FuiPopupOverlayDirective } from '@raintonic/formaui/cdk/form-field';
+
+/**
+ * Available dropdown-menu positions relative to the trigger element
+ */
+type FuiDropdownMenuPosition = 'top-start' | 'top' | 'top-end' | 'bottom-start' | 'bottom' | 'bottom-end' | 'left-start' | 'left' | 'left-end' | 'right-start' | 'right' | 'right-end';
+declare const FUI_DROPDOWN_MENU_POSITIONS: readonly ["top-start", "top", "top-end", "bottom-start", "bottom", "bottom-end", "left-start", "left", "left-end", "right-start", "right", "right-end"];
+/**
+ * Available dropdown-menu sizes
+ */
+type FuiDropdownMenuSize = 'sm' | 'md' | 'lg';
+declare const FUI_DROPDOWN_MENU_SIZES: readonly ["sm", "md", "lg"];
+/**
+ * # FuiDropdownMenu Component
+ *
+ * A dropdown menu component that provides a list of options or actions.
+ * Designed to work with external triggers using the fuiDropdownMenuTrigger directive.
+ *
+ * ## Features
+ * - Multiple positioning options relative to trigger
+ * - Keyboard navigation (Arrow keys, Enter, Escape)
+ * - Click outside to close
+ * - Full accessibility support (ARIA attributes, focus management)
+ * - Customizable size variants
+ * - Auto-positioning with collision detection
+ * - Portal attachment to document body to avoid clipping issues
+ *
+ * ## Usage
+ *
+ * ### Basic DropdownMenu with External Trigger
+ * ```html
+ * <button fuiButton fuiDropdownMenuTrigger [fuiDropdownMenuTriggerFor]="menu">
+ *   Open Menu
+ * </button>
+ * <fui-dropdown-menu #menu>
+ *   <fui-dropdown-menu-item>Option 1</fui-dropdown-menu-item>
+ *   <fui-dropdown-menu-item>Option 2</fui-dropdown-menu-item>
+ * </fui-dropdown-menu>
+ * ```
+ *
+ * ### DropdownMenu with Custom Position
+ * ```html
+ * <button fuiButton fuiDropdownMenuTrigger [fuiDropdownMenuTriggerFor]="menu">
+ *   Open Menu
+ * </button>
+ * <fui-dropdown-menu #menu position="top-start" size="lg">
+ *   <fui-dropdown-menu-item>Profile</fui-dropdown-menu-item>
+ *   <fui-dropdown-menu-item variant="danger">Logout</fui-dropdown-menu-item>
+ * </fui-dropdown-menu>
+ * ```
+ *
+ * ### DropdownMenu without Portal (for special cases)
+ * ```html
+ * <button fuiButton fuiDropdownMenuTrigger [fuiDropdownMenuTriggerFor]="menu">
+ *   Open Menu
+ * </button>
+ * <fui-dropdown-menu #menu [attachToBody]="false">
+ *   <fui-dropdown-menu-item>Option 1</fui-dropdown-menu-item>
+ *   <fui-dropdown-menu-item>Option 2</fui-dropdown-menu-item>
+ * </fui-dropdown-menu>
+ * ```
+ *
+ * ### DropdownMenu with Data Passed from Trigger
+ * ```html
+ * <button fuiButton fuiDropdownMenuTrigger
+ *         [fuiDropdownMenuTriggerFor]="dynamicMenu"
+ *         [menuTriggerData]="{ user: currentUser, items: menuItems }">
+ *   Open Menu
+ * </button>
+ * <fui-dropdown-menu #dynamicMenu>
+ *   <!-- Access data in component using menu.menuData() -->
+ * </fui-dropdown-menu>
+ * ```
+ *
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <fui-dropdown-menu #menu>
+ *       <fui-dropdown-menu-item *ngFor="let item of menu.menuData()?.items">
+ *         {{ item.label }}
+ *       </fui-dropdown-menu-item>
+ *     </fui-dropdown-menu>
+ *   `
+ * })
+ * export class MyComponent { }
+ * ```
+ */
+declare class FuiDropdownMenuComponent implements OnDestroy {
+    /**
+     * Menu position relative to the trigger element
+     * @default 'bottom-start'
+     */
+    readonly position: _angular_core.InputSignal<FuiDropdownMenuPosition>;
+    /**
+     * Menu size variant
+     * @default 'md'
+     */
+    readonly size: _angular_core.InputSignal<FuiDropdownMenuSize>;
+    /**
+     * Whether the menu should close when clicking outside
+     * @default true
+     */
+    readonly closeOnClickOutside: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the menu is disabled
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether to attach the menu panel to the document body to avoid clipping issues
+     * @default true
+     */
+    readonly attachToBody: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Emitted when the menu open state changes
+     */
+    readonly openChange: _angular_core.OutputEmitterRef<boolean>;
+    /**
+     * Emitted when a menu item is selected
+     */
+    readonly itemSelected: _angular_core.OutputEmitterRef<Event>;
+    protected readonly _isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly _animationState: _angular_core.WritableSignal<"void" | "enter" | "leave">;
+    private readonly _triggerElement;
+    private readonly _menuData;
+    private _previousFocusedElement;
+    private _closeAnimationTimeout;
+    readonly computedClasses: _angular_core.Signal<string>;
+    private readonly _destroyRef;
+    private readonly _elementRef;
+    private readonly _overlayService;
+    readonly _popup: FuiPopupOverlayDirective;
+    menuPanel?: ElementRef<HTMLElement>;
+    private readonly _menuItems;
+    constructor();
+    /**
+     * Whether the menu is currently open
+     */
+    isOpen(): boolean;
+    /**
+     * Opens the menu
+     */
+    open(): void;
+    /**
+     * Closes the menu
+     */
+    close(): void;
+    /**
+     * Toggles the menu open/closed state
+     */
+    toggle(): void;
+    /**
+     * Sets the trigger element for positioning (called by trigger directive)
+     */
+    setTriggerElement(element: HTMLElement): void;
+    /**
+     * Gets the menu data passed from the trigger
+     * Returns a signal containing the data
+     */
+    menuData(): unknown;
+    /**
+     * Sets the menu data (called by trigger directive)
+     * @param data The data to pass to the menu
+     */
+    setMenuData(data: unknown): void;
+    onDocumentKeydown(event: KeyboardEvent): void;
+    onMenuClick(event: Event): void;
+    ngOnDestroy(): void;
+    private _openMenu;
+    private _closeMenu;
+    private _getPositionsForMenuPosition;
+    private _restoreFocus;
+    private _getMenuItems;
+    /** @internal Called by FuiDropdownMenuTriggerDirective */
+    _focusFirstItem(): void;
+    /** @internal Called by FuiDropdownMenuTriggerDirective */
+    _focusLastItem(): void;
+    private _focusNextItem;
+    private _focusPreviousItem;
+    /**
+     * Focuses a menu item and updates roving tabindex across all items.
+     */
+    private _focusItem;
+    /**
+     * Resets all items to tabindex="-1" when the menu closes.
+     */
+    private _resetRovingTabindex;
+    /**
+     * Updates roving tabindex: sets tabindex="0" on the target item
+     * and tabindex="-1" on all other items.
+     */
+    private _updateRovingTabindex;
+    private _startCloseAnimation;
+    private _clearCloseTimeout;
+    /**
+     * Checks if this menu's overlay is the topmost (most recently opened) overlay.
+     * This ensures that only the topmost menu responds to keyboard events when
+     * multiple menus are open (e.g., nested menus).
+     */
+    private _isTopmostOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiDropdownMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiDropdownMenuComponent, "fui-dropdown-menu", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "closeOnClickOutside": { "alias": "closeOnClickOutside"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "attachToBody": { "alias": "attachToBody"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; "itemSelected": "itemSelected"; }, ["_menuItems"], ["*"], true, [{ directive: typeof i1.FuiPopupOverlayDirective; inputs: { "positions": "positions"; "panelClass": "panelClass"; "backdropClass": "backdropClass"; "scrollStrategy": "scrollStrategy"; "minWidthFromTrigger": "minWidthFromTrigger"; "closeOnEscape": "closeOnEscape"; "closeOnBackdrop": "closeOnBackdrop"; "viewportMargin": "viewportMargin"; }; outputs: { "openedChange": "openedChange"; "escapeKey": "escapeKey"; "backdropClick": "backdropClick"; }; }]>;
+}
+
+/**
+ * Available dropdown-menu item variants
+ */
+type DropdownMenuItemVariant = 'default' | 'danger';
+declare const DROPDOWN_MENU_ITEM_VARIANTS: readonly ["default", "danger"];
+/**
+ * # FuiDropdownMenuItem Component
+ *
+ * A menu item component designed to be used within fui-dropdown-menu.
+ * Provides consistent styling and behavior for menu options.
+ *
+ * ## Features
+ * - Default and danger variants
+ * - Full accessibility support (ARIA attributes, keyboard navigation)
+ * - Icon support with proper spacing
+ * - Disabled state support
+ * - Hover and focus states
+ * - Keyboard activation (Enter and Space)
+ *
+ * ## Usage
+ *
+ * ### Basic Menu Item
+ * ```html
+ * <fui-dropdown-menu-item>Profile</fui-dropdown-menu-item>
+ * ```
+ *
+ * ### Menu Item with Icon
+ * ```html
+ * <fui-dropdown-menu-item>
+ *   <fui-icon name="user" fuiPrefix></fui-icon>
+ *   Profile
+ * </fui-dropdown-menu-item>
+ * ```
+ *
+ * ### Danger Menu Item
+ * ```html
+ * <fui-dropdown-menu-item variant="danger">
+ *   <fui-icon name="trash" fuiPrefix></fui-icon>
+ *   Delete Account
+ * </fui-dropdown-menu-item>
+ * ```
+ *
+ * ### Disabled Menu Item
+ * ```html
+ * <fui-dropdown-menu-item [disabled]="true">
+ *   Unavailable Option
+ * </fui-dropdown-menu-item>
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { FuiDropdownMenuItemComponent } from '@raintonic/formaui/components/dropdown-menu';
+ *
+ * @Component({
+ *   standalone: true,
+ *   imports: [FuiDropdownMenuItemComponent],
+ *   templateUrl: './my-component.component.html',
+ *   styleUrl: './my-component.component.scss'
+ * })
+ * export class MyComponent {
+ *   onItemClick(event: Event) {
+ *     console.log('Menu item clicked:', event);
+ *   }
+ * }
+ * ```
+ */
+declare class FuiDropdownMenuItemComponent {
+    /**
+     * Menu item variant that determines the visual style
+     * @default 'default'
+     */
+    readonly variant: _angular_core.InputSignalWithTransform<DropdownMenuItemVariant, string>;
+    /**
+     * Whether the menu item is disabled
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Emitted when the menu item is clicked or activated
+     */
+    readonly selected: _angular_core.OutputEmitterRef<Event>;
+    /**
+     * Internal tabindex for roving tabindex pattern.
+     * Managed by the parent FuiDropdownMenuComponent.
+     * @internal
+     */
+    readonly tabIndex: _angular_core.WritableSignal<string>;
+    readonly computedClasses: _angular_core.Signal<string>;
+    /** @internal */ readonly _elementRef: ElementRef<HTMLElement>;
+    private readonly _renderer;
+    onClick(event: Event): void;
+    onKeydown(event: KeyboardEvent): void;
+    /**
+     * Focuses the menu item
+     */
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiDropdownMenuItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiDropdownMenuItemComponent, "fui-dropdown-menu-item", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, never, ["*"], true, never>;
+}
+
+/**
+ * # fuiDropdownMenuTrigger Directive
+ *
+ * A directive that marks an element as a dropdown menu trigger, similar to Angular Material's matMenuTriggerFor.
+ * This directive should be used in conjunction with FuiDropdownMenuComponent.
+ *
+ * ## Usage
+ *
+ * ### Basic Usage
+ * ```html
+ * <button fuiDropdownMenuTrigger [fuiDropdownMenuTriggerFor]="menu">Open Menu</button>
+ * <fui-dropdown-menu #menu>
+ *   <fui-dropdown-menu-item>Option 1</fui-dropdown-menu-item>
+ *   <fui-dropdown-menu-item>Option 2</fui-dropdown-menu-item>
+ * </fui-dropdown-menu>
+ * ```
+ *
+ * ### With Menu Reference
+ * ```html
+ * <button fuiDropdownMenuTrigger [fuiDropdownMenuTriggerFor]="userMenu">
+ *   <fui-icon name="user"></fui-icon>
+ *   User Menu
+ * </button>
+ *
+ * <fui-dropdown-menu #userMenu position="bottom-end">
+ *   <fui-dropdown-menu-item>Profile</fui-dropdown-menu-item>
+ *   <fui-dropdown-menu-item>Settings</fui-dropdown-menu-item>
+ *   <fui-dropdown-menu-item variant="danger">Logout</fui-dropdown-menu-item>
+ * </fui-dropdown-menu>
+ * ```
+ *
+ * ### Passing Data to Menu
+ * ```html
+ * <button fuiDropdownMenuTrigger
+ *         [fuiDropdownMenuTriggerFor]="dynamicMenu"
+ *         [menuTriggerData]="{ user: currentUser, role: 'admin' }">
+ *   Open Menu
+ * </button>
+ *
+ * <fui-dropdown-menu #dynamicMenu>
+ *   <!-- Access menu data in your component via menu.menuData() -->
+ * </fui-dropdown-menu>
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { FuiDropdownMenuTriggerDirective, FuiDropdownMenuComponent, FuiDropdownMenuItemComponent } from '@raintonic/formaui/components/dropdown-menu';
+ *
+ * @Component({
+ *   standalone: true,
+ *   imports: [FuiDropdownMenuTriggerDirective, FuiDropdownMenuComponent, FuiDropdownMenuItemComponent],
+ *   template: `
+ *     <button fuiDropdownMenuTrigger [fuiDropdownMenuTriggerFor]="menu">Open Menu</button>
+ *     <fui-dropdown-menu #menu>
+ *       <fui-dropdown-menu-item>Option 1</fui-dropdown-menu-item>
+ *       <fui-dropdown-menu-item>Option 2</fui-dropdown-menu-item>
+ *     </fui-dropdown-menu>
+ *   `
+ * })
+ * export class MyComponent { }
+ * ```
+ */
+declare class FuiDropdownMenuTriggerDirective implements AfterViewInit {
+    private readonly _elementRef;
+    /** The menu instance that this trigger should open */
+    readonly fuiDropdownMenuTriggerFor: _angular_core.InputSignal<FuiDropdownMenuComponent | null | undefined>;
+    /**
+     * Data to be passed to the menu.
+     * Can be accessed in the menu component or menu items.
+     * Similar to Angular Material's matMenuTriggerData.
+     */
+    readonly menuTriggerData: _angular_core.InputSignal<unknown>;
+    /** The menu instance that this trigger is associated with */
+    menu: FuiDropdownMenuComponent | null;
+    constructor();
+    ngAfterViewInit(): void;
+    onClick(event: Event): void;
+    onKeydown(event: KeyboardEvent): void;
+    /** Gets the trigger element */
+    getElement(): HTMLElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiDropdownMenuTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FuiDropdownMenuTriggerDirective, "[fuiDropdownMenuTrigger]", never, { "fuiDropdownMenuTriggerFor": { "alias": "fuiDropdownMenuTriggerFor"; "required": false; "isSignal": true; }; "menuTriggerData": { "alias": "menuTriggerData"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { DROPDOWN_MENU_ITEM_VARIANTS, FUI_DROPDOWN_MENU_POSITIONS, FUI_DROPDOWN_MENU_SIZES, FuiDropdownMenuComponent, FuiDropdownMenuItemComponent, FuiDropdownMenuTriggerDirective };
+export type { DropdownMenuItemVariant, FuiDropdownMenuPosition, FuiDropdownMenuSize };
+//# sourceMappingURL=raintonic-formaui-components-dropdown-menu.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-dropdown-menu.d.ts","sources":["../../../lib/components/dropdown-menu/dropdown-menu.component.ts","../../../lib/components/dropdown-menu/dropdown-menu-item.component.ts","../../../lib/components/dropdown-menu/dropdown-menu-trigger.directive.ts"],"mappings":";;;;;AAsBA;;AAEG;AACG,KAAM,uBAAuB;AAcnC,cAAa,2BAA2B;AAexC;;AAEG;AACG,KAAM,mBAAmB;AAE/B,cAAa,uBAAuB;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0EG;AACH,cA2Ba,wBAAyB,YAAW,SAAS;AACxD;;;AAGG;uBACc,aAAA,CAAA,WAAA,CAAA,uBAAA;AAEjB;;;AAGG;mBACU,aAAA,CAAA,WAAA,CAAA,mBAAA;AAEb;;;AAGG;kCACyB,aAAA,CAAA,wBAAA;AAE5B;;;AAGG;uBACc,aAAA,CAAA,wBAAA;AAEjB;;;AAGG;2BACkB,aAAA,CAAA,wBAAA;AAErB;;AAEG;yBACgB,aAAA,CAAA,gBAAA;AAEnB;;AAEG;2BACkB,aAAA,CAAA,gBAAA,CAAA,KAAA;AAGrB,gCAA0B,aAAA,CAAA,cAAA;AAC1B,wCAAkC,aAAA,CAAA,cAAA;AAClC;AACA;;;8BAKwB,aAAA,CAAA,MAAA;AAexB;AACA;AAEA;qBACe,wBAAA;AAG4B,gBAAY,UAAU,CAAC,WAAW;AAG7E;;AAiCA;;AAEG;AACH;AAIA;;AAEG;AACH;AAKA;;AAEG;AACH;AAIA;;AAEG;AACH;AAQA;;AAEG;AACH,+BAA2B,WAAW;AAItC;;;AAGG;AACH;AAIA;;;AAGG;AACH;AAKA,6BAAyB,aAAa;AAkCtC,uBAAmB,KAAK;AAYxB;AAUA;AA0DA;AAaA;AAqEA;AAWA;;AAQA;;AAQA;AAOA;AAWA;AAWA;;AAEG;AACH;AAKA;;AAEG;AACH;AAOA;;;AAGG;AACH;AAWA;AAcA;AAOA;;;;AAIG;AACH;oDA5dW,wBAAwB;sDAAxB,wBAAwB,miBAAA,EAAA,CAAA,wBAAA;AAyepC;;AC/nBD;;AAEG;KACS,uBAAuB;AAEnC,cAAa,2BAA2B;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DG;AACH,cAaa,4BAA4B;AACvC;;;AAGG;sBACa,aAAA,CAAA,wBAAA,CAAA,uBAAA;AAKhB;;;AAGG;uBACc,aAAA,CAAA,wBAAA;AAEjB;;AAEG;uBACc,aAAA,CAAA,gBAAA,CAAA,KAAA;AAEjB;;;;AAIG;uBACc,aAAA,CAAA,cAAA;8BAGO,aAAA,CAAA,MAAA;2CAUe,UAAU,CAAC,WAAW;AAC7D;AAGA,mBAAe,KAAK;AAWpB,qBAAiB,aAAa;AAgB9B;;AAEG;AACH;oDAzEW,4BAA4B;sDAA5B,4BAA4B;AA4ExC;;ACvKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DG;AACH,cAQa,+BAAgC,YAAW,aAAa;AACnE;;wCAGkC,aAAA,CAAA,WAAA,CAAA,wBAAA;AAElC;;;;AAIG;8BACqB,aAAA,CAAA,WAAA;;AAGxB,UAAM,wBAAwB;;AAc9B;AAWA,mBAAe,KAAK;AAkBpB,qBAAiB,aAAa;;AA6C9B,kBAAc,WAAW;oDAtGd,+BAA+B;sDAA/B,+BAA+B;AAyG3C;;;;","names":[]}

package/types/raintonic-formaui-components-dual-tier-navigation.d.ts

@@ -0,0 +1,87 @@
+import * as _angular_core from '@angular/core';
+import { MenuItem } from '@raintonic/formaui/core';
+
+declare class FuiDualTierNavigationComponent {
+    private readonly _injector;
+    readonly items: _angular_core.InputSignal<MenuItem[]>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly itemClick: _angular_core.OutputEmitterRef<MenuItem>;
+    readonly _readyItems: _angular_core.Signal<MenuItem[]>;
+    readonly _expandedId: _angular_core.WritableSignal<string | undefined>;
+    readonly _expandedItem: _angular_core.Signal<MenuItem | undefined>;
+    private _findItemById;
+    _closeFlyout(): void;
+    _onItemClick(item: MenuItem): void;
+    _onToggle(event: Event, item: MenuItem): void;
+    _onTriggerKeydown(event: KeyboardEvent, item: MenuItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiDualTierNavigationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiDualTierNavigationComponent, "fui-dual-tier-navigation", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
+}
+
+/**
+ * Renders a single top-level trigger item for the dual-tier navigation bar.
+ * Extracted so the main component stays under 200 lines.
+ */
+declare class DualTierNavTriggerComponent {
+    readonly item: _angular_core.InputSignal<MenuItem>;
+    readonly isExpanded: _angular_core.InputSignal<boolean>;
+    readonly flyoutId: _angular_core.InputSignal<string>;
+    readonly itemClick: _angular_core.OutputEmitterRef<MenuItem>;
+    readonly toggle: _angular_core.OutputEmitterRef<Event>;
+    readonly keydown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    readonly hasChildren: _angular_core.Signal<boolean>;
+    onClick(event: Event): void;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DualTierNavTriggerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DualTierNavTriggerComponent, "fui-dual-tier-nav-trigger", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; "isExpanded": { "alias": "isExpanded"; "required": false; "isSignal": true; }; "flyoutId": { "alias": "flyoutId"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; "toggle": "toggle"; "keydown": "keydown"; }, never, never, true, never>;
+}
+
+declare class DualTierNavSubmenuComponent {
+    private readonly _injector;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly items: _angular_core.InputSignal<MenuItem[]>;
+    readonly showHeader: _angular_core.InputSignal<boolean>;
+    readonly closable: _angular_core.InputSignal<boolean>;
+    readonly itemClick: _angular_core.OutputEmitterRef<MenuItem>;
+    readonly closePanel: _angular_core.OutputEmitterRef<void>;
+    readonly visibleItems: _angular_core.Signal<MenuItem[]>;
+    readonly _expanded: _angular_core.WritableSignal<Set<string>>;
+    constructor();
+    _hasChildren(item: MenuItem): boolean;
+    _isExpanded(item: MenuItem): boolean;
+    _onClose(): void;
+    _onClickItem(item: MenuItem): void;
+    _onToggleExpand(item: MenuItem, toggleSourceEl?: HTMLElement): void;
+    _onListKeydown(event: KeyboardEvent): void;
+    _onItemKeydown(event: KeyboardEvent, item: MenuItem): void;
+    private _focusItem;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DualTierNavSubmenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DualTierNavSubmenuComponent, "fui-dual-tier-nav-submenu", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "showHeader": { "alias": "showHeader"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; "closePanel": "closePanel"; }, never, never, true, never>;
+}
+
+declare class DualTierNavSubmenuHeaderComponent {
+    readonly title: _angular_core.InputSignal<string>;
+    readonly closable: _angular_core.InputSignal<boolean>;
+    readonly close: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DualTierNavSubmenuHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DualTierNavSubmenuHeaderComponent, "fui-dual-tier-nav-submenu-header", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; }, { "close": "close"; }, never, never, true, never>;
+}
+
+declare class DualTierNavSubmenuItemComponent {
+    readonly item: _angular_core.InputSignal<MenuItem>;
+    readonly isExpanded: _angular_core.InputSignal<boolean>;
+    readonly clickItem: _angular_core.OutputEmitterRef<MenuItem>;
+    readonly toggleExpand: _angular_core.OutputEmitterRef<{
+        item: MenuItem;
+        sourceEl?: HTMLElement;
+    }>;
+    readonly keydown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    hasChildren(): boolean;
+    _onClick(event: Event): void;
+    _onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DualTierNavSubmenuItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DualTierNavSubmenuItemComponent, "fui-dual-tier-nav-submenu-item", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; "isExpanded": { "alias": "isExpanded"; "required": false; "isSignal": true; }; }, { "clickItem": "clickItem"; "toggleExpand": "toggleExpand"; "keydown": "keydown"; }, never, never, true, never>;
+}
+
+export { DualTierNavSubmenuComponent, DualTierNavSubmenuHeaderComponent, DualTierNavSubmenuItemComponent, DualTierNavTriggerComponent, FuiDualTierNavigationComponent };
+//# sourceMappingURL=raintonic-formaui-components-dual-tier-navigation.d.ts.map

package/types/raintonic-formaui-components-dual-tier-navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-dual-tier-navigation.d.ts","sources":["../../../lib/components/dual-tier-navigation/dual-tier-navigation.component.ts","../../../lib/components/dual-tier-navigation/dual-tier-navigation-trigger.component.ts","../../../lib/components/dual-tier-navigation/dual-tier-navigation-submenu.component.ts","../../../lib/components/dual-tier-navigation/dual-tier-navigation-submenu-header.component.ts","../../../lib/components/dual-tier-navigation/dual-tier-navigation-submenu-item.component.ts"],"mappings":";;;AAeA,cAyGa,8BAA8B;AACzC;oBAEc,aAAA,CAAA,WAAA,CAAA,QAAA;wBACI,aAAA,CAAA,WAAA;wBACA,aAAA,CAAA,gBAAA,CAAA,QAAA;0BAEE,aAAA,CAAA,MAAA,CAAA,QAAA;0BAgBA,aAAA,CAAA,cAAA;4BAEE,aAAA,CAAA,MAAA,CAAA,QAAA;AAMtB;AAWA;AAaA,uBAAmB,QAAQ;qBAIV,KAAK,QAAQ,QAAQ;6BAMb,aAAa,QAAQ,QAAQ;oDAjE3C,8BAA8B;sDAA9B,8BAA8B;AAoI1C;;ACtPD;;;AAGG;AACH,cA8Ja,2BAA2B;mBACzB,aAAA,CAAA,WAAA,CAAA,QAAA;yBACM,aAAA,CAAA,WAAA;uBACF,aAAA,CAAA,WAAA;wBACC,aAAA,CAAA,gBAAA,CAAA,QAAA;qBACH,aAAA,CAAA,gBAAA,CAAA,KAAA;sBACC,aAAA,CAAA,gBAAA,CAAA,aAAA;0BAEI,aAAA,CAAA,MAAA;AAEpB,mBAAe,KAAK;AAcpB,qBAAiB,aAAa;oDAxBnB,2BAA2B;sDAA3B,2BAA2B;AA+BvC;;ACvLD,cA4Fa,2BAA2B;AACtC;oBAEc,aAAA,CAAA,WAAA;oBACA,aAAA,CAAA,WAAA,CAAA,QAAA;yBACK,aAAA,CAAA,WAAA;uBACF,aAAA,CAAA,WAAA;wBACC,aAAA,CAAA,gBAAA,CAAA,QAAA;yBACC,aAAA,CAAA,gBAAA;2BAEE,aAAA,CAAA,MAAA,CAAA,QAAA;wBACH,aAAA,CAAA,cAAA,CAAA,GAAA;;AAgBlB,uBAAmB,QAAQ;AAI3B,sBAAkB,QAAQ;AAI1B;AAIA,uBAAmB,QAAQ;0BAIL,QAAQ,mBAAmB,WAAW;AAyB5D,0BAAsB,aAAa;0BAmCb,aAAa,QAAQ,QAAQ;AAiBnD;oDAxHW,2BAA2B;sDAA3B,2BAA2B;AAkIvC;;AC3OD,cA4Da,iCAAiC;oBAC9B,aAAA,CAAA,WAAA;uBACG,aAAA,CAAA,WAAA;oBACH,aAAA,CAAA,gBAAA;oDAHH,iCAAiC;sDAAjC,iCAAiC;AAI7C;;AC9DD,cAgJa,+BAA+B;mBAC7B,aAAA,CAAA,WAAA,CAAA,QAAA;yBACM,aAAA,CAAA,WAAA;wBACD,aAAA,CAAA,gBAAA,CAAA,QAAA;AAClB,2BAAqB,aAAA,CAAA,gBAAA;cAAkB,QAAQ;mBAAa,WAAW;AAAM;sBAC7D,aAAA,CAAA,gBAAA,CAAA,aAAA;AAEhB;AAIA,oBAAgB,KAAK;AAcrB,sBAAkB,aAAa;oDAzBpB,+BAA+B;sDAA/B,+BAA+B;AAqD3C;;;;","names":[]}

package/types/raintonic-formaui-components-form-field.d.ts

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { Signal, InputSignal, QueryList, ElementRef, WritableSignal } from '@angular/core';
+import { Signal, InjectionToken, ElementRef, InputSignal, QueryList, WritableSignal } from '@angular/core';
 import * as _raintonic_formaui_core from '@raintonic/formaui/core';
 import { FuiIntlBase } from '@raintonic/formaui/core';
 
@@ -73,17 +73,41 @@ declare class FuiSuffixDirective {
 declare class FuiFormFieldIntl extends FuiIntlBase {
     copyAriaLabel: string;
     copiedAriaLabel: string;
+    copyTooltip: string;
+    copiedTooltip: string;
     static ɵfac: i0.ɵɵFactoryDeclaration<FuiFormFieldIntl, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FuiFormFieldIntl>;
 }
 
+/**
+ * Interface exposed by FuiFormFieldComponent for child controls.
+ *
+ * Child controls (select, autocomplete, date-picker) inject this token to
+ * access the form-field's overlay origin element — typically the wrapper
+ * container whose width the overlay panel should match.
+ */
+interface FuiFormFieldParent {
+    /**
+     * Returns the element that should be used as the width reference for
+     * overlay panels (e.g. select dropdown, autocomplete panel).
+     * This is typically the form-field wrapper element so the overlay
+     * correctly spans prefix/suffix areas.
+     */
+    getConnectedOverlayOrigin(): ElementRef<HTMLElement>;
+}
+/**
+ * Injection token for the parent form-field component.
+ * Child controls inject this (via @Optional()) to coordinate with the
+ * containing form-field without coupling to the component class directly.
+ */
+declare const FUI_FORM_FIELD: InjectionToken<FuiFormFieldParent>;
+
 /**
  * Available form field appearance modes.
  * - `'outline'` — default bordered appearance (Carbon Design System style)
  * - `'fill'` — filled background with bottom-border only
- * - `'float'` — floating-label that animates above the input on focus / value
  */
-type FormFieldAppearance = 'outline' | 'fill' | 'float';
+type FormFieldAppearance = 'outline' | 'fill';
 /**
  * # FormField Component
  *
@@ -162,20 +186,14 @@ type FormFieldAppearance = 'outline' | 'fill' | 'float';
  * }
  * ```
  */
-declare class FuiFormFieldComponent {
+declare class FuiFormFieldComponent implements FuiFormFieldParent {
     readonly intl: FuiFormFieldIntl;
     private readonly _cdr;
-    /**
-     * Whether the form field is in read-only mode.
-     * When true, hides the input and shows a plain text value instead.
-     * @default false
-     */
-    readonly readOnly: InputSignal<boolean>;
+    private readonly _elementRef;
     /**
      * Visual appearance variant.
      * - `'outline'` (default): bordered input with label above
      * - `'fill'`: filled background with bottom-border accent
-     * - `'float'`: label floats from inside the input to above it on focus/value
      */
     readonly appearance: InputSignal<FormFieldAppearance>;
     /**
@@ -187,28 +205,40 @@ declare class FuiFormFieldComponent {
     _prefixes?: QueryList<FuiPrefixDirective>;
     _suffixes?: QueryList<FuiSuffixDirective>;
     _connectionContainerRef?: ElementRef<HTMLElement>;
-    hideSubscript: InputSignal<boolean>;
+    private readonly _wrapperRef?;
+    hideSubscript: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly strengthMeter: Signal<_raintonic_formaui_core.FuiStrengthMeter | undefined>;
     readonly displayValue: Signal<string>;
     readonly isFocused: Signal<boolean>;
     readonly hasError: Signal<boolean>;
     readonly isDisabled: Signal<boolean>;
+    readonly isReadonly: Signal<boolean>;
     readonly isEmpty: Signal<boolean>;
     readonly isRequired: Signal<boolean>;
-    /**
-     * Whether the floating label should be in its "floated" (raised) position.
-     * Only meaningful when `appearance === 'float'`. True when the field is
-     * focused or contains a non-empty value.
-     */
-    readonly shouldFloat: Signal<boolean>;
+    /** Whether the projected control is a fui-number-input (needs zero horizontal padding) */
+    readonly isNumberInput: Signal<boolean>;
     /** Whether control-specific icons (dropdown caret, calendar) should be hidden in readOnly mode */
     readonly hideControlIcons: Signal<boolean>;
+    /** Whether the copy button should appear in read-only mode.
+     *  Delegates to the control's `readonlyCopyEnabled()` method.
+     *  Only plain inputs (`fuiInput`) opt in — defaults to `false`. */
+    readonly showCopyButton: Signal<boolean>;
     /** Whether the "copied" feedback indicator is active */
     readonly copied: WritableSignal<boolean>;
     private _copiedTimeout;
     readonly labelId: string;
     readonly hintId: string;
+    /** Whether the strength meter should be shown. Visible only when the control
+     * has a non-empty value (i.e. the user has typed something). */
+    readonly showStrengthMeter: Signal<boolean>;
     readonly errorId: string;
     constructor();
+    /**
+     * Returns the element that overlay panels (select, autocomplete, date-picker)
+     * should use as their width reference. This is the form-field wrapper which
+     * spans the full width including prefix/suffix areas.
+     */
+    getConnectedOverlayOrigin(): ElementRef<HTMLElement>;
     /**
      * Handles click on the form field container
      */
@@ -238,7 +268,7 @@ declare class FuiFormFieldComponent {
      */
     hasSuffix(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<FuiFormFieldComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FuiFormFieldComponent, "fui-form-field", never, { "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "hideRequiredMarker": { "alias": "hideRequiredMarker"; "required": false; "isSignal": true; }; "hideSubscript": { "alias": "hideSubscript"; "required": false; "isSignal": true; }; }, {}, ["control", "_prefixes", "_suffixes"], ["fui-label", "[fuiPrefix]", "*", "[fuiSuffix]", "fui-error", "fui-hint"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiFormFieldComponent, "fui-form-field", never, { "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "hideRequiredMarker": { "alias": "hideRequiredMarker"; "required": false; "isSignal": true; }; "hideSubscript": { "alias": "hideSubscript"; "required": false; "isSignal": true; }; }, {}, ["control", "strengthMeter", "_prefixes", "_suffixes"], ["fui-label", "[fuiPrefix]", "*", "[fuiSuffix]", "fui-error", "fui-hint", "fui-strength-meter"], true, never>;
 }
 
 /**
@@ -276,6 +306,6 @@ declare class FuiLabelComponent {
     static ɵcmp: i0.ɵɵComponentDeclaration<FuiLabelComponent, "fui-label", never, {}, {}, never, ["*"], true, never>;
 }
 
-export { FuiErrorComponent, FuiFormFieldComponent, FuiFormFieldIntl, FuiHintComponent, FuiLabelComponent, FuiPrefixDirective, FuiSuffixDirective };
-export type { FormFieldAppearance };
+export { FUI_FORM_FIELD, FuiErrorComponent, FuiFormFieldComponent, FuiFormFieldIntl, FuiHintComponent, FuiLabelComponent, FuiPrefixDirective, FuiSuffixDirective };
+export type { FormFieldAppearance, FuiFormFieldParent };
 //# sourceMappingURL=raintonic-formaui-components-form-field.d.ts.map

package/types/raintonic-formaui-components-form-field.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"raintonic-formaui-components-form-field.d.ts","sources":["../../../lib/components/form-field/error.component.ts","../../../lib/components/form-field/prefix.directive.ts","../../../lib/components/form-field/suffix.directive.ts","../../../lib/components/form-field/form-field.intl.ts","../../../lib/components/form-field/form-field.component.ts","../../../lib/components/form-field/hint.component.ts","../../../lib/components/form-field/label.component.ts"],"mappings":";;;;;AAGA;;;;;;;;;;;;;;;;AAgBG;AACH,cAWa,iBAAiB;AAC5B;;;;AAIG;kBACSA,EAAA,CAAA,WAAA;AAEZ;AAEA;;AAEG;oCAC6B,MAAM;yCAb3B,iBAAiB;2CAAjB,iBAAiB;AAsC7B;;ACnED;;;;;;;;;;;AAWG;AACH,cAOa,kBAAkB;yCAAlB,kBAAkB;2CAAlB,kBAAkB;AAAG;;ACnBlC;;;;;;;;;;;AAWG;AACH,cAOa,kBAAkB;yCAAlB,kBAAkB;2CAAlB,kBAAkB;AAAG;;AClBlC,cACa,gBAAiB,SAAQ,WAAW;AAC/C;AACA;yCAFW,gBAAgB;6CAAhB,gBAAgB;AAG5B;;ACoBD;;;;;AAKG;AACG,KAAM,mBAAmB;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6EG;AACH,cAuBa,qBAAqB;mBACnB,gBAAA;AACb;AAEA;;;;AAIG;AACH,uBAAmB,WAAW;AAE9B;;;;;AAKG;yBACgB,WAAA,CAAA,mBAAA;AAEnB;;;AAGG;AACH,iCAA6B,WAAW;AAGxC,aAAO,MAAA,CAAA,uBAAA,CAAA,mBAAA;AAEqD,gBAAY,SAAS,CAAC,kBAAkB;AACxC,gBAAY,SAAS,CAAC,kBAAkB;AAChD,8BAA0B,UAAU,CAAC,WAAW;AAEpG,mBAAa,WAAA;AAIb,2BAAuB,MAAM;AAmB7B,wBAAoB,MAAM;AAG1B,uBAAmB,MAAM;AAGzB,yBAAqB,MAAM;AAG3B,sBAAkB,MAAM;AAGxB,yBAAqB,MAAM;AAI3B;;;;AAIG;AACH,0BAAsB,MAAM;;AAM5B,+BAA2B,MAAM;;AAOjC,qBAAiB,cAAc;;;;;;AAuC/B;;AAEG;AACH,4BAAwB,UAAU;AAOlC;;AAEG;AACH;AAcA;;AAEG;;AAOH;;AAEG;AACH;AAoBA;;AAEG;AACH;AASA;;AAEG;AACH;AAIA;;AAEG;AACH;yCAjNW,qBAAqB;2CAArB,qBAAqB;AAoNjC;;AC1VD;;;;;;;;;;;;AAYG;AACH,cAQa,gBAAgB;yCAAhB,gBAAgB;2CAAhB,gBAAgB;AAAG;;ACrBhC;;;;;;;;;;;AAWG;AACH,cAQa,iBAAiB;yCAAjB,iBAAiB;2CAAjB,iBAAiB;AAAG;;;;","names":["_angular_core"]}
+{"version":3,"file":"raintonic-formaui-components-form-field.d.ts","sources":["../../../lib/components/form-field/error.component.ts","../../../lib/components/form-field/prefix.directive.ts","../../../lib/components/form-field/suffix.directive.ts","../../../lib/components/form-field/form-field.intl.ts","../../../lib/components/form-field/form-field-tokens.ts","../../../lib/components/form-field/form-field.component.ts","../../../lib/components/form-field/hint.component.ts","../../../lib/components/form-field/label.component.ts"],"mappings":";;;;;AAGA;;;;;;;;;;;;;;;;AAgBG;AACH,cAWa,iBAAiB;AAC5B;;;;AAIG;kBACSA,EAAA,CAAA,WAAA;AAEZ;AAEA;;AAEG;oCAC6B,MAAM;yCAb3B,iBAAiB;2CAAjB,iBAAiB;AAsC7B;;ACnED;;;;;;;;;;;AAWG;AACH,cAOa,kBAAkB;yCAAlB,kBAAkB;2CAAlB,kBAAkB;AAAG;;ACnBlC;;;;;;;;;;;AAWG;AACH,cAOa,kBAAkB;yCAAlB,kBAAkB;2CAAlB,kBAAkB;AAAG;;AClBlC,cACa,gBAAiB,SAAQ,WAAW;AAC/C;AACA;AACA;AACA;yCAJW,gBAAgB;6CAAhB,gBAAgB;AAK5B;;ACND;;;;;;AAMG;UACc,kBAAkB;AACjC;;;;;AAKG;AACH,iCAA6B,UAAU,CAAC,WAAW;AACpD;AAED;;;;AAIG;AACH,cAAa,cAAc,EAAA,cAAA,CAAA,kBAAA;;ACO3B;;;;AAIG;KACS,mBAAmB;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6EG;AACH,cA4Ba,qBAAsB,YAAW,kBAAkB;mBACjD,gBAAA;AACb;AACA;AAEA;;;;AAIG;yBACgB,WAAA,CAAA,mBAAA;AAEnB;;;AAGG;AACH,iCAA6B,WAAW;AAGxC,aAAO,MAAA,CAAA,uBAAA,CAAA,mBAAA;AAEqD,gBAAY,SAAS,CAAC,kBAAkB;AACxC,gBAAY,SAAS,CAAC,kBAAkB;AAChD,8BAA0B,UAAU,CAAC,WAAW;AAC5D;AAExC,mBAAaA,EAAA,CAAA,wBAAA;4BAGS,MAAA,CAAA,uBAAA,CAAA,gBAAA;AAItB,2BAAuB,MAAM;AAmB7B,wBAAoB,MAAM;AAG1B,uBAAmB,MAAM;AAGzB,yBAAqB,MAAM;AAG3B,yBAAqB,MAAM;AAG3B,sBAAkB,MAAM;AAGxB,yBAAqB,MAAM;;AAK3B,4BAAwB,MAAM;;AAK9B,+BAA2B,MAAM;AAMjC;;AAEmE;AACnE,6BAAyB,MAAM;;AAM/B,qBAAiB,cAAc;;;;AAO/B;AACgE;AAChE,gCAA4B,MAAM;;;AA8BlC;;;;AAIG;AACH,iCAA6B,UAAU,CAAC,WAAW;AAInD;;AAEG;AACH,4BAAwB,UAAU;AAOlC;;AAEG;AACH;AAcA;;AAEG;;AAOH;;AAEG;AACH;AAoBA;;AAEG;AACH;AASA;;AAEG;AACH;AAIA;;AAEG;AACH;yCA7NW,qBAAqB;2CAArB,qBAAqB;AAgOjC;;AC/WD;;;;;;;;;;;;AAYG;AACH,cAQa,gBAAgB;yCAAhB,gBAAgB;2CAAhB,gBAAgB;AAAG;;ACrBhC;;;;;;;;;;;AAWG;AACH,cAQa,iBAAiB;yCAAjB,iBAAiB;2CAAjB,iBAAiB;AAAG;;;;","names":["_angular_core"]}