@tolle_/tolle-ui 0.0.17-beta → 0.0.19-beta

package/esm2022/lib/otp.component.mjs

@@ -0,0 +1,127 @@
+import { Component, Input, forwardRef } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { NG_VALUE_ACCESSOR, FormsModule } from '@angular/forms';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+export class OtpComponent {
+    cdr;
+    length = 6;
+    disabled = false;
+    auto = false; // The toggle for automatic slot generation
+    value = '';
+    isFocused = false;
+    onChange = () => { };
+    onTouched = () => { };
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    onInputChange(event) {
+        const val = event.target.value.replace(/\D/g, '');
+        this.value = val;
+        this.onChange(val);
+        this.cdr.markForCheck();
+    }
+    // Visual logic for the automated slots
+    getSlotClass(index) {
+        const isActive = this.isFocused && this.value.length === index;
+        return cn('relative flex h-10 w-10 items-center justify-center border-y border-r border-input text-sm transition-all bg-background', index === 0 && 'rounded-l-md border-l', index === this.length - 1 && 'rounded-r-md', isActive && 'z-30 ring-2 ring-ring ring-offset-background');
+    }
+    writeValue(value) { this.value = value || ''; this.cdr.markForCheck(); }
+    registerOnChange(fn) { this.onChange = fn; }
+    registerOnTouched(fn) { this.onTouched = fn; }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: OtpComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: OtpComponent, isStandalone: true, selector: "tolle-otp", inputs: { length: "length", disabled: "disabled", auto: "auto" }, providers: [{
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => OtpComponent),
+                multi: true
+            }], ngImport: i0, template: `
+    <div class="relative flex items-center gap-2">
+      <input
+        #hiddenInput
+        type="text"
+        inputmode="numeric"
+        autocomplete="one-time-code"
+        [maxLength]="length"
+        class="absolute inset-0 opacity-0 cursor-default z-20"
+        [(ngModel)]="value"
+        (input)="onInputChange($event)"
+        (focus)="isFocused = true"
+        (blur)="isFocused = false"
+        [disabled]="disabled"
+      />
+
+      <div *ngIf="auto" class="flex items-center gap-2 pointer-events-none">
+        <div class="flex items-center">
+          <div *ngFor="let _ of [].constructor(length); let i = index"
+               [class]="getSlotClass(i)"
+          >
+            {{ value[i] || '' }}
+            <div *ngIf="isFocused && value.length === i" class="absolute inset-0 flex items-center justify-center">
+              <div class="h-4 w-px animate-caret-blink bg-foreground duration-1000"></div>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div *ngIf="!auto" class="flex items-center gap-2 pointer-events-none">
+        <ng-content></ng-content>
+      </div>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { 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: OtpComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tolle-otp',
+                    standalone: true,
+                    imports: [CommonModule, FormsModule],
+                    providers: [{
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => OtpComponent),
+                            multi: true
+                        }],
+                    template: `
+    <div class="relative flex items-center gap-2">
+      <input
+        #hiddenInput
+        type="text"
+        inputmode="numeric"
+        autocomplete="one-time-code"
+        [maxLength]="length"
+        class="absolute inset-0 opacity-0 cursor-default z-20"
+        [(ngModel)]="value"
+        (input)="onInputChange($event)"
+        (focus)="isFocused = true"
+        (blur)="isFocused = false"
+        [disabled]="disabled"
+      />
+
+      <div *ngIf="auto" class="flex items-center gap-2 pointer-events-none">
+        <div class="flex items-center">
+          <div *ngFor="let _ of [].constructor(length); let i = index"
+               [class]="getSlotClass(i)"
+          >
+            {{ value[i] || '' }}
+            <div *ngIf="isFocused && value.length === i" class="absolute inset-0 flex items-center justify-center">
+              <div class="h-4 w-px animate-caret-blink bg-foreground duration-1000"></div>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div *ngIf="!auto" class="flex items-center gap-2 pointer-events-none">
+        <ng-content></ng-content>
+      </div>
+    </div>
+  `
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { length: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], auto: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/popover-content.component.mjs

@@ -0,0 +1,44 @@
+import { Component, Input, } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+export class PopoverContentComponent {
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PopoverContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: PopoverContentComponent, isStandalone: true, selector: "tolle-popover-content", inputs: { class: "class" }, ngImport: i0, template: `
+    <div
+      [class]="cn(
+        'z-50 w-72 rounded-md border bg-popover p-4 text-popover-foreground shadow-md outline-none',
+        'animate-in fade-in zoom-in-95 duration-200',
+        class
+      )"
+      role="dialog"
+    >
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PopoverContentComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tolle-popover-content',
+                    standalone: true,
+                    imports: [CommonModule],
+                    template: `
+    <div
+      [class]="cn(
+        'z-50 w-72 rounded-md border bg-popover p-4 text-popover-foreground shadow-md outline-none',
+        'animate-in fade-in zoom-in-95 duration-200',
+        class
+      )"
+      role="dialog"
+    >
+      <ng-content></ng-content>
+    </div>
+  `
+                }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci1jb250ZW50LmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3RvbGxlL3NyYy9saWIvcG9wb3Zlci1jb250ZW50LmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsU0FBUyxFQUNULEtBQUssR0FDTixNQUFNLGVBQWUsQ0FBQztBQUN2QixPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLFlBQVksQ0FBQzs7QUFtQmhDLE1BQU0sT0FBTyx1QkFBdUI7SUFDekIsS0FBSyxHQUFHLEVBQUUsQ0FBQztJQUNWLEVBQUUsR0FBRyxFQUFFLENBQUM7d0dBRlAsdUJBQXVCOzRGQUF2Qix1QkFBdUIsNkdBYnhCOzs7Ozs7Ozs7OztHQVdULDJEQVpTLFlBQVk7OzRGQWNYLHVCQUF1QjtrQkFqQm5DLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLHVCQUF1QjtvQkFDakMsVUFBVSxFQUFFLElBQUk7b0JBQ2hCLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsUUFBUSxFQUFFOzs7Ozs7Ozs7OztHQVdUO2lCQUNGOzhCQUVVLEtBQUs7c0JBQWIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIENvbXBvbmVudCxcbiAgSW5wdXQsXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IGNuIH0gZnJvbSAnLi91dGlscy9jbic7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ3RvbGxlLXBvcG92ZXItY29udGVudCcsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICB0ZW1wbGF0ZTogYFxuICAgIDxkaXZcbiAgICAgIFtjbGFzc109XCJjbihcbiAgICAgICAgJ3otNTAgdy03MiByb3VuZGVkLW1kIGJvcmRlciBiZy1wb3BvdmVyIHAtNCB0ZXh0LXBvcG92ZXItZm9yZWdyb3VuZCBzaGFkb3ctbWQgb3V0bGluZS1ub25lJyxcbiAgICAgICAgJ2FuaW1hdGUtaW4gZmFkZS1pbiB6b29tLWluLTk1IGR1cmF0aW9uLTIwMCcsXG4gICAgICAgIGNsYXNzXG4gICAgICApXCJcbiAgICAgIHJvbGU9XCJkaWFsb2dcIlxuICAgID5cbiAgICAgIDxuZy1jb250ZW50PjwvbmctY29udGVudD5cbiAgICA8L2Rpdj5cbiAgYFxufSlcbmV4cG9ydCBjbGFzcyBQb3BvdmVyQ29udGVudENvbXBvbmVudCB7XG4gIEBJbnB1dCgpIGNsYXNzID0gJyc7XG4gIHByb3RlY3RlZCBjbiA9IGNuO1xufVxuIl19

