@copilotkitnext/angular 0.0.9-alpha.2 → 0.0.10

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

@@ -0,0 +1,89 @@
+import { Component, input, output, ChangeDetectionStrategy, ViewEncapsulation, } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { LucideAngularModule, ChevronDown } from "lucide-angular";
+import { cn } from "../../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 CopilotChatViewScrollToBottomButton {
+    inputClass = input();
+    disabled = input(false);
+    // Support function-style click handler via slot context
+    onClick = input();
+    // Simple, idiomatic Angular output
+    clicked = output();
+    // 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: CopilotChatViewScrollToBottomButton, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.13", type: CopilotChatViewScrollToBottomButton, isStandalone: true, selector: "copilot-chat-view-scroll-to-bottom-button", inputs: { inputClass: { classPropertyName: "inputClass", publicName: "inputClass", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, onClick: { classPropertyName: "onClick", publicName: "onClick", isSignal: true, isRequired: false, transformFunction: null } }, 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: CopilotChatViewScrollToBottomButton, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    selector: "copilot-chat-view-scroll-to-bottom-button",
+                    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>
+  `,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,456 @@
+import { Component, input, output, 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 { CopilotSlot } from "../../slots/copilot-slot";
+import { CopilotChatMessageView } from "./copilot-chat-message-view";
+import { CopilotChatViewScrollToBottomButton } from "./copilot-chat-view-scroll-to-bottom-button";
+import { StickToBottom } from "../../directives/stick-to-bottom";
+import { ScrollPosition } from "../../scroll-position";
+import { cn } from "../../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 CopilotChatViewScrollView {
+    cdr = inject(ChangeDetectorRef);
+    autoScroll = input(true);
+    inputContainerHeight = input(0);
+    isResizing = input(false);
+    inputClass = input();
+    messages = input([]);
+    messageView = input();
+    messageViewClass = input();
+    showCursor = input(false);
+    // Handler availability flags removed in favor of DI service
+    // Slot inputs
+    scrollToBottomButton = input();
+    scrollToBottomButtonClass = input();
+    // Output events (bubbled from message view)
+    assistantMessageThumbsUp = output();
+    assistantMessageThumbsDown = output();
+    assistantMessageReadAloud = output();
+    assistantMessageRegenerate = output();
+    userMessageCopy = output();
+    userMessageEdit = output();
+    // ViewChild references
+    scrollContainer;
+    contentContainer;
+    stickToBottomDirective;
+    // Default components
+    defaultMessageViewComponent = CopilotChatMessageView;
+    defaultScrollToBottomButtonComponent = CopilotChatViewScrollToBottomButton;
+    // Signals
+    hasMounted = signal(false);
+    showScrollButton = signal(false);
+    isAtBottom = signal(true);
+    paddingBottom = computed(() => this.inputContainerHeight() + 32);
+    // Computed class
+    computedClass = computed(() => cn(this.inputClass()));
+    destroy$ = new Subject();
+    platformId = inject(PLATFORM_ID);
+    scrollPositionService = inject(ScrollPosition);
+    // No mirroring of inputs; derive directly via computed()
+    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);
+        }
+    }
+    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: CopilotChatViewScrollView, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: CopilotChatViewScrollView, isStandalone: true, selector: "copilot-chat-view-scroll-view", inputs: { autoScroll: { classPropertyName: "autoScroll", publicName: "autoScroll", isSignal: true, isRequired: false, transformFunction: null }, inputContainerHeight: { classPropertyName: "inputContainerHeight", publicName: "inputContainerHeight", isSignal: true, isRequired: false, transformFunction: null }, isResizing: { classPropertyName: "isResizing", publicName: "isResizing", isSignal: true, isRequired: false, transformFunction: null }, inputClass: { classPropertyName: "inputClass", publicName: "inputClass", isSignal: true, isRequired: false, transformFunction: null }, messages: { classPropertyName: "messages", publicName: "messages", isSignal: true, isRequired: false, transformFunction: null }, messageView: { classPropertyName: "messageView", publicName: "messageView", isSignal: true, isRequired: false, transformFunction: null }, messageViewClass: { classPropertyName: "messageViewClass", publicName: "messageViewClass", isSignal: true, isRequired: false, transformFunction: null }, showCursor: { classPropertyName: "showCursor", publicName: "showCursor", isSignal: true, isRequired: false, transformFunction: null }, scrollToBottomButton: { classPropertyName: "scrollToBottomButton", publicName: "scrollToBottomButton", isSignal: true, isRequired: false, transformFunction: null }, scrollToBottomButtonClass: { classPropertyName: "scrollToBottomButtonClass", publicName: "scrollToBottomButtonClass", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { assistantMessageThumbsUp: "assistantMessageThumbsUp", assistantMessageThumbsDown: "assistantMessageThumbsDown", assistantMessageReadAloud: "assistantMessageReadAloud", assistantMessageRegenerate: "assistantMessageRegenerate", userMessageCopy: "userMessageCopy", userMessageEdit: "userMessageEdit" }, providers: [ScrollPosition], 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: StickToBottom, descendants: 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]="inputContainerHeight() + 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]="inputContainerHeight() + 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: CopilotSlot, selector: "copilot-slot", inputs: ["slot", "context", "defaultComponent", "outputs"] }, { kind: "component", type: CopilotChatMessageView, 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: StickToBottom, 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: CopilotChatViewScrollView, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    selector: "copilot-chat-view-scroll-view",
+                    imports: [
+                        CommonModule,
+                        ScrollingModule,
+                        CopilotSlot,
+                        CopilotChatMessageView,
+                        StickToBottom,
+                    ],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    providers: [ScrollPosition],
+                    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]="inputContainerHeight() + 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]="inputContainerHeight() + 16"
+          >
+            <copilot-slot
+              [slot]="scrollToBottomButton()"
+              [context]="scrollToBottomFromStickContext()"
+              [defaultComponent]="defaultScrollToBottomButtonComponent"
+              [outputs]="scrollToBottomFromStickOutputs"
+            >
+            </copilot-slot>
+          </div>
+        }
+      </div>
+    }
+  `,
+                }]
+        }], propDecorators: { scrollContainer: [{
+                type: ViewChild,
+                args: ["scrollContainer", { read: ElementRef }]
+            }], contentContainer: [{
+                type: ViewChild,
+                args: ["contentContainer", { read: ElementRef }]
+            }], stickToBottomDirective: [{
+                type: ViewChild,
+                args: [StickToBottom]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"copilot-chat-view-scroll-view.js","sourceRoot":"","sources":["../../../../../src/lib/components/chat/copilot-chat-view-scroll-view.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  input,\n  output,\n  ViewChild,\n  ElementRef,\n  ChangeDetectionStrategy,\n  ViewEncapsulation,\n  signal,\n  computed,\n  OnInit,\n  AfterViewInit,\n  OnDestroy,\n  inject,\n  PLATFORM_ID,\n  ChangeDetectorRef,\n} from \"@angular/core\";\nimport { CommonModule, isPlatformBrowser } from \"@angular/common\";\nimport { ScrollingModule } from \"@angular/cdk/scrolling\";\nimport { CopilotSlot } from \"../../slots/copilot-slot\";\nimport { CopilotChatMessageView } from \"./copilot-chat-message-view\";\nimport { CopilotChatViewScrollToBottomButton } from \"./copilot-chat-view-scroll-to-bottom-button\";\nimport { StickToBottom } from \"../../directives/stick-to-bottom\";\nimport { ScrollPosition } from \"../../scroll-position\";\nimport { Message } from \"@ag-ui/client\";\nimport { cn } from \"../../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  standalone: true,\n  selector: \"copilot-chat-view-scroll-view\",\n  imports: [\n    CommonModule,\n    ScrollingModule,\n    CopilotSlot,\n    CopilotChatMessageView,\n    StickToBottom,\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  providers: [ScrollPosition],\n  template: `\n    @if (!hasMounted()) {\n      <!-- SSR/Initial render without stick-to-bottom -->\n      <div\n        class=\"h-full max-h-full flex flex-col min-h-0 overflow-y-scroll overflow-x-hidden\"\n      >\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        >\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                  >\n                  </copilot-slot>\n                } @else {\n                  <copilot-chat-message-view\n                    [messages]=\"messages()\"\n                    [inputClass]=\"messageViewClass()\"\n                    [showCursor]=\"showCursor()\"\n                    (assistantMessageThumbsUp)=\"\n                      assistantMessageThumbsUp.emit($event)\n                    \"\n                    (assistantMessageThumbsDown)=\"\n                      assistantMessageThumbsDown.emit($event)\n                    \"\n                    (assistantMessageReadAloud)=\"\n                      assistantMessageReadAloud.emit($event)\n                    \"\n                    (assistantMessageRegenerate)=\"\n                      assistantMessageRegenerate.emit($event)\n                    \"\n                    (userMessageCopy)=\"userMessageCopy.emit($event)\"\n                    (userMessageEdit)=\"userMessageEdit.emit($event)\"\n                  >\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]=\"inputContainerHeight() + 16\"\n          >\n            <copilot-slot\n              [slot]=\"scrollToBottomButton()\"\n              [context]=\"scrollToBottomContext()\"\n              [defaultComponent]=\"defaultScrollToBottomButtonComponent\"\n              [outputs]=\"scrollToBottomOutputs\"\n            >\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                  >\n                  </copilot-slot>\n                } @else {\n                  <copilot-chat-message-view\n                    [messages]=\"messages()\"\n                    [inputClass]=\"messageViewClass()\"\n                    [showCursor]=\"showCursor()\"\n                    (assistantMessageThumbsUp)=\"\n                      assistantMessageThumbsUp.emit($event)\n                    \"\n                    (assistantMessageThumbsDown)=\"\n                      assistantMessageThumbsDown.emit($event)\n                    \"\n                    (assistantMessageReadAloud)=\"\n                      assistantMessageReadAloud.emit($event)\n                    \"\n                    (assistantMessageRegenerate)=\"\n                      assistantMessageRegenerate.emit($event)\n                    \"\n                    (userMessageCopy)=\"userMessageCopy.emit($event)\"\n                    (userMessageEdit)=\"userMessageEdit.emit($event)\"\n                  >\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]=\"inputContainerHeight() + 16\"\n          >\n            <copilot-slot\n              [slot]=\"scrollToBottomButton()\"\n              [context]=\"scrollToBottomFromStickContext()\"\n              [defaultComponent]=\"defaultScrollToBottomButtonComponent\"\n              [outputs]=\"scrollToBottomFromStickOutputs\"\n            >\n            </copilot-slot>\n          </div>\n        }\n      </div>\n    }\n  `,\n})\nexport class CopilotChatViewScrollView\n  implements OnInit, AfterViewInit, OnDestroy\n{\n  private cdr = inject(ChangeDetectorRef);\n\n  autoScroll = input<boolean>(true);\n\n  inputContainerHeight = input<number>(0);\n\n  isResizing = input<boolean>(false);\n  inputClass = input<string | undefined>();\n  messages = input<Message[]>([]);\n  messageView = input<any | undefined>();\n  messageViewClass = input<string | undefined>();\n  showCursor = input<boolean>(false);\n\n  // Handler availability flags removed in favor of DI service\n\n  // Slot inputs\n  scrollToBottomButton = input<any | undefined>();\n  scrollToBottomButtonClass = input<string | undefined>();\n\n  // Output events (bubbled from message view)\n  assistantMessageThumbsUp = output<{ message: Message }>();\n  assistantMessageThumbsDown = output<{ message: Message }>();\n  assistantMessageReadAloud = output<{ message: Message }>();\n  assistantMessageRegenerate = output<{ message: Message }>();\n  userMessageCopy = output<{ message: Message }>();\n  userMessageEdit = output<{ message: Message }>();\n\n  // ViewChild references\n  @ViewChild(\"scrollContainer\", { read: ElementRef })\n  scrollContainer?: ElementRef<HTMLElement>;\n  @ViewChild(\"contentContainer\", { read: ElementRef })\n  contentContainer?: ElementRef<HTMLElement>;\n  @ViewChild(StickToBottom) stickToBottomDirective?: StickToBottom;\n\n  // Default components\n  protected readonly defaultMessageViewComponent = CopilotChatMessageView;\n  protected readonly defaultScrollToBottomButtonComponent =\n    CopilotChatViewScrollToBottomButton;\n\n  // Signals\n  protected hasMounted = signal(false);\n  protected showScrollButton = signal(false);\n  protected isAtBottom = signal(true);\n  protected paddingBottom = computed(() => this.inputContainerHeight() + 32);\n\n  // Computed class\n  protected computedClass = computed(() => cn(this.inputClass()));\n\n  private destroy$ = new Subject<void>();\n  private platformId = inject(PLATFORM_ID);\n  private scrollPositionService = inject(ScrollPosition);\n\n  // No mirroring of inputs; derive directly via computed()\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  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(\n            this.scrollContainer.nativeElement,\n            10\n          );\n          this.showScrollButton.set(!initialState.isAtBottom);\n\n          // Monitor scroll position for manual mode\n          this.scrollPositionService\n            .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 = {\n    clicked: () => this.scrollToBottomFromStick(),\n  };\n\n  // Context methods for templates\n  messageViewContext(): any {\n    return {\n      messages: this.messages(),\n      inputClass: this.messageViewClass(),\n      showCursor: this.showCursor(),\n    };\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"]}