@tolle_/tolle-ui 18.2.29 → 18.2.30

package/esm2022/lib/message-scroller.component.mjs

@@ -0,0 +1,353 @@
+import { Component, Directive, Input, Output, EventEmitter, ElementRef, NgZone, ChangeDetectionStrategy, ChangeDetectorRef, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { Subscription } from 'rxjs';
+import { cn } from './utils/cn';
+import { MessageScrollerService } from './message-scroller.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * A scroll container built for conversations, where content streams in while
+ * the reader is still reading.
+ *
+ * A plain overflow-scroll div gets this wrong in both directions: it either
+ * pins to the bottom and yanks the page mid-sentence, or it never follows and
+ * the reader misses the reply. This handles the cases that are easy to get
+ * wrong — following the live edge only while the reader is already there,
+ * opening a saved thread at the newest turn rather than the absolute end, and
+ * holding position when older history loads in above.
+ *
+ * ```html
+ * <tolle-message-scroller startPosition="last-anchor">
+ *   <tolle-message-scroller-viewport>
+ *     <tolle-message-scroller-content>
+ *       <div tolleMessageScrollerItem [scrollAnchor]="turn.isNewTurn" *ngFor="let turn of turns">
+ *         …
+ *       </div>
+ *     </tolle-message-scroller-content>
+ *   </tolle-message-scroller-viewport>
+ *   <tolle-message-scroller-button />
+ * </tolle-message-scroller>
+ * ```
+ * @new
+ */
+export class MessageScrollerComponent {
+    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();
+    }
+    /**
+     * Where to land when the transcript first renders. `last-anchor` opens at the
+     * newest turn so a long answer starts from its first line.
+     * @default 'last-anchor'
+     */
+    startPosition = 'last-anchor';
+    /**
+     * Pixels of the previous turn kept visible above an anchored turn, so the
+     * reader can see what the reply is responding to. @default 48
+     */
+    scrollPreviousItemPeek = 48;
+    /**
+     * Distance from the bottom, in px, still treated as the live edge.
+     * @default 32
+     */
+    threshold = 32;
+    /** Extra Tailwind classes merged onto the frame via `cn()` (last-wins). */
+    class = '';
+    /** Emitted when the reader arrives at, or leaves, the live edge. */
+    atBottomChange = new EventEmitter();
+    service = inject(MessageScrollerService);
+    sub = new Subscription();
+    cn = cn;
+    ngOnInit() {
+        this.service.threshold = this.threshold;
+        this.sub.add(this.service.atBottom$.subscribe((v) => this.atBottomChange.emit(v)));
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+    }
+    /** Jumps to the newest content and resumes following. */
+    scrollToBottom(behavior = 'smooth') {
+        this.service.scrollToBottom(behavior);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MessageScrollerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: MessageScrollerComponent, isStandalone: true, selector: "tolle-message-scroller", inputs: { startPosition: "startPosition", scrollPreviousItemPeek: "scrollPreviousItemPeek", threshold: "threshold", class: "class" }, outputs: { atBottomChange: "atBottomChange" }, providers: [MessageScrollerService], usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="cn('relative flex min-h-0 flex-1 flex-col overflow-hidden', class)">
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, styles: [":host{display:flex;flex-direction:column;height:100%;min-height:0}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MessageScrollerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-message-scroller', standalone: true, imports: [CommonModule], providers: [MessageScrollerService], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="cn('relative flex min-h-0 flex-1 flex-col overflow-hidden', class)">
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:flex;flex-direction:column;height:100%;min-height:0}\n"] }]
+        }], propDecorators: { startPosition: [{
+                type: Input
+            }], scrollPreviousItemPeek: [{
+                type: Input
+            }], threshold: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], atBottomChange: [{
+                type: Output
+            }] } });
+/**
+ * The scrolling element. Watches its own size and its content's size so it can
+ * follow streamed text and hold position when history is prepended.
+ */
+export class MessageScrollerViewportComponent {
+    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 viewport via `cn()` (last-wins). */
+    class = '';
+    service = inject(MessageScrollerService);
+    scroller = inject(MessageScrollerComponent);
+    host = inject(ElementRef);
+    zone = inject(NgZone);
+    viewportEl = null;
+    resizeObserver;
+    mutationObserver;
+    onScroll = () => this.service.measure();
+    /** scrollHeight captured before each DOM mutation, to detect prepends. */
+    lastScrollHeight = 0;
+    lastScrollTop = 0;
+    cn = cn;
+    ngAfterViewInit() {
+        const el = this.host.nativeElement.querySelector('div');
+        if (!el)
+            return;
+        this.viewportEl = el;
+        this.service.registerViewport(el);
+        // Scroll fires at frame rate; keeping the listener outside Angular means we
+        // only re-enter change detection when a tracked boolean actually flips.
+        this.zone.runOutsideAngular(() => {
+            el.addEventListener('scroll', this.onScroll, { passive: true });
+            if (typeof ResizeObserver !== 'undefined') {
+                this.resizeObserver = new ResizeObserver(() => this.service.handleContentGrowth());
+                this.resizeObserver.observe(el);
+                const content = el.firstElementChild;
+                if (content)
+                    this.resizeObserver.observe(content);
+            }
+            if (typeof MutationObserver !== 'undefined') {
+                this.mutationObserver = new MutationObserver(() => this.afterMutation());
+                this.mutationObserver.observe(el, { childList: true, subtree: true, characterData: true });
+            }
+        });
+        this.lastScrollHeight = el.scrollHeight;
+        // Wait a frame so projected content has laid out before positioning.
+        setTimeout(() => {
+            this.service.applyStartPosition(this.scroller.startPosition, this.scroller.scrollPreviousItemPeek);
+            this.lastScrollHeight = el.scrollHeight;
+        });
+    }
+    ngOnDestroy() {
+        this.viewportEl?.removeEventListener('scroll', this.onScroll);
+        this.resizeObserver?.disconnect();
+        this.mutationObserver?.disconnect();
+    }
+    /**
+     * Distinguishes content appended below (stream) from content inserted above
+     * (history). Growth while the reader has NOT moved but the scrollable area
+     * above them has, means a prepend — restore their position rather than let
+     * the view lurch.
+     */
+    afterMutation() {
+        const el = this.viewportEl;
+        if (!el)
+            return;
+        const grew = el.scrollHeight - this.lastScrollHeight;
+        const readerMoved = el.scrollTop !== this.lastScrollTop;
+        if (grew > 0 && !readerMoved && !this.service.isFollowing && el.scrollTop > 0) {
+            this.service.preserveOnPrepend(this.lastScrollHeight);
+        }
+        else if (grew > 0) {
+            this.service.handleContentGrowth();
+        }
+        this.lastScrollHeight = el.scrollHeight;
+        this.lastScrollTop = el.scrollTop;
+        this.service.measure();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MessageScrollerViewportComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: MessageScrollerViewportComponent, isStandalone: true, selector: "tolle-message-scroller-viewport", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div #viewport [class]="cn('min-h-0 flex-1 overflow-y-auto overscroll-contain', class)">
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, styles: [":host{display:flex;flex-direction:column;flex:1 1 auto;min-height:0}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MessageScrollerViewportComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-message-scroller-viewport', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div #viewport [class]="cn('min-h-0 flex-1 overflow-y-auto overscroll-contain', class)">
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:flex;flex-direction:column;flex:1 1 auto;min-height:0}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/** The transcript itself. Announced politely so streamed replies reach screen readers. */
+export class MessageScrollerContentComponent {
+    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 transcript via `cn()` (last-wins). */
+    class = '';
+    cn = cn;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MessageScrollerContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: MessageScrollerContentComponent, isStandalone: true, selector: "tolle-message-scroller-content", inputs: { class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <div
+      role="log"
+      aria-live="polite"
+      aria-relevant="additions text"
+      [class]="cn('flex flex-col gap-4 p-4', class)"
+    >
+      <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: MessageScrollerContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-message-scroller-content', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div
+      role="log"
+      aria-live="polite"
+      aria-relevant="additions text"
+      [class]="cn('flex flex-col gap-4 p-4', class)"
+    >
+      <ng-content></ng-content>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+/**
+ * Marks one row of the transcript. Set `scrollAnchor` on the row that begins a
+ * conversation turn so `startPosition="last-anchor"` can open there.
+ */
+export class MessageScrollerItemDirective {
+    /** Marks this row as the start of a turn. @default false */
+    scrollAnchor = false;
+    service = inject(MessageScrollerService);
+    host = inject(ElementRef);
+    ngOnInit() {
+        if (this.scrollAnchor)
+            this.service.registerAnchor(this.host.nativeElement);
+    }
+    ngOnDestroy() {
+        this.service.unregisterAnchor(this.host.nativeElement);
+    }
+    /** Brings this row into view — use for jump-to-message. */
+    scrollIntoView(behavior = 'smooth') {
+        this.service.scrollToItem(this.host.nativeElement, behavior);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MessageScrollerItemDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: MessageScrollerItemDirective, isStandalone: true, selector: "[tolleMessageScrollerItem]", inputs: { scrollAnchor: "scrollAnchor" }, host: { properties: { "attr.data-scroll-anchor": "scrollAnchor ? '' : null" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MessageScrollerItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tolleMessageScrollerItem]',
+                    standalone: true,
+                    host: { '[attr.data-scroll-anchor]': `scrollAnchor ? '' : null` },
+                }]
+        }], propDecorators: { scrollAnchor: [{
+                type: Input
+            }] } });
+/** Floating "jump to latest" control. Hidden while the reader is already at the edge. */
+export class MessageScrollerButtonComponent {
+    /**
+     * 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();
+    }
+    /** Accessible name for the jump control. @default 'Jump to latest messages' */
+    ariaLabel = 'Jump to latest messages';
+    /** Extra Tailwind classes merged onto the button via `cn()` (last-wins). */
+    class = '';
+    service = inject(MessageScrollerService);
+    cdr = inject(ChangeDetectorRef);
+    sub = new Subscription();
+    atBottom = true;
+    cn = cn;
+    ngOnInit() {
+        this.sub.add(this.service.atBottom$.subscribe((v) => {
+            this.atBottom = v;
+            this.cdr.markForCheck();
+        }));
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+    }
+    jump() {
+        this.service.scrollToBottom();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MessageScrollerButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: MessageScrollerButtonComponent, isStandalone: true, selector: "tolle-message-scroller-button", inputs: { ariaLabel: "ariaLabel", class: "class" }, usesOnChanges: true, ngImport: i0, template: `
+    <button
+      *ngIf="!atBottom"
+      type="button"
+      [attr.aria-label]="ariaLabel"
+      [class]="cn(
+        'absolute bottom-4 left-1/2 z-10 flex -translate-x-1/2 items-center gap-1.5 rounded-full',
+        'border border-border bg-popover px-3 py-1.5 text-xs font-medium text-popover-foreground shadow-md',
+        'transition-colors hover:bg-accent hover:text-accent-foreground',
+        'focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',
+        class
+      )"
+      (click)="jump()"
+    >
+      <i class="ri-arrow-down-line" aria-hidden="true"></i>
+      <ng-content></ng-content>
+    </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: MessageScrollerButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-message-scroller-button', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <button
+      *ngIf="!atBottom"
+      type="button"
+      [attr.aria-label]="ariaLabel"
+      [class]="cn(
+        'absolute bottom-4 left-1/2 z-10 flex -translate-x-1/2 items-center gap-1.5 rounded-full',
+        'border border-border bg-popover px-3 py-1.5 text-xs font-medium text-popover-foreground shadow-md',
+        'transition-colors hover:bg-accent hover:text-accent-foreground',
+        'focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',
+        class
+      )"
+      (click)="jump()"
+    >
+      <i class="ri-arrow-down-line" aria-hidden="true"></i>
+      <ng-content></ng-content>
+    </button>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { ariaLabel: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message-scroller.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/message-scroller.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Directive, Input, Output, EventEmitter, ElementRef, NgZone, ChangeDetectionStrategy, ChangeDetectorRef, AfterViewInit, OnInit, OnDestroy, inject, OnChanges } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { Subscription } from 'rxjs';\nimport { cn } from './utils/cn';\nimport { MessageScrollerService, ScrollStartPosition } from './message-scroller.service';\n\n/**\n * A scroll container built for conversations, where content streams in while\n * the reader is still reading.\n *\n * A plain overflow-scroll div gets this wrong in both directions: it either\n * pins to the bottom and yanks the page mid-sentence, or it never follows and\n * the reader misses the reply. This handles the cases that are easy to get\n * wrong — following the live edge only while the reader is already there,\n * opening a saved thread at the newest turn rather than the absolute end, and\n * holding position when older history loads in above.\n *\n * ```html\n * <tolle-message-scroller startPosition=\"last-anchor\">\n *   <tolle-message-scroller-viewport>\n *     <tolle-message-scroller-content>\n *       <div tolleMessageScrollerItem [scrollAnchor]=\"turn.isNewTurn\" *ngFor=\"let turn of turns\">\n *         …\n *       </div>\n *     </tolle-message-scroller-content>\n *   </tolle-message-scroller-viewport>\n *   <tolle-message-scroller-button />\n * </tolle-message-scroller>\n * ```\n * @new\n */\n@Component({\n  selector: 'tolle-message-scroller',\n  // The host sits between a consumer-sized parent and the templated flex\n  // frame below; display:block would drop the parent's height and the\n  // frame's `flex-1 min-h-0` would have nothing to size against.\n  styles: [':host { display: flex; flex-direction: column; height: 100%; min-height: 0; }'],\n  standalone: true,\n  imports: [CommonModule],\n  providers: [MessageScrollerService],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"cn('relative flex min-h-0 flex-1 flex-col overflow-hidden', class)\">\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class MessageScrollerComponent implements OnChanges, OnInit, OnDestroy {\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  /**\n   * Where to land when the transcript first renders. `last-anchor` opens at the\n   * newest turn so a long answer starts from its first line.\n   * @default 'last-anchor'\n   */\n  @Input() startPosition: ScrollStartPosition = 'last-anchor';\n  /**\n   * Pixels of the previous turn kept visible above an anchored turn, so the\n   * reader can see what the reply is responding to. @default 48\n   */\n  @Input() scrollPreviousItemPeek = 48;\n  /**\n   * Distance from the bottom, in px, still treated as the live edge.\n   * @default 32\n   */\n  @Input() threshold = 32;\n  /** Extra Tailwind classes merged onto the frame via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted when the reader arrives at, or leaves, the live edge. */\n  @Output() atBottomChange = new EventEmitter<boolean>();\n\n  private readonly service = inject(MessageScrollerService);\n  private readonly sub = new Subscription();\n  protected cn = cn;\n\n  ngOnInit(): void {\n    this.service.threshold = this.threshold;\n    this.sub.add(this.service.atBottom$.subscribe((v) => this.atBottomChange.emit(v)));\n  }\n\n  ngOnDestroy(): void {\n    this.sub.unsubscribe();\n  }\n\n  /** Jumps to the newest content and resumes following. */\n  scrollToBottom(behavior: ScrollBehavior = 'smooth'): void {\n    this.service.scrollToBottom(behavior);\n  }\n}\n\n/**\n * The scrolling element. Watches its own size and its content's size so it can\n * follow streamed text and hold position when history is prepended.\n */\n@Component({\n  selector: 'tolle-message-scroller-viewport',\n  // Same reasoning as tolle-message-scroller: this host is the flex item the\n  // scrollable inner div sizes against, so it must join the flex chain itself.\n  styles: [':host { display: flex; flex-direction: column; flex: 1 1 auto; min-height: 0; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div #viewport [class]=\"cn('min-h-0 flex-1 overflow-y-auto overscroll-contain', class)\">\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class MessageScrollerViewportComponent implements OnChanges, AfterViewInit, OnDestroy {\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 viewport via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly service = inject(MessageScrollerService);\n  private readonly scroller = inject(MessageScrollerComponent);\n  private readonly host = inject<ElementRef<HTMLElement>>(ElementRef);\n  private readonly zone = inject(NgZone);\n\n  private viewportEl: HTMLElement | null = null;\n  private resizeObserver?: ResizeObserver;\n  private mutationObserver?: MutationObserver;\n  private onScroll = () => this.service.measure();\n  /** scrollHeight captured before each DOM mutation, to detect prepends. */\n  private lastScrollHeight = 0;\n  private lastScrollTop = 0;\n  protected cn = cn;\n\n  ngAfterViewInit(): void {\n    const el = this.host.nativeElement.querySelector<HTMLElement>('div');\n    if (!el) return;\n    this.viewportEl = el;\n    this.service.registerViewport(el);\n\n    // Scroll fires at frame rate; keeping the listener outside Angular means we\n    // only re-enter change detection when a tracked boolean actually flips.\n    this.zone.runOutsideAngular(() => {\n      el.addEventListener('scroll', this.onScroll, { passive: true });\n\n      if (typeof ResizeObserver !== 'undefined') {\n        this.resizeObserver = new ResizeObserver(() => this.service.handleContentGrowth());\n        this.resizeObserver.observe(el);\n        const content = el.firstElementChild;\n        if (content) this.resizeObserver.observe(content);\n      }\n\n      if (typeof MutationObserver !== 'undefined') {\n        this.mutationObserver = new MutationObserver(() => this.afterMutation());\n        this.mutationObserver.observe(el, { childList: true, subtree: true, characterData: true });\n      }\n    });\n\n    this.lastScrollHeight = el.scrollHeight;\n\n    // Wait a frame so projected content has laid out before positioning.\n    setTimeout(() => {\n      this.service.applyStartPosition(\n        this.scroller.startPosition,\n        this.scroller.scrollPreviousItemPeek\n      );\n      this.lastScrollHeight = el.scrollHeight;\n    });\n  }\n\n  ngOnDestroy(): void {\n    this.viewportEl?.removeEventListener('scroll', this.onScroll);\n    this.resizeObserver?.disconnect();\n    this.mutationObserver?.disconnect();\n  }\n\n  /**\n   * Distinguishes content appended below (stream) from content inserted above\n   * (history). Growth while the reader has NOT moved but the scrollable area\n   * above them has, means a prepend — restore their position rather than let\n   * the view lurch.\n   */\n  private afterMutation(): void {\n    const el = this.viewportEl;\n    if (!el) return;\n\n    const grew = el.scrollHeight - this.lastScrollHeight;\n    const readerMoved = el.scrollTop !== this.lastScrollTop;\n\n    if (grew > 0 && !readerMoved && !this.service.isFollowing && el.scrollTop > 0) {\n      this.service.preserveOnPrepend(this.lastScrollHeight);\n    } else if (grew > 0) {\n      this.service.handleContentGrowth();\n    }\n\n    this.lastScrollHeight = el.scrollHeight;\n    this.lastScrollTop = el.scrollTop;\n    this.service.measure();\n  }\n}\n\n/** The transcript itself. Announced politely so streamed replies reach screen readers. */\n@Component({\n  selector: 'tolle-message-scroller-content',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div\n      role=\"log\"\n      aria-live=\"polite\"\n      aria-relevant=\"additions text\"\n      [class]=\"cn('flex flex-col gap-4 p-4', class)\"\n    >\n      <ng-content></ng-content>\n    </div>\n  `,\n})\nexport class MessageScrollerContentComponent  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 transcript via `cn()` (last-wins). */\n  @Input() class = '';\n  protected cn = cn;\n}\n\n/**\n * Marks one row of the transcript. Set `scrollAnchor` on the row that begins a\n * conversation turn so `startPosition=\"last-anchor\"` can open there.\n */\n@Directive({\n  selector: '[tolleMessageScrollerItem]',\n  standalone: true,\n  host: { '[attr.data-scroll-anchor]': `scrollAnchor ? '' : null` },\n})\nexport class MessageScrollerItemDirective implements OnInit, OnDestroy {\n  /** Marks this row as the start of a turn. @default false */\n  @Input() scrollAnchor = false;\n\n  private readonly service = inject(MessageScrollerService);\n  private readonly host = inject<ElementRef<HTMLElement>>(ElementRef);\n\n  ngOnInit(): void {\n    if (this.scrollAnchor) this.service.registerAnchor(this.host.nativeElement);\n  }\n\n  ngOnDestroy(): void {\n    this.service.unregisterAnchor(this.host.nativeElement);\n  }\n\n  /** Brings this row into view — use for jump-to-message. */\n  scrollIntoView(behavior: ScrollBehavior = 'smooth'): void {\n    this.service.scrollToItem(this.host.nativeElement, behavior);\n  }\n}\n\n/** Floating \"jump to latest\" control. Hidden while the reader is already at the edge. */\n@Component({\n  selector: 'tolle-message-scroller-button',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <button\n      *ngIf=\"!atBottom\"\n      type=\"button\"\n      [attr.aria-label]=\"ariaLabel\"\n      [class]=\"cn(\n        'absolute bottom-4 left-1/2 z-10 flex -translate-x-1/2 items-center gap-1.5 rounded-full',\n        'border border-border bg-popover px-3 py-1.5 text-xs font-medium text-popover-foreground shadow-md',\n        'transition-colors hover:bg-accent hover:text-accent-foreground',\n        'focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',\n        class\n      )\"\n      (click)=\"jump()\"\n    >\n      <i class=\"ri-arrow-down-line\" aria-hidden=\"true\"></i>\n      <ng-content></ng-content>\n    </button>\n  `,\n})\nexport class MessageScrollerButtonComponent 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  /** Accessible name for the jump control. @default 'Jump to latest messages' */\n  @Input() ariaLabel = 'Jump to latest messages';\n  /** Extra Tailwind classes merged onto the button via `cn()` (last-wins). */\n  @Input() class = '';\n\n  private readonly service = inject(MessageScrollerService);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly sub = new Subscription();\n\n  atBottom = true;\n  protected cn = cn;\n\n  ngOnInit(): void {\n    this.sub.add(\n      this.service.atBottom$.subscribe((v) => {\n        this.atBottom = v;\n        this.cdr.markForCheck();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.sub.unsubscribe();\n  }\n\n  jump(): void {\n    this.service.scrollToBottom();\n  }\n}\n"]}

package/esm2022/lib/message-scroller.service.mjs

@@ -0,0 +1,157 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Scroll state for one `tolle-message-scroller`, shared with its viewport,
+ * items and buttons.
+ *
+ * The governing rule is: **never move the reader against their intent.** Every
+ * automatic scroll here is gated on the reader already being at the live edge.
+ * The moment they scroll up, auto-scroll switches off and stays off until they
+ * come back down or explicitly jump.
+ *
+ * Positions are read from and written to the DOM directly rather than mirrored
+ * into component state — scroll events fire far too often to run change
+ * detection on, and the values would be stale by the time they landed.
+ */
+export class MessageScrollerService {
+    /** The scrollable element, set by the viewport once it renders. */
+    viewport = null;
+    /** Rows registered as the start of a conversation turn, in DOM order. */
+    anchors = [];
+    atBottomSubject = new BehaviorSubject(true);
+    /** True while the reader is at (or within `threshold` of) the live edge. */
+    atBottom$ = this.atBottomSubject.asObservable();
+    followingSubject = new BehaviorSubject(true);
+    /**
+     * True while new content should pull the view along. Set false the instant
+     * the reader scrolls away from the bottom.
+     */
+    following$ = this.followingSubject.asObservable();
+    /** Distance from the bottom, in px, still considered "at the live edge". */
+    threshold = 32;
+    get atBottom() {
+        return this.atBottomSubject.value;
+    }
+    get isFollowing() {
+        return this.followingSubject.value;
+    }
+    registerViewport(el) {
+        this.viewport = el;
+    }
+    registerAnchor(el) {
+        if (!this.anchors.includes(el))
+            this.anchors.push(el);
+    }
+    unregisterAnchor(el) {
+        const i = this.anchors.indexOf(el);
+        if (i > -1)
+            this.anchors.splice(i, 1);
+    }
+    /**
+     * Recomputes whether we're at the live edge. Called from the viewport's
+     * scroll handler, which runs outside Angular — this only pushes through the
+     * subjects when the boolean actually flips, so we re-enter change detection
+     * once per state change instead of once per scroll event.
+     */
+    measure() {
+        const el = this.viewport;
+        if (!el)
+            return;
+        const distance = el.scrollHeight - el.scrollTop - el.clientHeight;
+        const atBottom = distance <= this.threshold;
+        if (atBottom !== this.atBottomSubject.value)
+            this.atBottomSubject.next(atBottom);
+        // Leaving the bottom stops following; returning resumes it. This is the
+        // whole "don't fight the reader" contract in two lines.
+        if (atBottom !== this.followingSubject.value)
+            this.followingSubject.next(atBottom);
+    }
+    /** Jumps to the live edge and resumes following. */
+    scrollToBottom(behavior = 'smooth') {
+        const el = this.viewport;
+        if (!el)
+            return;
+        el.scrollTo({ top: el.scrollHeight, behavior });
+        if (!this.followingSubject.value)
+            this.followingSubject.next(true);
+        if (!this.atBottomSubject.value)
+            this.atBottomSubject.next(true);
+    }
+    /** Scrolls a specific row into view, e.g. jump-to-message from a search result. */
+    scrollToItem(el, behavior = 'smooth') {
+        el.scrollIntoView({ behavior, block: 'start' });
+    }
+    /**
+     * Positions the transcript on open. `last-anchor` puts the newest turn at the
+     * top of the viewport instead of dumping the reader at the absolute end, so a
+     * long streamed answer starts from its beginning — with `peek` px of the
+     * previous turn left visible for context.
+     */
+    applyStartPosition(position, peek) {
+        const el = this.viewport;
+        if (!el)
+            return;
+        if (position === 'top') {
+            el.scrollTop = 0;
+            this.measure();
+            return;
+        }
+        if (position === 'last-anchor') {
+            const anchor = this.lastAnchorInDomOrder();
+            if (anchor) {
+                el.scrollTop = Math.max(0, anchor.offsetTop - el.offsetTop - peek);
+                this.measure();
+                return;
+            }
+            // No turns marked — fall through to the bottom.
+        }
+        el.scrollTop = el.scrollHeight;
+        this.measure();
+    }
+    /**
+     * Content grew. Follows only if the reader was already at the edge; uses
+     * 'auto' so streamed tokens don't queue a smooth animation per chunk.
+     */
+    handleContentGrowth() {
+        if (!this.followingSubject.value) {
+            // Not following, but the scrollbar just changed size — re-measure so the
+            // jump button's visibility stays honest.
+            this.measure();
+            return;
+        }
+        const el = this.viewport;
+        if (!el)
+            return;
+        el.scrollTop = el.scrollHeight;
+    }
+    /**
+     * History was prepended above the current view. Restores the reader's exact
+     * position by re-adding the height the new content introduced — otherwise the
+     * transcript visibly lurches downward as older messages load in.
+     */
+    preserveOnPrepend(previousScrollHeight) {
+        const el = this.viewport;
+        if (!el)
+            return;
+        const delta = el.scrollHeight - previousScrollHeight;
+        if (delta > 0)
+            el.scrollTop += delta;
+    }
+    /** Current scrollHeight, captured before a prepend so it can be compared after. */
+    snapshotScrollHeight() {
+        return this.viewport?.scrollHeight ?? 0;
+    }
+    /** The last registered anchor in document order (registration order can vary). */
+    lastAnchorInDomOrder() {
+        if (!this.anchors.length)
+            return undefined;
+        return [...this.anchors].sort((a, b) => a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1)[this.anchors.length - 1];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MessageScrollerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MessageScrollerService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MessageScrollerService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message-scroller.service.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/message-scroller.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\n\n/** Where a freshly-mounted scroller should start. */\nexport type ScrollStartPosition = 'top' | 'bottom' | 'last-anchor';\n\n/**\n * Scroll state for one `tolle-message-scroller`, shared with its viewport,\n * items and buttons.\n *\n * The governing rule is: **never move the reader against their intent.** Every\n * automatic scroll here is gated on the reader already being at the live edge.\n * The moment they scroll up, auto-scroll switches off and stays off until they\n * come back down or explicitly jump.\n *\n * Positions are read from and written to the DOM directly rather than mirrored\n * into component state — scroll events fire far too often to run change\n * detection on, and the values would be stale by the time they landed.\n */\n@Injectable()\nexport class MessageScrollerService {\n  /** The scrollable element, set by the viewport once it renders. */\n  private viewport: HTMLElement | null = null;\n\n  /** Rows registered as the start of a conversation turn, in DOM order. */\n  private anchors: HTMLElement[] = [];\n\n  private readonly atBottomSubject = new BehaviorSubject<boolean>(true);\n  /** True while the reader is at (or within `threshold` of) the live edge. */\n  readonly atBottom$ = this.atBottomSubject.asObservable();\n\n  private readonly followingSubject = new BehaviorSubject<boolean>(true);\n  /**\n   * True while new content should pull the view along. Set false the instant\n   * the reader scrolls away from the bottom.\n   */\n  readonly following$ = this.followingSubject.asObservable();\n\n  /** Distance from the bottom, in px, still considered \"at the live edge\". */\n  threshold = 32;\n\n  get atBottom(): boolean {\n    return this.atBottomSubject.value;\n  }\n\n  get isFollowing(): boolean {\n    return this.followingSubject.value;\n  }\n\n  registerViewport(el: HTMLElement): void {\n    this.viewport = el;\n  }\n\n  registerAnchor(el: HTMLElement): void {\n    if (!this.anchors.includes(el)) this.anchors.push(el);\n  }\n\n  unregisterAnchor(el: HTMLElement): void {\n    const i = this.anchors.indexOf(el);\n    if (i > -1) this.anchors.splice(i, 1);\n  }\n\n  /**\n   * Recomputes whether we're at the live edge. Called from the viewport's\n   * scroll handler, which runs outside Angular — this only pushes through the\n   * subjects when the boolean actually flips, so we re-enter change detection\n   * once per state change instead of once per scroll event.\n   */\n  measure(): void {\n    const el = this.viewport;\n    if (!el) return;\n\n    const distance = el.scrollHeight - el.scrollTop - el.clientHeight;\n    const atBottom = distance <= this.threshold;\n\n    if (atBottom !== this.atBottomSubject.value) this.atBottomSubject.next(atBottom);\n\n    // Leaving the bottom stops following; returning resumes it. This is the\n    // whole \"don't fight the reader\" contract in two lines.\n    if (atBottom !== this.followingSubject.value) this.followingSubject.next(atBottom);\n  }\n\n  /** Jumps to the live edge and resumes following. */\n  scrollToBottom(behavior: ScrollBehavior = 'smooth'): void {\n    const el = this.viewport;\n    if (!el) return;\n    el.scrollTo({ top: el.scrollHeight, behavior });\n    if (!this.followingSubject.value) this.followingSubject.next(true);\n    if (!this.atBottomSubject.value) this.atBottomSubject.next(true);\n  }\n\n  /** Scrolls a specific row into view, e.g. jump-to-message from a search result. */\n  scrollToItem(el: HTMLElement, behavior: ScrollBehavior = 'smooth'): void {\n    el.scrollIntoView({ behavior, block: 'start' });\n  }\n\n  /**\n   * Positions the transcript on open. `last-anchor` puts the newest turn at the\n   * top of the viewport instead of dumping the reader at the absolute end, so a\n   * long streamed answer starts from its beginning — with `peek` px of the\n   * previous turn left visible for context.\n   */\n  applyStartPosition(position: ScrollStartPosition, peek: number): void {\n    const el = this.viewport;\n    if (!el) return;\n\n    if (position === 'top') {\n      el.scrollTop = 0;\n      this.measure();\n      return;\n    }\n\n    if (position === 'last-anchor') {\n      const anchor = this.lastAnchorInDomOrder();\n      if (anchor) {\n        el.scrollTop = Math.max(0, anchor.offsetTop - el.offsetTop - peek);\n        this.measure();\n        return;\n      }\n      // No turns marked — fall through to the bottom.\n    }\n\n    el.scrollTop = el.scrollHeight;\n    this.measure();\n  }\n\n  /**\n   * Content grew. Follows only if the reader was already at the edge; uses\n   * 'auto' so streamed tokens don't queue a smooth animation per chunk.\n   */\n  handleContentGrowth(): void {\n    if (!this.followingSubject.value) {\n      // Not following, but the scrollbar just changed size — re-measure so the\n      // jump button's visibility stays honest.\n      this.measure();\n      return;\n    }\n    const el = this.viewport;\n    if (!el) return;\n    el.scrollTop = el.scrollHeight;\n  }\n\n  /**\n   * History was prepended above the current view. Restores the reader's exact\n   * position by re-adding the height the new content introduced — otherwise the\n   * transcript visibly lurches downward as older messages load in.\n   */\n  preserveOnPrepend(previousScrollHeight: number): void {\n    const el = this.viewport;\n    if (!el) return;\n    const delta = el.scrollHeight - previousScrollHeight;\n    if (delta > 0) el.scrollTop += delta;\n  }\n\n  /** Current scrollHeight, captured before a prepend so it can be compared after. */\n  snapshotScrollHeight(): number {\n    return this.viewport?.scrollHeight ?? 0;\n  }\n\n  /** The last registered anchor in document order (registration order can vary). */\n  private lastAnchorInDomOrder(): HTMLElement | undefined {\n    if (!this.anchors.length) return undefined;\n    return [...this.anchors].sort((a, b) =>\n      a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1\n    )[this.anchors.length - 1];\n  }\n}\n"]}