@raintonic/formaui 0.2.0

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

@@ -0,0 +1,70 @@
+import * as _angular_core from '@angular/core';
+import { DoCheck, OnDestroy, OutputEmitterRef, Signal, ElementRef } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { ErrorStateMatcher } from '@raintonic/formaui/core';
+
+type FuiToggleLabelPosition = 'before' | 'after';
+type FuiToggleSize = 'sm' | 'md';
+interface FuiToggleChange {
+    source: unknown;
+    checked: boolean;
+}
+
+declare class FuiToggleComponent implements ControlValueAccessor, DoCheck, OnDestroy {
+    static nextId: number;
+    readonly controlType = "fui-toggle";
+    readonly checkedInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly requiredInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly labelPosition: _angular_core.InputSignal<FuiToggleLabelPosition>;
+    readonly size: _angular_core.InputSignal<FuiToggleSize>;
+    readonly name: _angular_core.InputSignal<string | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    readonly ariaDescribedby: _angular_core.InputSignal<string | null>;
+    readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | null>;
+    readonly change: OutputEmitterRef<FuiToggleChange>;
+    private readonly _checked;
+    private readonly _focused;
+    private readonly _disabled;
+    private readonly _required;
+    private readonly _ngControlDisabled;
+    private readonly _errorState;
+    readonly checked: Signal<boolean>;
+    readonly focused: Signal<boolean>;
+    readonly errorState: Signal<boolean>;
+    readonly required: Signal<boolean>;
+    readonly disabled: Signal<boolean>;
+    readonly stateChanges: Subject<void>;
+    private _uid;
+    readonly id: string;
+    readonly inputId: string;
+    private _parentForm;
+    private _parentFormGroup;
+    private _defaultErrorStateMatcher;
+    private readonly _ngControlRef;
+    get ngControl(): NgControl | null;
+    readonly inputElement: Signal<ElementRef<HTMLInputElement> | undefined>;
+    private _onChange;
+    private _onTouched;
+    private _formControlInitialized;
+    constructor();
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInputChange(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    toggle(): void;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiToggleComponent, "fui-toggle", never, { "checkedInput": { "alias": "checked"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "requiredInput": { "alias": "required"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; }, { "change": "change"; }, never, ["*", "*"], true, never>;
+}
+
+export { FuiToggleComponent };
+export type { FuiToggleChange, FuiToggleLabelPosition, FuiToggleSize };
+//# sourceMappingURL=raintonic-formaui-components-toggle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-toggle.d.ts","sources":["../../../lib/components/toggle/toggle.types.ts","../../../lib/components/toggle/toggle.component.ts"],"mappings":";;;;;;KAAY,sBAAsB;KACtB,aAAa;UAER,eAAe;;;AAG/B;;ACmBD,cAsBa,kBAAmB,YAAW,oBAAoB,EAAE,OAAO,EAAE,SAAS;;;2BAK5D,aAAA,CAAA,wBAAA;4BACC,aAAA,CAAA,wBAAA;4BACA,aAAA,CAAA,wBAAA;4BACA,aAAA,CAAA,WAAA,CAAA,sBAAA;mBACT,aAAA,CAAA,WAAA,CAAA,aAAA;mBACA,aAAA,CAAA,WAAA;wBACK,aAAA,CAAA,WAAA;6BACK,aAAA,CAAA,WAAA;8BACC,aAAA,CAAA,WAAA;gCACE,aAAA,CAAA,WAAA,CAAA,iBAAA;AAG1B,qBAAiB,gBAAgB,CAAC,eAAe;AAGjD;AACA;AACA;AACA;AACA;AACA;AAGA,sBAAkB,MAAM;AACxB,sBAAkB,MAAM;yBACL,MAAA;AACnB,uBAAmB,MAAM;AACzB,uBAAmB,MAAM;2BAIJ,OAAA;;;;;;;AASrB;AACA,qBAAiB,SAAS;AAI1B,2BAAuB,MAAM,CAAC,UAAU,CAAC,gBAAgB;;;;;AA0CzD;AAgBA;AAKA;;AAQA;AAGA;AAMA,yBAAqB,KAAK;AAU1B;AAOA;AAQA;AAUA;oDArKW,kBAAkB;sDAAlB,kBAAkB;AAwK9B;;;;","names":[]}

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

@@ -0,0 +1,128 @@
+import * as i0 from '@angular/core';
+import { InputSignal, OutputEmitterRef, Signal } from '@angular/core';
+
+/**
+ * Toolbar menu item interface
+ */
+interface FuiToolbarMenuItem {
+    id: string | number;
+    icon: string;
+    label: string;
+    disabled?: boolean;
+    routerLink?: string | string[];
+    queryParams?: Record<string, string>;
+    fragment?: string;
+}
+/**
+ * User profile data interface
+ */
+interface FuiToolbarUserProfile {
+    name: string;
+    email: string;
+    avatar?: string;
+    initials?: string;
+}
+/**
+ * # FuiToolbar Component
+ *
+ * A top navigation toolbar following Carbon Design System principles.
+ * Provides space for logo, navigation menu items, and user profile area.
+ *
+ * ## Features
+ * - Logo area with customizable content
+ * - Icon-based navigation menu
+ * - User profile area with avatar/initials
+ * - Responsive design
+ * - Theme integration
+ * - Accessibility support
+ *
+ * ## Usage
+ *
+ * ### Basic Toolbar
+ * ```html
+ * <fui-toolbar
+ *   [menuItems]="menuItems"
+ *   [userProfile]="userProfile"
+ *   (menuItemClick)="onMenuItemClick($event)"
+ *   (userProfileClick)="onUserProfileClick()">
+ *   <div logo>
+ *     <img src="logo.svg" alt="Company Logo">
+ *   </div>
+ * </fui-toolbar>
+ * ```
+ *
+ * ### With Custom Logo
+ * ```html
+ * <fui-toolbar [menuItems]="menuItems" [userProfile]="userProfile">
+ *   <div logo class="custom-logo">
+ *     <h1>Holiday ERP</h1>
+ *   </div>
+ * </fui-toolbar>
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { FuiToolbarComponent, FuiToolbarMenuItem, FuiToolbarUserProfile } from '@raintonic/formaui/components/toolbar';
+ *
+ * @Component({
+ *   standalone: true,
+ *   imports: [FuiToolbarComponent],
+ *   template: `
+ *     <fui-toolbar
+ *       [menuItems]="menuItems"
+ *       [userProfile]="userProfile"
+ *       (menuItemClick)="onMenuItemClick($event)"
+ *       (userProfileClick)="onUserProfileClick()">
+ *       <div logo>
+ *         <img src="assets/logo.svg" alt="Holiday ERP">
+ *       </div>
+ *     </fui-toolbar>
+ *   `
+ * })
+ * export class AppLayoutComponent {
+ *   menuItems: FuiToolbarMenuItem[] = [
+ *     { id: 'dashboard', icon: 'house', label: 'Dashboard' },
+ *     { id: 'orders', icon: 'shopping-cart', label: 'Orders' },
+ *     { id: 'products', icon: 'package', label: 'Products' },
+ *     { id: 'customers', icon: 'users', label: 'Customers' },
+ *   ];
+ *
+ *   userProfile: FuiToolbarUserProfile = {
+ *     name: 'John Doe',
+ *     email: 'john.doe@company.com',
+ *     initials: 'JD'
+ *   };
+ *
+ *   onMenuItemClick(itemId: string | number): void {
+ *     console.log('Menu item clicked:', itemId);
+ *   }
+ *
+ *   onUserProfileClick(): void {
+ *     console.log('User profile clicked');
+ *   }
+ * }
+ * ```
+ */
+declare class FuiToolbarComponent {
+    readonly menuItems: InputSignal<FuiToolbarMenuItem[]>;
+    readonly userProfile: InputSignal<FuiToolbarUserProfile | null>;
+    readonly fixed: InputSignal<boolean>;
+    readonly activeMenuItemId: InputSignal<string | number>;
+    readonly ariaLabel: InputSignal<string>;
+    readonly userAriaLabel: InputSignal<string>;
+    readonly showSidebarToggle: InputSignal<boolean>;
+    readonly menuItemClick: OutputEmitterRef<string | number>;
+    readonly userProfileClick: OutputEmitterRef<void>;
+    readonly sidebarToggle: OutputEmitterRef<void>;
+    readonly firstName: Signal<string>;
+    readonly lastName: Signal<string>;
+    onMenuItemClick(item: FuiToolbarMenuItem): void;
+    onUserProfileClick(): void;
+    onSidebarToggleClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiToolbarComponent, "fui-toolbar", never, { "menuItems": { "alias": "menuItems"; "required": false; "isSignal": true; }; "userProfile": { "alias": "userProfile"; "required": false; "isSignal": true; }; "fixed": { "alias": "fixed"; "required": false; "isSignal": true; }; "activeMenuItemId": { "alias": "activeMenuItemId"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "userAriaLabel": { "alias": "userAriaLabel"; "required": false; "isSignal": true; }; "showSidebarToggle": { "alias": "showSidebarToggle"; "required": false; "isSignal": true; }; }, { "menuItemClick": "menuItemClick"; "userProfileClick": "userProfileClick"; "sidebarToggle": "sidebarToggle"; }, never, ["[logo]", "[more-buttons]"], true, never>;
+}
+
+export { FuiToolbarComponent };
+export type { FuiToolbarMenuItem, FuiToolbarUserProfile };
+//# sourceMappingURL=raintonic-formaui-components-toolbar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-toolbar.d.ts","sources":["../../../lib/components/toolbar/toolbar.component.ts"],"mappings":";;;AAgBA;;AAEG;UACc,kBAAkB;AACjC;;;;AAIA;kBACc,MAAM;;AAErB;AAED;;AAEG;UACc,qBAAqB;;;;;AAKrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFG;AACH,cAca,mBAAmB;wBAEV,WAAW,CAAC,kBAAkB;0BAC5B,WAAW,CAAC,qBAAqB;AACvD,oBAAgB,WAAW;+BACA,WAAW;wBACpB,WAAA;4BACI,WAAA;AAEtB,gCAA4B,WAAW;4BAGf,gBAAgB;AACxC,+BAA2B,gBAAgB;AAE3C,4BAAwB,gBAAgB;AAGxC,wBAAoB,MAAM;AAC1B,uBAAmB,MAAM;AAKzB,0BAAsB,kBAAkB;AAMxC;AAMA;yCApCW,mBAAmB;2CAAnB,mBAAmB;AAuC/B;;;;","names":[]}

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

@@ -0,0 +1,268 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, Signal } from '@angular/core';
+
+/**
+ * Available tooltip positions relative to the trigger element
+ */
+type TooltipPosition = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+/**
+ * Available tooltip sizes
+ */
+type TooltipSize = 'sm' | 'md' | 'lg';
+/**
+ * Tooltip trigger events
+ */
+type TooltipTrigger = 'hover' | 'focus' | 'click' | 'manual';
+/**
+ * Constants for validation
+ */
+declare const TOOLTIP_POSITIONS: readonly ["top", "top-start", "top-end", "bottom", "bottom-start", "bottom-end", "left", "left-start", "left-end", "right", "right-start", "right-end"];
+declare const TOOLTIP_SIZES: readonly ["sm", "md", "lg"];
+declare const TOOLTIP_TRIGGERS: readonly ["hover", "focus", "click", "manual"];
+/**
+ * Tooltip configuration interface
+ */
+interface TooltipConfig {
+    position?: TooltipPosition;
+    size?: TooltipSize;
+    trigger?: TooltipTrigger;
+    showDelay?: number;
+    hideDelay?: number;
+    disabled?: boolean;
+    maxWidth?: string;
+    offset?: number;
+    arrow?: boolean;
+}
+
+/**
+ * # Tooltip Directive
+ *
+ * A professional tooltip directive that provides contextual information on hover, focus, or click.
+ * Follows Material Design patterns with full accessibility support and advanced positioning.
+ *
+ * ## Features
+ * - Multiple positioning options (12 positions)
+ * - Configurable trigger events (hover, focus, click, manual)
+ * - Multiple variants for different semantic meanings
+ * - Flexible sizing options
+ * - Smart positioning with collision detection
+ * - Customizable delays and animations
+ * - Full accessibility support (ARIA attributes, keyboard navigation)
+ * - Arrow indicator support
+ * - Responsive design with max-width control
+ * - Theme support (light/dark)
+ *
+ * ## Usage
+ *
+ * ### Basic Tooltip
+ * ```html
+ * <button fuiTooltip="Save your changes">Save</button>
+ * ```
+ *
+ * ### Advanced Configuration
+ * ```html
+ * <button fuiTooltip="Delete this item permanently"
+ *         fuiTooltipPosition="top"
+ *         fuiTooltipVariant="error"
+ *         fuiTooltipSize="lg"
+ *         [fuiTooltipShowDelay]="500">
+ *   Delete
+ * </button>
+ * ```
+ *
+ * ### Click Trigger
+ * ```html
+ * <span fuiTooltip="Click to copy"
+ *       fuiTooltipTrigger="click"
+ *       fuiTooltipPosition="bottom">
+ *   📋 Copy to clipboard
+ * </span>
+ * ```
+ *
+ * ### Manual Control
+ * ```html
+ * <div fuiTooltip="Manual tooltip"
+ *      fuiTooltipTrigger="manual"
+ *      [fuiTooltipShow]="showTooltip">
+ *   Hover me
+ * </div>
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { FuiTooltipDirective } from '@raintonic/formaui/components/tooltip';
+ *
+ * @Component({
+ *   standalone: true,
+ *   imports: [FuiTooltipDirective],
+ *   template: `
+ *     <button fuiTooltip="This will save your work"
+ *             fuiTooltipPosition="top"
+ *             fuiTooltipVariant="info">
+ *       Save Document
+ *     </button>
+ *   `
+ * })
+ * export class MyComponent { }
+ * ```
+ */
+declare class FuiTooltipDirective implements OnDestroy {
+    private static _nextId;
+    /**
+     * Tooltip content text
+     */
+    readonly fuiTooltip: _angular_core.InputSignal<string>;
+    /**
+     * Tooltip position relative to the trigger element
+     * @default 'top'
+     */
+    readonly fuiTooltipPosition: _angular_core.InputSignalWithTransform<TooltipPosition, string>;
+    /**
+     * Tooltip size
+     * @default 'md'
+     */
+    readonly fuiTooltipSize: _angular_core.InputSignalWithTransform<TooltipSize, string>;
+    /**
+     * Tooltip trigger event
+     * @default 'hover'
+     */
+    readonly fuiTooltipTrigger: _angular_core.InputSignalWithTransform<TooltipTrigger, string>;
+    /**
+     * Delay before showing tooltip (in milliseconds)
+     * @default 500
+     */
+    readonly fuiTooltipShowDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Delay before hiding tooltip (in milliseconds)
+     * @default 0
+     */
+    readonly fuiTooltipHideDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Whether the tooltip is disabled
+     * @default false
+     */
+    readonly fuiTooltipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Maximum width of the tooltip
+     * @default '200px'
+     */
+    readonly fuiTooltipMaxWidth: _angular_core.InputSignal<string>;
+    /**
+     * Offset distance from the trigger element (in pixels)
+     * @default 8
+     */
+    readonly fuiTooltipOffset: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Whether to show an arrow pointing to the trigger element
+     * @default true
+     */
+    readonly fuiTooltipArrow: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Manual control for showing/hiding tooltip (only works with trigger="manual")
+     * @default false
+     */
+    readonly fuiTooltipShow: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly _isVisible;
+    private readonly _tooltipId;
+    private _overlayRef;
+    private _tooltipComponent;
+    private _showTimeout;
+    private _hideTimeout;
+    private _isHoveringTooltip;
+    readonly isVisible: Signal<boolean>;
+    readonly tooltipId: Signal<string>;
+    private readonly _elementRef;
+    private readonly _overlayService;
+    private readonly _environmentInjector;
+    constructor();
+    ngOnDestroy(): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onFocus(): void;
+    onBlur(): void;
+    onClick(): void;
+    onKeydown(event: KeyboardEvent): void;
+    /**
+     * Programmatically show the tooltip
+     */
+    show(): void;
+    /**
+     * Programmatically hide the tooltip
+     */
+    hide(): void;
+    /**
+     * Toggle tooltip visibility
+     */
+    toggle(): void;
+    private _scheduleShow;
+    private _scheduleHide;
+    private _showTooltip;
+    private _hideTooltip;
+    private _createTooltip;
+    private _getPositionsForTooltipPosition;
+    private _destroyTooltip;
+    private _clearTimeouts;
+    private readonly _onDocumentClick;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FuiTooltipDirective, "[fuiTooltip]", never, { "fuiTooltip": { "alias": "fuiTooltip"; "required": true; "isSignal": true; }; "fuiTooltipPosition": { "alias": "fuiTooltipPosition"; "required": false; "isSignal": true; }; "fuiTooltipSize": { "alias": "fuiTooltipSize"; "required": false; "isSignal": true; }; "fuiTooltipTrigger": { "alias": "fuiTooltipTrigger"; "required": false; "isSignal": true; }; "fuiTooltipShowDelay": { "alias": "fuiTooltipShowDelay"; "required": false; "isSignal": true; }; "fuiTooltipHideDelay": { "alias": "fuiTooltipHideDelay"; "required": false; "isSignal": true; }; "fuiTooltipDisabled": { "alias": "fuiTooltipDisabled"; "required": false; "isSignal": true; }; "fuiTooltipMaxWidth": { "alias": "fuiTooltipMaxWidth"; "required": false; "isSignal": true; }; "fuiTooltipOffset": { "alias": "fuiTooltipOffset"; "required": false; "isSignal": true; }; "fuiTooltipArrow": { "alias": "fuiTooltipArrow"; "required": false; "isSignal": true; }; "fuiTooltipShow": { "alias": "fuiTooltipShow"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @component FuiTooltipComponent
+ * @selector fui-tooltip
+ * @description Internal tooltip component rendered by FuiTooltipDirective via the overlay system.
+ * Not intended for direct use; created programmatically by the directive.
+ *
+ * @input content - (required) Tooltip text content.
+ * @input position - (required) Tooltip position relative to the trigger element.
+ * @input size - (required) Tooltip size variant.
+ * @input maxWidth - (required) Maximum CSS width of the tooltip.
+ * @input arrow - (required) Whether to render an arrow indicator.
+ * @input tooltipId - (required) Unique ID for ARIA accessibility linking.
+ *
+ * @example
+ * <!-- Used internally by FuiTooltipDirective -->
+ * <button fuiTooltip="Save your changes">Save</button>
+ *
+ * @internal
+ */
+declare class FuiTooltipComponent {
+    /**
+     * Tooltip content text
+     */
+    readonly content: _angular_core.InputSignal<string>;
+    /**
+     * Tooltip position
+     */
+    readonly position: _angular_core.InputSignal<TooltipPosition>;
+    /**
+     * Tooltip size
+     */
+    readonly size: _angular_core.InputSignal<TooltipSize>;
+    /**
+     * Maximum width of the tooltip
+     */
+    readonly maxWidth: _angular_core.InputSignal<string>;
+    /**
+     * Whether to show arrow
+     */
+    readonly arrow: _angular_core.InputSignal<boolean>;
+    /**
+     * Tooltip ID for accessibility
+     */
+    readonly tooltipId: _angular_core.InputSignal<string>;
+    /**
+     * Computed CSS classes for the tooltip
+     */
+    readonly computedClasses: Signal<string>;
+    /**
+     * Computed arrow classes based on position
+     */
+    readonly arrowClasses: Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiTooltipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiTooltipComponent, "fui-tooltip", never, { "content": { "alias": "content"; "required": true; "isSignal": true; }; "position": { "alias": "position"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": true; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": true; "isSignal": true; }; "arrow": { "alias": "arrow"; "required": true; "isSignal": true; }; "tooltipId": { "alias": "tooltipId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { FuiTooltipComponent, FuiTooltipDirective, TOOLTIP_POSITIONS, TOOLTIP_SIZES, TOOLTIP_TRIGGERS };
+export type { TooltipConfig, TooltipPosition, TooltipSize, TooltipTrigger };
+//# sourceMappingURL=raintonic-formaui-components-tooltip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-tooltip.d.ts","sources":["../../../lib/components/tooltip/tooltip.types.ts","../../../lib/components/tooltip/tooltip.directive.ts","../../../lib/components/tooltip/tooltip.component.ts"],"mappings":";;;AAAA;;AAEG;AACG,KAAM,eAAe;AAc3B;;AAEG;AACG,KAAM,WAAW;AAEvB;;AAEG;AACG,KAAM,cAAc;AAE1B;;AAEG;AACH,cAAa,iBAAiB;AAe9B,cAAa,aAAa;AAC1B,cAAa,gBAAgB;AAE7B;;AAEG;UACc,aAAa;eACjB,eAAe;WACnB,WAAW;cACR,cAAc;;;;;;;AAOzB;;AChCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEG;AACH,cAOa,mBAAoB,YAAW,SAAS;AACnD;AACA;;AAEG;yBACgB,aAAA,CAAA,WAAA;AAEnB;;;AAGG;iCACwB,aAAA,CAAA,wBAAA,CAAA,eAAA;AAI3B;;;AAGG;6BACoB,aAAA,CAAA,wBAAA,CAAA,WAAA;AAIvB;;;AAGG;gCACuB,aAAA,CAAA,wBAAA,CAAA,cAAA;AAI1B;;;AAGG;kCACyB,aAAA,CAAA,wBAAA;AAE5B;;;AAGG;kCACyB,aAAA,CAAA,wBAAA;AAE5B;;;AAGG;iCACwB,aAAA,CAAA,wBAAA;AAE3B;;;AAGG;iCACwB,aAAA,CAAA,WAAA;AAE3B;;;AAGG;+BACsB,aAAA,CAAA,wBAAA;AAEzB;;;AAGG;8BACqB,aAAA,CAAA,wBAAA;AAExB;;;AAGG;6BACoB,aAAA,CAAA,wBAAA;AAGvB;AACA;;;;;;AAQA,wBAAoB,MAAM;AAC1B,wBAAoB,MAAM;AAG1B;AACA;AACA;;AAyBA;AAMA;AAOA;AAOA;AAOA;AAOA;AAWA,qBAAiB,aAAa;AAO9B;;AAEG;AACH;AAMA;;AAEG;AACH;AAIA;;AAEG;AACH;AAQA;AAYA;AAgBA;AAgBA;AAUA;AAuDA;AAwDA;AAYA;AAWA;oDA7XW,mBAAmB;sDAAnB,mBAAmB;AAsY/B;;AC9eD;;;;;;;;;;;;;;;;;;AAkBG;AACH,cAgBa,mBAAmB;AAC9B;;AAEG;sBACa,aAAA,CAAA,WAAA;AAEhB;;AAEG;uBACc,aAAA,CAAA,WAAA,CAAA,eAAA;AAEjB;;AAEG;mBACU,aAAA,CAAA,WAAA,CAAA,WAAA;AAEb;;AAEG;uBACc,aAAA,CAAA,WAAA;AAEjB;;AAEG;oBACW,aAAA,CAAA,WAAA;AAEd;;AAEG;wBACe,aAAA,CAAA,WAAA;AAElB;;AAEG;AACH,8BAA0B,MAAM;AAUhC;;AAEG;AACH,2BAAuB,MAAM;oDA/ClB,mBAAmB;sDAAnB,mBAAmB;AA+D/B;;;;","names":[]}

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

@@ -0,0 +1,80 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, DoCheck, TemplateRef, Signal, ElementRef } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { Observable, Subject } from 'rxjs';
+import { FuiFormFieldControl } from '@raintonic/formaui/core';
+import { FuiTreeNode, FuiTreeNodeEvent, FuiTreeSelectionMode } from '@raintonic/formaui/components/tree';
+
+interface FuiTreeSelectChange<T = any> {
+    value: FuiTreeNode<T> | FuiTreeNode<T>[] | null;
+    source: any;
+}
+
+declare class FuiTreeSelectComponent<T = any> implements ControlValueAccessor, FuiFormFieldControl<T | T[]>, OnDestroy, DoCheck {
+    readonly nodes: _angular_core.InputSignal<FuiTreeNode<T>[]>;
+    readonly selectionMode: _angular_core.InputSignal<"multi" | "single" | "checkbox">;
+    readonly placeholderInput: _angular_core.InputSignal<string>;
+    readonly showSearch: _angular_core.InputSignal<boolean>;
+    readonly loadChildren: _angular_core.InputSignal<((node: FuiTreeNode<T>) => Observable<FuiTreeNode<T>[]>) | null>;
+    readonly nodeTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
+    readonly displayField: _angular_core.InputSignal<string | ((node: FuiTreeNode<T>) => string) | null>;
+    readonly disabledInput: _angular_core.InputSignal<boolean>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<FuiTreeSelectChange<T>>;
+    readonly stateChanges: Subject<void>;
+    private readonly _value;
+    readonly value: Signal<T | T[] | null>;
+    readonly placeholder: Signal<string>;
+    readonly focused: _angular_core.WritableSignal<boolean>;
+    readonly empty: Signal<boolean>;
+    readonly required: _angular_core.WritableSignal<boolean>;
+    private readonly _disabled;
+    readonly disabled: Signal<boolean>;
+    readonly errorState: _angular_core.WritableSignal<boolean>;
+    readonly controlType = "fui-tree-select";
+    readonly id: string;
+    readonly _panelOpen: _angular_core.WritableSignal<boolean>;
+    readonly _treeId: string;
+    readonly _searchFilter: _angular_core.WritableSignal<string>;
+    private _overlayRef;
+    private readonly _ngControlRef;
+    get ngControl(): NgControl | null;
+    private readonly _overlayService;
+    private readonly _elementRef;
+    readonly _selectedNodes: _angular_core.WritableSignal<FuiTreeNode<T>[]>;
+    trigger?: ElementRef<HTMLDivElement>;
+    panel?: ElementRef<HTMLDivElement>;
+    private _onChange;
+    private _onTouched;
+    constructor();
+    toggle(): void;
+    open(): void;
+    close(): void;
+    onContainerClick(_event: MouseEvent): void;
+    setDescribedByIds(_ids: string[]): void;
+    _onTreeSelect(event: FuiTreeNodeEvent<T>): void;
+    _onTreeUnselect(event: FuiTreeNodeEvent<T>): void;
+    _getDisplayValue(): string;
+    _getSelectedDisplayValues(): string[];
+    _onSearchInput(event: Event): void;
+    _onKeydown(event: KeyboardEvent): void;
+    readonly _treeSelectionMode: Signal<FuiTreeSelectionMode>;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(disabled: boolean): void;
+    ngOnDestroy(): void;
+    ngDoCheck(): void;
+    private _getNodeLabel;
+    private _deselectAll;
+    private _updateMultiSelection;
+    private _collectSelected;
+    private _syncSelectedFromValue;
+    private _createOverlay;
+    private _disposeOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiTreeSelectComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiTreeSelectComponent<any>, "fui-tree-select", never, { "nodes": { "alias": "nodes"; "required": true; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "placeholderInput": { "alias": "placeholder"; "required": false; "isSignal": true; }; "showSearch": { "alias": "showSearch"; "required": false; "isSignal": true; }; "loadChildren": { "alias": "loadChildren"; "required": false; "isSignal": true; }; "nodeTemplate": { "alias": "nodeTemplate"; "required": false; "isSignal": true; }; "displayField": { "alias": "displayField"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; }, never, never, true, never>;
+}
+
+export { FuiTreeSelectComponent };
+export type { FuiTreeSelectChange };
+//# sourceMappingURL=raintonic-formaui-components-tree-select.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-tree-select.d.ts","sources":["../../../lib/components/tree-select/tree-select.types.ts","../../../lib/components/tree-select/fui-tree-select.component.ts"],"mappings":";;;;;;;AAEM,UAAW,mBAAmB;AAClC,WAAO,WAAW,MAAM,WAAW;;AAEpC;;ACwBD,cAyBa,sBAAsB,qBACtB,oBAAoB,EAAE,mBAAmB,WAAW,SAAS,EAAE,OAAO;oBAGnE,aAAA,CAAA,WAAA,CAAA,WAAA;4BACQ,aAAA,CAAA,WAAA;+BACG,aAAA,CAAA,WAAA;yBACN,aAAA,CAAA,WAAA;AACnB,2BAAqB,aAAA,CAAA,WAAA,SAAiB,WAAW,QAAQ,UAAU,CAAC,WAAW;2BAC1D,aAAA,CAAA,WAAA,CAAA,WAAA;2BACA,aAAA,CAAA,WAAA,kBAA0B,WAAW;4BACpC,aAAA,CAAA,WAAA;8BAEE,aAAA,CAAA,gBAAA,CAAA,mBAAA;2BAGH,OAAA;AACrB;AACA,oBAAgB,MAAM;0BACF,MAAA;sBACJ,aAAA,CAAA,cAAA;oBACF,MAAA;uBAIG,aAAA,CAAA,cAAA;AACjB;uBACiB,MAAA;yBACE,aAAA,CAAA,cAAA;;;yBAKA,aAAA,CAAA,cAAA;;4BAEG,aAAA,CAAA,cAAA;;AAEtB;AACA,qBAAiB,SAAS;AAI1B;AACA;6BAGuB,aAAA,CAAA,cAAA,CAAA,WAAA;AAEkB,cAAU,UAAU,CAAC,cAAc;AACrC,YAAQ,UAAU,CAAC,cAAc;;;;AAmBxE;AAQA;AAYA;AAUA,6BAAyB,UAAU;AAInC;yBAKqB,gBAAgB;2BAkBd,gBAAgB;AAYvC;;AAUA,0BAAsB,KAAK;AAK3B,sBAAkB,aAAa;iCAcJ,MAAA,CAAA,oBAAA;AAK3B;AAMA;AAIA;AAIA;AAKA;AAKA;AAWA;AASA;AAOA;AAUA;AASA;AASA;AA+BA;oDAzRW,sBAAsB;sDAAtB,sBAAsB;AA+RlC;;;;","names":[]}

package/types/raintonic-formaui-components-tree-table.d.ts

@@ -0,0 +1,90 @@
+import * as _angular_core from '@angular/core';
+import { Observable } from 'rxjs';
+
+/** Tree table node */
+interface FuiTreeTableNode<T = any> {
+    data: T;
+    children?: FuiTreeTableNode<T>[] | Observable<FuiTreeTableNode<T>[]>;
+    expanded?: boolean;
+    selected?: boolean;
+    disabled?: boolean;
+    leaf?: boolean;
+}
+/** Flat representation of a tree table row */
+interface FuiFlatTreeTableRow<T = any> {
+    data: T;
+    origin: FuiTreeTableNode<T>;
+    level: number;
+    expandable: boolean;
+    expanded: boolean;
+    selected: boolean;
+    disabled: boolean;
+    loading: boolean;
+    _flatIndex: number;
+}
+/** Tree table header - same structure as AdvancedDataTableHeader */
+interface FuiTreeTableHeader {
+    label: string;
+    type: string;
+    field: string;
+    hasSort?: boolean;
+    hasFilter?: boolean;
+    stickyColumnStart?: boolean;
+    stickyColumnEnd?: boolean;
+}
+/** Tree table configuration */
+interface FuiTreeTableConfig {
+    headerSticky?: boolean;
+    headers: FuiTreeTableHeader[];
+    areRowsSelectable?: boolean;
+    /** Which column shows the tree structure. Defaults to first column. */
+    treeColumn?: string;
+    /** Indentation per level in pixels */
+    indentPx?: number;
+}
+/** Column filter */
+interface FuiTreeTableColumnFilter {
+    field: string;
+    operator: string;
+    value: string | number | boolean | Date | (string | number | Date)[];
+}
+/** Row expand/collapse event */
+interface FuiTreeTableRowEvent<T = any> {
+    row: FuiTreeTableNode<T>;
+    flatRow: FuiFlatTreeTableRow<T>;
+}
+
+declare class FuiTreeTableComponent<T = any> {
+    readonly config: _angular_core.InputSignal<FuiTreeTableConfig>;
+    readonly sort: _angular_core.InputSignal<{
+        field: string;
+        direction: "ASC" | "DESC";
+    } | null>;
+    readonly filters: _angular_core.InputSignal<FuiTreeTableColumnFilter[]>;
+    readonly enableRowHighlight: _angular_core.InputSignal<boolean>;
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    readonly nodes: _angular_core.InputSignal<FuiTreeTableNode<T>[]>;
+    readonly loadChildren: _angular_core.InputSignal<((node: FuiTreeTableNode<T>) => Observable<FuiTreeTableNode<T>[]>) | null>;
+    readonly sortChange: _angular_core.OutputEmitterRef<{
+        field: string;
+        direction: "ASC" | "DESC";
+    } | null>;
+    readonly filtersChange: _angular_core.OutputEmitterRef<FuiTreeTableColumnFilter[]>;
+    readonly rowDblClick: _angular_core.OutputEmitterRef<T>;
+    readonly rowExpand: _angular_core.OutputEmitterRef<FuiTreeTableRowEvent<T>>;
+    readonly rowCollapse: _angular_core.OutputEmitterRef<FuiTreeTableRowEvent<T>>;
+    private readonly _refreshCounter;
+    readonly flatRows: _angular_core.Signal<FuiFlatTreeTableRow<T>[]>;
+    readonly treeColumnField: _angular_core.Signal<string>;
+    readonly indentPx: _angular_core.Signal<number>;
+    private _flattenNodes;
+    onToggleRow(flatRow: FuiFlatTreeTableRow<T>): void;
+    onSortColumn(field: string): void;
+    getCellValue(row: T, field: string): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiTreeTableComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiTreeTableComponent<any>, "fui-tree-table", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "enableRowHighlight": { "alias": "enableRowHighlight"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "nodes": { "alias": "nodes"; "required": true; "isSignal": true; }; "loadChildren": { "alias": "loadChildren"; "required": false; "isSignal": true; }; }, { "sortChange": "sortChange"; "filtersChange": "filtersChange"; "rowDblClick": "rowDblClick"; "rowExpand": "rowExpand"; "rowCollapse": "rowCollapse"; }, never, never, true, never>;
+}
+
+export { FuiTreeTableComponent };
+export type { FuiFlatTreeTableRow, FuiTreeTableColumnFilter, FuiTreeTableConfig, FuiTreeTableHeader, FuiTreeTableNode, FuiTreeTableRowEvent };
+//# sourceMappingURL=raintonic-formaui-components-tree-table.d.ts.map

package/types/raintonic-formaui-components-tree-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-tree-table.d.ts","sources":["../../../lib/components/tree-table/tree-table.types.ts","../../../lib/components/tree-table/fui-tree-table.component.ts"],"mappings":";;;AAEA;AACM,UAAW,gBAAgB;;AAE/B,eAAW,gBAAgB,QAAQ,UAAU,CAAC,gBAAgB;;;;;AAK/D;AAED;AACM,UAAW,mBAAmB;;AAElC,YAAQ,gBAAgB;;;;;;;;AAQzB;AAED;UACiB,kBAAkB;;;;;;;;AAQlC;AAED;UACiB,kBAAkB;;aAExB,kBAAkB;;;;;;AAM5B;AAED;UACiB,wBAAwB;;;AAGvC,uCAAmC,IAAI,sBAAsB,IAAI;AAClE;AAED;AACM,UAAW,oBAAoB;AACnC,SAAK,gBAAgB;AACrB,aAAS,mBAAmB;AAC7B;;AC/CD,cAYa,qBAAqB;qBAEjB,aAAA,CAAA,WAAA,CAAA,kBAAA;AACf,mBAAa,aAAA,CAAA,WAAA;;AAAqC;AAA+B;sBACjE,aAAA,CAAA,WAAA,CAAA,wBAAA;iCACW,aAAA,CAAA,WAAA;2BACN,aAAA,CAAA,WAAA;oBAGP,aAAA,CAAA,WAAA,CAAA,gBAAA;AACd,2BAAqB,aAAA,CAAA,WAAA,SAAiB,gBAAgB,QAAQ,UAAU,CAAC,gBAAgB;AAGzF,yBAAmB,aAAA,CAAA,gBAAA;;AAAsC;AAA2B;4BAC9D,aAAA,CAAA,gBAAA,CAAA,wBAAA;0BACF,aAAA,CAAA,gBAAA;wBACF,aAAA,CAAA,gBAAA,CAAA,oBAAA;0BACE,aAAA,CAAA,gBAAA,CAAA,oBAAA;AAGpB;uBAEiB,aAAA,CAAA,MAAA,CAAA,mBAAA;8BAKO,aAAA,CAAA,MAAA;uBAKP,aAAA,CAAA,MAAA;AAGjB;yBA2BqB,mBAAmB;AAYxC;;oDA1EW,qBAAqB;sDAArB,qBAAqB;AA2FjC;;;;","names":[]}