@copilotkitnext/angular 0.0.2 → 0.0.5

package/dist/esm2022/components/chat/copilot-chat-view-scroll-to-bottom-button.component.mjs

@@ -0,0 +1,93 @@
+import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy, ViewEncapsulation } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { LucideAngularModule, ChevronDown } from 'lucide-angular';
+import { cn } from '../../lib/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "lucide-angular";
+/**
+ * ScrollToBottomButton component for CopilotChatView
+ * Matches React implementation exactly with same Tailwind classes
+ */
+export class CopilotChatViewScrollToBottomButtonComponent {
+    inputClass;
+    disabled = false;
+    // Support function-style click handler via slot context
+    onClick;
+    // Simple, idiomatic Angular output
+    clicked = new EventEmitter();
+    // Icon reference
+    ChevronDown = ChevronDown;
+    // Computed class matching React exactly
+    get computedClass() {
+        return cn(
+        // Base button styles
+        'rounded-full w-10 h-10 p-0', 
+        // Background colors
+        'bg-white dark:bg-gray-900', 
+        // Border and shadow
+        'shadow-lg border border-gray-200 dark:border-gray-700', 
+        // Hover states
+        'hover:bg-gray-50 dark:hover:bg-gray-800', 
+        // Layout
+        'flex items-center justify-center cursor-pointer', 
+        // Transition
+        'transition-colors', 
+        // Focus states
+        'focus:outline-none focus-visible:ring-2 focus-visible:ring-offset-2', 
+        // Custom classes
+        this.inputClass);
+    }
+    handleClick() {
+        if (!this.disabled) {
+            // Call input handler if provided (slot-style)
+            if (this.onClick) {
+                this.onClick();
+            }
+            this.clicked.emit();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotChatViewScrollToBottomButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: CopilotChatViewScrollToBottomButtonComponent, isStandalone: true, selector: "copilot-chat-view-scroll-to-bottom-button", inputs: { inputClass: "inputClass", disabled: "disabled", onClick: "onClick" }, outputs: { clicked: "clicked" }, ngImport: i0, template: `
+    <button
+      type="button"
+      [class]="computedClass"
+      [disabled]="disabled"
+      (click)="handleClick()">
+      <lucide-angular
+        [img]="ChevronDown"
+        class="w-4 h-4 text-gray-600 dark:text-white">
+      </lucide-angular>
+    </button>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: LucideAngularModule }, { kind: "component", type: i1.LucideAngularComponent, selector: "lucide-angular, lucide-icon, i-lucide, span-lucide", inputs: ["class", "name", "img", "color", "absoluteStrokeWidth", "size", "strokeWidth"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotChatViewScrollToBottomButtonComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'copilot-chat-view-scroll-to-bottom-button',
+                    standalone: true,
+                    imports: [CommonModule, LucideAngularModule],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    template: `
+    <button
+      type="button"
+      [class]="computedClass"
+      [disabled]="disabled"
+      (click)="handleClick()">
+      <lucide-angular
+        [img]="ChevronDown"
+        class="w-4 h-4 text-gray-600 dark:text-white">
+      </lucide-angular>
+    </button>
+  `
+                }]
+        }], propDecorators: { inputClass: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], onClick: [{
+                type: Input
+            }], clicked: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/components/chat/copilot-chat-view-scroll-view.component.mjs

@@ -0,0 +1,443 @@
+import { Component, Input, Output, EventEmitter, ViewChild, ElementRef, ChangeDetectionStrategy, ViewEncapsulation, signal, computed, inject, PLATFORM_ID, ChangeDetectorRef } from '@angular/core';
+import { CommonModule, isPlatformBrowser } from '@angular/common';
+import { ScrollingModule } from '@angular/cdk/scrolling';
+import { CopilotSlotComponent } from '../../lib/slots/copilot-slot.component';
+import { CopilotChatMessageViewComponent } from './copilot-chat-message-view.component';
+import { CopilotChatViewScrollToBottomButtonComponent } from './copilot-chat-view-scroll-to-bottom-button.component';
+import { StickToBottomDirective } from '../../directives/stick-to-bottom.directive';
+import { ScrollPositionService } from '../../services/scroll-position.service';
+import { cn } from '../../lib/utils';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/scrolling";
+/**
+ * ScrollView component for CopilotChatView
+ * Handles auto-scrolling and scroll position management
+ */
+export class CopilotChatViewScrollViewComponent {
+    cdr = inject(ChangeDetectorRef);
+    autoScroll = true;
+    _inputContainerHeight = 0;
+    set inputContainerHeight(value) {
+        this._inputContainerHeight = value;
+        this.inputContainerHeightSignal.set(value);
+        this.cdr.markForCheck();
+    }
+    get inputContainerHeight() {
+        return this._inputContainerHeight;
+    }
+    isResizing = false;
+    inputClass;
+    messages = [];
+    messageView;
+    messageViewClass;
+    showCursor = false;
+    // Handler availability flags removed in favor of DI service
+    // Slot inputs
+    scrollToBottomButton;
+    scrollToBottomButtonClass;
+    // Output events (bubbled from message view)
+    assistantMessageThumbsUp = new EventEmitter();
+    assistantMessageThumbsDown = new EventEmitter();
+    assistantMessageReadAloud = new EventEmitter();
+    assistantMessageRegenerate = new EventEmitter();
+    userMessageCopy = new EventEmitter();
+    userMessageEdit = new EventEmitter();
+    // ViewChild references
+    scrollContainer;
+    contentContainer;
+    stickToBottomDirective;
+    // Default components
+    defaultMessageViewComponent = CopilotChatMessageViewComponent;
+    defaultScrollToBottomButtonComponent = CopilotChatViewScrollToBottomButtonComponent;
+    // Signals
+    hasMounted = signal(false);
+    showScrollButton = signal(false);
+    isAtBottom = signal(true);
+    inputContainerHeightSignal = signal(0);
+    paddingBottom = computed(() => this.inputContainerHeightSignal() + 32);
+    // Computed class
+    computedClass = computed(() => cn(this.inputClass));
+    destroy$ = new Subject();
+    platformId = inject(PLATFORM_ID);
+    scrollPositionService = inject(ScrollPositionService);
+    ngOnInit() {
+        // Check if we're in the browser
+        if (isPlatformBrowser(this.platformId)) {
+            // Set mounted after a tick to allow for hydration
+            setTimeout(() => {
+                this.hasMounted.set(true);
+            }, 0);
+        }
+    }
+    ngOnChanges() {
+        // Update signals when inputs change
+        // Force change detection when inputContainerHeight changes
+        if (this.inputContainerHeight !== undefined) {
+            this.cdr.detectChanges();
+        }
+    }
+    ngAfterViewInit() {
+        if (!this.autoScroll) {
+            // Wait for the view to be fully rendered after hasMounted is set
+            setTimeout(() => {
+                if (this.scrollContainer) {
+                    // Check initial scroll position
+                    const initialState = this.scrollPositionService.getScrollState(this.scrollContainer.nativeElement, 10);
+                    this.showScrollButton.set(!initialState.isAtBottom);
+                    // Monitor scroll position for manual mode
+                    this.scrollPositionService.monitorScrollPosition(this.scrollContainer, 10)
+                        .pipe(takeUntil(this.destroy$))
+                        .subscribe(state => {
+                        this.showScrollButton.set(!state.isAtBottom);
+                    });
+                }
+            }, 100);
+        }
+    }
+    /**
+     * Handle isAtBottom change from StickToBottom directive
+     */
+    onIsAtBottomChange(isAtBottom) {
+        this.isAtBottom.set(isAtBottom);
+    }
+    /**
+     * Scroll to bottom for manual mode
+     */
+    scrollToBottom() {
+        if (this.scrollContainer) {
+            this.scrollPositionService.scrollToBottom(this.scrollContainer, true);
+        }
+    }
+    /**
+     * Scroll to bottom for stick-to-bottom mode
+     */
+    scrollToBottomFromStick() {
+        if (this.stickToBottomDirective) {
+            this.stickToBottomDirective.scrollToBottom('smooth');
+        }
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    // Output maps for slots
+    scrollToBottomOutputs = { clicked: () => this.scrollToBottom() };
+    scrollToBottomFromStickOutputs = { clicked: () => this.scrollToBottomFromStick() };
+    // Context methods for templates
+    messageViewContext() {
+        return { messages: this.messages, inputClass: this.messageViewClass, showCursor: this.showCursor };
+    }
+    scrollToBottomContext() {
+        return {
+            inputClass: this.scrollToBottomButtonClass,
+            onClick: () => this.scrollToBottom()
+        };
+    }
+    scrollToBottomFromStickContext() {
+        return {
+            inputClass: this.scrollToBottomButtonClass,
+            onClick: () => this.scrollToBottomFromStick()
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotChatViewScrollViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: CopilotChatViewScrollViewComponent, isStandalone: true, selector: "copilot-chat-view-scroll-view", inputs: { autoScroll: "autoScroll", inputContainerHeight: "inputContainerHeight", isResizing: "isResizing", inputClass: "inputClass", messages: "messages", messageView: "messageView", messageViewClass: "messageViewClass", showCursor: "showCursor", scrollToBottomButton: "scrollToBottomButton", scrollToBottomButtonClass: "scrollToBottomButtonClass" }, outputs: { assistantMessageThumbsUp: "assistantMessageThumbsUp", assistantMessageThumbsDown: "assistantMessageThumbsDown", assistantMessageReadAloud: "assistantMessageReadAloud", assistantMessageRegenerate: "assistantMessageRegenerate", userMessageCopy: "userMessageCopy", userMessageEdit: "userMessageEdit" }, providers: [ScrollPositionService], viewQueries: [{ propertyName: "scrollContainer", first: true, predicate: ["scrollContainer"], descendants: true, read: ElementRef }, { propertyName: "contentContainer", first: true, predicate: ["contentContainer"], descendants: true, read: ElementRef }, { propertyName: "stickToBottomDirective", first: true, predicate: StickToBottomDirective, descendants: true }], usesOnChanges: true, ngImport: i0, template: `
+    @if (!hasMounted()) {
+      <!-- SSR/Initial render without stick-to-bottom -->
+      <div class="h-full max-h-full flex flex-col min-h-0 overflow-y-scroll overflow-x-hidden">
+        <div class="px-4 sm:px-0">
+          <ng-content></ng-content>
+        </div>
+      </div>
+    } @else if (!autoScroll) {
+      <!-- Manual scroll mode -->
+      <div class="h-full max-h-full flex flex-col min-h-0 relative">
+        <div 
+          #scrollContainer
+          cdkScrollable
+          [class]="computedClass()"
+          class="overflow-y-scroll overflow-x-hidden">
+          <div #contentContainer class="px-4 sm:px-0">
+            <!-- Content with padding-bottom matching React -->
+            <div [style.padding-bottom.px]="paddingBottom()">
+              <div class="max-w-3xl mx-auto">
+                @if (messageView) {
+                  <copilot-slot
+                    [slot]="messageView"
+                    [context]="messageViewContext()"
+                    [defaultComponent]="defaultMessageViewComponent">
+                  </copilot-slot>
+                } @else {
+                  <copilot-chat-message-view
+                    [messages]="messages"
+                    [inputClass]="messageViewClass"
+                    [showCursor]="showCursor"
+                    (assistantMessageThumbsUp)="assistantMessageThumbsUp.emit($event)"
+                    (assistantMessageThumbsDown)="assistantMessageThumbsDown.emit($event)"
+                    (assistantMessageReadAloud)="assistantMessageReadAloud.emit($event)"
+                    (assistantMessageRegenerate)="assistantMessageRegenerate.emit($event)"
+                    (userMessageCopy)="userMessageCopy.emit($event)"
+                    (userMessageEdit)="userMessageEdit.emit($event)">
+                  </copilot-chat-message-view>
+                }
+              </div>
+            </div>
+          </div>
+        </div>
+        
+        <!-- Scroll to bottom button for manual mode, OUTSIDE scrollable content -->
+        @if (showScrollButton() && !isResizing) {
+          <div
+            class="absolute inset-x-0 flex justify-center z-30"
+            [style.bottom.px]="inputContainerHeightSignal() + 16">
+            <copilot-slot
+              [slot]="scrollToBottomButton"
+              [context]="scrollToBottomContext()"
+              [defaultComponent]="defaultScrollToBottomButtonComponent"
+              [outputs]="scrollToBottomOutputs">
+            </copilot-slot>
+          </div>
+        }
+      </div>
+    } @else {
+      <!-- Auto-scroll mode with StickToBottom directive -->
+      <div class="h-full max-h-full flex flex-col min-h-0 relative">
+        <div 
+          #scrollContainer
+          cdkScrollable
+          copilotStickToBottom
+          [enabled]="autoScroll"
+          [threshold]="10"
+          [debounceMs]="0"
+          [initialBehavior]="'smooth'"
+          [resizeBehavior]="'smooth'"
+          (isAtBottomChange)="onIsAtBottomChange($event)"
+          [class]="computedClass()"
+          class="overflow-y-scroll overflow-x-hidden">
+          
+          <!-- Scrollable content wrapper -->
+          <div class="px-4 sm:px-0">
+            <!-- Content with padding-bottom matching React -->
+            <div [style.padding-bottom.px]="paddingBottom()">
+              <div class="max-w-3xl mx-auto">
+                @if (messageView) {
+                  <copilot-slot
+                    [slot]="messageView"
+                    [context]="messageViewContext()"
+                    [defaultComponent]="defaultMessageViewComponent">
+                  </copilot-slot>
+                } @else {
+                  <copilot-chat-message-view
+                    [messages]="messages"
+                    [inputClass]="messageViewClass"
+                    [showCursor]="showCursor"
+                    (assistantMessageThumbsUp)="assistantMessageThumbsUp.emit($event)"
+                    (assistantMessageThumbsDown)="assistantMessageThumbsDown.emit($event)"
+                    (assistantMessageReadAloud)="assistantMessageReadAloud.emit($event)"
+                    (assistantMessageRegenerate)="assistantMessageRegenerate.emit($event)"
+                    (userMessageCopy)="userMessageCopy.emit($event)"
+                    (userMessageEdit)="userMessageEdit.emit($event)">
+                  </copilot-chat-message-view>
+                }
+              </div>
+            </div>
+          </div>
+        </div>
+        
+        <!-- Scroll to bottom button - hidden during resize, OUTSIDE scrollable content -->
+        @if (!isAtBottom() && !isResizing) {
+          <div
+            class="absolute inset-x-0 flex justify-center z-30"
+            [style.bottom.px]="inputContainerHeightSignal() + 16">
+            <copilot-slot
+              [slot]="scrollToBottomButton"
+              [context]="scrollToBottomFromStickContext()"
+              [defaultComponent]="defaultScrollToBottomButtonComponent"
+              [outputs]="scrollToBottomFromStickOutputs">
+            </copilot-slot>
+          </div>
+        }
+      </div>
+    }
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ScrollingModule }, { kind: "directive", type: i1.CdkScrollable, selector: "[cdk-scrollable], [cdkScrollable]" }, { kind: "component", type: CopilotSlotComponent, selector: "copilot-slot", inputs: ["slot", "context", "defaultComponent", "outputs"] }, { kind: "component", type: CopilotChatMessageViewComponent, selector: "copilot-chat-message-view", inputs: ["messages", "showCursor", "isLoading", "inputClass", "assistantMessageComponent", "assistantMessageTemplate", "assistantMessageClass", "userMessageComponent", "userMessageTemplate", "userMessageClass", "cursorComponent", "cursorTemplate", "cursorClass"], outputs: ["assistantMessageThumbsUp", "assistantMessageThumbsDown", "assistantMessageReadAloud", "assistantMessageRegenerate", "userMessageCopy", "userMessageEdit"] }, { kind: "directive", type: StickToBottomDirective, selector: "[copilotStickToBottom]", inputs: ["enabled", "threshold", "initialBehavior", "resizeBehavior", "debounceMs"], outputs: ["isAtBottomChange", "scrollToBottomRequested"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotChatViewScrollViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'copilot-chat-view-scroll-view',
+                    standalone: true,
+                    imports: [
+                        CommonModule,
+                        ScrollingModule,
+                        CopilotSlotComponent,
+                        CopilotChatMessageViewComponent,
+                        CopilotChatViewScrollToBottomButtonComponent,
+                        StickToBottomDirective
+                    ],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    providers: [ScrollPositionService],
+                    template: `
+    @if (!hasMounted()) {
+      <!-- SSR/Initial render without stick-to-bottom -->
+      <div class="h-full max-h-full flex flex-col min-h-0 overflow-y-scroll overflow-x-hidden">
+        <div class="px-4 sm:px-0">
+          <ng-content></ng-content>
+        </div>
+      </div>
+    } @else if (!autoScroll) {
+      <!-- Manual scroll mode -->
+      <div class="h-full max-h-full flex flex-col min-h-0 relative">
+        <div 
+          #scrollContainer
+          cdkScrollable
+          [class]="computedClass()"
+          class="overflow-y-scroll overflow-x-hidden">
+          <div #contentContainer class="px-4 sm:px-0">
+            <!-- Content with padding-bottom matching React -->
+            <div [style.padding-bottom.px]="paddingBottom()">
+              <div class="max-w-3xl mx-auto">
+                @if (messageView) {
+                  <copilot-slot
+                    [slot]="messageView"
+                    [context]="messageViewContext()"
+                    [defaultComponent]="defaultMessageViewComponent">
+                  </copilot-slot>
+                } @else {
+                  <copilot-chat-message-view
+                    [messages]="messages"
+                    [inputClass]="messageViewClass"
+                    [showCursor]="showCursor"
+                    (assistantMessageThumbsUp)="assistantMessageThumbsUp.emit($event)"
+                    (assistantMessageThumbsDown)="assistantMessageThumbsDown.emit($event)"
+                    (assistantMessageReadAloud)="assistantMessageReadAloud.emit($event)"
+                    (assistantMessageRegenerate)="assistantMessageRegenerate.emit($event)"
+                    (userMessageCopy)="userMessageCopy.emit($event)"
+                    (userMessageEdit)="userMessageEdit.emit($event)">
+                  </copilot-chat-message-view>
+                }
+              </div>
+            </div>
+          </div>
+        </div>
+        
+        <!-- Scroll to bottom button for manual mode, OUTSIDE scrollable content -->
+        @if (showScrollButton() && !isResizing) {
+          <div
+            class="absolute inset-x-0 flex justify-center z-30"
+            [style.bottom.px]="inputContainerHeightSignal() + 16">
+            <copilot-slot
+              [slot]="scrollToBottomButton"
+              [context]="scrollToBottomContext()"
+              [defaultComponent]="defaultScrollToBottomButtonComponent"
+              [outputs]="scrollToBottomOutputs">
+            </copilot-slot>
+          </div>
+        }
+      </div>
+    } @else {
+      <!-- Auto-scroll mode with StickToBottom directive -->
+      <div class="h-full max-h-full flex flex-col min-h-0 relative">
+        <div 
+          #scrollContainer
+          cdkScrollable
+          copilotStickToBottom
+          [enabled]="autoScroll"
+          [threshold]="10"
+          [debounceMs]="0"
+          [initialBehavior]="'smooth'"
+          [resizeBehavior]="'smooth'"
+          (isAtBottomChange)="onIsAtBottomChange($event)"
+          [class]="computedClass()"
+          class="overflow-y-scroll overflow-x-hidden">
+          
+          <!-- Scrollable content wrapper -->
+          <div class="px-4 sm:px-0">
+            <!-- Content with padding-bottom matching React -->
+            <div [style.padding-bottom.px]="paddingBottom()">
+              <div class="max-w-3xl mx-auto">
+                @if (messageView) {
+                  <copilot-slot
+                    [slot]="messageView"
+                    [context]="messageViewContext()"
+                    [defaultComponent]="defaultMessageViewComponent">
+                  </copilot-slot>
+                } @else {
+                  <copilot-chat-message-view
+                    [messages]="messages"
+                    [inputClass]="messageViewClass"
+                    [showCursor]="showCursor"
+                    (assistantMessageThumbsUp)="assistantMessageThumbsUp.emit($event)"
+                    (assistantMessageThumbsDown)="assistantMessageThumbsDown.emit($event)"
+                    (assistantMessageReadAloud)="assistantMessageReadAloud.emit($event)"
+                    (assistantMessageRegenerate)="assistantMessageRegenerate.emit($event)"
+                    (userMessageCopy)="userMessageCopy.emit($event)"
+                    (userMessageEdit)="userMessageEdit.emit($event)">
+                  </copilot-chat-message-view>
+                }
+              </div>
+            </div>
+          </div>
+        </div>
+        
+        <!-- Scroll to bottom button - hidden during resize, OUTSIDE scrollable content -->
+        @if (!isAtBottom() && !isResizing) {
+          <div
+            class="absolute inset-x-0 flex justify-center z-30"
+            [style.bottom.px]="inputContainerHeightSignal() + 16">
+            <copilot-slot
+              [slot]="scrollToBottomButton"
+              [context]="scrollToBottomFromStickContext()"
+              [defaultComponent]="defaultScrollToBottomButtonComponent"
+              [outputs]="scrollToBottomFromStickOutputs">
+            </copilot-slot>
+          </div>
+        }
+      </div>
+    }
+  `
+                }]
+        }], propDecorators: { autoScroll: [{
+                type: Input
+            }], inputContainerHeight: [{
+                type: Input
+            }], isResizing: [{
+                type: Input
+            }], inputClass: [{
+                type: Input
+            }], messages: [{
+                type: Input
+            }], messageView: [{
+                type: Input
+            }], messageViewClass: [{
+                type: Input
+            }], showCursor: [{
+                type: Input
+            }], scrollToBottomButton: [{
+                type: Input
+            }], scrollToBottomButtonClass: [{
+                type: Input
+            }], assistantMessageThumbsUp: [{
+                type: Output
+            }], assistantMessageThumbsDown: [{
+                type: Output
+            }], assistantMessageReadAloud: [{
+                type: Output
+            }], assistantMessageRegenerate: [{
+                type: Output
+            }], userMessageCopy: [{
+                type: Output
+            }], userMessageEdit: [{
+                type: Output
+            }], scrollContainer: [{
+                type: ViewChild,
+                args: ['scrollContainer', { read: ElementRef }]
+            }], contentContainer: [{
+                type: ViewChild,
+                args: ['contentContainer', { read: ElementRef }]
+            }], stickToBottomDirective: [{
+                type: ViewChild,
+                args: [StickToBottomDirective]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"copilot-chat-view-scroll-view.component.js","sourceRoot":"","sources":["../../../../src/components/chat/copilot-chat-view-scroll-view.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,KAAK,EACL,MAAM,EACN,YAAY,EACZ,SAAS,EACT,UAAU,EACV,uBAAuB,EACvB,iBAAiB,EACjB,MAAM,EACN,QAAQ,EAKR,MAAM,EACN,WAAW,EACX,iBAAiB,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,EAAiB,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AAC9E,OAAO,EAAE,+BAA+B,EAAE,MAAM,uCAAuC,CAAC;AACxF,OAAO,EAAE,4CAA4C,EAAE,MAAM,uDAAuD,CAAC;AACrH,OAAO,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AACpF,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAE/E,OAAO,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;;;AAE3C;;;GAGG;AAuIH,MAAM,OAAO,kCAAkC;IACrC,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;IAE/B,UAAU,GAAY,IAAI,CAAC;IAE5B,qBAAqB,GAAW,CAAC,CAAC;IAC1C,IACI,oBAAoB,CAAC,KAAa;QACpC,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;QACnC,IAAI,CAAC,0BAA0B,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAC3C,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;IAC1B,CAAC;IACD,IAAI,oBAAoB;QACtB,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACpC,CAAC;IAEQ,UAAU,GAAY,KAAK,CAAC;IAC5B,UAAU,CAAU;IACpB,QAAQ,GAAc,EAAE,CAAC;IACzB,WAAW,CAAO;IAClB,gBAAgB,CAAU;IAC1B,UAAU,GAAY,KAAK,CAAC;IAErC,4DAA4D;IAE5D,cAAc;IACL,oBAAoB,CAAO;IAC3B,yBAAyB,CAAU;IAE5C,4CAA4C;IAClC,wBAAwB,GAAG,IAAI,YAAY,EAAwB,CAAC;IACpE,0BAA0B,GAAG,IAAI,YAAY,EAAwB,CAAC;IACtE,yBAAyB,GAAG,IAAI,YAAY,EAAwB,CAAC;IACrE,0BAA0B,GAAG,IAAI,YAAY,EAAwB,CAAC;IACtE,eAAe,GAAG,IAAI,YAAY,EAAwB,CAAC;IAC3D,eAAe,GAAG,IAAI,YAAY,EAAwB,CAAC;IAErE,uBAAuB;IAC6B,eAAe,CAA2B;IACzC,gBAAgB,CAA2B;IAC7D,sBAAsB,CAA0B;IAEnF,qBAAqB;IACF,2BAA2B,GAAG,+BAA+B,CAAC;IAC9D,oCAAoC,GAAG,4CAA4C,CAAC;IAEvG,UAAU;IACA,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC3B,gBAAgB,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IACjC,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAC1B,0BAA0B,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACvC,aAAa,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,0BAA0B,EAAE,GAAG,EAAE,CAAC,CAAC;IAEjF,iBAAiB;IACP,aAAa,GAAG,QAAQ,CAAC,GAAG,EAAE,CACtC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CACpB,CAAC;IAEM,QAAQ,GAAG,IAAI,OAAO,EAAQ,CAAC;IAC/B,UAAU,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;IACjC,qBAAqB,GAAG,MAAM,CAAC,qBAAqB,CAAC,CAAC;IAE9D,QAAQ;QACN,gCAAgC;QAChC,IAAI,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YACvC,kDAAkD;YAClD,UAAU,CAAC,GAAG,EAAE;gBACd,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAC5B,CAAC,EAAE,CAAC,CAAC,CAAC;QACR,CAAC;IACH,CAAC;IAED,WAAW;QACT,oCAAoC;QACpC,2DAA2D;QAC3D,IAAI,IAAI,CAAC,oBAAoB,KAAK,SAAS,EAAE,CAAC;YAC5C,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC;QAC3B,CAAC;IACH,CAAC;IAED,eAAe;QACb,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,iEAAiE;YACjE,UAAU,CAAC,GAAG,EAAE;gBACd,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;oBACzB,gCAAgC;oBAChC,MAAM,YAAY,GAAG,IAAI,CAAC,qBAAqB,CAAC,cAAc,CAAC,IAAI,CAAC,eAAe,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC;oBACvG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;oBAEpD,0CAA0C;oBAC1C,IAAI,CAAC,qBAAqB,CAAC,qBAAqB,CAAC,IAAI,CAAC,eAAe,EAAE,EAAE,CAAC;yBACvE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;yBAC9B,SAAS,CAAC,KAAK,CAAC,EAAE;wBACjB,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;oBAC/C,CAAC,CAAC,CAAC;gBACP,CAAC;YACH,CAAC,EAAE,GAAG,CAAC,CAAC;QACV,CAAC;IACH,CAAC;IAED;;OAEG;IACH,kBAAkB,CAAC,UAAmB;QACpC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,IAAI,CAAC,qBAAqB,CAAC,cAAc,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC;QACxE,CAAC;IACH,CAAC;IAED;;OAEG;IACH,uBAAuB;QACrB,IAAI,IAAI,CAAC,sBAAsB,EAAE,CAAC;YAChC,IAAI,CAAC,sBAAsB,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;QACvD,CAAC;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACrB,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAED,wBAAwB;IACxB,qBAAqB,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;IACjE,8BAA8B,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,uBAAuB,EAAE,EAAE,CAAC;IAEnF,gCAAgC;IAChC,kBAAkB;QAChB,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,IAAI,CAAC,gBAAgB,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,CAAC;IACrG,CAAC;IAED,qBAAqB;QACnB,OAAO;YACL,UAAU,EAAE,IAAI,CAAC,yBAAyB;YAC1C,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,EAAE;SACrC,CAAC;IACJ,CAAC;IAED,8BAA8B;QAC5B,OAAO;YACL,UAAU,EAAE,IAAI,CAAC,yBAAyB;YAC1C,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,uBAAuB,EAAE;SAC9C,CAAC;IACJ,CAAC;wGAvJU,kCAAkC;4FAAlC,kCAAkC,muBAzHlC,CAAC,qBAAqB,CAAC,yHA+JI,UAAU,+GACT,UAAU,sEACtC,sBAAsB,qEAhKvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsHT,2DAhIC,YAAY,8BACZ,eAAe,6HACf,oBAAoB,qHACpB,+BAA+B,ofAE/B,sBAAsB;;4FA6Hb,kCAAkC;kBAtI9C,SAAS;mBAAC;oBACT,QAAQ,EAAE,+BAA+B;oBACzC,UAAU,EAAE,IAAI;oBAChB,OAAO,EAAE;wBACP,YAAY;wBACZ,eAAe;wBACf,oBAAoB;wBACpB,+BAA+B;wBAC/B,4CAA4C;wBAC5C,sBAAsB;qBACvB;oBACD,eAAe,EAAE,uBAAuB,CAAC,MAAM;oBAC/C,aAAa,EAAE,iBAAiB,CAAC,IAAI;oBACrC,SAAS,EAAE,CAAC,qBAAqB,CAAC;oBAClC,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsHT;iBACF;8BAIU,UAAU;sBAAlB,KAAK;gBAIF,oBAAoB;sBADvB,KAAK;gBAUG,UAAU;sBAAlB,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBACG,WAAW;sBAAnB,KAAK;gBACG,gBAAgB;sBAAxB,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBAKG,oBAAoB;sBAA5B,KAAK;gBACG,yBAAyB;sBAAjC,KAAK;gBAGI,wBAAwB;sBAAjC,MAAM;gBACG,0BAA0B;sBAAnC,MAAM;gBACG,yBAAyB;sBAAlC,MAAM;gBACG,0BAA0B;sBAAnC,MAAM;gBACG,eAAe;sBAAxB,MAAM;gBACG,eAAe;sBAAxB,MAAM;gBAG6C,eAAe;sBAAlE,SAAS;uBAAC,iBAAiB,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE;gBACG,gBAAgB;sBAApE,SAAS;uBAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE;gBAChB,sBAAsB;sBAAxD,SAAS;uBAAC,sBAAsB","sourcesContent":["import {\n  Component,\n  Input,\n  Output,\n  EventEmitter,\n  ViewChild,\n  ElementRef,\n  ChangeDetectionStrategy,\n  ViewEncapsulation,\n  signal,\n  computed,\n  OnInit,\n  OnChanges,\n  AfterViewInit,\n  OnDestroy,\n  inject,\n  PLATFORM_ID,\n  ChangeDetectorRef\n} from '@angular/core';\nimport { CommonModule, isPlatformBrowser } from '@angular/common';\nimport { CdkScrollable, ScrollingModule } from '@angular/cdk/scrolling';\nimport { CopilotSlotComponent } from '../../lib/slots/copilot-slot.component';\nimport { CopilotChatMessageViewComponent } from './copilot-chat-message-view.component';\nimport { CopilotChatViewScrollToBottomButtonComponent } from './copilot-chat-view-scroll-to-bottom-button.component';\nimport { StickToBottomDirective } from '../../directives/stick-to-bottom.directive';\nimport { ScrollPositionService } from '../../services/scroll-position.service';\nimport { Message } from '@ag-ui/client';\nimport { cn } from '../../lib/utils';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\n/**\n * ScrollView component for CopilotChatView\n * Handles auto-scrolling and scroll position management\n */\n@Component({\n  selector: 'copilot-chat-view-scroll-view',\n  standalone: true,\n  imports: [\n    CommonModule,\n    ScrollingModule,\n    CopilotSlotComponent,\n    CopilotChatMessageViewComponent,\n    CopilotChatViewScrollToBottomButtonComponent,\n    StickToBottomDirective\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  providers: [ScrollPositionService],\n  template: `\n    @if (!hasMounted()) {\n      <!-- SSR/Initial render without stick-to-bottom -->\n      <div class=\"h-full max-h-full flex flex-col min-h-0 overflow-y-scroll overflow-x-hidden\">\n        <div class=\"px-4 sm:px-0\">\n          <ng-content></ng-content>\n        </div>\n      </div>\n    } @else if (!autoScroll) {\n      <!-- Manual scroll mode -->\n      <div class=\"h-full max-h-full flex flex-col min-h-0 relative\">\n        <div \n          #scrollContainer\n          cdkScrollable\n          [class]=\"computedClass()\"\n          class=\"overflow-y-scroll overflow-x-hidden\">\n          <div #contentContainer class=\"px-4 sm:px-0\">\n            <!-- Content with padding-bottom matching React -->\n            <div [style.padding-bottom.px]=\"paddingBottom()\">\n              <div class=\"max-w-3xl mx-auto\">\n                @if (messageView) {\n                  <copilot-slot\n                    [slot]=\"messageView\"\n                    [context]=\"messageViewContext()\"\n                    [defaultComponent]=\"defaultMessageViewComponent\">\n                  </copilot-slot>\n                } @else {\n                  <copilot-chat-message-view\n                    [messages]=\"messages\"\n                    [inputClass]=\"messageViewClass\"\n                    [showCursor]=\"showCursor\"\n                    (assistantMessageThumbsUp)=\"assistantMessageThumbsUp.emit($event)\"\n                    (assistantMessageThumbsDown)=\"assistantMessageThumbsDown.emit($event)\"\n                    (assistantMessageReadAloud)=\"assistantMessageReadAloud.emit($event)\"\n                    (assistantMessageRegenerate)=\"assistantMessageRegenerate.emit($event)\"\n                    (userMessageCopy)=\"userMessageCopy.emit($event)\"\n                    (userMessageEdit)=\"userMessageEdit.emit($event)\">\n                  </copilot-chat-message-view>\n                }\n              </div>\n            </div>\n          </div>\n        </div>\n        \n        <!-- Scroll to bottom button for manual mode, OUTSIDE scrollable content -->\n        @if (showScrollButton() && !isResizing) {\n          <div\n            class=\"absolute inset-x-0 flex justify-center z-30\"\n            [style.bottom.px]=\"inputContainerHeightSignal() + 16\">\n            <copilot-slot\n              [slot]=\"scrollToBottomButton\"\n              [context]=\"scrollToBottomContext()\"\n              [defaultComponent]=\"defaultScrollToBottomButtonComponent\"\n              [outputs]=\"scrollToBottomOutputs\">\n            </copilot-slot>\n          </div>\n        }\n      </div>\n    } @else {\n      <!-- Auto-scroll mode with StickToBottom directive -->\n      <div class=\"h-full max-h-full flex flex-col min-h-0 relative\">\n        <div \n          #scrollContainer\n          cdkScrollable\n          copilotStickToBottom\n          [enabled]=\"autoScroll\"\n          [threshold]=\"10\"\n          [debounceMs]=\"0\"\n          [initialBehavior]=\"'smooth'\"\n          [resizeBehavior]=\"'smooth'\"\n          (isAtBottomChange)=\"onIsAtBottomChange($event)\"\n          [class]=\"computedClass()\"\n          class=\"overflow-y-scroll overflow-x-hidden\">\n          \n          <!-- Scrollable content wrapper -->\n          <div class=\"px-4 sm:px-0\">\n            <!-- Content with padding-bottom matching React -->\n            <div [style.padding-bottom.px]=\"paddingBottom()\">\n              <div class=\"max-w-3xl mx-auto\">\n                @if (messageView) {\n                  <copilot-slot\n                    [slot]=\"messageView\"\n                    [context]=\"messageViewContext()\"\n                    [defaultComponent]=\"defaultMessageViewComponent\">\n                  </copilot-slot>\n                } @else {\n                  <copilot-chat-message-view\n                    [messages]=\"messages\"\n                    [inputClass]=\"messageViewClass\"\n                    [showCursor]=\"showCursor\"\n                    (assistantMessageThumbsUp)=\"assistantMessageThumbsUp.emit($event)\"\n                    (assistantMessageThumbsDown)=\"assistantMessageThumbsDown.emit($event)\"\n                    (assistantMessageReadAloud)=\"assistantMessageReadAloud.emit($event)\"\n                    (assistantMessageRegenerate)=\"assistantMessageRegenerate.emit($event)\"\n                    (userMessageCopy)=\"userMessageCopy.emit($event)\"\n                    (userMessageEdit)=\"userMessageEdit.emit($event)\">\n                  </copilot-chat-message-view>\n                }\n              </div>\n            </div>\n          </div>\n        </div>\n        \n        <!-- Scroll to bottom button - hidden during resize, OUTSIDE scrollable content -->\n        @if (!isAtBottom() && !isResizing) {\n          <div\n            class=\"absolute inset-x-0 flex justify-center z-30\"\n            [style.bottom.px]=\"inputContainerHeightSignal() + 16\">\n            <copilot-slot\n              [slot]=\"scrollToBottomButton\"\n              [context]=\"scrollToBottomFromStickContext()\"\n              [defaultComponent]=\"defaultScrollToBottomButtonComponent\"\n              [outputs]=\"scrollToBottomFromStickOutputs\">\n            </copilot-slot>\n          </div>\n        }\n      </div>\n    }\n  `\n})\nexport class CopilotChatViewScrollViewComponent implements OnInit, OnChanges, AfterViewInit, OnDestroy {\n  private cdr = inject(ChangeDetectorRef);\n  \n  @Input() autoScroll: boolean = true;\n  \n  private _inputContainerHeight: number = 0;\n  @Input() \n  set inputContainerHeight(value: number) {\n    this._inputContainerHeight = value;\n    this.inputContainerHeightSignal.set(value);\n    this.cdr.markForCheck();\n  }\n  get inputContainerHeight(): number {\n    return this._inputContainerHeight;\n  }\n  \n  @Input() isResizing: boolean = false;\n  @Input() inputClass?: string;\n  @Input() messages: Message[] = [];\n  @Input() messageView?: any;\n  @Input() messageViewClass?: string;\n  @Input() showCursor: boolean = false;\n  \n  // Handler availability flags removed in favor of DI service\n  \n  // Slot inputs\n  @Input() scrollToBottomButton?: any;\n  @Input() scrollToBottomButtonClass?: string;\n  \n  // Output events (bubbled from message view)\n  @Output() assistantMessageThumbsUp = new EventEmitter<{ message: Message }>();\n  @Output() assistantMessageThumbsDown = new EventEmitter<{ message: Message }>();\n  @Output() assistantMessageReadAloud = new EventEmitter<{ message: Message }>();\n  @Output() assistantMessageRegenerate = new EventEmitter<{ message: Message }>();\n  @Output() userMessageCopy = new EventEmitter<{ message: Message }>();\n  @Output() userMessageEdit = new EventEmitter<{ message: Message }>();\n  \n  // ViewChild references\n  @ViewChild('scrollContainer', { read: ElementRef }) scrollContainer?: ElementRef<HTMLElement>;\n  @ViewChild('contentContainer', { read: ElementRef }) contentContainer?: ElementRef<HTMLElement>;\n  @ViewChild(StickToBottomDirective) stickToBottomDirective?: StickToBottomDirective;\n  \n  // Default components\n  protected readonly defaultMessageViewComponent = CopilotChatMessageViewComponent;\n  protected readonly defaultScrollToBottomButtonComponent = CopilotChatViewScrollToBottomButtonComponent;\n  \n  // Signals\n  protected hasMounted = signal(false);\n  protected showScrollButton = signal(false);\n  protected isAtBottom = signal(true);\n  protected inputContainerHeightSignal = signal(0);\n  protected paddingBottom = computed(() => this.inputContainerHeightSignal() + 32);\n  \n  // Computed class\n  protected computedClass = computed(() => \n    cn(this.inputClass)\n  );\n  \n  private destroy$ = new Subject<void>();\n  private platformId = inject(PLATFORM_ID);\n  private scrollPositionService = inject(ScrollPositionService);\n  \n  ngOnInit(): void {\n    // Check if we're in the browser\n    if (isPlatformBrowser(this.platformId)) {\n      // Set mounted after a tick to allow for hydration\n      setTimeout(() => {\n        this.hasMounted.set(true);\n      }, 0);\n    }\n  }\n  \n  ngOnChanges(): void {\n    // Update signals when inputs change\n    // Force change detection when inputContainerHeight changes\n    if (this.inputContainerHeight !== undefined) {\n      this.cdr.detectChanges();\n    }\n  }\n  \n  ngAfterViewInit(): void {\n    if (!this.autoScroll) {\n      // Wait for the view to be fully rendered after hasMounted is set\n      setTimeout(() => {\n        if (this.scrollContainer) {\n          // Check initial scroll position\n          const initialState = this.scrollPositionService.getScrollState(this.scrollContainer.nativeElement, 10);\n          this.showScrollButton.set(!initialState.isAtBottom);\n          \n          // Monitor scroll position for manual mode\n          this.scrollPositionService.monitorScrollPosition(this.scrollContainer, 10)\n            .pipe(takeUntil(this.destroy$))\n            .subscribe(state => {\n              this.showScrollButton.set(!state.isAtBottom);\n            });\n        }\n      }, 100);\n    }\n  }\n  \n  /**\n   * Handle isAtBottom change from StickToBottom directive\n   */\n  onIsAtBottomChange(isAtBottom: boolean): void {\n    this.isAtBottom.set(isAtBottom);\n  }\n  \n  /**\n   * Scroll to bottom for manual mode\n   */\n  scrollToBottom(): void {\n    if (this.scrollContainer) {\n      this.scrollPositionService.scrollToBottom(this.scrollContainer, true);\n    }\n  }\n  \n  /**\n   * Scroll to bottom for stick-to-bottom mode\n   */\n  scrollToBottomFromStick(): void {\n    if (this.stickToBottomDirective) {\n      this.stickToBottomDirective.scrollToBottom('smooth');\n    }\n  }\n  \n  ngOnDestroy(): void {\n    this.destroy$.next();\n    this.destroy$.complete();\n  }\n  \n  // Output maps for slots\n  scrollToBottomOutputs = { clicked: () => this.scrollToBottom() };\n  scrollToBottomFromStickOutputs = { clicked: () => this.scrollToBottomFromStick() };\n  \n  // Context methods for templates\n  messageViewContext(): any {\n    return { messages: this.messages, inputClass: this.messageViewClass, showCursor: this.showCursor };\n  }\n  \n  scrollToBottomContext(): any {\n    return { \n      inputClass: this.scrollToBottomButtonClass,\n      onClick: () => this.scrollToBottom()\n    };\n  }\n  \n  scrollToBottomFromStickContext(): any {\n    return { \n      inputClass: this.scrollToBottomButtonClass,\n      onClick: () => this.scrollToBottomFromStick()\n    };\n  }\n}\n"]}