@tolle_/tolle-ui 18.2.28 → 18.2.30

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

@@ -0,0 +1,526 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Injectable, Input, Output, ViewChild, forwardRef, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { BehaviorSubject, Subject, Subscription } from 'rxjs';
+import { cva } from 'class-variance-authority';
+import { cn } from './utils/cn';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const promptInputVariants = cva('flex w-full flex-col gap-2 rounded-lg border bg-background p-2 shadow-sm transition-colors focus-within:ring-2 focus-within:ring-offset-2 focus-within:ring-offset-background', {
+    variants: {
+        status: {
+            ready: 'border-input focus-within:ring-ring',
+            streaming: 'border-info focus-within:ring-info',
+            error: 'border-destructive focus-within:ring-destructive',
+        },
+        size: {
+            sm: 'p-1.5 text-xs',
+            default: 'p-2 text-sm',
+            lg: 'p-3 text-base',
+        },
+    },
+    defaultVariants: {
+        status: 'ready',
+        size: 'default',
+    },
+});
+/**
+ * Coordinates a `tolle-prompt-input` with its projected toolbar controls.
+ *
+ * The submit button is an OnPush child that must flip to a stop button the
+ * moment the status changes, so the composer publishes its state here instead
+ * of the button reading the parent's fields.
+ *
+ * Provided on `PromptInputComponent`, so each composer gets its own instance.
+ */
+export class PromptInputService {
+    statusSource = new BehaviorSubject('ready');
+    /** Emits the composer's current status. */
+    status$ = this.statusSource.asObservable();
+    canSubmitSource = new BehaviorSubject(false);
+    /** Emits whether there is submittable text and the composer is enabled. */
+    canSubmit$ = this.canSubmitSource.asObservable();
+    submitSource = new Subject();
+    /** Emits when a toolbar control asks the composer to submit. */
+    submit$ = this.submitSource.asObservable();
+    stopSource = new Subject();
+    /** Emits when a toolbar control asks the composer to stop streaming. */
+    stop$ = this.stopSource.asObservable();
+    /** The composer's current status. */
+    get status() {
+        return this.statusSource.value;
+    }
+    /** True when the composer has submittable text. */
+    get canSubmit() {
+        return this.canSubmitSource.value;
+    }
+    setStatus(status) {
+        if (this.statusSource.value !== status)
+            this.statusSource.next(status);
+    }
+    setCanSubmit(value) {
+        if (this.canSubmitSource.value !== value)
+            this.canSubmitSource.next(value);
+    }
+    requestSubmit() {
+        this.submitSource.next();
+    }
+    requestStop() {
+        this.stopSource.next();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PromptInputService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PromptInputService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PromptInputService, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * A message composer: an auto-growing textarea plus a toolbar, wired as a
+ * `ControlValueAccessor` so it drops into template- or reactive-driven forms.
+ *
+ * Enter submits and Shift+Enter inserts a newline (swap with `submitOnEnter`).
+ * While `status` is 'streaming' the projected `tolle-prompt-input-submit`
+ * becomes a stop button that emits `stopped`.
+ * @new
+ */
+export class PromptInputComponent {
+    /** Placeholder shown while the composer is empty. @default 'Send a message…' */
+    placeholder = 'Send a message…';
+    /** Blocks typing and submission. @default false */
+    disabled = false;
+    /** Rows the textarea may grow to before it starts scrolling. @default 8 */
+    maxRows = 8;
+    /** Lifecycle of the response being composed. @default 'ready' */
+    status = 'ready';
+    /** Size scale of the composer. @default 'default' */
+    size = 'default';
+    /** Submit on Enter, keeping Shift+Enter for newlines. @default true */
+    submitOnEnter = true;
+    /** Clears the composer after a successful submit. @default true */
+    clearOnSubmit = true;
+    /** Accessible name for the textarea. @default '' */
+    ariaLabel = '';
+    /** Extra Tailwind classes merged onto the composer via `cn()` (last-wins). */
+    class = '';
+    /** Extra Tailwind classes merged onto the textarea via `cn()` (last-wins). */
+    textareaClass = '';
+    /** Emitted with the trimmed message text when the user submits. */
+    submitted = new EventEmitter();
+    /** Emitted when the user cancels an in-flight streaming response. */
+    stopped = new EventEmitter();
+    /** Emitted with the message text whenever it changes. */
+    valueChange = new EventEmitter();
+    textarea;
+    service = inject(PromptInputService);
+    cdr = inject(ChangeDetectorRef);
+    subscriptions = new Subscription();
+    value = '';
+    onChange = () => { };
+    onTouched = () => { };
+    ngOnInit() {
+        this.syncService();
+        this.subscriptions.add(this.service.submit$.subscribe(() => this.submit()));
+        this.subscriptions.add(this.service.stop$.subscribe(() => this.stop()));
+    }
+    ngOnChanges() {
+        this.syncService();
+        // 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();
+    }
+    ngAfterViewInit() {
+        this.resize();
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    get computedClass() {
+        return cn(promptInputVariants({ status: this.status, size: this.size }), this.disabled && 'cursor-not-allowed opacity-60', this.class);
+    }
+    get textareaComputedClass() {
+        return cn('w-full resize-none bg-transparent px-2 py-1.5 text-sm text-foreground outline-none', 'placeholder:text-muted-foreground disabled:cursor-not-allowed', this.textareaClass);
+    }
+    onInput(event) {
+        const next = event.target.value;
+        this.setValue(next);
+        this.resize();
+    }
+    onKeyDown(event) {
+        if (event.key !== 'Enter' || !this.submitOnEnter)
+            return;
+        // Shift+Enter is the newline escape hatch; modifier chords and IME
+        // composition must never steal the keystroke.
+        if (event.shiftKey || event.altKey || event.ctrlKey || event.metaKey)
+            return;
+        if (event.isComposing)
+            return;
+        event.preventDefault();
+        this.submit();
+    }
+    onBlur() {
+        this.onTouched();
+    }
+    /** Submits the current text, unless the composer is empty, disabled or busy. */
+    submit() {
+        if (this.disabled || this.status === 'streaming')
+            return;
+        const text = this.value.trim();
+        if (!text)
+            return;
+        this.submitted.emit(text);
+        if (this.clearOnSubmit) {
+            this.setValue('');
+            if (this.textarea)
+                this.textarea.nativeElement.value = '';
+            this.resize();
+        }
+    }
+    /** Cancels an in-flight streaming response. */
+    stop() {
+        this.stopped.emit();
+    }
+    /** Moves focus into the textarea. */
+    focus() {
+        this.textarea?.nativeElement.focus();
+    }
+    writeValue(value) {
+        this.value = value ?? '';
+        if (this.textarea)
+            this.textarea.nativeElement.value = this.value;
+        this.service.setCanSubmit(this.canSubmit);
+        this.cdr.markForCheck();
+        this.resize();
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        this.syncService();
+        this.cdr.markForCheck();
+    }
+    get canSubmit() {
+        return !this.disabled && this.value.trim().length > 0;
+    }
+    setValue(next) {
+        this.value = next;
+        this.onChange(next);
+        this.valueChange.emit(next);
+        this.service.setCanSubmit(this.canSubmit);
+    }
+    syncService() {
+        this.service.setStatus(this.status);
+        this.service.setCanSubmit(this.canSubmit);
+    }
+    /**
+     * Grows the textarea with its content up to `maxRows`, then lets it scroll.
+     * Measured from the computed line height so it tracks the inherited font.
+     */
+    resize() {
+        const el = this.textarea?.nativeElement;
+        if (!el)
+            return;
+        el.style.height = 'auto';
+        const styles = getComputedStyle(el);
+        const parsedLineHeight = parseFloat(styles.lineHeight);
+        const lineHeight = Number.isFinite(parsedLineHeight)
+            ? parsedLineHeight
+            : parseFloat(styles.fontSize) * 1.5 || 20;
+        const vertical = parseFloat(styles.paddingTop || '0') +
+            parseFloat(styles.paddingBottom || '0') +
+            parseFloat(styles.borderTopWidth || '0') +
+            parseFloat(styles.borderBottomWidth || '0');
+        const max = lineHeight * Math.max(1, this.maxRows) + vertical;
+        const next = Math.min(el.scrollHeight, max);
+        el.style.height = next + 'px';
+        el.style.overflowY = el.scrollHeight > max ? 'auto' : 'hidden';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PromptInputComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: PromptInputComponent, isStandalone: true, selector: "tolle-prompt-input", inputs: { placeholder: "placeholder", disabled: "disabled", maxRows: "maxRows", status: "status", size: "size", submitOnEnter: "submitOnEnter", clearOnSubmit: "clearOnSubmit", ariaLabel: "ariaLabel", class: "class", textareaClass: "textareaClass" }, outputs: { submitted: "submitted", stopped: "stopped", valueChange: "valueChange" }, providers: [
+            PromptInputService,
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => PromptInputComponent),
+                multi: true,
+            },
+        ], viewQueries: [{ propertyName: "textarea", first: true, predicate: ["textarea"], descendants: true }], usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass">
+      <textarea
+        #textarea
+        data-prompt-input-textarea
+        rows="1"
+        [value]="value"
+        [attr.placeholder]="placeholder"
+        [disabled]="disabled"
+        [attr.aria-label]="ariaLabel || placeholder || 'Message'"
+        [attr.aria-invalid]="status === 'error' ? 'true' : null"
+        [class]="textareaComputedClass"
+        (input)="onInput($event)"
+        (keydown)="onKeyDown($event)"
+        (blur)="onBlur()"
+      ></textarea>
+
+      <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: PromptInputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-prompt-input', standalone: true, imports: [CommonModule], providers: [
+                        PromptInputService,
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => PromptInputComponent),
+                            multi: true,
+                        },
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass">
+      <textarea
+        #textarea
+        data-prompt-input-textarea
+        rows="1"
+        [value]="value"
+        [attr.placeholder]="placeholder"
+        [disabled]="disabled"
+        [attr.aria-label]="ariaLabel || placeholder || 'Message'"
+        [attr.aria-invalid]="status === 'error' ? 'true' : null"
+        [class]="textareaComputedClass"
+        (input)="onInput($event)"
+        (keydown)="onKeyDown($event)"
+        (blur)="onBlur()"
+      ></textarea>
+
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { placeholder: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], maxRows: [{
+                type: Input
+            }], status: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], submitOnEnter: [{
+                type: Input
+            }], clearOnSubmit: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], textareaClass: [{
+                type: Input
+            }], submitted: [{
+                type: Output
+            }], stopped: [{
+                type: Output
+            }], valueChange: [{
+                type: Output
+            }], textarea: [{
+                type: ViewChild,
+                args: ['textarea']
+            }] } });
+/** Bottom bar of a `tolle-prompt-input`: tools on the left, submit on the right. */
+export class PromptInputToolbarComponent {
+    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 toolbar via `cn()` (last-wins). */
+    class = '';
+    get computedClass() {
+        return cn('flex items-center justify-between gap-2 px-1', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PromptInputToolbarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: PromptInputToolbarComponent, isStandalone: true, selector: "tolle-prompt-input-toolbar", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass">
+      <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: PromptInputToolbarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-prompt-input-toolbar', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass">
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/** Left-aligned cluster of tool buttons inside a `tolle-prompt-input-toolbar`. */
+export class PromptInputToolsComponent {
+    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 tool row via `cn()` (last-wins). */
+    class = '';
+    get computedClass() {
+        return cn('flex flex-1 items-center gap-1 text-muted-foreground', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PromptInputToolsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: PromptInputToolsComponent, isStandalone: true, selector: "tolle-prompt-input-tools", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass">
+      <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: PromptInputToolsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-prompt-input-tools', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass">
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+const promptInputSubmitVariants = cva('inline-flex shrink-0 items-center justify-center gap-1.5 rounded-md font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background 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',
+            ghost: 'text-foreground hover:bg-accent hover:text-accent-foreground',
+        },
+        size: {
+            sm: 'h-7 px-2 text-xs',
+            default: 'size-8 text-sm',
+            lg: 'h-10 px-4 text-sm',
+        },
+    },
+    defaultVariants: {
+        variant: 'default',
+        size: 'default',
+    },
+});
+/**
+ * Send button for a `tolle-prompt-input`. Turns into a stop button while the
+ * composer's status is 'streaming', so one control covers both directions.
+ */
+export class PromptInputSubmitComponent {
+    /**
+     * 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();
+    }
+    /** Visual style of the button. @default 'default' */
+    variant = 'default';
+    /** Size of the button. @default 'default' */
+    size = 'default';
+    /** Accessible name while the composer is idle. @default 'Send message' */
+    submitLabel = 'Send message';
+    /** Accessible name while the composer is streaming. @default 'Stop generating' */
+    stopLabel = 'Stop generating';
+    /** Renders the label next to the icon. @default false */
+    showLabel = false;
+    /** Extra Tailwind classes merged onto the button via `cn()` (last-wins). */
+    class = '';
+    service = inject(PromptInputService);
+    cdr = inject(ChangeDetectorRef);
+    subscriptions = new Subscription();
+    status = 'ready';
+    canSubmit = false;
+    ngOnInit() {
+        this.subscriptions.add(this.service.status$.subscribe((status) => {
+            this.status = status;
+            this.cdr.markForCheck();
+        }));
+        this.subscriptions.add(this.service.canSubmit$.subscribe((canSubmit) => {
+            this.canSubmit = canSubmit;
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    /** True while the button is showing its stop affordance. */
+    get isStreaming() {
+        return this.status === 'streaming';
+    }
+    get currentIcon() {
+        return this.isStreaming ? 'ri-stop-circle-line' : 'ri-send-plane-2-fill';
+    }
+    get currentLabel() {
+        return this.isStreaming ? this.stopLabel : this.submitLabel;
+    }
+    /** Stopping stays available with an empty composer; sending does not. */
+    get isDisabled() {
+        return !this.isStreaming && !this.canSubmit;
+    }
+    get computedClass() {
+        return cn(promptInputSubmitVariants({ variant: this.variant, size: this.size }), this.isStreaming && 'bg-destructive text-destructive-foreground hover:bg-destructive/90', this.class);
+    }
+    onClick() {
+        if (this.isStreaming) {
+            this.service.requestStop();
+        }
+        else {
+            this.service.requestSubmit();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PromptInputSubmitComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: PromptInputSubmitComponent, isStandalone: true, selector: "tolle-prompt-input-submit", inputs: { variant: "variant", size: "size", submitLabel: "submitLabel", stopLabel: "stopLabel", showLabel: "showLabel", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <button
+      type="button"
+      data-prompt-input-submit
+      [attr.data-state]="status"
+      [attr.aria-label]="currentLabel"
+      [disabled]="isDisabled"
+      [class]="computedClass"
+      (click)="onClick()"
+    >
+      <i [class]="currentIcon" aria-hidden="true"></i>
+      <span *ngIf="showLabel">{{ currentLabel }}</span>
+    </button>
+  `, 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: PromptInputSubmitComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-prompt-input-submit', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <button
+      type="button"
+      data-prompt-input-submit
+      [attr.data-state]="status"
+      [attr.aria-label]="currentLabel"
+      [disabled]="isDisabled"
+      [class]="computedClass"
+      (click)="onClick()"
+    >
+      <i [class]="currentIcon" aria-hidden="true"></i>
+      <span *ngIf="showLabel">{{ currentLabel }}</span>
+    </button>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { variant: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], submitLabel: [{
+                type: Input
+            }], stopLabel: [{
+                type: Input
+            }], showLabel: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prompt-input.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/prompt-input.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, Injectable, Input, OnChanges, OnDestroy, OnInit, Output, ViewChild, forwardRef, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { BehaviorSubject, Subject, Subscription } from 'rxjs';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\nconst promptInputVariants = cva(\n  'flex w-full flex-col gap-2 rounded-lg border bg-background p-2 shadow-sm transition-colors focus-within:ring-2 focus-within:ring-offset-2 focus-within:ring-offset-background',\n  {\n    variants: {\n      status: {\n        ready: 'border-input focus-within:ring-ring',\n        streaming: 'border-info focus-within:ring-info',\n        error: 'border-destructive focus-within:ring-destructive',\n      },\n      size: {\n        sm: 'p-1.5 text-xs',\n        default: 'p-2 text-sm',\n        lg: 'p-3 text-base',\n      },\n    },\n    defaultVariants: {\n      status: 'ready',\n      size: 'default',\n    },\n  }\n);\n\nexport type PromptInputProps = VariantProps<typeof promptInputVariants>;\n\n/** Lifecycle of the response the composer is driving. */\nexport type PromptInputStatus = NonNullable<PromptInputProps['status']>;\n\n/**\n * Coordinates a `tolle-prompt-input` with its projected toolbar controls.\n *\n * The submit button is an OnPush child that must flip to a stop button the\n * moment the status changes, so the composer publishes its state here instead\n * of the button reading the parent's fields.\n *\n * Provided on `PromptInputComponent`, so each composer gets its own instance.\n */\n@Injectable()\nexport class PromptInputService {\n  private readonly statusSource = new BehaviorSubject<PromptInputStatus>('ready');\n  /** Emits the composer's current status. */\n  readonly status$ = this.statusSource.asObservable();\n\n  private readonly canSubmitSource = new BehaviorSubject<boolean>(false);\n  /** Emits whether there is submittable text and the composer is enabled. */\n  readonly canSubmit$ = this.canSubmitSource.asObservable();\n\n  private readonly submitSource = new Subject<void>();\n  /** Emits when a toolbar control asks the composer to submit. */\n  readonly submit$ = this.submitSource.asObservable();\n\n  private readonly stopSource = new Subject<void>();\n  /** Emits when a toolbar control asks the composer to stop streaming. */\n  readonly stop$ = this.stopSource.asObservable();\n\n  /** The composer's current status. */\n  get status(): PromptInputStatus {\n    return this.statusSource.value;\n  }\n\n  /** True when the composer has submittable text. */\n  get canSubmit(): boolean {\n    return this.canSubmitSource.value;\n  }\n\n  setStatus(status: PromptInputStatus): void {\n    if (this.statusSource.value !== status) this.statusSource.next(status);\n  }\n\n  setCanSubmit(value: boolean): void {\n    if (this.canSubmitSource.value !== value) this.canSubmitSource.next(value);\n  }\n\n  requestSubmit(): void {\n    this.submitSource.next();\n  }\n\n  requestStop(): void {\n    this.stopSource.next();\n  }\n}\n\n/**\n * A message composer: an auto-growing textarea plus a toolbar, wired as a\n * `ControlValueAccessor` so it drops into template- or reactive-driven forms.\n *\n * Enter submits and Shift+Enter inserts a newline (swap with `submitOnEnter`).\n * While `status` is 'streaming' the projected `tolle-prompt-input-submit`\n * becomes a stop button that emits `stopped`.\n * @new\n */\n@Component({\n  selector: 'tolle-prompt-input',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  providers: [\n    PromptInputService,\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => PromptInputComponent),\n      multi: true,\n    },\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"computedClass\">\n      <textarea\n        #textarea\n        data-prompt-input-textarea\n        rows=\"1\"\n        [value]=\"value\"\n        [attr.placeholder]=\"placeholder\"\n        [disabled]=\"disabled\"\n        [attr.aria-label]=\"ariaLabel || placeholder || 'Message'\"\n        [attr.aria-invalid]=\"status === 'error' ? 'true' : null\"\n        [class]=\"textareaComputedClass\"\n        (input)=\"onInput($event)\"\n        (keydown)=\"onKeyDown($event)\"\n        (blur)=\"onBlur()\"\n      ></textarea>\n\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class PromptInputComponent\n  implements ControlValueAccessor, OnInit, OnChanges, AfterViewInit, OnDestroy\n{\n  /** Placeholder shown while the composer is empty. @default 'Send a message…' */\n  @Input() placeholder = 'Send a message…';\n  /** Blocks typing and submission. @default false */\n  @Input() disabled = false;\n  /** Rows the textarea may grow to before it starts scrolling. @default 8 */\n  @Input() maxRows = 8;\n  /** Lifecycle of the response being composed. @default 'ready' */\n  @Input() status: PromptInputStatus = 'ready';\n  /** Size scale of the composer. @default 'default' */\n  @Input() size: PromptInputProps['size'] = 'default';\n  /** Submit on Enter, keeping Shift+Enter for newlines. @default true */\n  @Input() submitOnEnter = true;\n  /** Clears the composer after a successful submit. @default true */\n  @Input() clearOnSubmit = true;\n  /** Accessible name for the textarea. @default '' */\n  @Input() ariaLabel = '';\n  /** Extra Tailwind classes merged onto the composer via `cn()` (last-wins). */\n  @Input() class = '';\n  /** Extra Tailwind classes merged onto the textarea via `cn()` (last-wins). */\n  @Input() textareaClass = '';\n\n  /** Emitted with the trimmed message text when the user submits. */\n  @Output() submitted = new EventEmitter<string>();\n  /** Emitted when the user cancels an in-flight streaming response. */\n  @Output() stopped = new EventEmitter<void>();\n  /** Emitted with the message text whenever it changes. */\n  @Output() valueChange = new EventEmitter<string>();\n\n  @ViewChild('textarea') private textarea?: ElementRef<HTMLTextAreaElement>;\n\n  private readonly service = inject(PromptInputService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly subscriptions = new Subscription();\n\n  value = '';\n\n  private onChange: (value: string) => void = () => {};\n  private onTouched: () => void = () => {};\n\n  ngOnInit(): void {\n    this.syncService();\n    this.subscriptions.add(this.service.submit$.subscribe(() => this.submit()));\n    this.subscriptions.add(this.service.stop$.subscribe(() => this.stop()));\n  }\n\n  ngOnChanges(): void {\n    this.syncService();\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  ngAfterViewInit(): void {\n    this.resize();\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  get computedClass() {\n    return cn(\n      promptInputVariants({ status: this.status, size: this.size }),\n      this.disabled && 'cursor-not-allowed opacity-60',\n      this.class\n    );\n  }\n\n  get textareaComputedClass() {\n    return cn(\n      'w-full resize-none bg-transparent px-2 py-1.5 text-sm text-foreground outline-none',\n      'placeholder:text-muted-foreground disabled:cursor-not-allowed',\n      this.textareaClass\n    );\n  }\n\n  onInput(event: Event): void {\n    const next = (event.target as HTMLTextAreaElement).value;\n    this.setValue(next);\n    this.resize();\n  }\n\n  onKeyDown(event: KeyboardEvent): void {\n    if (event.key !== 'Enter' || !this.submitOnEnter) return;\n    // Shift+Enter is the newline escape hatch; modifier chords and IME\n    // composition must never steal the keystroke.\n    if (event.shiftKey || event.altKey || event.ctrlKey || event.metaKey) return;\n    if ((event as KeyboardEvent & { isComposing?: boolean }).isComposing) return;\n\n    event.preventDefault();\n    this.submit();\n  }\n\n  onBlur(): void {\n    this.onTouched();\n  }\n\n  /** Submits the current text, unless the composer is empty, disabled or busy. */\n  submit(): void {\n    if (this.disabled || this.status === 'streaming') return;\n    const text = this.value.trim();\n    if (!text) return;\n\n    this.submitted.emit(text);\n\n    if (this.clearOnSubmit) {\n      this.setValue('');\n      if (this.textarea) this.textarea.nativeElement.value = '';\n      this.resize();\n    }\n  }\n\n  /** Cancels an in-flight streaming response. */\n  stop(): void {\n    this.stopped.emit();\n  }\n\n  /** Moves focus into the textarea. */\n  focus(): void {\n    this.textarea?.nativeElement.focus();\n  }\n\n  writeValue(value: string | null): void {\n    this.value = value ?? '';\n    if (this.textarea) this.textarea.nativeElement.value = this.value;\n    this.service.setCanSubmit(this.canSubmit);\n    this.cdr.markForCheck();\n    this.resize();\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.syncService();\n    this.cdr.markForCheck();\n  }\n\n  private get canSubmit(): boolean {\n    return !this.disabled && this.value.trim().length > 0;\n  }\n\n  private setValue(next: string): void {\n    this.value = next;\n    this.onChange(next);\n    this.valueChange.emit(next);\n    this.service.setCanSubmit(this.canSubmit);\n  }\n\n  private syncService(): void {\n    this.service.setStatus(this.status);\n    this.service.setCanSubmit(this.canSubmit);\n  }\n\n  /**\n   * Grows the textarea with its content up to `maxRows`, then lets it scroll.\n   * Measured from the computed line height so it tracks the inherited font.\n   */\n  private resize(): void {\n    const el = this.textarea?.nativeElement;\n    if (!el) return;\n\n    el.style.height = 'auto';\n\n    const styles = getComputedStyle(el);\n    const parsedLineHeight = parseFloat(styles.lineHeight);\n    const lineHeight = Number.isFinite(parsedLineHeight)\n      ? parsedLineHeight\n      : parseFloat(styles.fontSize) * 1.5 || 20;\n    const vertical =\n      parseFloat(styles.paddingTop || '0') +\n      parseFloat(styles.paddingBottom || '0') +\n      parseFloat(styles.borderTopWidth || '0') +\n      parseFloat(styles.borderBottomWidth || '0');\n    const max = lineHeight * Math.max(1, this.maxRows) + vertical;\n\n    const next = Math.min(el.scrollHeight, max);\n    el.style.height = next + 'px';\n    el.style.overflowY = el.scrollHeight > max ? 'auto' : 'hidden';\n  }\n}\n\n/** Bottom bar of a `tolle-prompt-input`: tools on the left, submit on the right. */\n@Component({\n  selector: 'tolle-prompt-input-toolbar',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"computedClass\">\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class PromptInputToolbarComponent  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 toolbar via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get computedClass() {\n    return cn('flex items-center justify-between gap-2 px-1', this.class);\n  }\n}\n\n/** Left-aligned cluster of tool buttons inside a `tolle-prompt-input-toolbar`. */\n@Component({\n  selector: 'tolle-prompt-input-tools',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"computedClass\">\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class PromptInputToolsComponent  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 tool row via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get computedClass() {\n    return cn('flex flex-1 items-center gap-1 text-muted-foreground', this.class);\n  }\n}\n\nconst promptInputSubmitVariants = cva(\n  'inline-flex shrink-0 items-center justify-center gap-1.5 rounded-md font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background 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        ghost: 'text-foreground hover:bg-accent hover:text-accent-foreground',\n      },\n      size: {\n        sm: 'h-7 px-2 text-xs',\n        default: 'size-8 text-sm',\n        lg: 'h-10 px-4 text-sm',\n      },\n    },\n    defaultVariants: {\n      variant: 'default',\n      size: 'default',\n    },\n  }\n);\n\nexport type PromptInputSubmitProps = VariantProps<typeof promptInputSubmitVariants>;\n\n/**\n * Send button for a `tolle-prompt-input`. Turns into a stop button while the\n * composer's status is 'streaming', so one control covers both directions.\n */\n@Component({\n  selector: 'tolle-prompt-input-submit',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <button\n      type=\"button\"\n      data-prompt-input-submit\n      [attr.data-state]=\"status\"\n      [attr.aria-label]=\"currentLabel\"\n      [disabled]=\"isDisabled\"\n      [class]=\"computedClass\"\n      (click)=\"onClick()\"\n    >\n      <i [class]=\"currentIcon\" aria-hidden=\"true\"></i>\n      <span *ngIf=\"showLabel\">{{ currentLabel }}</span>\n    </button>\n  `,\n})\nexport class PromptInputSubmitComponent 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  /** Visual style of the button. @default 'default' */\n  @Input() variant: PromptInputSubmitProps['variant'] = 'default';\n  /** Size of the button. @default 'default' */\n  @Input() size: PromptInputSubmitProps['size'] = 'default';\n  /** Accessible name while the composer is idle. @default 'Send message' */\n  @Input() submitLabel = 'Send message';\n  /** Accessible name while the composer is streaming. @default 'Stop generating' */\n  @Input() stopLabel = 'Stop generating';\n  /** Renders the label next to the icon. @default false */\n  @Input() showLabel = false;\n  /** Extra Tailwind classes merged onto the button via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly service = inject(PromptInputService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly subscriptions = new Subscription();\n\n  status: PromptInputStatus = 'ready';\n  canSubmit = false;\n\n  ngOnInit(): void {\n    this.subscriptions.add(\n      this.service.status$.subscribe((status) => {\n        this.status = status;\n        this.cdr.markForCheck();\n      })\n    );\n    this.subscriptions.add(\n      this.service.canSubmit$.subscribe((canSubmit) => {\n        this.canSubmit = canSubmit;\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  /** True while the button is showing its stop affordance. */\n  get isStreaming(): boolean {\n    return this.status === 'streaming';\n  }\n\n  get currentIcon(): string {\n    return this.isStreaming ? 'ri-stop-circle-line' : 'ri-send-plane-2-fill';\n  }\n\n  get currentLabel(): string {\n    return this.isStreaming ? this.stopLabel : this.submitLabel;\n  }\n\n  /** Stopping stays available with an empty composer; sending does not. */\n  get isDisabled(): boolean {\n    return !this.isStreaming && !this.canSubmit;\n  }\n\n  get computedClass() {\n    return cn(\n      promptInputSubmitVariants({ variant: this.variant, size: this.size }),\n      this.isStreaming && 'bg-destructive text-destructive-foreground hover:bg-destructive/90',\n      this.class\n    );\n  }\n\n  onClick(): void {\n    if (this.isStreaming) {\n      this.service.requestStop();\n    } else {\n      this.service.requestSubmit();\n    }\n  }\n}\n"]}