@raintonic/formaui 0.2.0

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

@@ -0,0 +1,108 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, WritableSignal, Signal, ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+type SliderValue = number | [number, number];
+interface SliderChange {
+    source: unknown;
+    value: SliderValue;
+}
+type SliderFormatLabelFn = (value: number) => string;
+
+/**
+ * # FuiSliderComponent
+ *
+ * A slider (range input) component with single and dual-thumb (range) support.
+ * Integrates with Angular Reactive Forms via ControlValueAccessor.
+ *
+ * ## Features
+ * - Single value and range (dual-thumb) modes
+ * - Configurable min/max/step
+ * - Optional tick marks and tooltips
+ * - Custom label formatting
+ * - Keyboard navigation (Arrow keys, Home, End, PageUp/Down)
+ * - Drag and click-to-move interaction
+ * - Full accessibility (ARIA slider role)
+ *
+ * ## Usage
+ *
+ * ### Basic Slider
+ * ```html
+ * <fui-slider [formControl]="volumeControl"></fui-slider>
+ * ```
+ *
+ * ### Range Slider
+ * ```html
+ * <fui-slider [range]="true" [formControl]="priceRange"></fui-slider>
+ * ```
+ *
+ * ### With Ticks and Custom Label
+ * ```html
+ * <fui-slider [showTicks]="true" [formatLabel]="formatCurrency" [min]="0" [max]="1000" [step]="100"></fui-slider>
+ * ```
+ */
+declare class FuiSliderComponent implements ControlValueAccessor, OnDestroy {
+    private readonly _document;
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly range: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showTicks: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showTooltip: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly formatLabel: _angular_core.InputSignal<SliderFormatLabelFn>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly ariaLabelLow: _angular_core.InputSignal<string | null>;
+    readonly ariaLabelHigh: _angular_core.InputSignal<string | null>;
+    readonly valueChange: _angular_core.OutputEmitterRef<SliderValue>;
+    readonly dragStart: _angular_core.OutputEmitterRef<void>;
+    readonly dragEnd: _angular_core.OutputEmitterRef<void>;
+    readonly _value: WritableSignal<number>;
+    readonly _valueLow: WritableSignal<number>;
+    readonly _valueHigh: WritableSignal<number>;
+    readonly _dragging: WritableSignal<'low' | 'high' | null>;
+    readonly _hovered: WritableSignal<'low' | 'high' | null>;
+    readonly _sliderContainer: Signal<ElementRef<HTMLElement> | undefined>;
+    readonly _percentage: Signal<number>;
+    readonly _percentageLow: Signal<number>;
+    readonly _percentageHigh: Signal<number>;
+    readonly _tickValues: Signal<number[]>;
+    private _onChange;
+    private _onTouched;
+    private _boundOnMouseMove;
+    private _boundOnMouseUp;
+    private _boundOnTouchMove;
+    private _boundOnTouchEnd;
+    writeValue(value: SliderValue): void;
+    registerOnChange(fn: (value: SliderValue) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(_isDisabled: boolean): void;
+    ngOnDestroy(): void;
+    _valueToPercent(value: number): number;
+    _isTickActive(tick: number): boolean;
+    _snapToStep(value: number): number;
+    _clamp(value: number, min: number, max: number): number;
+    _onTrackClick(event: MouseEvent): void;
+    _onThumbMouseDown(event: MouseEvent, thumb: 'low' | 'high'): void;
+    _onThumbTouchStart(event: TouchEvent, thumb: 'low' | 'high'): void;
+    _onThumbKeydown(event: KeyboardEvent, thumb: 'low' | 'high'): void;
+    private _onMouseMove;
+    private _onMouseUp;
+    private _onTouchMove;
+    private _onTouchEnd;
+    private _endDrag;
+    private _removeDocumentListeners;
+    private _getValueFromEvent;
+    private _getValueFromClientX;
+    private _updateDraggingThumb;
+    private _getThumbValue;
+    private _setThumbValue;
+    private _setNearestThumb;
+    private _emitChange;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiSliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiSliderComponent, "fui-slider", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "showTicks": { "alias": "showTicks"; "required": false; "isSignal": true; }; "showTooltip": { "alias": "showTooltip"; "required": false; "isSignal": true; }; "formatLabel": { "alias": "formatLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelLow": { "alias": "ariaLabelLow"; "required": false; "isSignal": true; }; "ariaLabelHigh": { "alias": "ariaLabelHigh"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "dragStart": "dragStart"; "dragEnd": "dragEnd"; }, never, never, true, never>;
+}
+
+export { FuiSliderComponent };
+export type { SliderChange, SliderFormatLabelFn, SliderValue };
+//# sourceMappingURL=raintonic-formaui-components-slider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-slider.d.ts","sources":["../../../lib/components/slider/slider.types.ts","../../../lib/components/slider/slider.component.ts"],"mappings":";;;;AAAM,KAAM,WAAW;UAEN,YAAY;;WAEpB,WAAW;AACnB;AAEK,KAAM,mBAAmB;;ACa/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;AACH,cAsBa,kBAAmB,YAAW,oBAAoB,EAAE,SAAS;AACxE;kBAGY,aAAA,CAAA,WAAA;kBACA,aAAA,CAAA,WAAA;mBACC,aAAA,CAAA,WAAA;oBACC,aAAA,CAAA,wBAAA;wBACI,aAAA,CAAA,wBAAA;0BACE,aAAA,CAAA,wBAAA;0BACA,aAAA,CAAA,WAAA,CAAA,mBAAA;uBACH,aAAA,CAAA,wBAAA;wBACC,aAAA,CAAA,WAAA;2BACG,aAAA,CAAA,WAAA;4BACC,aAAA,CAAA,WAAA;0BAGF,aAAA,CAAA,gBAAA,CAAA,WAAA;wBACF,aAAA,CAAA,gBAAA;sBACF,aAAA,CAAA,gBAAA;AAGhB,qBAAiB,cAAc;AAC/B,wBAAoB,cAAc;AAClC,yBAAqB,cAAc;wBACf,cAAc;uBACf,cAAc;AAGjC,+BAA2B,MAAM,CAAC,UAAU,CAAC,WAAW;AAIxD,0BAAsB,MAAM;AAE5B,6BAAyB,MAAM;AAE/B,8BAA0B,MAAM;0BAGV,MAAM;;;;;;;AA8B5B,sBAAkB,WAAW;iCAWA,WAAW;AAIxC;AAIA;AAIA;AAMA;AAOA;AAOA;AAQA;AAMA,yBAAqB,UAAU;6BAcN,UAAU;8BAYT,UAAU;2BAYb,aAAa;AA6CpC;AAMA;AAMA;AASA;AAMA;AAQA;AAOA;AAIA;AAUA;AAOA;AAOA;AAcA;AAcA;oDApTW,kBAAkB;sDAAlB,kBAAkB;AAyT9B;;;;","names":[]}

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

@@ -0,0 +1,42 @@
+import * as _angular_core from '@angular/core';
+
+type FuiSpinnerMode = 'indeterminate' | 'determinate';
+type FuiSpinnerSize = 'sm' | 'md' | 'lg';
+
+/**
+ * @component FuiSpinnerComponent
+ * @selector fui-spinner
+ * @description A circular loading spinner with determinate and indeterminate modes.
+ * Supports an overlay mode that covers its parent container.
+ *
+ * @input mode - Spinner mode: 'determinate' | 'indeterminate'. Default 'indeterminate'.
+ * @input value - Progress value (0-100) for determinate mode. Default 0.
+ * @input size - Spinner size: 'sm' | 'md' | 'lg'. Default 'md'.
+ * @input color - Optional custom CSS color for the spinner stroke.
+ * @input overlay - Whether to render as a full-area overlay. Default false.
+ * @input ariaLabel - Accessible label. Default 'Loading'.
+ *
+ * @example
+ * <fui-spinner></fui-spinner>
+ *
+ * @example
+ * <fui-spinner mode="determinate" [value]="progress" size="lg"></fui-spinner>
+ */
+declare class FuiSpinnerComponent {
+    readonly mode: _angular_core.InputSignal<FuiSpinnerMode>;
+    readonly value: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly size: _angular_core.InputSignal<FuiSpinnerSize>;
+    readonly color: _angular_core.InputSignal<string | null>;
+    readonly overlay: _angular_core.InputSignal<boolean>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    private readonly RADIUS;
+    readonly circumference: number;
+    readonly clampedValue: _angular_core.Signal<number>;
+    readonly strokeDashoffset: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiSpinnerComponent, "fui-spinner", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "overlay": { "alias": "overlay"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { FuiSpinnerComponent };
+export type { FuiSpinnerMode, FuiSpinnerSize };
+//# sourceMappingURL=raintonic-formaui-components-spinner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-spinner.d.ts","sources":["../../../lib/components/spinner/spinner.types.ts","../../../lib/components/spinner/spinner.component.ts"],"mappings":";;KAAY,cAAc;AACpB,KAAM,cAAc;;ACE1B;;;;;;;;;;;;;;;;;;AAkBG;AACH,cAwBa,mBAAmB;mBACjB,aAAA,CAAA,WAAA,CAAA,cAAA;oBACC,aAAA,CAAA,wBAAA;mBACD,aAAA,CAAA,WAAA,CAAA,cAAA;oBACC,aAAA,CAAA,WAAA;sBACE,aAAA,CAAA,WAAA;wBACE,aAAA,CAAA,WAAA;AAElB;;2BAGqB,aAAA,CAAA,MAAA;+BACI,aAAA,CAAA,MAAA;oDAZd,mBAAmB;sDAAnB,mBAAmB;AAe/B;;;;","names":[]}

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

@@ -0,0 +1,126 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, WritableSignal, Signal, TemplateRef } from '@angular/core';
+import { AbstractControl } from '@angular/forms';
+
+type StepperOrientation = 'horizontal' | 'vertical';
+type StepState = 'active' | 'completed' | 'error' | 'disabled' | 'default';
+interface StepSelectionChange {
+    selectedIndex: number;
+    previousIndex: number;
+    selectedStep: unknown;
+    previousStep: unknown;
+}
+declare const FORMAUI_STEPPER: InjectionToken<unknown>;
+
+/**
+ * # FuiStepComponent
+ *
+ * Represents a single step within an `fui-stepper`.
+ * Each step has a label, optional description/icon, and content that is lazily rendered.
+ *
+ * ## Usage
+ *
+ * ```html
+ * <fui-stepper>
+ *   <fui-step label="Account" description="Create your account">
+ *     <p>Account creation form here...</p>
+ *   </fui-step>
+ *   <fui-step label="Profile" icon="user">
+ *     <p>Profile setup here...</p>
+ *   </fui-step>
+ * </fui-stepper>
+ * ```
+ */
+declare class FuiStepComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly description: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly completed: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly editable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly errorMessage: _angular_core.InputSignal<string>;
+    readonly stepControl: _angular_core.InputSignal<AbstractControl<any, any, any> | null>;
+    readonly optional: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly _interacted: WritableSignal<boolean>;
+    readonly contentTemplate: Signal<TemplateRef<unknown> | undefined>;
+    readonly hasError: Signal<boolean>;
+    readonly state: Signal<StepState>;
+    /** Mark this step as interacted and select it via the parent stepper. */
+    select(): void;
+    /** 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>;
+}
+
+/**
+ * # FuiStepperComponent
+ *
+ * A stepper component that guides users through a sequence of steps.
+ * Supports horizontal and vertical orientations, linear and non-linear navigation,
+ * step validation, and lazy content rendering.
+ *
+ * ## Usage
+ *
+ * ### Basic horizontal stepper
+ * ```html
+ * <fui-stepper>
+ *   <fui-step label="Step 1">Content 1</fui-step>
+ *   <fui-step label="Step 2">Content 2</fui-step>
+ *   <fui-step label="Step 3">Content 3</fui-step>
+ * </fui-stepper>
+ * ```
+ *
+ * ### Vertical stepper
+ * ```html
+ * <fui-stepper orientation="vertical">
+ *   <fui-step label="Step 1">Content 1</fui-step>
+ *   <fui-step label="Step 2">Content 2</fui-step>
+ * </fui-stepper>
+ * ```
+ *
+ * ### Linear stepper with form validation
+ * ```html
+ * <fui-stepper [linear]="true">
+ *   <fui-step label="Account" [stepControl]="accountForm">
+ *     <form [formGroup]="accountForm">...</form>
+ *   </fui-step>
+ *   <fui-step label="Address" [stepControl]="addressForm">
+ *     <form [formGroup]="addressForm">...</form>
+ *   </fui-step>
+ * </fui-stepper>
+ * ```
+ */
+declare class FuiStepperComponent {
+    readonly orientation: _angular_core.InputSignal<StepperOrientation>;
+    readonly linear: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly selectedIndex: _angular_core.InputSignal<number>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<StepSelectionChange>;
+    readonly animationDone: _angular_core.OutputEmitterRef<void>;
+    readonly steps: _angular_core.Signal<readonly FuiStepComponent[]>;
+    readonly _selectedIndex: WritableSignal<number>;
+    readonly _uniqueId: number;
+    readonly _selectedStep: _angular_core.Signal<FuiStepComponent>;
+    constructor();
+    /** Navigate to the next step. In linear mode, validates the current step first. */
+    next(): void;
+    /** Navigate to the previous step. */
+    previous(): void;
+    /** Navigate directly to a specific step by index. */
+    goToStep(index: number): void;
+    /** Reset all steps and return to the first step. */
+    reset(): void;
+    /** @internal Handle step header click */
+    _onStepHeaderClick(index: number): void;
+    /** @internal Check if a step is disabled for navigation */
+    _isStepDisabled(index: number): boolean;
+    /** @internal Handle keyboard navigation on step headers */
+    _onHeaderKeydown(event: KeyboardEvent, currentIndex: number): void;
+    /** @internal Set the selected index and emit selection change */
+    private _setSelectedIndex;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiStepperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiStepperComponent, "fui-stepper", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "linear": { "alias": "linear"; "required": false; "isSignal": true; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "animationDone": "animationDone"; }, ["steps"], never, true, never>;
+}
+
+export { FORMAUI_STEPPER, FuiStepComponent, FuiStepperComponent };
+export type { StepSelectionChange, StepState, StepperOrientation };
+//# sourceMappingURL=raintonic-formaui-components-stepper.d.ts.map

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

@@ -0,0 +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":[]}

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

@@ -0,0 +1,96 @@
+import * as i0 from '@angular/core';
+import { InputSignal, TemplateRef, AfterContentInit, ModelSignal, OutputEmitterRef, QueryList, ElementRef, WritableSignal } from '@angular/core';
+
+/**
+ * @component FuiTabComponent
+ * @selector fui-tab
+ * @description Individual tab definition used inside `fui-tab-group`. Provides a label
+ * for the tab header and wraps its content in an `ng-template` for lazy rendering.
+ *
+ * @input label - (required) Text displayed in the tab header button
+ * @input disabled - Whether the tab is disabled and cannot be selected (default: false)
+ *
+ * @example
+ * <fui-tab label="Settings" [disabled]="!canEdit">
+ *   <p>Settings panel content here.</p>
+ * </fui-tab>
+ */
+declare class FuiTabComponent {
+    /**
+     * The label for the tab
+     */
+    readonly label: InputSignal<string>;
+    /**
+     * Whether the tab is disabled
+     */
+    readonly disabled: InputSignal<boolean>;
+    /**
+     * Template reference for the tab content
+     */
+    content: TemplateRef<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiTabComponent, "fui-tab", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * @component FuiTabGroupComponent
+ * @selector fui-tab-group
+ * @description Container for `fui-tab` components. Manages tab selection, keyboard navigation
+ * (ArrowLeft/Right, Home, End, Enter, Space), and roving tabindex for accessibility.
+ * Uses content projection to collect tab definitions and renders their content lazily.
+ *
+ * @input selectedIndex - Two-way model signal for the active tab index (default: 0)
+ *
+ * @output selectedTabChange - Emits the FuiTabComponent instance when a new tab is selected
+ *
+ * @cssvar --fui-tab-label-font-size - Font size of tab labels
+ * @cssvar --fui-tab-label-min-height - Minimum height of tab header buttons
+ * @cssvar --fui-tab-label-padding-x - Horizontal padding of tab labels
+ * @cssvar --fui-tab-label-padding-y - Vertical padding of tab labels
+ * @cssvar --fui-tab-panel-padding - Padding of the tab content panel
+ * @cssvar --fui-tab-indicator-height - Height of the active-tab underline indicator
+ * @cssvar --fui-tab-active-color - Color of the active tab label and indicator
+ *
+ * @example
+ * <fui-tab-group [(selectedIndex)]="activeTab">
+ *   <fui-tab label="Overview">Overview content</fui-tab>
+ *   <fui-tab label="Details">Details content</fui-tab>
+ *   <fui-tab label="History" [disabled]="true">History content</fui-tab>
+ * </fui-tab-group>
+ */
+declare class FuiTabGroupComponent implements AfterContentInit {
+    /** Unique ID prefix for this tab group instance to avoid collisions */
+    readonly tabGroupId: string;
+    /**
+     * The index of the selected tab
+     */
+    readonly selectedIndex: ModelSignal<number>;
+    /**
+     * Event emitted when a tab is selected
+     */
+    readonly selectedTabChange: OutputEmitterRef<FuiTabComponent>;
+    /**
+     * Query for all tab components
+     */
+    tabComponents: QueryList<FuiTabComponent>;
+    /**
+     * Query for tab header buttons for focus management
+     */
+    tabButtons: QueryList<ElementRef<HTMLButtonElement>>;
+    /**
+     * Signal containing all tabs
+     */
+    readonly tabs: WritableSignal<FuiTabComponent[]>;
+    constructor();
+    ngAfterContentInit(): void;
+    /**
+     * Select a tab by index
+     */
+    selectTab(index: number): void;
+    onKeydown(event: KeyboardEvent, index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiTabGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiTabGroupComponent, "fui-tab-group", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; "selectedTabChange": "selectedTabChange"; }, ["tabComponents"], never, true, never>;
+}
+
+export { FuiTabComponent, FuiTabGroupComponent };
+//# sourceMappingURL=raintonic-formaui-components-tab.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-tab.d.ts","sources":["../../../lib/components/tab/tab.component.ts","../../../lib/components/tab/tab-group.component.ts"],"mappings":";;;AAEA;;;;;;;;;;;;;AAaG;AACH,cASa,eAAe;AAC1B;;AAEG;AACH,oBAAgB,WAAW;AAE3B;;AAEG;AACH,uBAAmB,WAAW;AAE9B;;AAEG;AACuC,aAAU,WAAW;yCAdpD,eAAe;2CAAf,eAAe;AAe3B;;AClBD;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACH,cAYa,oBAAqB,YAAW,gBAAgB;;;AAI3D;;AAEG;AACH,4BAAwB,WAAW;AAEnC;;AAEG;AACH,gCAA4B,gBAAgB,CAAC,eAAe;AAE5D;;AAEG;AAC+B,mBAAgB,SAAS,CAAC,eAAe;AAE3E;;AAEG;gBACqC,SAAS,CAAC,UAAU,CAAC,iBAAiB;AAE9E;;AAEG;mBACY,cAAc,CAAC,eAAe;;AAiB7C;AASA;;AAEG;AACH;qBAQiB,aAAa;yCAhEnB,oBAAoB;2CAApB,oBAAoB;AAoGhC;;;;","names":[]}

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

@@ -0,0 +1,34 @@
+import * as _angular_core from '@angular/core';
+
+type FuiTagVariant = 'primary' | 'secondary' | 'success' | 'warning' | 'danger' | 'info';
+type FuiTagSize = 'sm' | 'md';
+declare const FUI_TAG_VARIANTS: readonly FuiTagVariant[];
+declare const FUI_TAG_SIZES: readonly FuiTagSize[];
+interface FuiTagRemoveEvent {
+    tag: unknown;
+}
+
+declare class FuiTagComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly variant: _angular_core.InputSignalWithTransform<FuiTagVariant, string>;
+    readonly size: _angular_core.InputSignal<FuiTagSize>;
+    readonly icon: _angular_core.InputSignal<string | null>;
+    readonly removable: _angular_core.InputSignal<boolean>;
+    readonly selectable: _angular_core.InputSignal<boolean>;
+    readonly selected: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly removed: _angular_core.OutputEmitterRef<FuiTagRemoveEvent>;
+    readonly selectedChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly _selected: _angular_core.WritableSignal<boolean>;
+    readonly computedClasses: _angular_core.Signal<string>;
+    constructor();
+    onClick(): void;
+    onSpace(event: Event): void;
+    onRemove(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiTagComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiTagComponent, "fui-tag", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "removed": "removed"; "selectedChange": "selectedChange"; }, never, never, true, never>;
+}
+
+export { FUI_TAG_SIZES, FUI_TAG_VARIANTS, FuiTagComponent };
+export type { FuiTagRemoveEvent, FuiTagSize, FuiTagVariant };
+//# sourceMappingURL=raintonic-formaui-components-tag.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-tag.d.ts","sources":["../../../lib/components/tag/tag.types.ts","../../../lib/components/tag/tag.component.ts"],"mappings":";;AAAM,KAAM,aAAa;KACb,UAAU;AAEtB,cAAa,gBAAgB,WAAW,aAAa;AAQrD,cAAa,aAAa,WAAW,UAAU;UAE9B,iBAAiB;;AAEjC;;ACDD,cAsBa,eAAe;oBACZ,aAAA,CAAA,WAAA;sBACE,aAAA,CAAA,wBAAA,CAAA,aAAA;mBAGH,aAAA,CAAA,WAAA,CAAA,UAAA;mBACA,aAAA,CAAA,WAAA;wBACK,aAAA,CAAA,WAAA;yBACC,aAAA,CAAA,WAAA;uBACF,aAAA,CAAA,WAAA;uBACA,aAAA,CAAA,wBAAA;sBAED,aAAA,CAAA,gBAAA,CAAA,iBAAA;6BACO,aAAA,CAAA,gBAAA;wBAEL,aAAA,CAAA,cAAA;8BAEM,aAAA,CAAA,MAAA;;AAUxB;AAQA,mBAAe,KAAK;AAKpB,oBAAgB,KAAK;oDAxCV,eAAe;sDAAf,eAAe;AA8C3B;;;;","names":[]}

package/types/raintonic-formaui-components-time-picker.d.ts

@@ -0,0 +1,172 @@
+import * as _angular_core from '@angular/core';
+import { DoCheck, OnDestroy, InputSignal, InputSignalWithTransform, OutputEmitterRef, WritableSignal, ElementRef, AfterViewInit } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { FuiFormFieldControl, ErrorStateMatcher } from '@raintonic/formaui/core';
+
+type TimeFormat = '12h' | '24h';
+interface TimeValue {
+    hours: number;
+    minutes: number;
+    seconds?: number;
+}
+interface TimeOption {
+    label: string;
+    value: TimeValue;
+    disabled: boolean;
+}
+
+declare class FuiTimePickerComponent implements ControlValueAccessor, FuiFormFieldControl<string>, DoCheck, OnDestroy {
+    static nextId: number;
+    readonly controlType = "fui-time-picker";
+    readonly formatInput: InputSignal<TimeFormat>;
+    readonly showSeconds: InputSignalWithTransform<boolean, unknown>;
+    readonly minuteStep: InputSignal<number>;
+    readonly min: InputSignal<string>;
+    readonly max: InputSignal<string>;
+    readonly placeholderInput: InputSignal<string>;
+    readonly disabledInput: InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: InputSignalWithTransform<boolean, unknown>;
+    readonly errorStateMatcher: InputSignal<ErrorStateMatcher | null>;
+    readonly timeChange: OutputEmitterRef<string>;
+    /** @internal */ readonly _value: WritableSignal<TimeValue | null>;
+    private readonly _focused;
+    private readonly _disabled;
+    private readonly _ngControlDisabled;
+    private readonly _required;
+    private readonly _errorState;
+    readonly _readOnly: WritableSignal<boolean>;
+    readonly _panelOpen: WritableSignal<boolean>;
+    readonly stateChanges: Subject<void>;
+    private _uid;
+    _ariaDescribedby: string | null;
+    private _parentForm;
+    private _parentFormGroup;
+    private _defaultErrorStateMatcher;
+    private readonly _ngControlRef;
+    get ngControl(): NgControl | null;
+    readonly placeholder: _angular_core.Signal<string>;
+    readonly required: WritableSignal<boolean>;
+    readonly value: _angular_core.Signal<string | null>;
+    readonly focused: WritableSignal<boolean>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    readonly errorState: WritableSignal<boolean>;
+    readonly id: string;
+    readonly empty: _angular_core.Signal<boolean>;
+    readonly _displayValue: _angular_core.Signal<string>;
+    readonly displayValue: _angular_core.Signal<string>;
+    readonly _timeOptions: _angular_core.Signal<TimeOption[]>;
+    inputElement?: ElementRef<HTMLInputElement>;
+    timeListPanel?: ElementRef<HTMLDivElement>;
+    private _overlayRef;
+    private _overlaySubscriptions;
+    private readonly _overlayService;
+    private readonly _elementRef;
+    private readonly _document;
+    private readonly _ngZone;
+    private _outsideClickSub?;
+    private _onChange;
+    private _onTouched;
+    constructor();
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onContainerClick(_event: MouseEvent): void;
+    setDescribedByIds(ids: string[]): void;
+    setReadOnly(readOnly: boolean): void;
+    open(): void;
+    close(): void;
+    _togglePanel(): void;
+    _onManualInput(_event: Event): void;
+    _onKeydown(event: KeyboardEvent): void;
+    _onFocus(): void;
+    _onBlur(): void;
+    /** Called when user selects an option from the time list dropdown. */
+    _onOptionSelected(value: TimeValue): void;
+    private _listenForOutsideClicks;
+    private _setValue;
+    private _createOverlay;
+    private _disposeOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiTimePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiTimePickerComponent, "fui-time-picker", never, { "formatInput": { "alias": "format"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; "minuteStep": { "alias": "minuteStep"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "placeholderInput": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; }, { "timeChange": "timeChange"; }, never, never, true, never>;
+}
+
+/**
+ * Convert a TimeValue to total minutes for comparison purposes.
+ */
+declare function timeToMinutes(time: TimeValue): number;
+/**
+ * Compare two TimeValue objects.
+ * Returns -1 if a < b, 0 if equal, 1 if a > b.
+ */
+declare function compareTime(a: TimeValue, b: TimeValue): number;
+/**
+ * Check if a time is within an optional min/max range (inclusive).
+ */
+declare function isTimeInRange(time: TimeValue, min?: TimeValue, max?: TimeValue): boolean;
+/**
+ * Format a TimeValue for display.
+ * - 24h: "14:30" or "14:30:00"
+ * - 12h: "2:30 PM" or "2:30:00 PM"
+ */
+declare function formatTime(value: TimeValue | null, format: TimeFormat, showSeconds: boolean): string;
+/**
+ * Parse a time string into a TimeValue.
+ * Supports formats: "HH:mm", "HH:mm:ss", "h:mm AM/PM", "h:mm:ss AM/PM"
+ * Returns null if the string cannot be parsed.
+ */
+declare function parseTimeString(str: string, format: TimeFormat): TimeValue | null;
+/**
+ * Generate time options for the dropdown list.
+ */
+declare function generateTimeOptions(format: TimeFormat, minuteStep: number, showSeconds: boolean, min?: TimeValue, max?: TimeValue): TimeOption[];
+/**
+ * Convert a TimeValue to an ISO-like string "HH:mm" or "HH:mm:ss".
+ */
+declare function timeValueToString(value: TimeValue | null, showSeconds: boolean): string;
+/**
+ * Parse an ISO-like time string "HH:mm" or "HH:mm:ss" into a TimeValue.
+ * This always parses in 24h format regardless of display format.
+ */
+declare function parseISOTimeString(str: string): TimeValue | null;
+
+declare class FuiTimeListComponent implements AfterViewInit {
+    /** The list of time options to display. */
+    readonly options: _angular_core.InputSignal<TimeOption[]>;
+    /** Currently selected time value. */
+    readonly selectedValue: _angular_core.InputSignal<TimeValue | null>;
+    /** Time format for display. */
+    readonly format: _angular_core.InputSignal<TimeFormat>;
+    /** Emitted when an option is selected. */
+    readonly optionSelected: _angular_core.OutputEmitterRef<TimeValue>;
+    /** Index of the currently focused option for keyboard navigation. */
+    readonly _focusedIndex: _angular_core.WritableSignal<number>;
+    listContainer?: ElementRef<HTMLDivElement>;
+    constructor();
+    ngAfterViewInit(): void;
+    /** Check if an option matches the selected value. */
+    _isSelected(option: TimeOption): boolean;
+    /** Handle option click. */
+    _selectOption(option: TimeOption): void;
+    /** Handle keyboard navigation. */
+    onKeydown(event: KeyboardEvent): void;
+    /** Move focus by delta, skipping disabled options. */
+    private _moveFocus;
+    /** Set focused index and scroll into view. */
+    private _setFocusedIndex;
+    /** Select the currently focused option. */
+    private _selectFocused;
+    /** Scroll to a specific index in the list. */
+    private _scrollToIndex;
+    /** Scroll to the selected option. */
+    private _scrollToSelected;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiTimeListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiTimeListComponent, "fui-time-list", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "selectedValue": { "alias": "selectedValue"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; }, { "optionSelected": "optionSelected"; }, never, never, true, never>;
+}
+
+export { FuiTimeListComponent, FuiTimePickerComponent, compareTime, formatTime, generateTimeOptions, isTimeInRange, parseISOTimeString, parseTimeString, timeToMinutes, timeValueToString };
+export type { TimeFormat, TimeOption, TimeValue };
+//# sourceMappingURL=raintonic-formaui-components-time-picker.d.ts.map

package/types/raintonic-formaui-components-time-picker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-time-picker.d.ts","sources":["../../../lib/components/time-picker/time-picker.types.ts","../../../lib/components/time-picker/time-picker.component.ts","../../../lib/components/time-picker/time-picker.utils.ts","../../../lib/components/time-picker/time-list.component.ts"],"mappings":";;;;;;KAAY,UAAU;UAEL,SAAS;;;;AAIzB;UAEgB,UAAU;;WAElB,SAAS;;AAEjB;;AC4BD,cA6Ba,sBAAuB,YAAW,oBAAoB,EAAE,mBAAmB,UAAU,OAAO,EAAE,SAAS;;;AAKlH,0BAAsB,WAAW,CAAC,UAAU;0BACtB,wBAAwB;AAG9C,yBAAqB,WAAW;AAChC,kBAAc,WAAW;AACzB,kBAAc,WAAW;AACzB,+BAA2B,WAAW;4BACd,wBAAwB;uBAI7B,wBAAwB;gCAGf,WAAW,CAAC,iBAAiB;AAGzD,yBAAqB,gBAAgB;sCAGH,cAAc,CAAC,SAAS;AAC1D;AACA;AACA;AACA;AACA;AACA,wBAAoB,cAAc;yBACf,cAAA;2BAGE,OAAA;;AAErB;;;;AAMA;AACA,qBAAiB,SAAS;0BAKN,aAAA,CAAA,MAAA;uBACH,cAAA;oBACH,aAAA,CAAA,MAAA;sBAIE,cAAA;uBACC,aAAA,CAAA,MAAA;yBACE,cAAA;;oBAGL,aAAA,CAAA,MAAA;4BAKQ,aAAA,CAAA,MAAA;2BAKD,aAAA,CAAA,MAAA;2BAGA,aAAA,CAAA,MAAA,CAAA,UAAA;AAayB,mBAAe,UAAU,CAAC,gBAAgB;AACzC,oBAAgB,UAAU,CAAC,cAAc;;;AAKxF;AACA;AACA;AACA;;;;;AAwCA;AAgBA;AAQA;AAUA;AAIA;AAIA;AAOA,6BAAyB,UAAU;AASnC;AAIA;AAMA;AAcA;AAcA;AAWA,2BAAuB,KAAK;AAI5B,sBAAkB,aAAa;AAa/B;AAIA;;AAwBA,6BAAyB,SAAS;AAMlC;AA0BA;AAQA;AAiDA;oDAzXW,sBAAsB;sDAAtB,sBAAsB;AAgYlC;;ACncD;;AAEG;AACH,iBAAgB,aAAa,OAAO,SAAS;AAI7C;;;AAGG;AACH,iBAAgB,WAAW,IAAI,SAAS,KAAK,SAAS;AAQtD;;AAEG;AACH,iBAAgB,aAAa,OAAO,SAAS,QAAQ,SAAS,QAAQ,SAAS;AAM/E;;;;AAIG;AACH,iBAAgB,UAAU,QAAQ,SAAS,iBAAiB,UAAU;AAuBtE;;;;AAIG;AACH,iBAAgB,eAAe,sBAAsB,UAAU,GAAG,SAAS;AAsC3E;;AAEG;AACH,iBAAgB,mBAAmB,SACzB,UAAU,kDAGZ,SAAS,QACT,SAAS,GACd,UAAU;AAgBb;;AAEG;AACH,iBAAgB,iBAAiB,QAAQ,SAAS;AAOlD;;;AAGG;AACH,iBAAgB,kBAAkB,eAAe,SAAS;;AC7H1D,cAWa,oBAAqB,YAAW,aAAa;;sBAExC,aAAA,CAAA,WAAA,CAAA,UAAA;;4BAGM,aAAA,CAAA,WAAA,CAAA,SAAA;;qBAGP,aAAA,CAAA,WAAA,CAAA,UAAA;;6BAGQ,aAAA,CAAA,gBAAA,CAAA,SAAA;;4BAGD,aAAA,CAAA,cAAA;AAEyB,oBAAgB,UAAU,CAAC,cAAc;;AAcxF;;AAKA,wBAAoB,UAAU;;AAO9B,0BAAsB,UAAU;;AAMhC,qBAAiB,aAAa;;AA6B9B;;AAmBA;;AAMA;;AASA;;AAqBA;oDApIW,oBAAoB;sDAApB,oBAAoB;AAkJhC;;;;","names":[]}