@tolle_/tolle-ui 18.2.28 → 18.2.30

package/esm2022/lib/input-group.component.mjs

@@ -0,0 +1,418 @@
+import { Component, Input, Output, EventEmitter, forwardRef } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { NG_VALUE_ACCESSOR, FormsModule } from '@angular/forms';
+import { cva } from 'class-variance-authority';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+const inputGroupVariants = cva('group/input-group relative flex w-full items-center rounded-md border border-input bg-background shadow-sm transition-colors ' +
+    'focus-within:border-primary/80 focus-within:ring-4 focus-within:ring-ring/30 ' +
+    'has-[input:disabled]:cursor-not-allowed has-[input:disabled]:opacity-50', {
+    variants: {
+        size: {
+            xs: 'h-8 gap-1 px-1.5 text-xs',
+            sm: 'h-9 gap-1.5 px-2 text-sm',
+            default: 'h-10 gap-2 px-2 text-sm',
+            lg: 'h-11 gap-2 px-3 text-base',
+        },
+        invalid: {
+            true: 'border-destructive focus-within:border-destructive/80 focus-within:ring-destructive/30',
+            false: '',
+        },
+        // `block-start` / `block-end` addons stack, so the group can no longer be a
+        // fixed-height row.
+        stacked: {
+            true: 'h-auto flex-col items-stretch gap-0 px-0 py-0',
+            false: '',
+        },
+    },
+    defaultVariants: { size: 'default', invalid: false, stacked: false },
+});
+/**
+ * Wraps an input with leading/trailing addons — icons, text, buttons or a
+ * spinner — inside a single bordered control that shows one shared focus ring.
+ *
+ * Put a `tolle-input-group-input` (or `tolle-input-group-textarea`) inside,
+ * alongside any number of `tolle-input-group-addon` elements.
+ * @new
+ */
+export class InputGroupComponent {
+    /** Height and text size of the group; match it to the input inside. @default 'default' */
+    size = 'default';
+    /** Applies the destructive border and focus ring. @default false */
+    invalid = false;
+    /** Switches to a stacked column layout for `block-start`/`block-end` addons. @default false */
+    stacked = false;
+    /** Extra Tailwind classes merged onto the group via `cn()` (last-wins). */
+    class = '';
+    get computedClass() {
+        return cn(inputGroupVariants({ size: this.size, invalid: this.invalid, stacked: this.stacked }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputGroupComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: InputGroupComponent, isStandalone: true, selector: "tolle-input-group", inputs: { size: "size", invalid: "invalid", stacked: "stacked", class: "class" }, ngImport: i0, template: `<div [class]="computedClass"><ng-content></ng-content></div>`, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputGroupComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-input-group', standalone: true, imports: [CommonModule], template: `<div [class]="computedClass"><ng-content></ng-content></div>`, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { size: [{
+                type: Input
+            }], invalid: [{
+                type: Input
+            }], stacked: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+const inputGroupAddonVariants = cva('flex shrink-0 items-center gap-1.5 text-muted-foreground', {
+    variants: {
+        align: {
+            'inline-start': 'order-first',
+            'inline-end': 'order-last',
+            'block-start': 'order-first w-full border-b border-border px-3 py-1.5',
+            'block-end': 'order-last w-full border-t border-border px-3 py-1.5',
+        },
+    },
+    defaultVariants: { align: 'inline-start' },
+});
+/**
+ * A slot beside (or above/below) the input for icons, text or buttons.
+ * Use `block-start` / `block-end` together with the group's `stacked` input.
+ */
+export class InputGroupAddonComponent {
+    /** Where the addon sits relative to the input. @default 'inline-start' */
+    align = 'inline-start';
+    /** Extra Tailwind classes merged onto the addon via `cn()` (last-wins). */
+    class = '';
+    get computedClass() {
+        return cn(inputGroupAddonVariants({ align: this.align }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputGroupAddonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: InputGroupAddonComponent, isStandalone: true, selector: "tolle-input-group-addon", inputs: { align: "align", class: "class" }, ngImport: i0, template: `<div [class]="computedClass"><ng-content></ng-content></div>`, isInline: true, styles: [":host{display:inline-flex}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputGroupAddonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-input-group-addon', standalone: true, imports: [CommonModule], template: `<div [class]="computedClass"><ng-content></ng-content></div>`, styles: [":host{display:inline-flex}\n"] }]
+        }], propDecorators: { align: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+const inputGroupButtonVariants = cva('inline-flex shrink-0 items-center justify-center gap-1 rounded font-medium transition-colors ' +
+    'focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-1 ' +
+    'disabled:pointer-events-none disabled:opacity-50', {
+    variants: {
+        variant: {
+            default: 'bg-primary text-primary-foreground hover:bg-primary/90',
+            secondary: 'bg-secondary text-secondary-foreground hover:bg-secondary/80',
+            outline: 'border border-border bg-transparent hover:bg-accent hover:text-accent-foreground',
+            ghost: 'bg-transparent hover:bg-accent hover:text-accent-foreground',
+            destructive: 'bg-destructive text-destructive-foreground hover:bg-destructive/90',
+        },
+        size: {
+            xs: 'h-6 px-2 text-xs',
+            sm: 'h-7 px-2.5 text-sm',
+            'icon-xs': 'h-6 w-6 p-0 text-xs',
+            'icon-sm': 'h-7 w-7 p-0 text-sm',
+        },
+    },
+    defaultVariants: { variant: 'ghost', size: 'icon-sm' },
+});
+/** A compact button sized to sit inside an input group addon. */
+export class InputGroupButtonComponent {
+    /** Visual style of the button. @default 'ghost' */
+    variant = 'ghost';
+    /** Size of the button; the `icon-*` sizes render a square. @default 'icon-sm' */
+    size = 'icon-sm';
+    /** Native button type. @default 'button' */
+    type = 'button';
+    /** Disables the button. @default false */
+    disabled = false;
+    /** Accessible name — required when the button shows only an icon. @default '' */
+    ariaLabel = '';
+    /** Extra Tailwind classes merged onto the button via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the click event when the button is pressed. */
+    clicked = new EventEmitter();
+    get computedClass() {
+        return cn(inputGroupButtonVariants({ variant: this.variant, size: this.size }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputGroupButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: InputGroupButtonComponent, isStandalone: true, selector: "tolle-input-group-button", inputs: { variant: "variant", size: "size", type: "type", disabled: "disabled", ariaLabel: "ariaLabel", class: "class" }, outputs: { clicked: "clicked" }, ngImport: i0, template: `
+    <button
+      [type]="type"
+      [disabled]="disabled"
+      [attr.aria-label]="ariaLabel || null"
+      [class]="computedClass"
+      (click)="clicked.emit($event)"
+    >
+      <ng-content></ng-content>
+    </button>
+  `, isInline: true, styles: [":host{display:inline-flex}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputGroupButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-input-group-button', standalone: true, imports: [CommonModule], template: `
+    <button
+      [type]="type"
+      [disabled]="disabled"
+      [attr.aria-label]="ariaLabel || null"
+      [class]="computedClass"
+      (click)="clicked.emit($event)"
+    >
+      <ng-content></ng-content>
+    </button>
+  `, styles: [":host{display:inline-flex}\n"] }]
+        }], propDecorators: { variant: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], clicked: [{
+                type: Output
+            }] } });
+/** Plain text inside an addon — a unit, prefix, or character counter. */
+export class InputGroupTextComponent {
+    /** Extra Tailwind classes merged onto the text via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputGroupTextComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: InputGroupTextComponent, isStandalone: true, selector: "tolle-input-group-text", inputs: { class: "class" }, ngImport: i0, template: `<span [class]="cn('select-none whitespace-nowrap text-sm text-muted-foreground', class)"><ng-content></ng-content></span>`, isInline: true, styles: [":host{display:inline-flex}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputGroupTextComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-input-group-text', standalone: true, imports: [CommonModule], template: `<span [class]="cn('select-none whitespace-nowrap text-sm text-muted-foreground', class)"><ng-content></ng-content></span>`, styles: [":host{display:inline-flex}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/**
+ * The input inside a `tolle-input-group`. Deliberately borderless and
+ * unfocusable-looking — the surrounding group owns the border and focus ring.
+ */
+export class InputGroupInputComponent {
+    cdr;
+    /** Id applied to the underlying `<input>`. */
+    id = `input-group-input-${Math.random().toString(36).slice(2, 11)}`;
+    /** Native input type. @default 'text' */
+    type = 'text';
+    /** Placeholder text. @default '' */
+    placeholder = '';
+    /** Disables the input. @default false */
+    disabled = false;
+    /** Makes the input read-only. @default false */
+    readonly = false;
+    /** Id of the element describing this input, for `aria-describedby`. @default '' */
+    ariaDescribedby = '';
+    /** Extra Tailwind classes merged onto the input via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the new value on every keystroke. */
+    valueChange = new EventEmitter();
+    value = '';
+    onChange = () => { };
+    onTouched = () => { };
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    get computedClass() {
+        return cn('min-w-0 flex-1 border-none bg-transparent p-0 text-foreground outline-none', 'placeholder:text-muted-foreground', 'focus:outline-none focus:ring-0 focus:shadow-none', 'disabled:cursor-not-allowed', this.class);
+    }
+    onInputChange(event) {
+        if (this.readonly || this.disabled)
+            return;
+        const next = event.target.value;
+        this.value = next;
+        this.onChange(next);
+        this.valueChange.emit(next);
+    }
+    writeValue(value) {
+        this.value = value;
+        this.cdr.markForCheck();
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        this.cdr.markForCheck();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputGroupInputComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: InputGroupInputComponent, isStandalone: true, selector: "tolle-input-group-input", inputs: { id: "id", type: "type", placeholder: "placeholder", disabled: "disabled", readonly: "readonly", ariaDescribedby: "ariaDescribedby", class: "class" }, outputs: { valueChange: "valueChange" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => InputGroupInputComponent),
+                multi: true,
+            },
+        ], ngImport: i0, template: `
+    <input
+      [id]="id"
+      [type]="type"
+      [placeholder]="placeholder"
+      [disabled]="disabled"
+      [readOnly]="readonly"
+      [value]="value ?? ''"
+      [attr.aria-describedby]="ariaDescribedby || null"
+      [class]="computedClass"
+      (input)="onInputChange($event)"
+      (blur)="onTouched()"
+    />
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: FormsModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputGroupInputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-input-group-input', standalone: true, imports: [CommonModule, FormsModule], providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => InputGroupInputComponent),
+                            multi: true,
+                        },
+                    ], template: `
+    <input
+      [id]="id"
+      [type]="type"
+      [placeholder]="placeholder"
+      [disabled]="disabled"
+      [readOnly]="readonly"
+      [value]="value ?? ''"
+      [attr.aria-describedby]="ariaDescribedby || null"
+      [class]="computedClass"
+      (input)="onInputChange($event)"
+      (blur)="onTouched()"
+    />
+  `, styles: [":host{display:block}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { id: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], ariaDescribedby: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }] } });
+/** The textarea equivalent of `tolle-input-group-input`. */
+export class InputGroupTextareaComponent {
+    cdr;
+    /** Id applied to the underlying `<textarea>`. */
+    id = `input-group-textarea-${Math.random().toString(36).slice(2, 11)}`;
+    /** Visible rows. @default 3 */
+    rows = 3;
+    /** Placeholder text. @default '' */
+    placeholder = '';
+    /** Disables the textarea. @default false */
+    disabled = false;
+    /** Makes the textarea read-only. @default false */
+    readonly = false;
+    /** Id of the element describing this textarea, for `aria-describedby`. @default '' */
+    ariaDescribedby = '';
+    /** Extra Tailwind classes merged onto the textarea via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the new value on every keystroke. */
+    valueChange = new EventEmitter();
+    value = '';
+    onChange = () => { };
+    onTouched = () => { };
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    get computedClass() {
+        return cn('min-w-0 flex-1 resize-none border-none bg-transparent p-0 py-2 text-foreground outline-none', 'placeholder:text-muted-foreground', 'focus:outline-none focus:ring-0 focus:shadow-none', 'disabled:cursor-not-allowed', this.class);
+    }
+    onInputChange(event) {
+        if (this.readonly || this.disabled)
+            return;
+        const next = event.target.value;
+        this.value = next;
+        this.onChange(next);
+        this.valueChange.emit(next);
+    }
+    writeValue(value) {
+        this.value = value;
+        this.cdr.markForCheck();
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        this.cdr.markForCheck();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputGroupTextareaComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: InputGroupTextareaComponent, isStandalone: true, selector: "tolle-input-group-textarea", inputs: { id: "id", rows: "rows", placeholder: "placeholder", disabled: "disabled", readonly: "readonly", ariaDescribedby: "ariaDescribedby", class: "class" }, outputs: { valueChange: "valueChange" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => InputGroupTextareaComponent),
+                multi: true,
+            },
+        ], ngImport: i0, template: `
+    <textarea
+      [id]="id"
+      [rows]="rows"
+      [placeholder]="placeholder"
+      [disabled]="disabled"
+      [readOnly]="readonly"
+      [value]="value ?? ''"
+      [attr.aria-describedby]="ariaDescribedby || null"
+      [class]="computedClass"
+      (input)="onInputChange($event)"
+      (blur)="onTouched()"
+    ></textarea>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: FormsModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputGroupTextareaComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-input-group-textarea', standalone: true, imports: [CommonModule, FormsModule], providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => InputGroupTextareaComponent),
+                            multi: true,
+                        },
+                    ], template: `
+    <textarea
+      [id]="id"
+      [rows]="rows"
+      [placeholder]="placeholder"
+      [disabled]="disabled"
+      [readOnly]="readonly"
+      [value]="value ?? ''"
+      [attr.aria-describedby]="ariaDescribedby || null"
+      [class]="computedClass"
+      (input)="onInputChange($event)"
+      (blur)="onTouched()"
+    ></textarea>
+  `, styles: [":host{display:block}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { id: [{
+                type: Input
+            }], rows: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], ariaDescribedby: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-group.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/input-group.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, forwardRef, ChangeDetectorRef } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR, FormsModule } from '@angular/forms';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\nconst inputGroupVariants = cva(\n  'group/input-group relative flex w-full items-center rounded-md border border-input bg-background shadow-sm transition-colors ' +\n    'focus-within:border-primary/80 focus-within:ring-4 focus-within:ring-ring/30 ' +\n    'has-[input:disabled]:cursor-not-allowed has-[input:disabled]:opacity-50',\n  {\n    variants: {\n      size: {\n        xs: 'h-8 gap-1 px-1.5 text-xs',\n        sm: 'h-9 gap-1.5 px-2 text-sm',\n        default: 'h-10 gap-2 px-2 text-sm',\n        lg: 'h-11 gap-2 px-3 text-base',\n      },\n      invalid: {\n        true: 'border-destructive focus-within:border-destructive/80 focus-within:ring-destructive/30',\n        false: '',\n      },\n      // `block-start` / `block-end` addons stack, so the group can no longer be a\n      // fixed-height row.\n      stacked: {\n        true: 'h-auto flex-col items-stretch gap-0 px-0 py-0',\n        false: '',\n      },\n    },\n    defaultVariants: { size: 'default', invalid: false, stacked: false },\n  }\n);\n\nexport type InputGroupProps = VariantProps<typeof inputGroupVariants>;\n\n/**\n * Wraps an input with leading/trailing addons — icons, text, buttons or a\n * spinner — inside a single bordered control that shows one shared focus ring.\n *\n * Put a `tolle-input-group-input` (or `tolle-input-group-textarea`) inside,\n * alongside any number of `tolle-input-group-addon` elements.\n * @new\n */\n@Component({\n  selector: 'tolle-input-group',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  template: `<div [class]=\"computedClass\"><ng-content></ng-content></div>`,\n})\nexport class InputGroupComponent {\n  /** Height and text size of the group; match it to the input inside. @default 'default' */\n  @Input() size: InputGroupProps['size'] = 'default';\n  /** Applies the destructive border and focus ring. @default false */\n  @Input() invalid = false;\n  /** Switches to a stacked column layout for `block-start`/`block-end` addons. @default false */\n  @Input() stacked = false;\n  /** Extra Tailwind classes merged onto the group via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get computedClass() {\n    return cn(\n      inputGroupVariants({ size: this.size, invalid: this.invalid, stacked: this.stacked }),\n      this.class\n    );\n  }\n}\n\nconst inputGroupAddonVariants = cva('flex shrink-0 items-center gap-1.5 text-muted-foreground', {\n  variants: {\n    align: {\n      'inline-start': 'order-first',\n      'inline-end': 'order-last',\n      'block-start': 'order-first w-full border-b border-border px-3 py-1.5',\n      'block-end': 'order-last w-full border-t border-border px-3 py-1.5',\n    },\n  },\n  defaultVariants: { align: 'inline-start' },\n});\n\nexport type InputGroupAddonProps = VariantProps<typeof inputGroupAddonVariants>;\n\n/**\n * A slot beside (or above/below) the input for icons, text or buttons.\n * Use `block-start` / `block-end` together with the group's `stacked` input.\n */\n@Component({\n  selector: 'tolle-input-group-addon',\n  styles: [':host { display: inline-flex; }'],\n  standalone: true,\n  imports: [CommonModule],\n  template: `<div [class]=\"computedClass\"><ng-content></ng-content></div>`,\n})\nexport class InputGroupAddonComponent {\n  /** Where the addon sits relative to the input. @default 'inline-start' */\n  @Input() align: InputGroupAddonProps['align'] = 'inline-start';\n  /** Extra Tailwind classes merged onto the addon via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get computedClass() {\n    return cn(inputGroupAddonVariants({ align: this.align }), this.class);\n  }\n}\n\nconst inputGroupButtonVariants = cva(\n  'inline-flex shrink-0 items-center justify-center gap-1 rounded font-medium transition-colors ' +\n    'focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-1 ' +\n    'disabled:pointer-events-none disabled:opacity-50',\n  {\n    variants: {\n      variant: {\n        default: 'bg-primary text-primary-foreground hover:bg-primary/90',\n        secondary: 'bg-secondary text-secondary-foreground hover:bg-secondary/80',\n        outline: 'border border-border bg-transparent hover:bg-accent hover:text-accent-foreground',\n        ghost: 'bg-transparent hover:bg-accent hover:text-accent-foreground',\n        destructive: 'bg-destructive text-destructive-foreground hover:bg-destructive/90',\n      },\n      size: {\n        xs: 'h-6 px-2 text-xs',\n        sm: 'h-7 px-2.5 text-sm',\n        'icon-xs': 'h-6 w-6 p-0 text-xs',\n        'icon-sm': 'h-7 w-7 p-0 text-sm',\n      },\n    },\n    defaultVariants: { variant: 'ghost', size: 'icon-sm' },\n  }\n);\n\nexport type InputGroupButtonProps = VariantProps<typeof inputGroupButtonVariants>;\n\n/** A compact button sized to sit inside an input group addon. */\n@Component({\n  selector: 'tolle-input-group-button',\n  styles: [':host { display: inline-flex; }'],\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <button\n      [type]=\"type\"\n      [disabled]=\"disabled\"\n      [attr.aria-label]=\"ariaLabel || null\"\n      [class]=\"computedClass\"\n      (click)=\"clicked.emit($event)\"\n    >\n      <ng-content></ng-content>\n    </button>\n  `,\n})\nexport class InputGroupButtonComponent {\n  /** Visual style of the button. @default 'ghost' */\n  @Input() variant: InputGroupButtonProps['variant'] = 'ghost';\n  /** Size of the button; the `icon-*` sizes render a square. @default 'icon-sm' */\n  @Input() size: InputGroupButtonProps['size'] = 'icon-sm';\n  /** Native button type. @default 'button' */\n  @Input() type: 'button' | 'submit' | 'reset' = 'button';\n  /** Disables the button. @default false */\n  @Input() disabled = false;\n  /** Accessible name — required when the button shows only an icon. @default '' */\n  @Input() ariaLabel = '';\n  /** Extra Tailwind classes merged onto the button via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the click event when the button is pressed. */\n  @Output() clicked = new EventEmitter<MouseEvent>();\n\n  get computedClass() {\n    return cn(inputGroupButtonVariants({ variant: this.variant, size: this.size }), this.class);\n  }\n}\n\n/** Plain text inside an addon — a unit, prefix, or character counter. */\n@Component({\n  selector: 'tolle-input-group-text',\n  styles: [':host { display: inline-flex; }'],\n  standalone: true,\n  imports: [CommonModule],\n  template: `<span [class]=\"cn('select-none whitespace-nowrap text-sm text-muted-foreground', class)\"><ng-content></ng-content></span>`,\n})\nexport class InputGroupTextComponent {\n  /** Extra Tailwind classes merged onto the text via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/**\n * The input inside a `tolle-input-group`. Deliberately borderless and\n * unfocusable-looking — the surrounding group owns the border and focus ring.\n */\n@Component({\n  selector: 'tolle-input-group-input',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule, FormsModule],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => InputGroupInputComponent),\n      multi: true,\n    },\n  ],\n  template: `\n    <input\n      [id]=\"id\"\n      [type]=\"type\"\n      [placeholder]=\"placeholder\"\n      [disabled]=\"disabled\"\n      [readOnly]=\"readonly\"\n      [value]=\"value ?? ''\"\n      [attr.aria-describedby]=\"ariaDescribedby || null\"\n      [class]=\"computedClass\"\n      (input)=\"onInputChange($event)\"\n      (blur)=\"onTouched()\"\n    />\n  `,\n})\nexport class InputGroupInputComponent implements ControlValueAccessor {\n  /** Id applied to the underlying `<input>`. */\n  @Input() id = `input-group-input-${Math.random().toString(36).slice(2, 11)}`;\n  /** Native input type. @default 'text' */\n  @Input() type = 'text';\n  /** Placeholder text. @default '' */\n  @Input() placeholder = '';\n  /** Disables the input. @default false */\n  @Input() disabled = false;\n  /** Makes the input read-only. @default false */\n  @Input() readonly = false;\n  /** Id of the element describing this input, for `aria-describedby`. @default '' */\n  @Input() ariaDescribedby = '';\n  /** Extra Tailwind classes merged onto the input via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the new value on every keystroke. */\n  @Output() valueChange = new EventEmitter<string>();\n\n  value: string | null = '';\n  onChange: (value: string) => void = () => {};\n  onTouched: () => void = () => {};\n\n  constructor(private cdr: ChangeDetectorRef) {}\n\n  get computedClass() {\n    return cn(\n      'min-w-0 flex-1 border-none bg-transparent p-0 text-foreground outline-none',\n      'placeholder:text-muted-foreground',\n      'focus:outline-none focus:ring-0 focus:shadow-none',\n      'disabled:cursor-not-allowed',\n      this.class\n    );\n  }\n\n  onInputChange(event: Event): void {\n    if (this.readonly || this.disabled) return;\n    const next = (event.target as HTMLInputElement).value;\n    this.value = next;\n    this.onChange(next);\n    this.valueChange.emit(next);\n  }\n\n  writeValue(value: string | null): void {\n    this.value = value;\n    this.cdr.markForCheck();\n  }\n\n  registerOnChange(fn: (value: string) => void): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n    this.cdr.markForCheck();\n  }\n}\n\n/** The textarea equivalent of `tolle-input-group-input`. */\n@Component({\n  selector: 'tolle-input-group-textarea',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule, FormsModule],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => InputGroupTextareaComponent),\n      multi: true,\n    },\n  ],\n  template: `\n    <textarea\n      [id]=\"id\"\n      [rows]=\"rows\"\n      [placeholder]=\"placeholder\"\n      [disabled]=\"disabled\"\n      [readOnly]=\"readonly\"\n      [value]=\"value ?? ''\"\n      [attr.aria-describedby]=\"ariaDescribedby || null\"\n      [class]=\"computedClass\"\n      (input)=\"onInputChange($event)\"\n      (blur)=\"onTouched()\"\n    ></textarea>\n  `,\n})\nexport class InputGroupTextareaComponent implements ControlValueAccessor {\n  /** Id applied to the underlying `<textarea>`. */\n  @Input() id = `input-group-textarea-${Math.random().toString(36).slice(2, 11)}`;\n  /** Visible rows. @default 3 */\n  @Input() rows = 3;\n  /** Placeholder text. @default '' */\n  @Input() placeholder = '';\n  /** Disables the textarea. @default false */\n  @Input() disabled = false;\n  /** Makes the textarea read-only. @default false */\n  @Input() readonly = false;\n  /** Id of the element describing this textarea, for `aria-describedby`. @default '' */\n  @Input() ariaDescribedby = '';\n  /** Extra Tailwind classes merged onto the textarea via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the new value on every keystroke. */\n  @Output() valueChange = new EventEmitter<string>();\n\n  value: string | null = '';\n  onChange: (value: string) => void = () => {};\n  onTouched: () => void = () => {};\n\n  constructor(private cdr: ChangeDetectorRef) {}\n\n  get computedClass() {\n    return cn(\n      'min-w-0 flex-1 resize-none border-none bg-transparent p-0 py-2 text-foreground outline-none',\n      'placeholder:text-muted-foreground',\n      'focus:outline-none focus:ring-0 focus:shadow-none',\n      'disabled:cursor-not-allowed',\n      this.class\n    );\n  }\n\n  onInputChange(event: Event): void {\n    if (this.readonly || this.disabled) return;\n    const next = (event.target as HTMLTextAreaElement).value;\n    this.value = next;\n    this.onChange(next);\n    this.valueChange.emit(next);\n  }\n\n  writeValue(value: string | null): void {\n    this.value = value;\n    this.cdr.markForCheck();\n  }\n\n  registerOnChange(fn: (value: string) => void): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n    this.cdr.markForCheck();\n  }\n}\n"]}

package/esm2022/lib/input.component.mjs

@@ -183,22 +183,17 @@ export class InputComponent {
         </p>
       </ng-container>
     </div>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] });
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputComponent, decorators: [{
             type: Component,
-            args: [{
-                    selector: 'tolle-input',
-                    standalone: true,
-                    imports: [CommonModule, FormsModule],
-                    providers: [
+            args: [{ selector: 'tolle-input', standalone: true, imports: [CommonModule, FormsModule], providers: [
                         {
                             provide: NG_VALUE_ACCESSOR,
                             useExisting: forwardRef(() => InputComponent),
                             multi: true
                         }
-                    ],
-                    template: `
+                    ], template: `
     <div class="flex flex-col gap-1.5 w-full">
       <label
         *ngIf="label"
@@ -254,8 +249,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
         </p>
       </ng-container>
     </div>
-  `,
-                }]
+  `, styles: [":host{display:block}\n"] }]
         }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { inputElement: [{
                 type: ViewChild,
                 args: ['inputElement']
@@ -286,4 +280,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             }], hideHintOnFocus: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/input.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, forwardRef, ChangeDetectorRef, ElementRef, ViewChild, AfterViewInit } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR, FormsModule } from '@angular/forms';\nimport { cn } from './utils/cn';\n\n@Component({\n  selector: 'tolle-input',\n  standalone: true,\n  imports: [CommonModule, FormsModule],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => InputComponent),\n      multi: true\n    }\n  ],\n  template: `\n    <div class=\"flex flex-col gap-1.5 w-full\">\n      <label\n        *ngIf=\"label\"\n        [for]=\"id\"\n        [class]=\"computedLabelClass\">\n        {{ label }}\n      </label>\n\n      <div\n        [class]=\"computedContainerClass\"\n        (click)=\"focusInput()\"\n      >\n        <div class=\"h-full flex items-center text-muted-foreground group-focus-within:text-primary transition-colors duration-200\">\n          <ng-content select=\"[prefix]\"></ng-content>\n        </div>\n\n        <input\n          #inputElement\n          [id]=\"id\"\n          [type]=\"type\"\n          [placeholder]=\"placeholder\"\n          [disabled]=\"disabled\"\n          [readOnly]=\"readonly\"\n          [(ngModel)]=\"value\"\n          (blur)=\"onBlur()\"\n          (focus)=\"onFocus()\"\n          (input)=\"onInputChange($event)\"\n          [class]=\"computedInputClass\"\n          [attr.aria-invalid]=\"error || null\"\n          [attr.aria-describedby]=\"error && errorMessage ? id + '-error' : (hint ? id + '-hint' : null)\"\n        />\n\n        <div class=\"h-full flex items-center text-muted-foreground group-focus-within:text-primary transition-colors duration-200\">\n          <ng-content select=\"[suffix]\"></ng-content>\n        </div>\n      </div>\n\n      <ng-container *ngIf=\"!disabled\">\n        <p\n          *ngIf=\"hint && !error\"\n          [id]=\"id + '-hint'\"\n          class=\"text-xs text-muted-foreground px-1 transition-opacity duration-200\"\n          [class.opacity-0]=\"isFocused && hideHintOnFocus\"\n        >\n          {{ hint }}\n        </p>\n        <p\n          *ngIf=\"error && errorMessage\"\n          [id]=\"id + '-error'\"\n          class=\"text-xs text-destructive px-1\"\n        >\n          {{ errorMessage }}\n        </p>\n      </ng-container>\n    </div>\n  `,\n})\nexport class InputComponent implements ControlValueAccessor, AfterViewInit {\n  @ViewChild('inputElement') inputElement!: ElementRef<HTMLInputElement>;\n\n  @Input() id: string = `input-${Math.random().toString(36).substr(2, 9)}`;\n  @Input() label: string = '';\n  @Input() hint: string = '';\n  @Input() errorMessage: string = '';\n  @Input() type: string = 'text';\n  @Input() placeholder: string = '';\n  @Input() size: 'xs' | 'sm' | 'default' | 'lg' = 'default';\n  @Input() containerClass: string = '';\n  @Input() class: string = '';\n\n  // New States\n  @Input() disabled: boolean = false;\n  @Input() readonly: boolean = false;\n  @Input() error: boolean = false;\n\n  // Focus behavior\n  @Input() hideHintOnFocus: boolean = true;\n\n  value: any = '';\n  onChange: any = () => { };\n  onTouched: any = () => { };\n  isFocused: boolean = false;\n\n  constructor(private cdr: ChangeDetectorRef) { }\n\n  ngAfterViewInit() {\n    if (this.inputElement?.nativeElement.hasAttribute('autofocus')) {\n      setTimeout(() => this.inputElement.nativeElement.focus());\n    }\n  }\n\n  writeValue(value: any): void {\n    this.value = value;\n    this.cdr.markForCheck();\n  }\n\n  registerOnChange(fn: any): void { this.onChange = fn; }\n  registerOnTouched(fn: any): void { this.onTouched = fn; }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n    this.cdr.markForCheck();\n  }\n\n  onInputChange(event: Event): void {\n    if (this.readonly || this.disabled) return;\n    const val = (event.target as HTMLInputElement).value;\n    this.value = val;\n    this.onChange(val);\n  }\n\n  onFocus(): void {\n    this.isFocused = true;\n  }\n\n  onBlur(): void {\n    this.isFocused = false;\n    this.onTouched();\n  }\n\n  focusInput(): void {\n    if (!this.disabled && this.inputElement) {\n      this.inputElement.nativeElement.focus();\n    }\n  }\n\n  protected readonly cn = cn;\n\n  get computedLabelClass() {\n    return cn(\n      \"text-sm font-medium text-foreground leading-none transition-opacity duration-200\",\n      this.disabled && \"opacity-50\"\n    );\n  }\n\n  get computedContainerClass() {\n    return cn(\n      // Base styles\n      \"group relative flex items-center w-full rounded-md border transition-all duration-200\",\n      \"bg-background\",\n\n      // Border and shadow\n      \"border-input shadow-sm\",\n\n      // Sizing\n      this.size === 'xs' && \"h-8 px-2 gap-1.5 text-xs\",\n      this.size === 'sm' && \"h-9 px-3 gap-2 text-sm\",\n      this.size === 'default' && \"h-10 px-3 gap-2 text-sm\",\n      this.size === 'lg' && \"h-11 px-4 gap-3 text-base\",\n\n      // Focus state - SIMPLE AND ELEGANT LIKE ZARDUI\n      // The magic happens in CSS: border darkens automatically on focus\n      !(this.readonly || this.disabled) && [\n        \"focus-within:border-primary/80\",\n        \"focus-within:ring-4\",\n        \"focus-within:ring-ring/30\",\n        \"focus-within:ring-offset-0\",\n        \"focus-within:shadow-none\",\n      ],\n\n      // Error state\n      this.error && [\n        \"border-destructive\",\n        !(this.readonly || this.disabled) && [\n          \"focus-within:border-destructive/80\",\n          \"focus-within:ring-destructive/30\"\n        ]\n      ],\n\n      // Disabled state\n      this.disabled && [\n        \"cursor-not-allowed opacity-50\",\n        \"border-opacity-50\"\n      ],\n\n      // Readonly state\n      this.readonly && [\n        \"cursor-default\",\n        \"border-dashed\",\n        !this.disabled && \"focus-within:ring-0 focus-within:border-opacity-100\"\n      ],\n\n      this.containerClass\n    );\n  }\n\n  get computedInputClass() {\n    return cn(\n      // Base styles\n      \"flex-1 bg-transparent border-none p-0\",\n      \"placeholder:text-muted-foreground\",\n\n      // Remove all default focus styles\n      \"focus:outline-none focus:ring-0 focus:shadow-none\",\n\n      // Text sizing\n      this.size === 'xs' && \"text-xs\",\n      this.size === 'sm' && \"text-sm\",\n      this.size === 'default' && \"text-sm\",\n      this.size === 'lg' && \"text-base\",\n\n      // Cursor states\n      this.disabled && \"cursor-not-allowed\",\n      this.readonly && \"cursor-default\",\n\n      // Text color\n      \"text-foreground\",\n\n      // Selection color\n      \"selection:bg-primary/20 selection:text-foreground\",\n\n      this.class\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/input.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, forwardRef, ChangeDetectorRef, ElementRef, ViewChild, AfterViewInit } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR, FormsModule } from '@angular/forms';\nimport { cn } from './utils/cn';\n\n@Component({\n  selector: 'tolle-input',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule, FormsModule],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => InputComponent),\n      multi: true\n    }\n  ],\n  template: `\n    <div class=\"flex flex-col gap-1.5 w-full\">\n      <label\n        *ngIf=\"label\"\n        [for]=\"id\"\n        [class]=\"computedLabelClass\">\n        {{ label }}\n      </label>\n\n      <div\n        [class]=\"computedContainerClass\"\n        (click)=\"focusInput()\"\n      >\n        <div class=\"h-full flex items-center text-muted-foreground group-focus-within:text-primary transition-colors duration-200\">\n          <ng-content select=\"[prefix]\"></ng-content>\n        </div>\n\n        <input\n          #inputElement\n          [id]=\"id\"\n          [type]=\"type\"\n          [placeholder]=\"placeholder\"\n          [disabled]=\"disabled\"\n          [readOnly]=\"readonly\"\n          [(ngModel)]=\"value\"\n          (blur)=\"onBlur()\"\n          (focus)=\"onFocus()\"\n          (input)=\"onInputChange($event)\"\n          [class]=\"computedInputClass\"\n          [attr.aria-invalid]=\"error || null\"\n          [attr.aria-describedby]=\"error && errorMessage ? id + '-error' : (hint ? id + '-hint' : null)\"\n        />\n\n        <div class=\"h-full flex items-center text-muted-foreground group-focus-within:text-primary transition-colors duration-200\">\n          <ng-content select=\"[suffix]\"></ng-content>\n        </div>\n      </div>\n\n      <ng-container *ngIf=\"!disabled\">\n        <p\n          *ngIf=\"hint && !error\"\n          [id]=\"id + '-hint'\"\n          class=\"text-xs text-muted-foreground px-1 transition-opacity duration-200\"\n          [class.opacity-0]=\"isFocused && hideHintOnFocus\"\n        >\n          {{ hint }}\n        </p>\n        <p\n          *ngIf=\"error && errorMessage\"\n          [id]=\"id + '-error'\"\n          class=\"text-xs text-destructive px-1\"\n        >\n          {{ errorMessage }}\n        </p>\n      </ng-container>\n    </div>\n  `,\n})\nexport class InputComponent implements ControlValueAccessor, AfterViewInit {\n  @ViewChild('inputElement') inputElement!: ElementRef<HTMLInputElement>;\n\n  @Input() id: string = `input-${Math.random().toString(36).substr(2, 9)}`;\n  @Input() label: string = '';\n  @Input() hint: string = '';\n  @Input() errorMessage: string = '';\n  @Input() type: string = 'text';\n  @Input() placeholder: string = '';\n  @Input() size: 'xs' | 'sm' | 'default' | 'lg' = 'default';\n  @Input() containerClass: string = '';\n  @Input() class: string = '';\n\n  // New States\n  @Input() disabled: boolean = false;\n  @Input() readonly: boolean = false;\n  @Input() error: boolean = false;\n\n  // Focus behavior\n  @Input() hideHintOnFocus: boolean = true;\n\n  value: any = '';\n  onChange: any = () => { };\n  onTouched: any = () => { };\n  isFocused: boolean = false;\n\n  constructor(private cdr: ChangeDetectorRef) { }\n\n  ngAfterViewInit() {\n    if (this.inputElement?.nativeElement.hasAttribute('autofocus')) {\n      setTimeout(() => this.inputElement.nativeElement.focus());\n    }\n  }\n\n  writeValue(value: any): void {\n    this.value = value;\n    this.cdr.markForCheck();\n  }\n\n  registerOnChange(fn: any): void { this.onChange = fn; }\n  registerOnTouched(fn: any): void { this.onTouched = fn; }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n    this.cdr.markForCheck();\n  }\n\n  onInputChange(event: Event): void {\n    if (this.readonly || this.disabled) return;\n    const val = (event.target as HTMLInputElement).value;\n    this.value = val;\n    this.onChange(val);\n  }\n\n  onFocus(): void {\n    this.isFocused = true;\n  }\n\n  onBlur(): void {\n    this.isFocused = false;\n    this.onTouched();\n  }\n\n  focusInput(): void {\n    if (!this.disabled && this.inputElement) {\n      this.inputElement.nativeElement.focus();\n    }\n  }\n\n  protected readonly cn = cn;\n\n  get computedLabelClass() {\n    return cn(\n      \"text-sm font-medium text-foreground leading-none transition-opacity duration-200\",\n      this.disabled && \"opacity-50\"\n    );\n  }\n\n  get computedContainerClass() {\n    return cn(\n      // Base styles\n      \"group relative flex items-center w-full rounded-md border transition-all duration-200\",\n      \"bg-background\",\n\n      // Border and shadow\n      \"border-input shadow-sm\",\n\n      // Sizing\n      this.size === 'xs' && \"h-8 px-2 gap-1.5 text-xs\",\n      this.size === 'sm' && \"h-9 px-3 gap-2 text-sm\",\n      this.size === 'default' && \"h-10 px-3 gap-2 text-sm\",\n      this.size === 'lg' && \"h-11 px-4 gap-3 text-base\",\n\n      // Focus state - SIMPLE AND ELEGANT LIKE ZARDUI\n      // The magic happens in CSS: border darkens automatically on focus\n      !(this.readonly || this.disabled) && [\n        \"focus-within:border-primary/80\",\n        \"focus-within:ring-4\",\n        \"focus-within:ring-ring/30\",\n        \"focus-within:ring-offset-0\",\n        \"focus-within:shadow-none\",\n      ],\n\n      // Error state\n      this.error && [\n        \"border-destructive\",\n        !(this.readonly || this.disabled) && [\n          \"focus-within:border-destructive/80\",\n          \"focus-within:ring-destructive/30\"\n        ]\n      ],\n\n      // Disabled state\n      this.disabled && [\n        \"cursor-not-allowed opacity-50\",\n        \"border-opacity-50\"\n      ],\n\n      // Readonly state\n      this.readonly && [\n        \"cursor-default\",\n        \"border-dashed\",\n        !this.disabled && \"focus-within:ring-0 focus-within:border-opacity-100\"\n      ],\n\n      this.containerClass\n    );\n  }\n\n  get computedInputClass() {\n    return cn(\n      // Base styles\n      \"flex-1 bg-transparent border-none p-0\",\n      \"placeholder:text-muted-foreground\",\n\n      // Remove all default focus styles\n      \"focus:outline-none focus:ring-0 focus:shadow-none\",\n\n      // Text sizing\n      this.size === 'xs' && \"text-xs\",\n      this.size === 'sm' && \"text-sm\",\n      this.size === 'default' && \"text-sm\",\n      this.size === 'lg' && \"text-base\",\n\n      // Cursor states\n      this.disabled && \"cursor-not-allowed\",\n      this.readonly && \"cursor-default\",\n\n      // Text color\n      \"text-foreground\",\n\n      // Selection color\n      \"selection:bg-primary/20 selection:text-foreground\",\n\n      this.class\n    );\n  }\n}\n"]}