@tolle_/tolle-ui 18.2.29 → 18.2.30

package/esm2022/lib/task.component.mjs

@@ -0,0 +1,359 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Injectable, Input, Output, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { skip } from 'rxjs/operators';
+import { cva } from 'class-variance-authority';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const taskVariants = cva('w-full rounded-lg border bg-card text-card-foreground transition-colors', {
+    variants: {
+        status: {
+            pending: 'border-border',
+            'in-progress': 'border-info/40',
+            completed: 'border-success/40',
+            error: 'border-destructive/40',
+        },
+    },
+    defaultVariants: { status: 'pending' },
+});
+const taskIconVariants = cva('shrink-0 text-base leading-none', {
+    variants: {
+        status: {
+            pending: 'text-muted-foreground',
+            'in-progress': 'text-info',
+            completed: 'text-success',
+            error: 'text-destructive',
+        },
+    },
+    defaultVariants: { status: 'pending' },
+});
+/** Remixicon class used for each task status. */
+const TASK_ICONS = {
+    pending: 'ri-circle-line',
+    'in-progress': 'ri-loader-4-line animate-spin',
+    completed: 'ri-checkbox-circle-fill',
+    error: 'ri-error-warning-fill',
+};
+/**
+ * Coordinates a `tolle-task` and its trigger/content children.
+ *
+ * The children are `OnPush` and none of the parent's state arrives as their own
+ * inputs, so it is published here as observables and every subscriber calls
+ * `markForCheck()`.
+ */
+export class TaskService {
+    openSource = new BehaviorSubject(false);
+    /** Emits whether the task's content is expanded. */
+    open$ = this.openSource.asObservable();
+    statusSource = new BehaviorSubject('pending');
+    /** Emits the task's current status. */
+    status$ = this.statusSource.asObservable();
+    titleSource = new BehaviorSubject('');
+    /** Emits the task's title. */
+    title$ = this.titleSource.asObservable();
+    get open() {
+        return this.openSource.value;
+    }
+    get status() {
+        return this.statusSource.value;
+    }
+    get title() {
+        return this.titleSource.value;
+    }
+    setOpen(open) {
+        if (this.openSource.value !== open)
+            this.openSource.next(open);
+    }
+    toggle() {
+        this.openSource.next(!this.openSource.value);
+    }
+    setStatus(status) {
+        if (this.statusSource.value !== status)
+            this.statusSource.next(status);
+    }
+    setTitle(title) {
+        if (this.titleSource.value !== title)
+            this.titleSource.next(title);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TaskService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TaskService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TaskService, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * A collapsible record of one unit of agent work — a title, a status, and the
+ * individual steps taken, revealed on demand.
+ *
+ * ```html
+ * <tolle-task status="completed" title="Read the codebase" [open]="true">
+ *   <tolle-task-trigger></tolle-task-trigger>
+ *   <tolle-task-content>
+ *     <tolle-task-item>
+ *       Searched <tolle-task-item-file>utils/cn.ts</tolle-task-item-file>
+ *     </tolle-task-item>
+ *   </tolle-task-content>
+ * </tolle-task>
+ * ```
+ * @new
+ */
+export class TaskComponent {
+    cdr = inject(ChangeDetectorRef);
+    /** Lifecycle state of the task; drives the icon and border colour. @default 'pending' */
+    status = 'pending';
+    /** Title shown by `tolle-task-trigger`. @default '' */
+    title = '';
+    /** Whether the task's content is expanded. @default false */
+    open = false;
+    /** Extra Tailwind classes merged onto the task via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the new expanded state whenever the task opens or closes. */
+    openChange = new EventEmitter();
+    service = inject(TaskService);
+    sub = new Subscription();
+    ngOnInit() {
+        this.push();
+        // skip(1) drops the BehaviorSubject's replayed value so the component does
+        // not emit an `openChange` for its own initial state.
+        this.sub.add(this.service.open$.pipe(skip(1)).subscribe((open) => this.openChange.emit(open)));
+    }
+    ngOnChanges() {
+        this.push();
+        // A bound `class` input is written through Angular's styling path,
+        // which does not mark an OnPush view dirty on its own.
+        this.cdr.markForCheck();
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+    }
+    push() {
+        this.service.setStatus(this.status);
+        this.service.setTitle(this.title);
+        this.service.setOpen(this.open);
+    }
+    get computedClass() {
+        return cn(taskVariants({ status: this.status }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TaskComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: TaskComponent, isStandalone: true, selector: "tolle-task", inputs: { status: "status", title: "title", open: "open", class: "class" }, outputs: { openChange: "openChange" }, providers: [TaskService], usesOnChanges: true, ngImport: i0, template: `<div [class]="computedClass" [attr.data-status]="status"><ng-content></ng-content></div>`, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TaskComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-task', standalone: true, imports: [CommonModule], providers: [TaskService], changeDetection: ChangeDetectionStrategy.OnPush, template: `<div [class]="computedClass" [attr.data-status]="status"><ng-content></ng-content></div>`, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { status: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], open: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], openChange: [{
+                type: Output
+            }] } });
+/** Header row of a `tolle-task`: status icon, title, and the expand chevron. */
+export class TaskTriggerComponent {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */
+    class = '';
+    service = inject(TaskService);
+    cdr = inject(ChangeDetectorRef);
+    sub = new Subscription();
+    isOpen = false;
+    status = 'pending';
+    title = '';
+    ngOnInit() {
+        this.sub.add(this.service.open$.subscribe((open) => {
+            this.isOpen = open;
+            this.cdr.markForCheck();
+        }));
+        this.sub.add(this.service.status$.subscribe((status) => {
+            this.status = status;
+            this.cdr.markForCheck();
+        }));
+        this.sub.add(this.service.title$.subscribe((title) => {
+            this.title = title;
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+    }
+    get iconClass() {
+        return cn(taskIconVariants({ status: this.status }), TASK_ICONS[this.status]);
+    }
+    get computedClass() {
+        return cn('flex w-full items-center gap-2 rounded-lg px-3 py-2 text-sm font-medium text-foreground outline-none transition-colors', 'hover:bg-accent/50 focus-visible:ring-2 focus-visible:ring-ring', this.class);
+    }
+    toggle() {
+        this.service.toggle();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TaskTriggerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: TaskTriggerComponent, isStandalone: true, selector: "tolle-task-trigger", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <button
+      type="button"
+      [attr.aria-expanded]="isOpen"
+      [attr.data-state]="isOpen ? 'open' : 'closed'"
+      [class]="computedClass"
+      (click)="toggle()"
+    >
+      <i [class]="iconClass" [attr.data-status]="status" aria-hidden="true"></i>
+      <span class="min-w-0 flex-1 truncate text-left">{{ title }}</span>
+      <ng-content></ng-content>
+      <i
+        [class]="isOpen ? 'ri-arrow-down-s-line shrink-0 text-muted-foreground' : 'ri-arrow-right-s-line shrink-0 text-muted-foreground'"
+        aria-hidden="true"
+      ></i>
+    </button>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TaskTriggerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-task-trigger', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <button
+      type="button"
+      [attr.aria-expanded]="isOpen"
+      [attr.data-state]="isOpen ? 'open' : 'closed'"
+      [class]="computedClass"
+      (click)="toggle()"
+    >
+      <i [class]="iconClass" [attr.data-status]="status" aria-hidden="true"></i>
+      <span class="min-w-0 flex-1 truncate text-left">{{ title }}</span>
+      <ng-content></ng-content>
+      <i
+        [class]="isOpen ? 'ri-arrow-down-s-line shrink-0 text-muted-foreground' : 'ri-arrow-right-s-line shrink-0 text-muted-foreground'"
+        aria-hidden="true"
+      ></i>
+    </button>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/** The body of a `tolle-task`; rendered only while the task is expanded. */
+export class TaskContentComponent {
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Extra Tailwind classes merged onto the content via `cn()` (last-wins). */
+    class = '';
+    service = inject(TaskService);
+    cdr = inject(ChangeDetectorRef);
+    sub = new Subscription();
+    isOpen = false;
+    ngOnInit() {
+        this.sub.add(this.service.open$.subscribe((open) => {
+            this.isOpen = open;
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+    }
+    get computedClass() {
+        return cn('flex flex-col gap-1 border-t border-border px-3 py-2', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TaskContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: TaskContentComponent, isStandalone: true, selector: "tolle-task-content", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div *ngIf="isOpen" [attr.data-state]="'open'" [class]="computedClass">
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TaskContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-task-content', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div *ngIf="isOpen" [attr.data-state]="'open'" [class]="computedClass">
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/** One line of work inside a `tolle-task-content`. */
+export class TaskItemComponent {
+    cdr = inject(ChangeDetectorRef);
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Extra Tailwind classes merged onto the item via `cn()` (last-wins). */
+    class = '';
+    get computedClass() {
+        return cn('flex items-start gap-2 text-sm text-muted-foreground', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TaskItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: TaskItemComponent, isStandalone: true, selector: "tolle-task-item", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass">
+      <i class="ri-corner-down-right-line mt-0.5 shrink-0 text-muted-foreground" aria-hidden="true"></i>
+      <span class="min-w-0 flex-1"><ng-content></ng-content></span>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TaskItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-task-item', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass">
+      <i class="ri-corner-down-right-line mt-0.5 shrink-0 text-muted-foreground" aria-hidden="true"></i>
+      <span class="min-w-0 flex-1"><ng-content></ng-content></span>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/** An inline file chip, for naming the file a task step touched. */
+export class TaskItemFileComponent {
+    cdr = inject(ChangeDetectorRef);
+    /**
+     * Angular writes a bound `class` input through its styling path, which does
+     * not mark an OnPush component dirty — without this hook the component keeps
+     * rendering the class it was born with.
+     */
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    /** Remixicon class for the leading file glyph. @default 'ri-file-line' */
+    icon = 'ri-file-line';
+    /** Extra Tailwind classes merged onto the chip via `cn()` (last-wins). */
+    class = '';
+    get computedClass() {
+        return cn('inline-flex items-center gap-1 rounded-md border border-border bg-muted px-1.5 py-0.5 align-middle text-xs font-medium text-foreground', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TaskItemFileComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: TaskItemFileComponent, isStandalone: true, selector: "tolle-task-item-file", inputs: { icon: "icon", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <span [class]="computedClass">
+      <i [class]="icon + ' shrink-0 text-muted-foreground'" aria-hidden="true"></i>
+      <ng-content></ng-content>
+    </span>
+  `, isInline: true, styles: [":host{display:inline-flex}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TaskItemFileComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-task-item-file', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <span [class]="computedClass">
+      <i [class]="icon + ' shrink-0 text-muted-foreground'" aria-hidden="true"></i>
+      <ng-content></ng-content>
+    </span>
+  `, styles: [":host{display:inline-flex}\n"] }]
+        }], propDecorators: { icon: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/task.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Injectable, Input, OnChanges, OnDestroy, OnInit, Output, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { skip } from 'rxjs/operators';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\n/** Lifecycle of a single agent task. */\nexport type TaskStatus = 'pending' | 'in-progress' | 'completed' | 'error';\n\nconst taskVariants = cva(\n  'w-full rounded-lg border bg-card text-card-foreground transition-colors',\n  {\n    variants: {\n      status: {\n        pending: 'border-border',\n        'in-progress': 'border-info/40',\n        completed: 'border-success/40',\n        error: 'border-destructive/40',\n      },\n    },\n    defaultVariants: { status: 'pending' },\n  }\n);\n\nconst taskIconVariants = cva('shrink-0 text-base leading-none', {\n  variants: {\n    status: {\n      pending: 'text-muted-foreground',\n      'in-progress': 'text-info',\n      completed: 'text-success',\n      error: 'text-destructive',\n    },\n  },\n  defaultVariants: { status: 'pending' },\n});\n\nexport type TaskProps = VariantProps<typeof taskVariants>;\n\n/** Remixicon class used for each task status. */\nconst TASK_ICONS: Record<TaskStatus, string> = {\n  pending: 'ri-circle-line',\n  'in-progress': 'ri-loader-4-line animate-spin',\n  completed: 'ri-checkbox-circle-fill',\n  error: 'ri-error-warning-fill',\n};\n\n/**\n * Coordinates a `tolle-task` and its trigger/content children.\n *\n * The children are `OnPush` and none of the parent's state arrives as their own\n * inputs, so it is published here as observables and every subscriber calls\n * `markForCheck()`.\n */\n@Injectable()\nexport class TaskService {\n  private readonly openSource = new BehaviorSubject<boolean>(false);\n  /** Emits whether the task's content is expanded. */\n  readonly open$ = this.openSource.asObservable();\n\n  private readonly statusSource = new BehaviorSubject<TaskStatus>('pending');\n  /** Emits the task's current status. */\n  readonly status$ = this.statusSource.asObservable();\n\n  private readonly titleSource = new BehaviorSubject<string>('');\n  /** Emits the task's title. */\n  readonly title$ = this.titleSource.asObservable();\n\n  get open(): boolean {\n    return this.openSource.value;\n  }\n\n  get status(): TaskStatus {\n    return this.statusSource.value;\n  }\n\n  get title(): string {\n    return this.titleSource.value;\n  }\n\n  setOpen(open: boolean): void {\n    if (this.openSource.value !== open) this.openSource.next(open);\n  }\n\n  toggle(): void {\n    this.openSource.next(!this.openSource.value);\n  }\n\n  setStatus(status: TaskStatus): void {\n    if (this.statusSource.value !== status) this.statusSource.next(status);\n  }\n\n  setTitle(title: string): void {\n    if (this.titleSource.value !== title) this.titleSource.next(title);\n  }\n}\n\n/**\n * A collapsible record of one unit of agent work — a title, a status, and the\n * individual steps taken, revealed on demand.\n *\n * ```html\n * <tolle-task status=\"completed\" title=\"Read the codebase\" [open]=\"true\">\n *   <tolle-task-trigger></tolle-task-trigger>\n *   <tolle-task-content>\n *     <tolle-task-item>\n *       Searched <tolle-task-item-file>utils/cn.ts</tolle-task-item-file>\n *     </tolle-task-item>\n *   </tolle-task-content>\n * </tolle-task>\n * ```\n * @new\n */\n@Component({\n  selector: 'tolle-task',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  providers: [TaskService],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `<div [class]=\"computedClass\" [attr.data-status]=\"status\"><ng-content></ng-content></div>`,\n})\nexport class TaskComponent implements OnInit, OnChanges, OnDestroy {\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  /** Lifecycle state of the task; drives the icon and border colour. @default 'pending' */\n  @Input() status: TaskStatus = 'pending';\n  /** Title shown by `tolle-task-trigger`. @default '' */\n  @Input() title = '';\n  /** Whether the task's content is expanded. @default false */\n  @Input() open = false;\n  /** Extra Tailwind classes merged onto the task via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the new expanded state whenever the task opens or closes. */\n  @Output() openChange = new EventEmitter<boolean>();\n\n  private readonly service = inject(TaskService);\n  private readonly sub = new Subscription();\n\n  ngOnInit(): void {\n    this.push();\n    // skip(1) drops the BehaviorSubject's replayed value so the component does\n    // not emit an `openChange` for its own initial state.\n    this.sub.add(this.service.open$.pipe(skip(1)).subscribe((open) => this.openChange.emit(open)));\n  }\n\n  ngOnChanges(): void {\n    this.push();\n  \n    // A bound `class` input is written through Angular's styling path,\n    // which does not mark an OnPush view dirty on its own.\n    this.cdr.markForCheck();\n  }\n\n  ngOnDestroy(): void {\n    this.sub.unsubscribe();\n  }\n\n  private push(): void {\n    this.service.setStatus(this.status);\n    this.service.setTitle(this.title);\n    this.service.setOpen(this.open);\n  }\n\n  get computedClass() {\n    return cn(taskVariants({ status: this.status }), this.class);\n  }\n}\n\n/** Header row of a `tolle-task`: status icon, title, and the expand chevron. */\n@Component({\n  selector: 'tolle-task-trigger',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <button\n      type=\"button\"\n      [attr.aria-expanded]=\"isOpen\"\n      [attr.data-state]=\"isOpen ? 'open' : 'closed'\"\n      [class]=\"computedClass\"\n      (click)=\"toggle()\"\n    >\n      <i [class]=\"iconClass\" [attr.data-status]=\"status\" aria-hidden=\"true\"></i>\n      <span class=\"min-w-0 flex-1 truncate text-left\">{{ title }}</span>\n      <ng-content></ng-content>\n      <i\n        [class]=\"isOpen ? 'ri-arrow-down-s-line shrink-0 text-muted-foreground' : 'ri-arrow-right-s-line shrink-0 text-muted-foreground'\"\n        aria-hidden=\"true\"\n      ></i>\n    </button>\n  `,\n})\nexport class TaskTriggerComponent implements OnChanges, OnInit, OnDestroy {\n\n  /**\n   * Angular writes a bound `class` input through its styling path, which does\n   * not mark an OnPush component dirty — without this hook the component keeps\n   * rendering the class it was born with.\n   */\n  ngOnChanges(): void {\n    this.cdr.markForCheck();\n  }\n\n  /** Extra Tailwind classes merged onto the trigger via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly service = inject(TaskService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly sub = new Subscription();\n\n  isOpen = false;\n  status: TaskStatus = 'pending';\n  title = '';\n\n  ngOnInit(): void {\n    this.sub.add(\n      this.service.open$.subscribe((open) => {\n        this.isOpen = open;\n        this.cdr.markForCheck();\n      })\n    );\n    this.sub.add(\n      this.service.status$.subscribe((status) => {\n        this.status = status;\n        this.cdr.markForCheck();\n      })\n    );\n    this.sub.add(\n      this.service.title$.subscribe((title) => {\n        this.title = title;\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.sub.unsubscribe();\n  }\n\n  get iconClass() {\n    return cn(taskIconVariants({ status: this.status }), TASK_ICONS[this.status]);\n  }\n\n  get computedClass() {\n    return cn(\n      'flex w-full items-center gap-2 rounded-lg px-3 py-2 text-sm font-medium text-foreground outline-none transition-colors',\n      'hover:bg-accent/50 focus-visible:ring-2 focus-visible:ring-ring',\n      this.class\n    );\n  }\n\n  toggle(): void {\n    this.service.toggle();\n  }\n}\n\n/** The body of a `tolle-task`; rendered only while the task is expanded. */\n@Component({\n  selector: 'tolle-task-content',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div *ngIf=\"isOpen\" [attr.data-state]=\"'open'\" [class]=\"computedClass\">\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class TaskContentComponent implements OnChanges, OnInit, OnDestroy {\n\n  /**\n   * Angular writes a bound `class` input through its styling path, which does\n   * not mark an OnPush component dirty — without this hook the component keeps\n   * rendering the class it was born with.\n   */\n  ngOnChanges(): void {\n    this.cdr.markForCheck();\n  }\n\n  /** Extra Tailwind classes merged onto the content via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly service = inject(TaskService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly sub = new Subscription();\n\n  isOpen = false;\n\n  ngOnInit(): void {\n    this.sub.add(\n      this.service.open$.subscribe((open) => {\n        this.isOpen = open;\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.sub.unsubscribe();\n  }\n\n  get computedClass() {\n    return cn('flex flex-col gap-1 border-t border-border px-3 py-2', this.class);\n  }\n}\n\n/** One line of work inside a `tolle-task-content`. */\n@Component({\n  selector: 'tolle-task-item',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"computedClass\">\n      <i class=\"ri-corner-down-right-line mt-0.5 shrink-0 text-muted-foreground\" aria-hidden=\"true\"></i>\n      <span class=\"min-w-0 flex-1\"><ng-content></ng-content></span>\n    </div>\n  `,\n})\nexport class TaskItemComponent  implements OnChanges{\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  /**\n   * Angular writes a bound `class` input through its styling path, which does\n   * not mark an OnPush component dirty — without this hook the component keeps\n   * rendering the class it was born with.\n   */\n  ngOnChanges(): void {\n    this.cdr.markForCheck();\n  }\n\n  /** Extra Tailwind classes merged onto the item via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get computedClass() {\n    return cn('flex items-start gap-2 text-sm text-muted-foreground', this.class);\n  }\n}\n\n/** An inline file chip, for naming the file a task step touched. */\n@Component({\n  selector: 'tolle-task-item-file',\n  styles: [':host { display: inline-flex; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <span [class]=\"computedClass\">\n      <i [class]=\"icon + ' shrink-0 text-muted-foreground'\" aria-hidden=\"true\"></i>\n      <ng-content></ng-content>\n    </span>\n  `,\n})\nexport class TaskItemFileComponent  implements OnChanges{\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  /**\n   * Angular writes a bound `class` input through its styling path, which does\n   * not mark an OnPush component dirty — without this hook the component keeps\n   * rendering the class it was born with.\n   */\n  ngOnChanges(): void {\n    this.cdr.markForCheck();\n  }\n\n  /** Remixicon class for the leading file glyph. @default 'ri-file-line' */\n  @Input() icon = 'ri-file-line';\n  /** Extra Tailwind classes merged onto the chip via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get computedClass() {\n    return cn(\n      'inline-flex items-center gap-1 rounded-md border border-border bg-muted px-1.5 py-0.5 align-middle text-xs font-medium text-foreground',\n      this.class\n    );\n  }\n}\n"]}

package/esm2022/lib/textarea.component.mjs

@@ -173,22 +173,17 @@ export class TextareaComponent {
         </p>
       </div>
     </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: TextareaComponent, decorators: [{
             type: Component,
-            args: [{
-                    selector: 'tolle-textarea',
-                    standalone: true,
-                    imports: [CommonModule, FormsModule],
-                    providers: [
+            args: [{ selector: 'tolle-textarea', standalone: true, imports: [CommonModule, FormsModule], providers: [
                         {
                             provide: NG_VALUE_ACCESSOR,
                             useExisting: forwardRef(() => TextareaComponent),
                             multi: true
                         }
-                    ],
-                    template: `
+                    ], template: `
     <div class="flex flex-col gap-1.5 w-full">
       <label
         *ngIf="label"
@@ -244,8 +239,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
         </p>
       </div>
     </div>
-  `
-                }]
+  `, styles: [":host{display:block}\n"] }]
         }], propDecorators: { textareaElement: [{
                 type: ViewChild,
                 args: ['textareaElement']
@@ -280,4 +274,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\n        *ngIf=\"label\"\n        [for]=\"id\"\n        [class]=\"computedLabelClass\"\n      >\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)=\"onBlur()\"\n          (focus)=\"onFocus()\"\n          [class]=\"textareaClasses\"\n          [style.resize]=\"(autoGrow || readonly || disabled) ? 'none' : 'vertical'\"\n          [style.overflow]=\"autoGrow ? 'hidden' : 'auto'\"\n          [attr.aria-invalid]=\"error || null\"\n          [attr.aria-describedby]=\"error && errorMessage ? id + '-error' : (hint ? id + '-hint' : null)\"\n          [attr.maxlength]=\"maxLength\"\n        ></textarea>\n      </div>\n\n      <div *ngIf=\"(showCharacterCount || hint || errorMessage) && !disabled\" class=\"flex justify-between items-center px-1\">\n        <p\n          *ngIf=\"hint && !error\"\n          [id]=\"id + '-hint'\"\n          class=\"text-xs text-muted-foreground 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\"\n        >\n          {{ errorMessage }}\n        </p>\n        <p\n          *ngIf=\"showCharacterCount\"\n          class=\"text-[10px] uppercase tracking-wider text-muted-foreground ml-auto font-medium transition-opacity duration-200\"\n          [class.opacity-0]=\"isFocused && hideCharacterCountOnFocus\"\n        >\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).substring(2, 9)}`;\n  @Input() label = '';\n  @Input() placeholder = '';\n  @Input() hint = '';\n  @Input() errorMessage = '';\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  // Focus behavior\n  @Input() hideHintOnFocus = true;\n  @Input() hideCharacterCountOnFocus = false;\n\n  // New States\n  @Input() disabled = false;\n  @Input() readonly = false;\n\n  value: string = '';\n  isFocused: boolean = false;\n  onChange: any = () => {};\n  onTouched: any = () => {};\n\n  ngAfterViewInit() {\n    if (this.autoGrow) this.resize();\n  }\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 textareaClasses() {\n    return cn(\n      // Base styles\n      'flex w-full rounded-md border bg-background px-3 py-2 text-sm',\n      'ring-offset-background transition-all duration-200',\n      'placeholder:text-muted-foreground',\n\n      // Border and shadow\n      'border-input shadow-sm',\n\n      // Minimum height\n      'min-h-[80px]',\n\n      // Focus state - SIMPLE LIKE ZARDUI\n      !(this.readonly || this.disabled) && [\n        'focus:outline-none',\n        'focus:ring-4',\n        'focus:ring-ring/30',\n        'focus:ring-offset-0',\n        'focus:shadow-none',\n        // Border darkens on focus automatically\n        'focus:border-primary/80'\n      ],\n\n      // Error state\n      this.error && [\n        'border-destructive',\n        !(this.readonly || this.disabled) && [\n          'focus:border-destructive/80',\n          'focus: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:ring-0 focus:border-opacity-100'\n      ],\n\n      // Scrollbar styling\n      'scrollbar-thin scrollbar-thumb-muted scrollbar-track-transparent',\n\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  onFocus(): void {\n    this.isFocused = true;\n  }\n\n  onBlur(): void {\n    this.isFocused = false;\n    this.onTouched();\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\n  registerOnChange(fn: any): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\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  styles: [':host { display: block; }'],\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\n        *ngIf=\"label\"\n        [for]=\"id\"\n        [class]=\"computedLabelClass\"\n      >\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)=\"onBlur()\"\n          (focus)=\"onFocus()\"\n          [class]=\"textareaClasses\"\n          [style.resize]=\"(autoGrow || readonly || disabled) ? 'none' : 'vertical'\"\n          [style.overflow]=\"autoGrow ? 'hidden' : 'auto'\"\n          [attr.aria-invalid]=\"error || null\"\n          [attr.aria-describedby]=\"error && errorMessage ? id + '-error' : (hint ? id + '-hint' : null)\"\n          [attr.maxlength]=\"maxLength\"\n        ></textarea>\n      </div>\n\n      <div *ngIf=\"(showCharacterCount || hint || errorMessage) && !disabled\" class=\"flex justify-between items-center px-1\">\n        <p\n          *ngIf=\"hint && !error\"\n          [id]=\"id + '-hint'\"\n          class=\"text-xs text-muted-foreground 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\"\n        >\n          {{ errorMessage }}\n        </p>\n        <p\n          *ngIf=\"showCharacterCount\"\n          class=\"text-[10px] uppercase tracking-wider text-muted-foreground ml-auto font-medium transition-opacity duration-200\"\n          [class.opacity-0]=\"isFocused && hideCharacterCountOnFocus\"\n        >\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).substring(2, 9)}`;\n  @Input() label = '';\n  @Input() placeholder = '';\n  @Input() hint = '';\n  @Input() errorMessage = '';\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  // Focus behavior\n  @Input() hideHintOnFocus = true;\n  @Input() hideCharacterCountOnFocus = false;\n\n  // New States\n  @Input() disabled = false;\n  @Input() readonly = false;\n\n  value: string = '';\n  isFocused: boolean = false;\n  onChange: any = () => {};\n  onTouched: any = () => {};\n\n  ngAfterViewInit() {\n    if (this.autoGrow) this.resize();\n  }\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 textareaClasses() {\n    return cn(\n      // Base styles\n      'flex w-full rounded-md border bg-background px-3 py-2 text-sm',\n      'ring-offset-background transition-all duration-200',\n      'placeholder:text-muted-foreground',\n\n      // Border and shadow\n      'border-input shadow-sm',\n\n      // Minimum height\n      'min-h-[80px]',\n\n      // Focus state - SIMPLE LIKE ZARDUI\n      !(this.readonly || this.disabled) && [\n        'focus:outline-none',\n        'focus:ring-4',\n        'focus:ring-ring/30',\n        'focus:ring-offset-0',\n        'focus:shadow-none',\n        // Border darkens on focus automatically\n        'focus:border-primary/80'\n      ],\n\n      // Error state\n      this.error && [\n        'border-destructive',\n        !(this.readonly || this.disabled) && [\n          'focus:border-destructive/80',\n          'focus: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:ring-0 focus:border-opacity-100'\n      ],\n\n      // Scrollbar styling\n      'scrollbar-thin scrollbar-thumb-muted scrollbar-track-transparent',\n\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  onFocus(): void {\n    this.isFocused = true;\n  }\n\n  onBlur(): void {\n    this.isFocused = false;\n    this.onTouched();\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\n  registerOnChange(fn: any): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\n}\n"]}