@raintonic/formaui 0.2.0

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

@@ -0,0 +1,307 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, AfterViewInit, InputSignal, OutputEmitterRef, WritableSignal, InjectionToken, DoCheck, AfterContentInit, Signal, ElementRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { FuiFormFieldControl, ErrorStateMatcher } from '@raintonic/formaui/core';
+
+/**
+ * # 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>
+ * ```
+ */
+declare class FuiOptionComponent implements OnDestroy, AfterViewInit {
+    static nextId: number;
+    /**
+     * The value of the option
+     */
+    readonly value: InputSignal<unknown>;
+    /**
+     * Whether the option is disabled
+     * @default false
+     */
+    readonly disabled: InputSignal<boolean>;
+    /**
+     * Event emitted when the option is selected
+     */
+    readonly selectionChange: OutputEmitterRef<{
+        source: FuiOptionComponent;
+        value: unknown;
+    }>;
+    readonly _selected: WritableSignal<boolean>;
+    readonly _active: WritableSignal<boolean>;
+    readonly stateChanges: Subject<void>;
+    private readonly _element;
+    private readonly _parentSelect;
+    readonly id: string;
+    readonly _showCheckmark: WritableSignal<boolean>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    get viewValue(): string;
+    _handleClick(event: Event): void;
+    _handleMouseEnter(): void;
+    _handleMouseLeave(): void;
+    /**
+     * Selects the option
+     */
+    select(): void;
+    /**
+     * Deselects the option
+     */
+    deselect(): void;
+    /**
+     * Sets the option as active (keyboard navigation)
+     */
+    setActive(): void;
+    /**
+     * Sets the option as inactive
+     */
+    setInactive(): void;
+    /**
+     * Sets focus onto this option
+     */
+    focus(): void;
+    /**
+     * Gets the label to be used when displaying the option
+     */
+    getLabel(): string;
+    /**
+     * 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<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>;
+}
+
+/**
+ * Interface representing the parent select contract that options need.
+ * Used to break the circular dependency between select and option components.
+ */
+interface FuiSelectParent {
+    multiple(): boolean;
+    _onOptionSelected(option: any): void;
+}
+/**
+ * Injection token used to provide the parent select to options.
+ */
+declare const FUI_SELECT: InjectionToken<FuiSelectParent>;
+
+/**
+ * Available select sizes
+ */
+type FuiSelectSize = 'sm' | 'md' | 'lg';
+/**
+ * Available select variants following Carbon Design System patterns
+ */
+type FuiSelectVariant = 'outlined' | 'filled';
+/**
+ * Selection change event object emitted when the select's selection changes
+ */
+interface FuiSelectChange {
+    source: FuiSelectComponent;
+    value: unknown;
+}
+/**
+ * # fui-select Component
+ *
+ * A select component designed to work seamlessly with fui-form-field.
+ * Similar to Angular Material's mat-select integration with mat-form-field.
+ * Provides full Reactive Forms support with validation and error handling.
+ *
+ * ## Features
+ * - Works inside fui-form-field like mat-select
+ * - Full Reactive Forms integration (ControlValueAccessor)
+ * - Multiple selection support
+ * - Options via projected content (fui-option)
+ * - Disabled and readonly states
+ * - Full accessibility support
+ * - Full keyboard navigation (Arrow keys, Enter, Space, Escape, Home, End)
+ * - Type-ahead search functionality
+ *
+ * ## Usage
+ *
+ * ### Basic Select with Form Field
+ * ```html
+ * <fui-form-field>
+ *   <label>Country</label>
+ *   <fui-select placeholder="Select a country">
+ *     <fui-option value="us">United States</fui-option>
+ *     <fui-option value="ca">Canada</fui-option>
+ *     <fui-option value="mx">Mexico</fui-option>
+ *   </fui-select>
+ * </fui-form-field>
+ * ```
+ *
+ * ### With Reactive Forms and Validation
+ * ```html
+ * <form [formGroup]="form">
+ *   <fui-form-field>
+ *     <label>Country</label>
+ *     <fui-select formControlName="country" placeholder="Select a country">
+ *       <fui-option value="us">United States</fui-option>
+ *       <fui-option value="ca">Canada</fui-option>
+ *     </fui-select>
+ *     <fui-error *ngIf="form.get('country')?.hasError('required')">
+ *       Country is required
+ *     </fui-error>
+ *   </fui-form-field>
+ * </form>
+ * ```
+ *
+ * ### Multiple Selection
+ * ```html
+ * <fui-form-field>
+ *   <label>Skills</label>
+ *   <fui-select formControlName="skills" [multiple]="true">
+ *     <fui-option value="js">JavaScript</fui-option>
+ *     <fui-option value="ts">TypeScript</fui-option>
+ *     <fui-option value="py">Python</fui-option>
+ *   </fui-select>
+ * </fui-form-field>
+ * ```
+ */
+declare class FuiSelectComponent implements ControlValueAccessor, FuiFormFieldControl, DoCheck, OnDestroy, AfterContentInit {
+    static nextId: number;
+    readonly controlType = "fui-select";
+    readonly placeholderInput: InputSignal<string>;
+    readonly disabledInput: InputSignal<boolean>;
+    readonly readonly: InputSignal<boolean>;
+    readonly multiple: InputSignal<boolean>;
+    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<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>;
+    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>;
+    readonly options: Signal<readonly FuiOptionComponent[]>;
+    readonly panelOpen: WritableSignal<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 TYPE_AHEAD_DEBOUNCE;
+    private _onChange;
+    private _onTouched;
+    readonly displayValue: Signal<string>;
+    constructor();
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    ngAfterContentInit(): 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;
+    private _syncOptionsSelection;
+    _onFocus(): void;
+    _onBlur(event?: FocusEvent): void;
+    focus(): void;
+    blur(): void;
+    toggle(): void;
+    open(): void;
+    close(restoreFocus?: boolean): void;
+    _onOptionSelected(option: FuiOptionComponent): void;
+    _getDisplayValue(): string;
+    _handleKeydown(event: KeyboardEvent): void;
+    private _handleClosedKeydown;
+    private _handleOpenKeydown;
+    private _setNextActiveOption;
+    private _setActiveOptionIndex;
+    private _setInitialActiveOption;
+    private _scrollToActiveOption;
+    private _handleTypeahead;
+    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>;
+    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>;
+}
+
+export { FUI_SELECT, 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

@@ -0,0 +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;AAgDA;AAkBA;AAwBA;AAuBA;AAyBA;AA2BA;AAQA;AAQA;AAKA;AAgCA;AAsDA;;AAkBA;;;AAGG;AACH;AASA,oBAAgB,MAAM;;yCAvwBX,kBAAkB;2CAAlB,kBAAkB;AA+wB9B;;;;","names":[]}

package/types/raintonic-formaui-components-side-panel.d.ts

@@ -0,0 +1,51 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * @component FuiSidePanelComponent
+ * @selector fui-side-panel
+ * @description A slide-in side panel overlay with optional backdrop, focus trapping, and keyboard dismiss.
+ * Renders from the right edge of the viewport with configurable width and top offset.
+ *
+ * @input open - Whether the side panel is visible. Default false.
+ * @input title - Title text displayed in the panel header.
+ * @input width - CSS width of the panel. Default '500px'.
+ * @input hasBackdrop - Whether to show a backdrop behind the panel. Default true.
+ * @input topOffset - CSS top offset (e.g. to clear a fixed toolbar). Default '0px'.
+ * @input ariaLabel - ARIA label for the panel when no visible title is present.
+ * @input ariaLabelledBy - ID of an element that labels the panel.
+ * @output closed - Emits when the panel requests closing (close button, Escape, or backdrop click).
+ *
+ * @cssvar --_side-panel-top-offset - Internal CSS variable set from the topOffset input.
+ *
+ * @example
+ * <fui-side-panel [open]="isPanelOpen" title="Details" (closed)="isPanelOpen = false">
+ *   <p>Panel content here.</p>
+ * </fui-side-panel>
+ */
+declare class FuiSidePanelComponent {
+    private readonly _document;
+    readonly open: _angular_core.InputSignal<boolean>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly width: _angular_core.InputSignal<string>;
+    readonly hasBackdrop: _angular_core.InputSignal<boolean>;
+    readonly topOffset: _angular_core.InputSignal<string>;
+    /** ARIA label for the side panel, used when no visible title is present */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /** ID of an element that labels the side panel */
+    readonly ariaLabelledBy: _angular_core.InputSignal<string | null>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private _panelElement?;
+    private _previouslyFocusedElement;
+    constructor();
+    onKeydown(event: KeyboardEvent): void;
+    close(): void;
+    private _saveFocusAndTrap;
+    private _restoreFocus;
+    private _focusFirstTabbable;
+    private _getFocusableElements;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiSidePanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiSidePanelComponent, "fui-side-panel", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "topOffset": { "alias": "topOffset"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["*", "[sidePanelFooter]"], true, never>;
+}
+
+export { FuiSidePanelComponent };
+//# sourceMappingURL=raintonic-formaui-components-side-panel.d.ts.map

package/types/raintonic-formaui-components-side-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-side-panel.d.ts","sources":["../../../lib/components/side-panel/side-panel.component.ts"],"mappings":";;AAeA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACH,cAea,qBAAqB;AAChC;mBAEa,aAAA,CAAA,WAAA;oBACC,aAAA,CAAA,WAAA;oBACA,aAAA,CAAA,WAAA;0BACM,aAAA,CAAA,WAAA;wBACF,aAAA,CAAA,WAAA;;wBAGA,aAAA,CAAA,WAAA;;6BAGK,aAAA,CAAA,WAAA;qBAER,aAAA,CAAA,gBAAA;;;;AAoBf,qBAAiB,aAAa;AAmC9B;AAIA;AAQA;AAOA;AASA;oDAlGW,qBAAqB;sDAArB,qBAAqB;AAkHjC;;;;","names":[]}

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

@@ -0,0 +1,174 @@
+import * as i0 from '@angular/core';
+import { InputSignal, OutputEmitterRef, WritableSignal, Signal } from '@angular/core';
+
+/**
+ * Sidebar mode type
+ */
+type FuiSidebarMode = 'side' | 'over' | 'push';
+/**
+ * Sidebar position type
+ */
+type FuiSidebarPosition = 'start' | 'end';
+/**
+ * Sidebar navigation item interface
+ */
+interface FuiSidebarNavItem {
+    id: string;
+    label: string;
+    icon?: string;
+    route?: string;
+    active?: boolean;
+    disabled?: boolean;
+    children?: FuiSidebarNavItem[];
+    expanded?: boolean;
+}
+/**
+ * # FuiSidebar Component
+ *
+ * A flexible sidebar component following Carbon Design System principles.
+ * Provides navigation with Angular Material-like APIs and responsive behavior.
+ *
+ * ## Features
+ * - Multiple modes: side, over, push
+ * - Collapsible with toggle functionality
+ * - Hierarchical navigation support
+ * - Responsive behavior
+ * - Theme integration
+ * - Accessibility support
+ * - Custom content projection
+ *
+ * ## Usage
+ *
+ * ### Basic Sidebar
+ * ```html
+ * <fui-sidebar
+ *   [opened]="sidebarOpen"
+ *   [mode]="'side'"
+ *   [navItems]="navigationItems"
+ *   (openedChange)="onSidebarToggle($event)"
+ *   (navItemClick)="onNavItemClick($event)">
+ *
+ *   <div header>
+ *     <h3>Navigation</h3>
+ *   </div>
+ *
+ *   <div footer>
+ *     <p>Version 1.0.0</p>
+ *   </div>
+ * </fui-sidebar>
+ * ```
+ *
+ * ### Responsive Sidebar
+ * ```html
+ * <fui-sidebar
+ *   [opened]="sidebarOpen"
+ *   [mode]="isDesktop ? 'side' : 'over'"
+ *   [backdrop]="!isDesktop"
+ *   [navItems]="navigationItems">
+ * </fui-sidebar>
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { FuiSidebarComponent, FuiSidebarNavItem } from '@raintonic/formaui/components/sidebar';
+ *
+ * @Component({
+ *   standalone: true,
+ *   imports: [FuiSidebarComponent],
+ *   template: `
+ *     <fui-sidebar
+ *       [opened]="sidebarOpen"
+ *       [mode]="sidebarMode"
+ *       [navItems]="navItems"
+ *       (openedChange)="onSidebarToggle($event)"
+ *       (navItemClick)="onNavItemClick($event)">
+ *
+ *       <div header class="sidebar-header">
+ *         <h3>Holiday ERP</h3>
+ *       </div>
+ *     </fui-sidebar>
+ *   `
+ * })
+ * export class AppLayoutComponent {
+ *   sidebarOpen = true;
+ *   sidebarMode: FuiSidebarMode = 'side';
+ *
+ *   navItems: FuiSidebarNavItem[] = [
+ *     { id: 'dashboard', label: 'Dashboard', icon: 'house', route: '/dashboard' },
+ *     {
+ *       id: 'sales',
+ *       label: 'Sales',
+ *       icon: 'shopping-cart',
+ *       children: [
+ *         { id: 'orders', label: 'Orders', route: '/sales/orders' },
+ *         { id: 'invoices', label: 'Invoices', route: '/sales/invoices' },
+ *       ]
+ *     },
+ *     { id: 'products', label: 'Products', icon: 'package', route: '/products' },
+ *   ];
+ *
+ *   onSidebarToggle(opened: boolean): void {
+ *     this.sidebarOpen = opened;
+ *   }
+ *
+ *   onNavItemClick(item: FuiSidebarNavItem): void {
+ *     console.log('Navigation item clicked:', item.id);
+ *   }
+ * }
+ * ```
+ */
+declare class FuiSidebarComponent {
+    readonly opened: InputSignal<boolean>;
+    readonly mode: InputSignal<FuiSidebarMode>;
+    readonly position: InputSignal<FuiSidebarPosition>;
+    readonly backdrop: InputSignal<boolean>;
+    readonly width: InputSignal<string>;
+    readonly navItems: InputSignal<FuiSidebarNavItem[]>;
+    readonly collapsible: InputSignal<boolean>;
+    readonly openedChange: OutputEmitterRef<boolean>;
+    readonly navItemClick: OutputEmitterRef<FuiSidebarNavItem>;
+    readonly backdropClick: OutputEmitterRef<void>;
+    readonly expandedItems: WritableSignal<Set<string>>;
+    readonly sidebarClasses: Signal<string>;
+    readonly backdropClasses: Signal<string>;
+    readonly sidebarStyles: Signal<Record<string, string>>;
+    /**
+     * Toggle sidebar open/closed state
+     */
+    toggle(): void;
+    /**
+     * Open the sidebar
+     */
+    open(): void;
+    /**
+     * Close the sidebar
+     */
+    close(): void;
+    /**
+     * Handle navigation item click
+     */
+    onNavItemClick(item: FuiSidebarNavItem): void;
+    /**
+     * Toggle expansion state of a navigation item
+     */
+    toggleItemExpansion(itemId: string): void;
+    /**
+     * Check if item is expanded
+     */
+    isItemExpanded(itemId: string): boolean;
+    /**
+     * Handle backdrop click
+     */
+    onBackdropClick(): void;
+    /**
+     * Get navigation item classes
+     */
+    getNavItemClasses(item: FuiSidebarNavItem, level?: number): string;
+    onEsc(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiSidebarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiSidebarComponent, "fui-sidebar", never, { "opened": { "alias": "opened"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "backdrop": { "alias": "backdrop"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "navItems": { "alias": "navItems"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; }, { "openedChange": "openedChange"; "navItemClick": "navItemClick"; "backdropClick": "backdropClick"; }, never, ["[header]", "*", "[footer]"], true, never>;
+}
+
+export { FuiSidebarComponent };
+export type { FuiSidebarMode, FuiSidebarNavItem, FuiSidebarPosition };
+//# sourceMappingURL=raintonic-formaui-components-sidebar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-sidebar.d.ts","sources":["../../../lib/components/sidebar/sidebar.component.ts"],"mappings":";;;AAiBA;;AAEG;AACG,KAAM,cAAc;AAE1B;;AAEG;KACS,kBAAkB;AAE9B;;AAEG;UACc,iBAAiB;;;;;;;AAOhC,eAAW,iBAAiB;;AAE7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8FG;AACH,cAkBa,mBAAmB;AAE9B,qBAAiB,WAAW;AAC5B,mBAAe,WAAW,CAAC,cAAc;AACzC,uBAAmB,WAAW,CAAC,kBAAkB;AACjD,uBAAmB,WAAW;AAC9B,oBAAgB,WAAW;uBACR,WAAW,CAAC,iBAAiB;AAChD,0BAAsB,WAAW;AAGjC,2BAAuB,gBAAgB;AACvC,2BAAuB,gBAAgB,CAAC,iBAAiB;AACzD,4BAAwB,gBAAgB;4BAGhB,cAAc,CAAC,GAAG;AAG1C,6BAAyB,MAAM;AAa/B,8BAA0B,MAAM;AAUhC,4BAAwB,MAAM,CAAC,MAAM;AAMrC;;AAEG;AACH;AAKA;;AAEG;AACH;AAMA;;AAEG;AACH;AAMA;;AAEG;AACH,yBAAqB,iBAAiB;AAkBtC;;AAEG;AACH;AAaA;;AAEG;AACH;AAIA;;AAEG;AACH;AAKA;;AAEG;4BACqB,iBAAiB;AA2BzC;yCA5JW,mBAAmB;2CAAnB,mBAAmB;AAiK/B;;;;","names":[]}

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

@@ -0,0 +1,20 @@
+import * as _angular_core from '@angular/core';
+
+type FuiSkeletonVariant = 'text' | 'circle' | 'rect';
+
+declare class FuiSkeletonComponent {
+    readonly variant: _angular_core.InputSignal<FuiSkeletonVariant>;
+    readonly width: _angular_core.InputSignal<string | null>;
+    readonly height: _angular_core.InputSignal<string | null>;
+    readonly lines: _angular_core.InputSignal<number>;
+    readonly animated: _angular_core.InputSignal<boolean>;
+    readonly borderRadius: _angular_core.InputSignal<string | null>;
+    readonly computedStyles: _angular_core.Signal<Record<string, string>>;
+    readonly linesArray: _angular_core.Signal<number[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiSkeletonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiSkeletonComponent, "fui-skeleton", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "animated": { "alias": "animated"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { FuiSkeletonComponent };
+export type { FuiSkeletonVariant };
+//# sourceMappingURL=raintonic-formaui-components-skeleton.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-skeleton.d.ts","sources":["../../../lib/components/skeleton/skeleton.types.ts","../../../lib/components/skeleton/skeleton.component.ts"],"mappings":";;AAAM,KAAM,kBAAkB;;ACG9B,cAkBa,oBAAoB;sBACf,aAAA,CAAA,WAAA,CAAA,kBAAA;oBACF,aAAA,CAAA,WAAA;qBACC,aAAA,CAAA,WAAA;oBACD,aAAA,CAAA,WAAA;uBACG,aAAA,CAAA,WAAA;2BACI,aAAA,CAAA,WAAA;6BAEE,aAAA,CAAA,MAAA,CAAA,MAAA;yBAmBJ,aAAA,CAAA,MAAA;oDA3BR,oBAAoB;sDAApB,oBAAoB;AA4BhC;;;;","names":[]}