package/esm2022/lib/popover.component.mjs

@@ -0,0 +1,105 @@
+import { CommonModule } from '@angular/common';
+import { computePosition, flip, shift, offset, autoUpdate } from '@floating-ui/dom';
+import { Component, EventEmitter, HostListener, Input, Output, ViewChild } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class PopoverComponent {
+    placement = 'bottom';
+    onOpen = new EventEmitter();
+    onClose = new EventEmitter();
+    triggerEl;
+    popoverEl;
+    isOpen = false;
+    cleanup;
+    toggle() {
+        this.isOpen ? this.close() : this.open();
+    }
+    open() {
+        this.isOpen = true;
+        this.onOpen.emit();
+        setTimeout(() => this.updatePosition());
+    }
+    close() {
+        this.isOpen = false;
+        this.onClose.emit();
+        if (this.cleanup)
+            this.cleanup();
+    }
+    updatePosition() {
+        if (!this.triggerEl || !this.popoverEl)
+            return;
+        this.cleanup = autoUpdate(this.triggerEl.nativeElement, this.popoverEl.nativeElement, () => {
+            computePosition(this.triggerEl.nativeElement, this.popoverEl.nativeElement, {
+                placement: this.placement,
+                middleware: [offset(8), flip(), shift({ padding: 8 })],
+            }).then(({ x, y }) => {
+                Object.assign(this.popoverEl.nativeElement.style, {
+                    left: `${x}px`,
+                    top: `${y}px`,
+                });
+            });
+        });
+    }
+    onClickOutside(event) {
+        if (this.isOpen &&
+            !this.triggerEl.nativeElement.contains(event.target) &&
+            !this.popoverEl?.nativeElement.contains(event.target)) {
+            this.close();
+        }
+    }
+    ngOnDestroy() {
+        if (this.cleanup)
+            this.cleanup();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PopoverComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: PopoverComponent, isStandalone: true, selector: "tolle-popover", inputs: { placement: "placement" }, outputs: { onOpen: "onOpen", onClose: "onClose" }, host: { listeners: { "document:mousedown": "onClickOutside($event)" } }, viewQueries: [{ propertyName: "triggerEl", first: true, predicate: ["trigger"], descendants: true }, { propertyName: "popoverEl", first: true, predicate: ["popover"], descendants: true }], ngImport: i0, template: `
+    <div class="inline-block" #trigger (click)="toggle()">
+      <ng-content select="[trigger]"></ng-content>
+    </div>
+
+    <div
+      *ngIf="isOpen"
+      #popover
+      class="absolute top-0 left-0 w-max z-[9999]"
+    >
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PopoverComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tolle-popover',
+                    standalone: true,
+                    imports: [CommonModule],
+                    template: `
+    <div class="inline-block" #trigger (click)="toggle()">
+      <ng-content select="[trigger]"></ng-content>
+    </div>
+
+    <div
+      *ngIf="isOpen"
+      #popover
+      class="absolute top-0 left-0 w-max z-[9999]"
+    >
+      <ng-content></ng-content>
+    </div>
+  `,
+                }]
+        }], propDecorators: { placement: [{
+                type: Input
+            }], onOpen: [{
+                type: Output
+            }], onClose: [{
+                type: Output
+            }], triggerEl: [{
+                type: ViewChild,
+                args: ['trigger']
+            }], popoverEl: [{
+                type: ViewChild,
+                args: ['popover']
+            }], onClickOutside: [{
+                type: HostListener,
+                args: ['document:mousedown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,78 @@
+import { Component, Input, forwardRef } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { cn } from './utils/cn';
+import { RadioService } from './radio-service';
+import * as i0 from "@angular/core";
+import * as i1 from "./radio-service";
+export class RadioGroupComponent {
+    radioService;
+    class = '';
+    disabled = false;
+    name = `radio-group-${Math.random().toString(36).substring(2, 9)}`;
+    value;
+    onChange = () => { };
+    onTouched = () => { };
+    constructor(radioService) {
+        this.radioService = radioService;
+        this.radioService.selectedValue$.subscribe(val => {
+            this.value = val;
+            this.onChange(val);
+        });
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        this.radioService.setDisabled(isDisabled);
+    }
+    ngOnChanges() {
+        this.radioService.setDisabled(this.disabled);
+    }
+    writeValue(value) {
+        this.value = value;
+        this.radioService.select(value);
+    }
+    registerOnChange(fn) { this.onChange = fn; }
+    registerOnTouched(fn) { this.onTouched = fn; }
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RadioGroupComponent, deps: [{ token: i1.RadioService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: RadioGroupComponent, isStandalone: true, selector: "tolle-radio-group", inputs: { class: "class", disabled: "disabled", name: "name" }, providers: [
+            RadioService,
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => RadioGroupComponent),
+                multi: true
+            }
+        ], usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="cn('grid gap-2', class)" role="radiogroup">
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RadioGroupComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tolle-radio-group',
+                    standalone: true,
+                    imports: [CommonModule],
+                    providers: [
+                        RadioService,
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => RadioGroupComponent),
+                            multi: true
+                        }
+                    ],
+                    template: `
+    <div [class]="cn('grid gap-2', class)" role="radiogroup">
+      <ng-content></ng-content>
+    </div>
+  `
+                }]
+        }], ctorParameters: () => [{ type: i1.RadioService }], propDecorators: { class: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/radio-item.component.mjs

@@ -0,0 +1,112 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { cn } from './utils/cn';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./radio-service";
+import * as i2 from "@angular/common";
+export class RadioItemComponent {
+    radioService;
+    cdr;
+    value;
+    disabled = false;
+    class = '';
+    isSelected = false;
+    groupDisabled = false;
+    sub = new Subscription();
+    get isEffectiveDisabled() {
+        return this.disabled || this.groupDisabled;
+    }
+    // Inject ChangeDetectorRef to ensure UI updates when service emits
+    constructor(radioService, cdr) {
+        this.radioService = radioService;
+        this.cdr = cdr;
+    }
+    ngOnInit() {
+        // Listen for selection changes
+        this.sub.add(this.radioService.selectedValue$.subscribe(val => {
+            this.isSelected = (val === this.value);
+            this.cdr.markForCheck(); // Trigger UI refresh
+        }));
+        // Listen for group-level disabled state
+        this.sub.add(this.radioService.disabled$.subscribe(dis => {
+            this.groupDisabled = dis;
+            this.cdr.markForCheck(); // Trigger UI refresh
+        }));
+    }
+    select() {
+        this.radioService.select(this.value);
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe(); // Clean up subscriptions
+    }
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RadioItemComponent, deps: [{ token: i1.RadioService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: RadioItemComponent, isStandalone: true, selector: "tolle-radio-item", inputs: { value: "value", disabled: "disabled", class: "class" }, ngImport: i0, template: `
+    <div
+      (click)="!isEffectiveDisabled && select()"
+      [class]="cn(
+        'flex items-center space-x-2 group py-1',
+        isEffectiveDisabled ? 'cursor-not-allowed opacity-50' : 'cursor-pointer'
+      )"
+    >
+      <div [class]="cn(
+        'aspect-square h-4 w-4 rounded-full border border-primary text-primary transition-all flex items-center justify-center',
+        'ring-offset-background focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',
+        !isEffectiveDisabled && 'group-hover:border-primary/70',
+        isSelected ? 'bg-background' : 'bg-transparent',
+        class
+      )">
+        <div
+          *ngIf="isSelected"
+          class="h-2.5 w-2.5 rounded-full bg-primary animate-in zoom-in-50 duration-200"
+        ></div>
+      </div>
+
+      <label class="text-sm font-medium leading-none select-none" [class.cursor-pointer]="!isEffectiveDisabled">
+        <ng-content></ng-content>
+      </label>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RadioItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tolle-radio-item',
+                    standalone: true,
+                    imports: [CommonModule],
+                    template: `
+    <div
+      (click)="!isEffectiveDisabled && select()"
+      [class]="cn(
+        'flex items-center space-x-2 group py-1',
+        isEffectiveDisabled ? 'cursor-not-allowed opacity-50' : 'cursor-pointer'
+      )"
+    >
+      <div [class]="cn(
+        'aspect-square h-4 w-4 rounded-full border border-primary text-primary transition-all flex items-center justify-center',
+        'ring-offset-background focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',
+        !isEffectiveDisabled && 'group-hover:border-primary/70',
+        isSelected ? 'bg-background' : 'bg-transparent',
+        class
+      )">
+        <div
+          *ngIf="isSelected"
+          class="h-2.5 w-2.5 rounded-full bg-primary animate-in zoom-in-50 duration-200"
+        ></div>
+      </div>
+
+      <label class="text-sm font-medium leading-none select-none" [class.cursor-pointer]="!isEffectiveDisabled">
+        <ng-content></ng-content>
+      </label>
+    </div>
+  `
+                }]
+        }], ctorParameters: () => [{ type: i1.RadioService }, { type: i0.ChangeDetectorRef }], propDecorators: { value: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/radio-service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class RadioService {
+    selectedValueSource = new BehaviorSubject(null);
+    selectedValue$ = this.selectedValueSource.asObservable();
+    disabledSource = new BehaviorSubject(false);
+    disabled$ = this.disabledSource.asObservable();
+    select(value) {
+        if (!this.disabledSource.value) {
+            this.selectedValueSource.next(value);
+        }
+    }
+    setDisabled(isDisabled) {
+        this.disabledSource.next(isDisabled);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RadioService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RadioService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RadioService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFkaW8tc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3RvbGxlL3NyYy9saWIvcmFkaW8tc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBQyxlQUFlLEVBQVUsTUFBTSxNQUFNLENBQUM7O0FBRzlDLE1BQU0sT0FBTyxZQUFZO0lBQ2YsbUJBQW1CLEdBQUcsSUFBSSxlQUFlLENBQU0sSUFBSSxDQUFDLENBQUM7SUFDN0QsY0FBYyxHQUFHLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUVqRCxjQUFjLEdBQUcsSUFBSSxlQUFlLENBQVUsS0FBSyxDQUFDLENBQUM7SUFDN0QsU0FBUyxHQUFHLElBQUksQ0FBQyxjQUFjLENBQUMsWUFBWSxFQUFFLENBQUM7SUFFL0MsTUFBTSxDQUFDLEtBQVU7UUFDZixJQUFJLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUMvQixJQUFJLENBQUMsbUJBQW1CLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3ZDLENBQUM7SUFDSCxDQUFDO0lBRUQsV0FBVyxDQUFDLFVBQW1CO1FBQzdCLElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBQ3ZDLENBQUM7d0dBZlUsWUFBWTs0R0FBWixZQUFZOzs0RkFBWixZQUFZO2tCQUR4QixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtCZWhhdmlvclN1YmplY3QsIFN1YmplY3R9IGZyb20gJ3J4anMnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgUmFkaW9TZXJ2aWNlIHtcbiAgcHJpdmF0ZSBzZWxlY3RlZFZhbHVlU291cmNlID0gbmV3IEJlaGF2aW9yU3ViamVjdDxhbnk+KG51bGwpO1xuICBzZWxlY3RlZFZhbHVlJCA9IHRoaXMuc2VsZWN0ZWRWYWx1ZVNvdXJjZS5hc09ic2VydmFibGUoKTtcblxuICBwcml2YXRlIGRpc2FibGVkU291cmNlID0gbmV3IEJlaGF2aW9yU3ViamVjdDxib29sZWFuPihmYWxzZSk7XG4gIGRpc2FibGVkJCA9IHRoaXMuZGlzYWJsZWRTb3VyY2UuYXNPYnNlcnZhYmxlKCk7XG5cbiAgc2VsZWN0KHZhbHVlOiBhbnkpIHtcbiAgICBpZiAoIXRoaXMuZGlzYWJsZWRTb3VyY2UudmFsdWUpIHtcbiAgICAgIHRoaXMuc2VsZWN0ZWRWYWx1ZVNvdXJjZS5uZXh0KHZhbHVlKTtcbiAgICB9XG4gIH1cblxuICBzZXREaXNhYmxlZChpc0Rpc2FibGVkOiBib29sZWFuKSB7XG4gICAgdGhpcy5kaXNhYmxlZFNvdXJjZS5uZXh0KGlzRGlzYWJsZWQpO1xuICB9XG59XG4iXX0=

package/esm2022/lib/textarea.component.mjs

@@ -34,7 +34,7 @@ export class TextareaComponent {
         // Border colors
         this.error ? 'border-destructive' : 'border-input', 
         // Disabled vs Readonly styles
-        this.disabled && 'cursor-not-allowed opacity-50 bg-muted/30', this.readonly && 'cursor-default bg-muted/10 border-dashed focus-visible:ring-0', 'scrollbar-thin scrollbar-thumb-muted scrollbar-track-transparent', 'min-h-[80px]', this.className);
+        this.disabled && 'cursor-not-allowed opacity-50', this.readonly && 'cursor-default border-dashed focus-visible:ring-0', 'scrollbar-thin scrollbar-thumb-muted scrollbar-track-transparent', 'min-h-[80px]', this.className);
     }
     handleInput(event) {
         if (this.readonly || this.disabled)
@@ -174,4 +174,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             }], readonly: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"textarea.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/textarea.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, forwardRef, ViewChild, ElementRef, 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-textarea',\n  standalone: true,\n  imports: [CommonModule, FormsModule],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => TextareaComponent),\n      multi: true\n    }\n  ],\n  template: `\n    <div class=\"flex flex-col gap-1.5 w-full\">\n      <label *ngIf=\"label\" [for]=\"id\"\n             [class.opacity-50]=\"disabled\"\n             class=\"text-sm font-medium text-foreground leading-none transition-opacity\">\n        {{ label }}\n      </label>\n\n      <div class=\"relative\">\n        <textarea\n          #textareaElement\n          [id]=\"id\"\n          [placeholder]=\"placeholder\"\n          [disabled]=\"disabled\"\n          [readOnly]=\"readonly\"\n          [rows]=\"rows\"\n          [(ngModel)]=\"value\"\n          (input)=\"handleInput($event)\"\n          (blur)=\"onTouched()\"\n          [class]=\"textareaClasses\"\n          [style.resize]=\"(autoGrow || readonly || disabled) ? 'none' : 'vertical'\"\n          [style.overflow]=\"autoGrow ? 'hidden' : 'auto'\"\n        ></textarea>\n      </div>\n\n      <div *ngIf=\"(showCharacterCount || hint) && !disabled\" class=\"flex justify-between items-center px-1\">\n        <p *ngIf=\"hint\" class=\"text-xs text-muted-foreground\">{{ hint }}</p>\n        <p *ngIf=\"showCharacterCount\" class=\"text-[10px] uppercase tracking-wider text-muted-foreground ml-auto font-medium\">\n          {{ value.length || 0 }}{{ maxLength ? ' / ' + maxLength : '' }}\n        </p>\n      </div>\n    </div>\n  `\n})\nexport class TextareaComponent implements ControlValueAccessor, AfterViewInit {\n  @ViewChild('textareaElement') textareaElement!: ElementRef<HTMLTextAreaElement>;\n\n  @Input() id = `textarea-${Math.random().toString(36).substr(2, 9)}`;\n  @Input() label = '';\n  @Input() placeholder = '';\n  @Input() hint = '';\n  @Input() rows = 3;\n  @Input() maxLength?: number;\n  @Input() showCharacterCount = false;\n  @Input() autoGrow = false;\n  @Input() error = false;\n  @Input() className = '';\n\n  // New States\n  @Input() disabled = false;\n  @Input() readonly = false;\n\n  value: string = '';\n  onChange: any = () => {};\n  onTouched: any = () => {};\n\n  ngAfterViewInit() {\n    if (this.autoGrow) this.resize();\n  }\n\n  get textareaClasses() {\n    return cn(\n      'flex w-full rounded-md border bg-background px-3 py-2 text-sm ring-offset-background transition-all duration-200 shadow-sm',\n      'placeholder:text-muted-foreground focus-visible:outline-none',\n\n      // Focus States (Disabled only when readonly or disabled is true)\n      !(this.readonly || this.disabled) && 'focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-1',\n\n      // Border colors\n      this.error ? 'border-destructive' : 'border-input',\n\n      // Disabled vs Readonly styles\n      this.disabled && 'cursor-not-allowed opacity-50 bg-muted/30',\n      this.readonly && 'cursor-default bg-muted/10 border-dashed focus-visible:ring-0',\n\n      'scrollbar-thin scrollbar-thumb-muted scrollbar-track-transparent',\n      'min-h-[80px]',\n      this.className\n    );\n  }\n\n  handleInput(event: any) {\n    if (this.readonly || this.disabled) return;\n    const val = event.target.value;\n    this.value = val;\n    this.onChange(val);\n    if (this.autoGrow) this.resize();\n  }\n\n  private resize() {\n    const textarea = this.textareaElement.nativeElement;\n    textarea.style.height = 'auto';\n    textarea.style.height = `${textarea.scrollHeight}px`;\n  }\n\n  writeValue(value: any): void {\n    this.value = value;\n    if (this.autoGrow) setTimeout(() => this.resize());\n  }\n  registerOnChange(fn: any): void { this.onChange = fn; }\n  registerOnTouched(fn: any): void { this.onTouched = fn; }\n  setDisabledState(isDisabled: boolean): void { this.disabled = isDisabled; }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"textarea.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/textarea.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, forwardRef, ViewChild, ElementRef, 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-textarea',\n  standalone: true,\n  imports: [CommonModule, FormsModule],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => TextareaComponent),\n      multi: true\n    }\n  ],\n  template: `\n    <div class=\"flex flex-col gap-1.5 w-full\">\n      <label *ngIf=\"label\" [for]=\"id\"\n             [class.opacity-50]=\"disabled\"\n             class=\"text-sm font-medium text-foreground leading-none transition-opacity\">\n        {{ label }}\n      </label>\n\n      <div class=\"relative\">\n        <textarea\n          #textareaElement\n          [id]=\"id\"\n          [placeholder]=\"placeholder\"\n          [disabled]=\"disabled\"\n          [readOnly]=\"readonly\"\n          [rows]=\"rows\"\n          [(ngModel)]=\"value\"\n          (input)=\"handleInput($event)\"\n          (blur)=\"onTouched()\"\n          [class]=\"textareaClasses\"\n          [style.resize]=\"(autoGrow || readonly || disabled) ? 'none' : 'vertical'\"\n          [style.overflow]=\"autoGrow ? 'hidden' : 'auto'\"\n        ></textarea>\n      </div>\n\n      <div *ngIf=\"(showCharacterCount || hint) && !disabled\" class=\"flex justify-between items-center px-1\">\n        <p *ngIf=\"hint\" class=\"text-xs text-muted-foreground\">{{ hint }}</p>\n        <p *ngIf=\"showCharacterCount\" class=\"text-[10px] uppercase tracking-wider text-muted-foreground ml-auto font-medium\">\n          {{ value.length || 0 }}{{ maxLength ? ' / ' + maxLength : '' }}\n        </p>\n      </div>\n    </div>\n  `\n})\nexport class TextareaComponent implements ControlValueAccessor, AfterViewInit {\n  @ViewChild('textareaElement') textareaElement!: ElementRef<HTMLTextAreaElement>;\n\n  @Input() id = `textarea-${Math.random().toString(36).substr(2, 9)}`;\n  @Input() label = '';\n  @Input() placeholder = '';\n  @Input() hint = '';\n  @Input() rows = 3;\n  @Input() maxLength?: number;\n  @Input() showCharacterCount = false;\n  @Input() autoGrow = false;\n  @Input() error = false;\n  @Input() className = '';\n\n  // New States\n  @Input() disabled = false;\n  @Input() readonly = false;\n\n  value: string = '';\n  onChange: any = () => {};\n  onTouched: any = () => {};\n\n  ngAfterViewInit() {\n    if (this.autoGrow) this.resize();\n  }\n\n  get textareaClasses() {\n    return cn(\n      'flex w-full rounded-md border bg-background px-3 py-2 text-sm ring-offset-background transition-all duration-200 shadow-sm',\n      'placeholder:text-muted-foreground focus-visible:outline-none',\n\n      // Focus States (Disabled only when readonly or disabled is true)\n      !(this.readonly || this.disabled) && 'focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-1',\n\n      // Border colors\n      this.error ? 'border-destructive' : 'border-input',\n\n      // Disabled vs Readonly styles\n      this.disabled && 'cursor-not-allowed opacity-50',\n      this.readonly && 'cursor-default border-dashed focus-visible:ring-0',\n\n      'scrollbar-thin scrollbar-thumb-muted scrollbar-track-transparent',\n      'min-h-[80px]',\n      this.className\n    );\n  }\n\n  handleInput(event: any) {\n    if (this.readonly || this.disabled) return;\n    const val = event.target.value;\n    this.value = val;\n    this.onChange(val);\n    if (this.autoGrow) this.resize();\n  }\n\n  private resize() {\n    const textarea = this.textareaElement.nativeElement;\n    textarea.style.height = 'auto';\n    textarea.style.height = `${textarea.scrollHeight}px`;\n  }\n\n  writeValue(value: any): void {\n    this.value = value;\n    if (this.autoGrow) setTimeout(() => this.resize());\n  }\n  registerOnChange(fn: any): void { this.onChange = fn; }\n  registerOnTouched(fn: any): void { this.onTouched = fn; }\n  setDisabledState(isDisabled: boolean): void { this.disabled = isDisabled; }\n}\n"]}