@tolle_/tolle-ui 18.2.29 → 18.2.30

package/esm2022/lib/conversation.component.mjs

@@ -0,0 +1,442 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Injectable, Input, Output, ViewChild, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+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";
+/**
+ * Coordinates a `tolle-conversation` and its projected parts.
+ *
+ * The transcript owns the scroll position; the empty state and the
+ * "jump to latest" button are OnPush children that cannot read the parent's
+ * fields directly, so everything they need is published here as an observable.
+ *
+ * Provided on `ConversationComponent`, so each transcript gets its own instance.
+ */
+export class ConversationService {
+    atBottomSource = new BehaviorSubject(true);
+    /** Emits whether the transcript is scrolled to (or near) the newest message. */
+    atBottom$ = this.atBottomSource.asObservable();
+    emptySource = new BehaviorSubject(false);
+    /** Emits whether the transcript has no messages yet. */
+    empty$ = this.emptySource.asObservable();
+    scrollRequestSource = new Subject();
+    /** Emits when a child asks the transcript to scroll to the newest message. */
+    scrollRequest$ = this.scrollRequestSource.asObservable();
+    /** True while the transcript is pinned to the bottom. */
+    get atBottom() {
+        return this.atBottomSource.value;
+    }
+    /** True while the transcript is empty. */
+    get empty() {
+        return this.emptySource.value;
+    }
+    setAtBottom(value) {
+        if (this.atBottomSource.value !== value)
+            this.atBottomSource.next(value);
+    }
+    setEmpty(value) {
+        if (this.emptySource.value !== value)
+            this.emptySource.next(value);
+    }
+    /** Asks the transcript to scroll to the newest message. */
+    requestScrollToBottom(behavior = 'smooth') {
+        this.scrollRequestSource.next(behavior);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConversationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConversationService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConversationService, decorators: [{
+            type: Injectable
+        }] });
+const conversationVariants = cva('relative flex w-full flex-col overflow-hidden', {
+    variants: {
+        size: {
+            sm: 'max-h-72',
+            default: 'max-h-[32rem]',
+            lg: 'max-h-[48rem]',
+            full: 'h-full max-h-full',
+        },
+    },
+    defaultVariants: {
+        size: 'default',
+    },
+});
+/**
+ * A scrollable chat transcript. Announces new messages politely, keeps itself
+ * pinned to the newest message while the reader is already at the bottom, and
+ * hosts the empty state plus the floating "jump to latest" button.
+ *
+ * Compose it from `tolle-conversation-content`,
+ * `tolle-conversation-empty-state` and `tolle-conversation-scroll-button`.
+ * @new
+ */
+export class ConversationComponent {
+    cdr = inject(ChangeDetectorRef);
+    /** Height preset for the scroll region. @default 'default' */
+    size = 'default';
+    /** Keeps the newest message in view while the reader is already at the bottom. @default true */
+    autoScroll = true;
+    /** Set true before the first message so the empty state shows. @default false */
+    empty = false;
+    /** Distance from the bottom, in px, still counted as "at the bottom". @default 32 */
+    threshold = 32;
+    /** Accessible name for the transcript. @default '' */
+    ariaLabel = '';
+    /** Extra Tailwind classes merged onto the transcript via `cn()` (last-wins). */
+    class = '';
+    /** Extra Tailwind classes merged onto the scrolling viewport via `cn()` (last-wins). */
+    viewportClass = '';
+    /** Emitted whenever the transcript becomes pinned to, or leaves, the bottom. */
+    atBottomChange = new EventEmitter();
+    viewport;
+    service = inject(ConversationService);
+    subscriptions = new Subscription();
+    observer;
+    ngOnInit() {
+        this.service.setEmpty(this.empty);
+        this.subscriptions.add(this.service.scrollRequest$.subscribe((behavior) => this.scrollToBottom(behavior)));
+    }
+    ngOnChanges() {
+        this.service.setEmpty(this.empty);
+        // 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.measure();
+        // New messages arrive as DOM mutations rather than as inputs on this
+        // component, so watching the subtree is the only content-agnostic way to
+        // keep a transcript of projected messages pinned to the bottom.
+        if (typeof MutationObserver !== 'undefined' && this.viewport) {
+            this.observer = new MutationObserver(() => this.onContentChanged());
+            this.observer.observe(this.viewport.nativeElement, {
+                childList: true,
+                subtree: true,
+                characterData: true,
+            });
+        }
+    }
+    ngOnDestroy() {
+        this.observer?.disconnect();
+        this.subscriptions.unsubscribe();
+    }
+    get computedClass() {
+        return cn(conversationVariants({ size: this.size }), this.class);
+    }
+    get viewportComputedClass() {
+        return cn('flex-1 overflow-y-auto overflow-x-hidden outline-none', this.viewportClass);
+    }
+    /** Scrolls the transcript to the newest message. */
+    scrollToBottom(behavior = 'smooth') {
+        const el = this.viewport?.nativeElement;
+        if (!el)
+            return;
+        if (typeof el.scrollTo === 'function') {
+            el.scrollTo({ top: el.scrollHeight, behavior });
+        }
+        else {
+            el.scrollTop = el.scrollHeight;
+        }
+        this.measure();
+    }
+    /** Recomputes whether the viewport is at the bottom and publishes the result. */
+    onScroll() {
+        this.measure();
+    }
+    onContentChanged() {
+        if (this.autoScroll && this.service.atBottom) {
+            this.scrollToBottom('auto');
+        }
+        else {
+            this.measure();
+        }
+    }
+    measure() {
+        const el = this.viewport?.nativeElement;
+        if (!el)
+            return;
+        const distance = el.scrollHeight - el.scrollTop - el.clientHeight;
+        const next = distance <= this.threshold;
+        if (next !== this.service.atBottom) {
+            this.service.setAtBottom(next);
+            this.atBottomChange.emit(next);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConversationComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ConversationComponent, isStandalone: true, selector: "tolle-conversation", inputs: { size: "size", autoScroll: "autoScroll", empty: "empty", threshold: "threshold", ariaLabel: "ariaLabel", class: "class", viewportClass: "viewportClass" }, outputs: { atBottomChange: "atBottomChange" }, providers: [ConversationService], viewQueries: [{ propertyName: "viewport", first: true, predicate: ["viewport"], descendants: true }], usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass">
+      <div
+        #viewport
+        data-conversation-viewport
+        role="log"
+        aria-live="polite"
+        aria-relevant="additions text"
+        [attr.aria-label]="ariaLabel || null"
+        [class]="viewportComputedClass"
+        (scroll)="onScroll()"
+      >
+        <ng-content></ng-content>
+      </div>
+
+      <ng-content select="tolle-conversation-scroll-button"></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: ConversationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-conversation', standalone: true, imports: [CommonModule], providers: [ConversationService], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass">
+      <div
+        #viewport
+        data-conversation-viewport
+        role="log"
+        aria-live="polite"
+        aria-relevant="additions text"
+        [attr.aria-label]="ariaLabel || null"
+        [class]="viewportComputedClass"
+        (scroll)="onScroll()"
+      >
+        <ng-content></ng-content>
+      </div>
+
+      <ng-content select="tolle-conversation-scroll-button"></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { size: [{
+                type: Input
+            }], autoScroll: [{
+                type: Input
+            }], empty: [{
+                type: Input
+            }], threshold: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], viewportClass: [{
+                type: Input
+            }], atBottomChange: [{
+                type: Output
+            }], viewport: [{
+                type: ViewChild,
+                args: ['viewport']
+            }] } });
+/** Vertical stack of messages inside a `tolle-conversation`. */
+export class ConversationContentComponent {
+    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 stack via `cn()` (last-wins). */
+    class = '';
+    get computedClass() {
+        return cn('flex flex-col gap-4 p-4', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConversationContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ConversationContentComponent, isStandalone: true, selector: "tolle-conversation-content", 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: ConversationContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-conversation-content', 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
+            }] } });
+/**
+ * Placeholder shown while a `tolle-conversation` has no messages. Renders
+ * nothing once the transcript reports content, so it can stay in the template.
+ */
+export class ConversationEmptyStateComponent {
+    /**
+     * 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 illustration. @default 'ri-chat-3-line' */
+    icon = 'ri-chat-3-line';
+    /** Headline shown above the description. @default 'No messages yet' */
+    title = 'No messages yet';
+    /** Supporting copy under the headline. @default 'Start the conversation by sending a message.' */
+    description = 'Start the conversation by sending a message.';
+    /** Extra Tailwind classes merged onto the empty state via `cn()` (last-wins). */
+    class = '';
+    service = inject(ConversationService);
+    cdr = inject(ChangeDetectorRef);
+    subscriptions = new Subscription();
+    visible = false;
+    ngOnInit() {
+        this.subscriptions.add(this.service.empty$.subscribe((empty) => {
+            this.visible = empty;
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    get computedClass() {
+        return cn('flex flex-col items-center justify-center gap-2 px-6 py-12 text-center', this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConversationEmptyStateComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ConversationEmptyStateComponent, isStandalone: true, selector: "tolle-conversation-empty-state", inputs: { icon: "icon", title: "title", description: "description", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div *ngIf="visible" data-conversation-empty [class]="computedClass">
+      <div
+        *ngIf="icon"
+        class="flex size-10 items-center justify-center rounded-full bg-muted text-muted-foreground"
+      >
+        <i [class]="icon" aria-hidden="true"></i>
+      </div>
+
+      <p *ngIf="title" class="text-sm font-medium text-foreground">{{ title }}</p>
+      <p *ngIf="description" class="max-w-sm text-sm text-muted-foreground">{{ description }}</p>
+
+      <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: ConversationEmptyStateComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-conversation-empty-state', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div *ngIf="visible" data-conversation-empty [class]="computedClass">
+      <div
+        *ngIf="icon"
+        class="flex size-10 items-center justify-center rounded-full bg-muted text-muted-foreground"
+      >
+        <i [class]="icon" aria-hidden="true"></i>
+      </div>
+
+      <p *ngIf="title" class="text-sm font-medium text-foreground">{{ title }}</p>
+      <p *ngIf="description" class="max-w-sm text-sm text-muted-foreground">{{ description }}</p>
+
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { icon: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+const conversationScrollButtonVariants = cva('absolute bottom-4 left-1/2 z-10 inline-flex -translate-x-1/2 items-center justify-center gap-1.5 rounded-full border shadow-md transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background', {
+    variants: {
+        variant: {
+            default: 'border-transparent bg-primary text-primary-foreground hover:bg-primary/90',
+            secondary: 'border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80',
+            outline: 'border-border bg-background text-foreground hover:bg-accent hover:text-accent-foreground',
+        },
+        size: {
+            sm: 'h-7 px-2 text-xs',
+            default: 'h-8 px-3 text-xs',
+            icon: 'size-8 p-0 text-sm',
+        },
+    },
+    defaultVariants: {
+        variant: 'outline',
+        size: 'default',
+    },
+});
+/**
+ * Floating "jump to latest" control. Appears only while the transcript is
+ * scrolled away from the newest message, and scrolls it back on click.
+ */
+export class ConversationScrollButtonComponent {
+    /**
+     * 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 'outline' */
+    variant = 'outline';
+    /** Size of the button; 'icon' drops the text label. @default 'default' */
+    size = 'default';
+    /** Button text and accessible name. @default 'Jump to latest' */
+    label = 'Jump to latest';
+    /** Extra Tailwind classes merged onto the button via `cn()` (last-wins). */
+    class = '';
+    /** Emitted when the reader jumps back to the newest message. */
+    jumped = new EventEmitter();
+    service = inject(ConversationService);
+    cdr = inject(ChangeDetectorRef);
+    subscriptions = new Subscription();
+    visible = false;
+    ngOnInit() {
+        this.subscriptions.add(this.service.atBottom$.subscribe((atBottom) => {
+            this.visible = !atBottom;
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    get computedClass() {
+        return cn(conversationScrollButtonVariants({ variant: this.variant, size: this.size }), this.class);
+    }
+    onClick() {
+        this.service.requestScrollToBottom('smooth');
+        this.jumped.emit();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConversationScrollButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ConversationScrollButtonComponent, isStandalone: true, selector: "tolle-conversation-scroll-button", inputs: { variant: "variant", size: "size", label: "label", class: "class" }, outputs: { jumped: "jumped" }, usesOnChanges: true, ngImport: i0, template: `
+    <button
+      *ngIf="visible"
+      type="button"
+      data-conversation-scroll-button
+      [attr.aria-label]="label"
+      [class]="computedClass"
+      (click)="onClick()"
+    >
+      <i class="ri-arrow-down-line" aria-hidden="true"></i>
+      <span *ngIf="size !== 'icon'">{{ label }}</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: ConversationScrollButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-conversation-scroll-button', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <button
+      *ngIf="visible"
+      type="button"
+      data-conversation-scroll-button
+      [attr.aria-label]="label"
+      [class]="computedClass"
+      (click)="onClick()"
+    >
+      <i class="ri-arrow-down-line" aria-hidden="true"></i>
+      <span *ngIf="size !== 'icon'">{{ label }}</span>
+    </button>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { variant: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], jumped: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"conversation.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/conversation.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, Injectable, Input, OnChanges, OnDestroy, OnInit, Output, ViewChild, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { BehaviorSubject, Subject, Subscription } from 'rxjs';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\n\n/**\n * Coordinates a `tolle-conversation` and its projected parts.\n *\n * The transcript owns the scroll position; the empty state and the\n * \"jump to latest\" button are OnPush children that cannot read the parent's\n * fields directly, so everything they need is published here as an observable.\n *\n * Provided on `ConversationComponent`, so each transcript gets its own instance.\n */\n@Injectable()\nexport class ConversationService {\n  private readonly atBottomSource = new BehaviorSubject<boolean>(true);\n  /** Emits whether the transcript is scrolled to (or near) the newest message. */\n  readonly atBottom$ = this.atBottomSource.asObservable();\n\n  private readonly emptySource = new BehaviorSubject<boolean>(false);\n  /** Emits whether the transcript has no messages yet. */\n  readonly empty$ = this.emptySource.asObservable();\n\n  private readonly scrollRequestSource = new Subject<ScrollBehavior>();\n  /** Emits when a child asks the transcript to scroll to the newest message. */\n  readonly scrollRequest$ = this.scrollRequestSource.asObservable();\n\n  /** True while the transcript is pinned to the bottom. */\n  get atBottom(): boolean {\n    return this.atBottomSource.value;\n  }\n\n  /** True while the transcript is empty. */\n  get empty(): boolean {\n    return this.emptySource.value;\n  }\n\n  setAtBottom(value: boolean): void {\n    if (this.atBottomSource.value !== value) this.atBottomSource.next(value);\n  }\n\n  setEmpty(value: boolean): void {\n    if (this.emptySource.value !== value) this.emptySource.next(value);\n  }\n\n  /** Asks the transcript to scroll to the newest message. */\n  requestScrollToBottom(behavior: ScrollBehavior = 'smooth'): void {\n    this.scrollRequestSource.next(behavior);\n  }\n}\n\nconst conversationVariants = cva('relative flex w-full flex-col overflow-hidden', {\n  variants: {\n    size: {\n      sm: 'max-h-72',\n      default: 'max-h-[32rem]',\n      lg: 'max-h-[48rem]',\n      full: 'h-full max-h-full',\n    },\n  },\n  defaultVariants: {\n    size: 'default',\n  },\n});\n\nexport type ConversationProps = VariantProps<typeof conversationVariants>;\n\n/**\n * A scrollable chat transcript. Announces new messages politely, keeps itself\n * pinned to the newest message while the reader is already at the bottom, and\n * hosts the empty state plus the floating \"jump to latest\" button.\n *\n * Compose it from `tolle-conversation-content`,\n * `tolle-conversation-empty-state` and `tolle-conversation-scroll-button`.\n * @new\n */\n@Component({\n  selector: 'tolle-conversation',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  providers: [ConversationService],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"computedClass\">\n      <div\n        #viewport\n        data-conversation-viewport\n        role=\"log\"\n        aria-live=\"polite\"\n        aria-relevant=\"additions text\"\n        [attr.aria-label]=\"ariaLabel || null\"\n        [class]=\"viewportComputedClass\"\n        (scroll)=\"onScroll()\"\n      >\n        <ng-content></ng-content>\n      </div>\n\n      <ng-content select=\"tolle-conversation-scroll-button\"></ng-content>\n    </div>\n  `,\n})\nexport class ConversationComponent implements OnInit, OnChanges, AfterViewInit, OnDestroy {\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  /** Height preset for the scroll region. @default 'default' */\n  @Input() size: ConversationProps['size'] = 'default';\n  /** Keeps the newest message in view while the reader is already at the bottom. @default true */\n  @Input() autoScroll = true;\n  /** Set true before the first message so the empty state shows. @default false */\n  @Input() empty = false;\n  /** Distance from the bottom, in px, still counted as \"at the bottom\". @default 32 */\n  @Input() threshold = 32;\n  /** Accessible name for the transcript. @default '' */\n  @Input() ariaLabel = '';\n  /** Extra Tailwind classes merged onto the transcript via `cn()` (last-wins). */\n  @Input() class = '';\n  /** Extra Tailwind classes merged onto the scrolling viewport via `cn()` (last-wins). */\n  @Input() viewportClass = '';\n\n  /** Emitted whenever the transcript becomes pinned to, or leaves, the bottom. */\n  @Output() atBottomChange = new EventEmitter<boolean>();\n\n  @ViewChild('viewport') private viewport?: ElementRef<HTMLElement>;\n\n  private readonly service = inject(ConversationService);\n  private readonly subscriptions = new Subscription();\n  private observer?: MutationObserver;\n\n  ngOnInit(): void {\n    this.service.setEmpty(this.empty);\n    this.subscriptions.add(\n      this.service.scrollRequest$.subscribe((behavior) => this.scrollToBottom(behavior))\n    );\n  }\n\n  ngOnChanges(): void {\n    this.service.setEmpty(this.empty);\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.measure();\n\n    // New messages arrive as DOM mutations rather than as inputs on this\n    // component, so watching the subtree is the only content-agnostic way to\n    // keep a transcript of projected messages pinned to the bottom.\n    if (typeof MutationObserver !== 'undefined' && this.viewport) {\n      this.observer = new MutationObserver(() => this.onContentChanged());\n      this.observer.observe(this.viewport.nativeElement, {\n        childList: true,\n        subtree: true,\n        characterData: true,\n      });\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.observer?.disconnect();\n    this.subscriptions.unsubscribe();\n  }\n\n  get computedClass() {\n    return cn(conversationVariants({ size: this.size }), this.class);\n  }\n\n  get viewportComputedClass() {\n    return cn('flex-1 overflow-y-auto overflow-x-hidden outline-none', this.viewportClass);\n  }\n\n  /** Scrolls the transcript to the newest message. */\n  scrollToBottom(behavior: ScrollBehavior = 'smooth'): void {\n    const el = this.viewport?.nativeElement;\n    if (!el) return;\n    if (typeof el.scrollTo === 'function') {\n      el.scrollTo({ top: el.scrollHeight, behavior });\n    } else {\n      el.scrollTop = el.scrollHeight;\n    }\n    this.measure();\n  }\n\n  /** Recomputes whether the viewport is at the bottom and publishes the result. */\n  onScroll(): void {\n    this.measure();\n  }\n\n  private onContentChanged(): void {\n    if (this.autoScroll && this.service.atBottom) {\n      this.scrollToBottom('auto');\n    } else {\n      this.measure();\n    }\n  }\n\n  private measure(): void {\n    const el = this.viewport?.nativeElement;\n    if (!el) return;\n    const distance = el.scrollHeight - el.scrollTop - el.clientHeight;\n    const next = distance <= this.threshold;\n    if (next !== this.service.atBottom) {\n      this.service.setAtBottom(next);\n      this.atBottomChange.emit(next);\n    }\n  }\n}\n\n/** Vertical stack of messages inside a `tolle-conversation`. */\n@Component({\n  selector: 'tolle-conversation-content',\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 ConversationContentComponent  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 stack via `cn()` (last-wins). */\n  @Input() class = '';\n\n  get computedClass() {\n    return cn('flex flex-col gap-4 p-4', this.class);\n  }\n}\n\n/**\n * Placeholder shown while a `tolle-conversation` has no messages. Renders\n * nothing once the transcript reports content, so it can stay in the template.\n */\n@Component({\n  selector: 'tolle-conversation-empty-state',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div *ngIf=\"visible\" data-conversation-empty [class]=\"computedClass\">\n      <div\n        *ngIf=\"icon\"\n        class=\"flex size-10 items-center justify-center rounded-full bg-muted text-muted-foreground\"\n      >\n        <i [class]=\"icon\" aria-hidden=\"true\"></i>\n      </div>\n\n      <p *ngIf=\"title\" class=\"text-sm font-medium text-foreground\">{{ title }}</p>\n      <p *ngIf=\"description\" class=\"max-w-sm text-sm text-muted-foreground\">{{ description }}</p>\n\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class ConversationEmptyStateComponent 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  /** Remixicon class for the illustration. @default 'ri-chat-3-line' */\n  @Input() icon = 'ri-chat-3-line';\n  /** Headline shown above the description. @default 'No messages yet' */\n  @Input() title = 'No messages yet';\n  /** Supporting copy under the headline. @default 'Start the conversation by sending a message.' */\n  @Input() description = 'Start the conversation by sending a message.';\n  /** Extra Tailwind classes merged onto the empty state via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly service = inject(ConversationService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly subscriptions = new Subscription();\n\n  visible = false;\n\n  ngOnInit(): void {\n    this.subscriptions.add(\n      this.service.empty$.subscribe((empty) => {\n        this.visible = empty;\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  get computedClass() {\n    return cn(\n      'flex flex-col items-center justify-center gap-2 px-6 py-12 text-center',\n      this.class\n    );\n  }\n}\n\nconst conversationScrollButtonVariants = cva(\n  'absolute bottom-4 left-1/2 z-10 inline-flex -translate-x-1/2 items-center justify-center gap-1.5 rounded-full border shadow-md transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background',\n  {\n    variants: {\n      variant: {\n        default: 'border-transparent bg-primary text-primary-foreground hover:bg-primary/90',\n        secondary: 'border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80',\n        outline: 'border-border bg-background text-foreground hover:bg-accent hover:text-accent-foreground',\n      },\n      size: {\n        sm: 'h-7 px-2 text-xs',\n        default: 'h-8 px-3 text-xs',\n        icon: 'size-8 p-0 text-sm',\n      },\n    },\n    defaultVariants: {\n      variant: 'outline',\n      size: 'default',\n    },\n  }\n);\n\nexport type ConversationScrollButtonProps = VariantProps<typeof conversationScrollButtonVariants>;\n\n/**\n * Floating \"jump to latest\" control. Appears only while the transcript is\n * scrolled away from the newest message, and scrolls it back on click.\n */\n@Component({\n  selector: 'tolle-conversation-scroll-button',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <button\n      *ngIf=\"visible\"\n      type=\"button\"\n      data-conversation-scroll-button\n      [attr.aria-label]=\"label\"\n      [class]=\"computedClass\"\n      (click)=\"onClick()\"\n    >\n      <i class=\"ri-arrow-down-line\" aria-hidden=\"true\"></i>\n      <span *ngIf=\"size !== 'icon'\">{{ label }}</span>\n    </button>\n  `,\n})\nexport class ConversationScrollButtonComponent 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 'outline' */\n  @Input() variant: ConversationScrollButtonProps['variant'] = 'outline';\n  /** Size of the button; 'icon' drops the text label. @default 'default' */\n  @Input() size: ConversationScrollButtonProps['size'] = 'default';\n  /** Button text and accessible name. @default 'Jump to latest' */\n  @Input() label = 'Jump to latest';\n  /** Extra Tailwind classes merged onto the button via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted when the reader jumps back to the newest message. */\n  @Output() jumped = new EventEmitter<void>();\n\n  private readonly service = inject(ConversationService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly subscriptions = new Subscription();\n\n  visible = false;\n\n  ngOnInit(): void {\n    this.subscriptions.add(\n      this.service.atBottom$.subscribe((atBottom) => {\n        this.visible = !atBottom;\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  get computedClass() {\n    return cn(\n      conversationScrollButtonVariants({ variant: this.variant, size: this.size }),\n      this.class\n    );\n  }\n\n  onClick(): void {\n    this.service.requestScrollToBottom('smooth');\n    this.jumped.emit();\n  }\n}\n"]}