@raintonic/formaui 0.2.0

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

@@ -0,0 +1,271 @@
+import * as i0 from '@angular/core';
+import { Signal, InputSignal, QueryList, ElementRef, WritableSignal } from '@angular/core';
+import * as _raintonic_formaui_core from '@raintonic/formaui/core';
+
+/**
+ * FuiErrorComponent
+ *
+ * Validation error message shown under the form field. Can automatically show/hide
+ * based on a specific error key, or use with *ngIf for custom control logic.
+ * The component provides proper accessibility roles and live region behavior.
+ *
+ * @example
+ * ```html
+ * <!-- Automatic error key handling -->
+ * <fui-error key="required">This field is required</fui-error>
+ * <fui-error key="email">Please enter a valid email</fui-error>
+ *
+ * <!-- Manual control (backward compatible) -->
+ * <fui-error *ngIf="control.hasError('custom')">Custom error</fui-error>
+ * ```
+ */
+declare class FuiErrorComponent {
+    /**
+     * Optional error key to match against form control errors.
+     * When provided, the error will only show if the control has this specific error.
+     * When not provided, the error will always show (backward compatible behavior).
+     */
+    readonly key: i0.InputSignal<string | undefined>;
+    private readonly _parent;
+    /**
+     * Computed signal to determine if this error should be hidden
+     */
+    protected readonly _shouldHide: Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiErrorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiErrorComponent, "fui-error", never, { "key": { "alias": "key"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Prefix directive for content to be placed before the input in fui-form-field
+ *
+ * @example
+ * ```html
+ * <fui-form-field>
+ *   <fui-label>Price</fui-label>
+ *   <span fuiPrefix>$</span>
+ *   <input fuiInput type="number">
+ * </fui-form-field>
+ * ```
+ */
+declare class FuiPrefixDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiPrefixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FuiPrefixDirective, "[fuiPrefix]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Suffix directive for content to be placed after the input in fui-form-field
+ *
+ * @example
+ * ```html
+ * <fui-form-field>
+ *   <fui-label>Weight</fui-label>
+ *   <input fuiInput type="number">
+ *   <span fuiSuffix>kg</span>
+ * </fui-form-field>
+ * ```
+ */
+declare class FuiSuffixDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiSuffixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FuiSuffixDirective, "[fuiSuffix]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Available form field appearance modes.
+ * - `'outline'` — default bordered appearance (Carbon Design System style)
+ * - `'fill'` — filled background with bottom-border only
+ * - `'float'` — floating-label that animates above the input on focus / value
+ */
+type FormFieldAppearance = 'outline' | 'fill' | 'float';
+/**
+ * # FormField Component
+ *
+ * A form field wrapper component that provides consistent styling and behavior
+ * for form controls. Follows Angular Material patterns with Carbon Design System styling.
+ *
+ * ## Features
+ * - Floating labels with configurable behavior
+ * - Error message display with animations
+ * - Helper text support
+ * - Prefix and suffix support
+ * - Outline appearance with Carbon Design System styling
+ * - Full accessibility support
+ * - Automatic integration with form controls
+ *
+ * ## Usage
+ *
+ * ### Basic Form Field
+ * ```html
+ * <fui-form-field>
+ *   <fui-label>Email</fui-label>
+ *   <input fuiInput type="email" placeholder="Enter your email">
+ * </fui-form-field>
+ * ```
+ *
+ * ### With Error Messages
+ * ```html
+ * <fui-form-field>
+ *   <fui-label>Username</fui-label>
+ *   <input fuiInput formControlName="username">
+ *   <fui-error key="required">Username is required</fui-error>
+ *   <fui-error key="minlength">Username must be at least 3 characters</fui-error>
+ * </fui-form-field>
+ * ```
+ *
+ * ### With Helper Text and Icons
+ * ```html
+ * <fui-form-field>
+ *   <fui-label>Password</fui-label>
+ *   <fui-icon fuiPrefix name="lock"></fui-icon>
+ *   <input fuiInput type="password">
+ *   <button fuiSuffix fuiButton variant="ghost" (click)="togglePasswordVisibility()">
+ *     <fui-icon [name]="showPassword ? 'eye-slash' : 'eye'"></fui-icon>
+ *   </button>
+ *   <fui-hint>Must be at least 8 characters</fui-hint>
+ * </fui-form-field>
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { FuiFormFieldComponent } from '@raintonic/formaui/components/form-field';
+ * import { FuiInputDirective } from '@raintonic/formaui/components/input';
+ *
+ * @Component({
+ *   standalone: true,
+ *   imports: [FuiFormFieldComponent, FuiInputDirective, ReactiveFormsModule],
+ *   template: `
+ *     <form [formGroup]="form">
+ *       <fui-form-field>
+ *         <fui-label>Email Address</fui-label>
+ *         <input fuiInput type="email" formControlName="email">
+ *         <fui-error key="required">Email is required</fui-error>
+ *         <fui-error key="email">Please enter a valid email</fui-error>
+ *       </fui-form-field>
+ *     </form>
+ *   `
+ * })
+ * export class MyFormComponent {
+ *   form = this.fb.group({
+ *     email: ['', [Validators.required, Validators.email]]
+ *   });
+ *
+ *   get emailControl() {
+ *     return this.form.get('email');
+ *   }
+ * }
+ * ```
+ */
+declare class FuiFormFieldComponent {
+    /**
+     * Whether the form field is in read-only mode.
+     * When true, hides the input and shows a plain text value instead.
+     * @default false
+     */
+    readonly readOnly: InputSignal<boolean>;
+    /**
+     * Visual appearance variant.
+     * - `'outline'` (default): bordered input with label above
+     * - `'fill'`: filled background with bottom-border accent
+     * - `'float'`: label floats from inside the input to above it on focus/value
+     */
+    readonly appearance: InputSignal<FormFieldAppearance>;
+    /**
+     * Whether to hide the required marker
+     * @default false
+     */
+    readonly hideRequiredMarker: InputSignal<boolean>;
+    control: Signal<_raintonic_formaui_core.FuiFormFieldControl<unknown> | undefined>;
+    _prefixes?: QueryList<FuiPrefixDirective>;
+    _suffixes?: QueryList<FuiSuffixDirective>;
+    _connectionContainerRef?: ElementRef<HTMLElement>;
+    hideSubscript: InputSignal<boolean>;
+    readonly displayValue: Signal<string>;
+    readonly isFocused: Signal<boolean>;
+    readonly hasError: Signal<boolean>;
+    readonly isDisabled: Signal<boolean>;
+    readonly isEmpty: Signal<boolean>;
+    readonly isRequired: Signal<boolean>;
+    /**
+     * Whether the floating label should be in its "floated" (raised) position.
+     * Only meaningful when `appearance === 'float'`. True when the field is
+     * focused or contains a non-empty value.
+     */
+    readonly shouldFloat: Signal<boolean>;
+    /** Whether control-specific icons (dropdown caret, calendar) should be hidden in readOnly mode */
+    readonly hideControlIcons: Signal<boolean>;
+    /** Whether the "copied" feedback indicator is active */
+    readonly copied: WritableSignal<boolean>;
+    private _copiedTimeout;
+    readonly labelId: string;
+    readonly hintId: string;
+    readonly errorId: string;
+    constructor();
+    /**
+     * Handles click on the form field container
+     */
+    onContainerClick(event: MouseEvent): void;
+    /**
+     * Copies the display value to the clipboard
+     */
+    copyValue(): void;
+    /**
+     * Gets the current error messages
+     */
+    getErrorMessages(): string[];
+    /**
+     * Checks if the form field contains a select control
+     */
+    hasSelectControl(): boolean;
+    /**
+     * Checks if the select control is a multiple select
+     */
+    isMultipleSelect(): boolean;
+    /**
+     * Whether there is projected prefix content
+     */
+    hasPrefix(): boolean;
+    /**
+     * Whether there is projected suffix content
+     */
+    hasSuffix(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiFormFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiFormFieldComponent, "fui-form-field", never, { "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "hideRequiredMarker": { "alias": "hideRequiredMarker"; "required": false; "isSignal": true; }; "hideSubscript": { "alias": "hideSubscript"; "required": false; "isSignal": true; }; }, {}, ["control", "_prefixes", "_suffixes"], ["fui-label", "[fuiPrefix]", "*", "[fuiSuffix]", "fui-error", "fui-hint"], true, never>;
+}
+
+/**
+ * @component FuiHintComponent
+ * @selector fui-hint
+ * @description Helper text displayed below the form field input when there is no error.
+ * Automatically hidden when the parent form field is in an error state.
+ *
+ * @example
+ * <fui-form-field>
+ *   <fui-label>Email</fui-label>
+ *   <input fuiInput type="email">
+ *   <fui-hint>We will never share your email</fui-hint>
+ * </fui-form-field>
+ */
+declare class FuiHintComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiHintComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiHintComponent, "fui-hint", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * @component FuiLabelComponent
+ * @selector fui-label
+ * @description Label element projected inside `fui-form-field` to provide an accessible
+ * field label. Automatically linked to the form control via `aria-labelledby`.
+ *
+ * @example
+ * <fui-form-field>
+ *   <fui-label>Email</fui-label>
+ *   <input fuiInput type="email">
+ * </fui-form-field>
+ */
+declare class FuiLabelComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiLabelComponent, "fui-label", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { FuiErrorComponent, FuiFormFieldComponent, FuiHintComponent, FuiLabelComponent, FuiPrefixDirective, FuiSuffixDirective };
+export type { FormFieldAppearance };
+//# sourceMappingURL=raintonic-formaui-components-form-field.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-form-field.d.ts","sources":["../../../lib/components/form-field/error.component.ts","../../../lib/components/form-field/prefix.directive.ts","../../../lib/components/form-field/suffix.directive.ts","../../../lib/components/form-field/form-field.component.ts","../../../lib/components/form-field/hint.component.ts","../../../lib/components/form-field/label.component.ts"],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;AAgBG;AACH,cAWa,iBAAiB;AAC5B;;;;AAIG;kBACSA,EAAA,CAAA,WAAA;AAEZ;AAEA;;AAEG;oCAC6B,MAAM;yCAb3B,iBAAiB;2CAAjB,iBAAiB;AAsC7B;;ACnED;;;;;;;;;;;AAWG;AACH,cAOa,kBAAkB;yCAAlB,kBAAkB;2CAAlB,kBAAkB;AAAG;;ACnBlC;;;;;;;;;;;AAWG;AACH,cAOa,kBAAkB;yCAAlB,kBAAkB;2CAAlB,kBAAkB;AAAG;;ACElC;;;;;AAKG;AACG,KAAM,mBAAmB;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6EG;AACH,cAuBa,qBAAqB;AAChC;;;;AAIG;AACH,uBAAmB,WAAW;AAE9B;;;;;AAKG;yBACgB,WAAA,CAAA,mBAAA;AAEnB;;;AAGG;AACH,iCAA6B,WAAW;AAGxC,aAAO,MAAA,CAAA,uBAAA,CAAA,mBAAA;AAEqD,gBAAY,SAAS,CAAC,kBAAkB;AACxC,gBAAY,SAAS,CAAC,kBAAkB;AAChD,8BAA0B,UAAU,CAAC,WAAW;AAEpG,mBAAa,WAAA;AAIb,2BAAuB,MAAM;AAmB7B,wBAAoB,MAAM;AAG1B,uBAAmB,MAAM;AAGzB,yBAAqB,MAAM;AAG3B,sBAAkB,MAAM;AAGxB,yBAAqB,MAAM;AAI3B;;;;AAIG;AACH,0BAAsB,MAAM;;AAM5B,+BAA2B,MAAM;;AAOjC,qBAAiB,cAAc;;;;;;AAqC/B;;AAEG;AACH,4BAAwB,UAAU;AAOlC;;AAEG;AACH;AAcA;;AAEG;;AAOH;;AAEG;AACH;AAoBA;;AAEG;AACH;AASA;;AAEG;AACH;AAIA;;AAEG;AACH;yCA5MW,qBAAqB;2CAArB,qBAAqB;AA+MjC;;ACjVD;;;;;;;;;;;;AAYG;AACH,cAQa,gBAAgB;yCAAhB,gBAAgB;2CAAhB,gBAAgB;AAAG;;ACrBhC;;;;;;;;;;;AAWG;AACH,cAQa,iBAAiB;yCAAjB,iBAAiB;2CAAjB,iBAAiB;AAAG;;;;","names":["_angular_core"]}

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

@@ -0,0 +1,61 @@
+import * as i0 from '@angular/core';
+import { InputSignal, Signal, InjectionToken } from '@angular/core';
+
+/**
+ * Available icon sizes following Carbon Design System
+ */
+type FuiIconSize = 'sm' | 'md' | 'lg' | 'xl';
+/**
+ * Available icon weights
+ */
+type FuiIconWeight = 'thin' | 'light' | 'regular' | 'bold' | 'fill';
+/**
+ * # FuiIcon Component
+ *
+ * A wrapper component for Phosphor Icons with consistent sizing and styling.
+ * Provides easy access to the complete Phosphor Icons library with theme integration.
+ *
+ * ## Usage
+ *
+ * ### Basic Icon
+ * ```html
+ * <fui-icon name="heart"></fui-icon>
+ * ```
+ */
+declare class FuiIconComponent {
+    private static readonly _loadedWeights;
+    private readonly _config;
+    private readonly _document;
+    name: InputSignal<string>;
+    size: InputSignal<FuiIconSize>;
+    weight: InputSignal<FuiIconWeight>;
+    color: InputSignal<string | undefined>;
+    ariaLabel: InputSignal<string | undefined>;
+    spin: InputSignal<boolean>;
+    pulse: InputSignal<boolean>;
+    readonly computedClasses: Signal<string>;
+    readonly iconClass: Signal<string>;
+    constructor();
+    /**
+     * Dynamically loads the CSS for a specific Phosphor Icons weight from CDN
+     * @param weight The icon weight to load
+     */
+    private _loadPhosphorWeight;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiIconComponent, "fui-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "weight": { "alias": "weight"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "spin": { "alias": "spin"; "required": false; "isSignal": true; }; "pulse": { "alias": "pulse"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface FuiIconConfig {
+    /** Base URL for the Phosphor Icons CDN */
+    cdnBase: string;
+    /** SRI hashes per weight. If provided, integrity attribute is added to link elements */
+    integrity?: Partial<Record<FuiIconWeight, string>>;
+    /** If true, disables automatic CDN loading. Consumer must load icon CSS manually. */
+    disableAutoLoad?: boolean;
+}
+declare const FUI_ICON_DEFAULT_CONFIG: FuiIconConfig;
+declare const FUI_ICON_CONFIG: InjectionToken<FuiIconConfig>;
+
+export { FUI_ICON_CONFIG, FUI_ICON_DEFAULT_CONFIG, FuiIconComponent };
+export type { FuiIconConfig, FuiIconSize, FuiIconWeight };
+//# sourceMappingURL=raintonic-formaui-components-icon.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-icon.d.ts","sources":["../../../lib/components/icon/icon.component.ts","../../../lib/components/icon/icon-config.ts"],"mappings":";;;AAaA;;AAEG;AACG,KAAM,WAAW;AAEvB;;AAEG;AACG,KAAM,aAAa;AAEzB;;;;;;;;;;;;AAYG;AACH,cAca,gBAAgB;AAE3B;AAEA;AACA;AAGA,UAAM,WAAW;AACjB,UAAM,WAAW,CAAC,WAAW;AAC7B,YAAQ,WAAW,CAAC,aAAa;AACjC,WAAO,WAAW;AAClB,eAAW,WAAW;AACtB,UAAM,WAAW;AACjB,WAAO,WAAW;AAGlB,8BAA0B,MAAM;AAchC,wBAAoB,MAAM;;AAc1B;;;AAGG;AACH;yCAjDW,gBAAgB;2CAAhB,gBAAgB;AAsF5B;;UCrIgB,aAAa;;;;gBAIhB,OAAO,CAAC,MAAM,CAAC,aAAa;;;AAGzC;AAED,cAAa,uBAAuB,EAAE,aAErC;AAED,cAAa,eAAe,EAAA,cAAA,CAAA,aAAA;;;;","names":[]}

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

@@ -0,0 +1,149 @@
+import * as _angular_core from '@angular/core';
+import { DoCheck, OnDestroy, InputSignal, WritableSignal, OutputEmitterRef } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { FuiFormFieldControl, ErrorStateMatcher } from '@raintonic/formaui/core';
+
+/**
+ * Available input types
+ */
+type FuiInputType = 'text' | 'email' | 'password' | 'number' | 'tel' | 'url' | 'search' | 'date' | 'time' | 'datetime-local';
+/**
+ * # FuiInput Directive
+ *
+ * An input directive that integrates seamlessly with fui-form-field and Angular Forms.
+ * Follows Angular Material patterns with Carbon Design System styling.
+ *
+ * ## Features
+ * - Full integration with fui-form-field
+ * - Reactive Forms and Template-driven Forms support
+ * - Multiple input types support
+ * - Error state handling with customizable error messages
+ * - Accessibility features (ARIA attributes, labels)
+ * - Smooth animations and transitions
+ * - Theme-aware styling
+ *
+ * ## Usage
+ *
+ * ### Basic Input with Form Field
+ * ```html
+ * <fui-form-field>
+ *   <fui-label>Email</fui-label>
+ *   <input fuiInput type="email" placeholder="Enter your email">
+ * </fui-form-field>
+ * ```
+ *
+ * ### With Reactive Forms
+ * ```html
+ * <fui-form-field>
+ *   <fui-label>Username</fui-label>
+ *   <input fuiInput formControlName="username">
+ *   <fui-error *ngIf="form.get('username')?.hasError('required')">
+ *     Username is required
+ *   </fui-error>
+ * </fui-form-field>
+ * ```
+ *
+ * ### Password Input with Toggle
+ * ```html
+ * <fui-form-field>
+ *   <fui-label>Password</fui-label>
+ *   <input fuiInput [type]="showPassword ? 'text' : 'password'">
+ *   <button fuiSuffix fuiButton variant="ghost" (click)="togglePassword()">
+ *     <fui-icon [name]="showPassword ? 'eye-slash' : 'eye'"></fui-icon>
+ *   </button>
+ * </fui-form-field>
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { FuiInputDirective } from '@raintonic/formaui/components/input';
+ * import { FuiFormFieldComponent } from '@raintonic/formaui/components/form-field';
+ *
+ * @Component({
+ *   standalone: true,
+ *   imports: [FuiInputDirective, FuiFormFieldComponent, ReactiveFormsModule],
+ *   template: `
+ *     <form [formGroup]="form">
+ *       <fui-form-field>
+ *         <fui-label>Email</fui-label>
+ *         <input fuiInput type="email" formControlName="email">
+ *         <fui-error *ngIf="emailControl?.invalid && emailControl?.touched">
+ *           Please enter a valid email
+ *         </fui-error>
+ *       </fui-form-field>
+ *     </form>
+ *   `
+ * })
+ * export class MyFormComponent {
+ *   form = this.fb.group({
+ *     email: ['', [Validators.required, Validators.email]]
+ *   });
+ *
+ *   get emailControl() {
+ *     return this.form.get('email');
+ *   }
+ * }
+ * ```
+ */
+declare class FuiInputDirective implements ControlValueAccessor, FuiFormFieldControl<string>, DoCheck, OnDestroy {
+    static nextId: number;
+    readonly controlType = "fui-input";
+    type: InputSignal<FuiInputType>;
+    placeholder: InputSignal<string>;
+    readonly: InputSignal<boolean>;
+    maxlength: InputSignal<number | null>;
+    minlength: InputSignal<number | null>;
+    pattern: InputSignal<string | null>;
+    required: WritableSignal<boolean>;
+    errorStateMatcher: InputSignal<ErrorStateMatcher | null>;
+    readonly disabledInput: InputSignal<boolean>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    readonly valueChange: OutputEmitterRef<string>;
+    private readonly _focused;
+    readonly focused: WritableSignal<boolean>;
+    readonly stateChanges: Subject<void>;
+    private readonly _value;
+    readonly value: WritableSignal<string>;
+    private readonly _disabled;
+    private readonly _ngControlDisabled;
+    private _uid;
+    _ariaDescribedby: string | null;
+    private readonly _errorState;
+    readonly errorState: WritableSignal<boolean>;
+    private _parentForm;
+    private _parentFormGroup;
+    private _defaultErrorStateMatcher;
+    private readonly _elementRef;
+    readonly empty: _angular_core.Signal<boolean>;
+    readonly id: string;
+    private _onChange;
+    private _onTouched;
+    private readonly _ngControlRef;
+    get ngControl(): NgControl | null;
+    constructor();
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onContainerClick(_event: MouseEvent): void;
+    setDescribedByIds(ids: string[]): void;
+    onInput(event: Event): void;
+    onChange(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    focus(): void;
+    blur(): void;
+    /**
+     * Check if the element is a select element
+     */
+    isSelect(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FuiInputDirective, "input[fuiInput], textarea[fuiInput], select[fuiInput]", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "minlength": { "alias": "minlength"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabledInput"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+export { FuiInputDirective };
+export type { FuiInputType };
+//# sourceMappingURL=raintonic-formaui-components-input.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-input.d.ts","sources":["../../../lib/components/input/input.directive.ts"],"mappings":";;;;;;AAuBA;;AAEG;AACG,KAAM,YAAY;AAYxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6EG;AACH,cAsCa,iBAAkB,YAAW,oBAAoB,EAAE,mBAAmB,UAAU,OAAO,EAAE,SAAS;;;AAM7G,UAAM,WAAW,CAAC,YAAY;AAC9B,iBAAa,WAAW;AAExB,cAAU,WAAW;AAGrB,eAAW,WAAW;AACtB,eAAW,WAAW;AACtB,aAAS,WAAW;AAGpB,cAAU,cAAc;AAExB,uBAAmB,WAAW,CAAC,iBAAiB;AAChD,4BAAwB,WAAW;uBAClB,aAAA,CAAA,MAAA;AAGjB,0BAAsB,gBAAgB;AAGtC;sBACgB,cAAA;2BACK,OAAA;AAErB;oBACc,cAAA;AACd;AACA;;AAEA;AAGA;yBACmB,cAAA;;;;AAQnB;oBAIc,aAAA,CAAA,MAAA;;;;AAcd;AAEA,qBAAiB,SAAS;;AAmC1B;AAgBA;AAKA;;AAYA;AAIA;AAKA,6BAAyB,UAAU;AAMnC;AAMA,mBAAe,KAAK;AAYpB,oBAAgB,KAAK;AAerB;AAQA;AASA;AAIA;AAIA;;AAEG;AACH;oDApNW,iBAAiB;sDAAjB,iBAAiB;AAuN7B;;;;","names":[]}

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

@@ -0,0 +1,48 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, ElementRef } from '@angular/core';
+
+type FuiListSelectionMode = 'none' | 'single' | 'multi';
+interface FuiListSelectionChange<T = unknown> {
+    source: unknown;
+    value: T[];
+}
+interface FuiListHost {
+    interactive(): boolean;
+    selectionMode(): FuiListSelectionMode;
+    selectItem(item: unknown): void;
+}
+declare const FUI_LIST: InjectionToken<FuiListHost>;
+
+declare class FuiListItemComponent {
+    readonly value: _angular_core.InputSignal<unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly _selected: _angular_core.WritableSignal<boolean>;
+    readonly _focused: _angular_core.WritableSignal<boolean>;
+    readonly _elementRef: ElementRef<any>;
+    private _list;
+    readonly _isInteractive: _angular_core.Signal<boolean>;
+    readonly _isSelectable: _angular_core.Signal<boolean>;
+    readonly _role: _angular_core.Signal<"option" | "listitem">;
+    onClick(): void;
+    onSpace(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiListItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiListItemComponent, "fui-list-item", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["[fuiListItemIcon], [fuiListItemAvatar]", "*", "[fuiListItemAction]"], true, never>;
+}
+
+declare class FuiListComponent {
+    readonly interactive: _angular_core.InputSignal<boolean>;
+    readonly selectionMode: _angular_core.InputSignal<FuiListSelectionMode>;
+    readonly dividers: _angular_core.InputSignal<boolean>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<FuiListSelectionChange<unknown>>;
+    readonly items: _angular_core.Signal<readonly FuiListItemComponent[]>;
+    readonly _selectedValues: _angular_core.WritableSignal<Set<unknown>>;
+    selectItem(item: FuiListItemComponent): void;
+    isSelected(value: unknown): boolean;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiListComponent, "fui-list", never, { "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "dividers": { "alias": "dividers"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; }, ["items"], ["*"], true, never>;
+}
+
+export { FUI_LIST, FuiListComponent, FuiListItemComponent };
+export type { FuiListHost, FuiListSelectionChange, FuiListSelectionMode };
+//# sourceMappingURL=raintonic-formaui-components-list.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-list.d.ts","sources":["../../../lib/components/list/list.types.ts","../../../lib/components/list/list-item.component.ts","../../../lib/components/list/list.component.ts"],"mappings":";;;AAEM,KAAM,oBAAoB;AAE1B,UAAW,sBAAsB;;;AAGtC;UAEgB,WAAW;;qBAET,oBAAoB;AACrC;AACD;AAED,cAAa,QAAQ,EAAA,cAAA,CAAA,WAAA;;ACFrB,cAsBa,oBAAoB;oBACjB,aAAA,CAAA,WAAA;uBACG,aAAA,CAAA,wBAAA;wBAEC,aAAA,CAAA,cAAA;uBACD,aAAA,CAAA,cAAA;0BAEG,UAAA;;6BAIG,aAAA,CAAA,MAAA;4BAGD,aAAA,CAAA,MAAA;oBACR,aAAA,CAAA,MAAA;AAEd;AAOA,mBAAe,KAAK;oDAxBT,oBAAoB;sDAApB,oBAAoB;AA4BhC;;ACnDD,cAkBa,gBAAgB;0BACP,aAAA,CAAA,WAAA;4BACE,aAAA,CAAA,WAAA,CAAA,oBAAA;uBACL,aAAA,CAAA,WAAA;8BAEO,aAAA,CAAA,gBAAA,CAAA,sBAAA;oBAEV,aAAA,CAAA,MAAA,UAAA,oBAAA;8BAEU,aAAA,CAAA,cAAA,CAAA,GAAA;AAExB,qBAAiB,oBAAoB;AAiCrC;AAIA,qBAAiB,aAAa;oDAhDnB,gBAAgB;sDAAhB,gBAAgB;AA8F5B;;;;","names":[]}