@copilotkitnext/angular 0.0.2 → 0.0.4

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

@@ -0,0 +1,479 @@
+import { Component, Input, Output, EventEmitter, ContentChild, ViewChild, ElementRef, ChangeDetectionStrategy, ViewEncapsulation, signal, computed, effect } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { CopilotSlotComponent } from '../../lib/slots/copilot-slot.component';
+import { CopilotChatMessageViewComponent } from './copilot-chat-message-view.component';
+import { CopilotChatInputComponent } from './copilot-chat-input.component';
+import { CopilotChatViewScrollViewComponent } from './copilot-chat-view-scroll-view.component';
+import { CopilotChatViewScrollToBottomButtonComponent } from './copilot-chat-view-scroll-to-bottom-button.component';
+import { CopilotChatViewFeatherComponent } from './copilot-chat-view-feather.component';
+import { CopilotChatViewInputContainerComponent } from './copilot-chat-view-input-container.component';
+import { CopilotChatViewDisclaimerComponent } from './copilot-chat-view-disclaimer.component';
+import { cn } from '../../lib/utils';
+import { ResizeObserverService } from '../../services/resize-observer.service';
+import { CopilotChatViewHandlersService } from './copilot-chat-view-handlers.service';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/resize-observer.service";
+import * as i2 from "./copilot-chat-view-handlers.service";
+import * as i3 from "@angular/common";
+/**
+ * CopilotChatView component - Angular port of the React component.
+ * A complete chat interface with message feed and input components.
+ *
+ * @example
+ * ```html
+ * <copilot-chat-view
+ *   [messages]="messages"
+ *   [autoScroll]="true"
+ *   [messageViewProps]="{ assistantMessage: { onThumbsUp: handleThumbsUp } }">
+ * </copilot-chat-view>
+ * ```
+ */
+export class CopilotChatViewComponent {
+    resizeObserverService;
+    cdr;
+    handlers;
+    // Core inputs matching React props
+    messages = [];
+    autoScroll = true;
+    showCursor = false;
+    // MessageView slot inputs
+    messageViewComponent;
+    messageViewTemplate;
+    messageViewClass;
+    // ScrollView slot inputs
+    scrollViewComponent;
+    scrollViewTemplate;
+    scrollViewClass;
+    // ScrollToBottomButton slot inputs
+    scrollToBottomButtonComponent;
+    scrollToBottomButtonTemplate;
+    scrollToBottomButtonClass;
+    // Input slot inputs
+    inputComponent;
+    inputTemplate;
+    // InputContainer slot inputs
+    inputContainerComponent;
+    inputContainerTemplate;
+    inputContainerClass;
+    // Feather slot inputs
+    featherComponent;
+    featherTemplate;
+    featherClass;
+    // Disclaimer slot inputs
+    disclaimerComponent;
+    disclaimerTemplate;
+    disclaimerClass;
+    disclaimerText;
+    // Custom layout template (render prop pattern)
+    customLayoutTemplate;
+    // Named template slots for deep customization
+    sendButtonTemplate;
+    toolbarTemplate;
+    textAreaTemplate;
+    audioRecorderTemplate;
+    assistantMessageMarkdownRendererTemplate;
+    thumbsUpButtonTemplate;
+    thumbsDownButtonTemplate;
+    readAloudButtonTemplate;
+    regenerateButtonTemplate;
+    // Output events for assistant message actions (bubbled from child components)
+    assistantMessageThumbsUp = new EventEmitter();
+    assistantMessageThumbsDown = new EventEmitter();
+    assistantMessageReadAloud = new EventEmitter();
+    assistantMessageRegenerate = new EventEmitter();
+    // Output events for user message actions (if applicable)
+    userMessageCopy = new EventEmitter();
+    userMessageEdit = new EventEmitter();
+    // ViewChild references
+    inputContainerSlotRef;
+    // Default components for slots
+    defaultScrollViewComponent = CopilotChatViewScrollViewComponent;
+    defaultScrollToBottomButtonComponent = CopilotChatViewScrollToBottomButtonComponent;
+    defaultInputContainerComponent = CopilotChatViewInputContainerComponent;
+    defaultFeatherComponent = CopilotChatViewFeatherComponent;
+    defaultDisclaimerComponent = CopilotChatViewDisclaimerComponent;
+    // Signals for reactive state
+    messagesSignal = signal([]);
+    autoScrollSignal = signal(true);
+    showCursorSignal = signal(false);
+    disclaimerTextSignal = signal(undefined);
+    disclaimerClassSignal = signal(undefined);
+    inputContainerHeight = signal(0);
+    isResizing = signal(false);
+    contentPaddingBottom = computed(() => this.inputContainerHeight() + 32);
+    // Computed signals
+    computedClass = computed(() => cn('relative h-full'));
+    // Slot resolution computed signals
+    messageViewSlot = computed(() => this.messageViewTemplate || this.messageViewComponent);
+    scrollViewSlot = computed(() => this.scrollViewTemplate || this.scrollViewComponent);
+    scrollToBottomButtonSlot = computed(() => this.scrollToBottomButtonTemplate || this.scrollToBottomButtonComponent);
+    inputSlot = computed(() => this.inputTemplate || this.inputComponent);
+    inputContainerSlot = computed(() => this.inputContainerTemplate || this.inputContainerComponent);
+    featherSlot = computed(() => this.featherTemplate || this.featherComponent);
+    disclaimerSlot = computed(() => this.disclaimerTemplate || this.disclaimerComponent);
+    // Context objects for slots
+    scrollViewContext = computed(() => ({
+        autoScroll: this.autoScrollSignal(),
+        scrollToBottomButton: this.scrollToBottomButtonSlot(),
+        scrollToBottomButtonClass: this.scrollToBottomButtonClass,
+        inputContainerHeight: this.inputContainerHeight(),
+        isResizing: this.isResizing(),
+        messages: this.messagesSignal(),
+        messageView: this.messageViewSlot(),
+        messageViewClass: this.messageViewClass
+    }));
+    // Removed scrollViewPropsComputed - no longer needed
+    inputContainerContext = computed(() => ({
+        input: this.inputSlot(),
+        disclaimer: this.disclaimerSlot(),
+        disclaimerText: this.disclaimerTextSignal(),
+        disclaimerClass: this.disclaimerClassSignal(),
+        inputContainerClass: this.inputContainerClass
+    }));
+    // Removed inputContainerPropsComputed - no longer needed
+    // Layout context for custom templates (render prop pattern)
+    layoutContext = computed(() => ({
+        messageView: this.messageViewSlot(),
+        input: this.inputSlot(),
+        scrollView: this.scrollViewSlot(),
+        scrollToBottomButton: this.scrollToBottomButtonSlot(),
+        feather: this.featherSlot(),
+        inputContainer: this.inputContainerSlot(),
+        disclaimer: this.disclaimerSlot()
+    }));
+    destroy$ = new Subject();
+    resizeTimeoutRef;
+    constructor(resizeObserverService, cdr, handlers) {
+        this.resizeObserverService = resizeObserverService;
+        this.cdr = cdr;
+        this.handlers = handlers;
+        // Set up effect to handle resize state timeout
+        effect(() => {
+            const resizing = this.isResizing();
+            if (resizing && this.resizeTimeoutRef) {
+                clearTimeout(this.resizeTimeoutRef);
+                this.resizeTimeoutRef = undefined;
+            }
+        });
+    }
+    ngOnInit() {
+        // Initialize signals with input values
+        this.messagesSignal.set(this.messages);
+        this.autoScrollSignal.set(this.autoScroll);
+        this.showCursorSignal.set(this.showCursor);
+        this.disclaimerTextSignal.set(this.disclaimerText);
+        this.disclaimerClassSignal.set(this.disclaimerClass);
+        // Initialize handler availability in the view-scoped service
+        this.handlers.hasAssistantThumbsUpHandler.set(this.assistantMessageThumbsUp.observed);
+        this.handlers.hasAssistantThumbsDownHandler.set(this.assistantMessageThumbsDown.observed);
+        this.handlers.hasAssistantReadAloudHandler.set(this.assistantMessageReadAloud.observed);
+        this.handlers.hasAssistantRegenerateHandler.set(this.assistantMessageRegenerate.observed);
+        this.handlers.hasUserCopyHandler.set(this.userMessageCopy.observed);
+        this.handlers.hasUserEditHandler.set(this.userMessageEdit.observed);
+    }
+    ngOnChanges() {
+        // Update signals when inputs change
+        this.messagesSignal.set(this.messages);
+        this.autoScrollSignal.set(this.autoScroll);
+        this.showCursorSignal.set(this.showCursor);
+        this.disclaimerTextSignal.set(this.disclaimerText);
+        this.disclaimerClassSignal.set(this.disclaimerClass);
+        // Keep handler availability in sync
+        this.handlers.hasAssistantThumbsUpHandler.set(this.assistantMessageThumbsUp.observed);
+        this.handlers.hasAssistantThumbsDownHandler.set(this.assistantMessageThumbsDown.observed);
+        this.handlers.hasAssistantReadAloudHandler.set(this.assistantMessageReadAloud.observed);
+        this.handlers.hasAssistantRegenerateHandler.set(this.assistantMessageRegenerate.observed);
+        this.handlers.hasUserCopyHandler.set(this.userMessageCopy.observed);
+        this.handlers.hasUserEditHandler.set(this.userMessageEdit.observed);
+    }
+    ngAfterViewInit() {
+        // Don't set a default height - measure it dynamically
+        // Set up input container height monitoring
+        const measureAndObserve = () => {
+            if (!this.inputContainerSlotRef || !this.inputContainerSlotRef.nativeElement) {
+                return false;
+            }
+            // The slot ref points to the copilot-slot element
+            // We need to find the actual input container component inside it
+            const slotElement = this.inputContainerSlotRef.nativeElement;
+            const componentElement = slotElement.querySelector('copilot-chat-view-input-container');
+            if (!componentElement) {
+                return false;
+            }
+            // Look for the absolute positioned div that contains the input
+            let innerDiv = componentElement.querySelector('div.absolute');
+            // If not found by class, try first child
+            if (!innerDiv) {
+                innerDiv = componentElement.firstElementChild;
+            }
+            if (!innerDiv) {
+                return false;
+            }
+            // Measure the actual height
+            const measuredHeight = innerDiv.offsetHeight;
+            if (measuredHeight === 0) {
+                return false;
+            }
+            // Success! Set the initial height
+            this.inputContainerHeight.set(measuredHeight);
+            this.cdr.detectChanges();
+            // Create an ElementRef wrapper for ResizeObserver
+            const innerDivRef = new ElementRef(innerDiv);
+            // Set up ResizeObserver to track changes
+            this.resizeObserverService.observeElement(innerDivRef, 0, 250)
+                .pipe(takeUntil(this.destroy$))
+                .subscribe(state => {
+                const newHeight = state.height;
+                if (newHeight !== this.inputContainerHeight() && newHeight > 0) {
+                    this.inputContainerHeight.set(newHeight);
+                    this.isResizing.set(true);
+                    this.cdr.detectChanges();
+                    // Clear existing timeout
+                    if (this.resizeTimeoutRef) {
+                        clearTimeout(this.resizeTimeoutRef);
+                    }
+                    // Set isResizing to false after a short delay
+                    this.resizeTimeoutRef = window.setTimeout(() => {
+                        this.isResizing.set(false);
+                        this.resizeTimeoutRef = undefined;
+                        this.cdr.detectChanges();
+                    }, 250);
+                }
+            });
+            return true;
+        };
+        // Try to measure immediately
+        if (!measureAndObserve()) {
+            // If failed, retry with increasing delays
+            let attempts = 0;
+            const maxAttempts = 10;
+            const retry = () => {
+                attempts++;
+                if (measureAndObserve()) {
+                    // Successfully measured
+                }
+                else if (attempts < maxAttempts) {
+                    // Exponential backoff: 50ms, 100ms, 200ms, 400ms, etc.
+                    const delay = 50 * Math.pow(2, Math.min(attempts - 1, 4));
+                    setTimeout(retry, delay);
+                }
+                else {
+                    // Failed to measure after max attempts
+                }
+            };
+            // Start retry with first delay
+            setTimeout(retry, 50);
+        }
+    }
+    ngOnDestroy() {
+        if (this.resizeTimeoutRef) {
+            clearTimeout(this.resizeTimeoutRef);
+        }
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotChatViewComponent, deps: [{ token: i1.ResizeObserverService }, { token: i0.ChangeDetectorRef }, { token: i2.CopilotChatViewHandlersService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: CopilotChatViewComponent, isStandalone: true, selector: "copilot-chat-view", inputs: { messages: "messages", autoScroll: "autoScroll", showCursor: "showCursor", messageViewComponent: "messageViewComponent", messageViewTemplate: "messageViewTemplate", messageViewClass: "messageViewClass", scrollViewComponent: "scrollViewComponent", scrollViewTemplate: "scrollViewTemplate", scrollViewClass: "scrollViewClass", scrollToBottomButtonComponent: "scrollToBottomButtonComponent", scrollToBottomButtonTemplate: "scrollToBottomButtonTemplate", scrollToBottomButtonClass: "scrollToBottomButtonClass", inputComponent: "inputComponent", inputTemplate: "inputTemplate", inputContainerComponent: "inputContainerComponent", inputContainerTemplate: "inputContainerTemplate", inputContainerClass: "inputContainerClass", featherComponent: "featherComponent", featherTemplate: "featherTemplate", featherClass: "featherClass", disclaimerComponent: "disclaimerComponent", disclaimerTemplate: "disclaimerTemplate", disclaimerClass: "disclaimerClass", disclaimerText: "disclaimerText" }, outputs: { assistantMessageThumbsUp: "assistantMessageThumbsUp", assistantMessageThumbsDown: "assistantMessageThumbsDown", assistantMessageReadAloud: "assistantMessageReadAloud", assistantMessageRegenerate: "assistantMessageRegenerate", userMessageCopy: "userMessageCopy", userMessageEdit: "userMessageEdit" }, providers: [ResizeObserverService, CopilotChatViewHandlersService], queries: [{ propertyName: "customLayoutTemplate", first: true, predicate: ["customLayout"], descendants: true }, { propertyName: "sendButtonTemplate", first: true, predicate: ["sendButton"], descendants: true }, { propertyName: "toolbarTemplate", first: true, predicate: ["toolbar"], descendants: true }, { propertyName: "textAreaTemplate", first: true, predicate: ["textArea"], descendants: true }, { propertyName: "audioRecorderTemplate", first: true, predicate: ["audioRecorder"], descendants: true }, { propertyName: "assistantMessageMarkdownRendererTemplate", first: true, predicate: ["assistantMessageMarkdownRenderer"], descendants: true }, { propertyName: "thumbsUpButtonTemplate", first: true, predicate: ["thumbsUpButton"], descendants: true }, { propertyName: "thumbsDownButtonTemplate", first: true, predicate: ["thumbsDownButton"], descendants: true }, { propertyName: "readAloudButtonTemplate", first: true, predicate: ["readAloudButton"], descendants: true }, { propertyName: "regenerateButtonTemplate", first: true, predicate: ["regenerateButton"], descendants: true }], viewQueries: [{ propertyName: "inputContainerSlotRef", first: true, predicate: ["inputContainerSlotRef"], descendants: true, read: ElementRef }], usesOnChanges: true, ngImport: i0, template: `
+    <!-- Custom layout template support (render prop pattern) -->
+    @if (customLayoutTemplate) {
+      <ng-container *ngTemplateOutlet="customLayoutTemplate; context: layoutContext()"></ng-container>
+    } @else {
+      <!-- Default layout - exact React DOM structure -->
+      <div [class]="computedClass()">
+        <!-- ScrollView -->
+        <copilot-chat-view-scroll-view
+          [autoScroll]="autoScrollSignal()"
+          [inputContainerHeight]="inputContainerHeight()"
+          [isResizing]="isResizing()"
+          [messages]="messagesSignal()"
+          [messageView]="messageViewSlot()"
+          [messageViewClass]="messageViewClass"
+          [scrollToBottomButton]="scrollToBottomButtonSlot()"
+          [scrollToBottomButtonClass]="scrollToBottomButtonClass"
+          [showCursor]="showCursorSignal()"
+          (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-view-scroll-view>
+
+        <!-- Feather effect -->
+        <copilot-slot
+          [slot]="featherSlot()"
+          [context]="{ inputClass: featherClass }"
+          [defaultComponent]="defaultFeatherComponent">
+        </copilot-slot>
+
+        <!-- Input container -->
+        <copilot-slot
+          #inputContainerSlotRef
+          [slot]="inputContainerSlot()"
+          [context]="inputContainerContext()"
+          [defaultComponent]="defaultInputContainerComponent">
+        </copilot-slot>
+      </div>
+    }
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i3.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: CopilotSlotComponent, selector: "copilot-slot", inputs: ["slot", "context", "defaultComponent", "outputs"] }, { kind: "component", type: CopilotChatViewScrollViewComponent, selector: "copilot-chat-view-scroll-view", inputs: ["autoScroll", "inputContainerHeight", "isResizing", "inputClass", "messages", "messageView", "messageViewClass", "showCursor", "scrollToBottomButton", "scrollToBottomButtonClass"], outputs: ["assistantMessageThumbsUp", "assistantMessageThumbsDown", "assistantMessageReadAloud", "assistantMessageRegenerate", "userMessageCopy", "userMessageEdit"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotChatViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'copilot-chat-view',
+                    standalone: true,
+                    imports: [
+                        CommonModule,
+                        CopilotSlotComponent,
+                        CopilotChatMessageViewComponent,
+                        CopilotChatInputComponent,
+                        CopilotChatViewScrollViewComponent,
+                        CopilotChatViewScrollToBottomButtonComponent,
+                        CopilotChatViewFeatherComponent,
+                        CopilotChatViewInputContainerComponent,
+                        CopilotChatViewDisclaimerComponent
+                    ],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    providers: [ResizeObserverService, CopilotChatViewHandlersService],
+                    template: `
+    <!-- Custom layout template support (render prop pattern) -->
+    @if (customLayoutTemplate) {
+      <ng-container *ngTemplateOutlet="customLayoutTemplate; context: layoutContext()"></ng-container>
+    } @else {
+      <!-- Default layout - exact React DOM structure -->
+      <div [class]="computedClass()">
+        <!-- ScrollView -->
+        <copilot-chat-view-scroll-view
+          [autoScroll]="autoScrollSignal()"
+          [inputContainerHeight]="inputContainerHeight()"
+          [isResizing]="isResizing()"
+          [messages]="messagesSignal()"
+          [messageView]="messageViewSlot()"
+          [messageViewClass]="messageViewClass"
+          [scrollToBottomButton]="scrollToBottomButtonSlot()"
+          [scrollToBottomButtonClass]="scrollToBottomButtonClass"
+          [showCursor]="showCursorSignal()"
+          (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-view-scroll-view>
+
+        <!-- Feather effect -->
+        <copilot-slot
+          [slot]="featherSlot()"
+          [context]="{ inputClass: featherClass }"
+          [defaultComponent]="defaultFeatherComponent">
+        </copilot-slot>
+
+        <!-- Input container -->
+        <copilot-slot
+          #inputContainerSlotRef
+          [slot]="inputContainerSlot()"
+          [context]="inputContainerContext()"
+          [defaultComponent]="defaultInputContainerComponent">
+        </copilot-slot>
+      </div>
+    }
+  `
+                }]
+        }], ctorParameters: () => [{ type: i1.ResizeObserverService }, { type: i0.ChangeDetectorRef }, { type: i2.CopilotChatViewHandlersService }], propDecorators: { messages: [{
+                type: Input
+            }], autoScroll: [{
+                type: Input
+            }], showCursor: [{
+                type: Input
+            }], messageViewComponent: [{
+                type: Input
+            }], messageViewTemplate: [{
+                type: Input
+            }], messageViewClass: [{
+                type: Input
+            }], scrollViewComponent: [{
+                type: Input
+            }], scrollViewTemplate: [{
+                type: Input
+            }], scrollViewClass: [{
+                type: Input
+            }], scrollToBottomButtonComponent: [{
+                type: Input
+            }], scrollToBottomButtonTemplate: [{
+                type: Input
+            }], scrollToBottomButtonClass: [{
+                type: Input
+            }], inputComponent: [{
+                type: Input
+            }], inputTemplate: [{
+                type: Input
+            }], inputContainerComponent: [{
+                type: Input
+            }], inputContainerTemplate: [{
+                type: Input
+            }], inputContainerClass: [{
+                type: Input
+            }], featherComponent: [{
+                type: Input
+            }], featherTemplate: [{
+                type: Input
+            }], featherClass: [{
+                type: Input
+            }], disclaimerComponent: [{
+                type: Input
+            }], disclaimerTemplate: [{
+                type: Input
+            }], disclaimerClass: [{
+                type: Input
+            }], disclaimerText: [{
+                type: Input
+            }], customLayoutTemplate: [{
+                type: ContentChild,
+                args: ['customLayout']
+            }], sendButtonTemplate: [{
+                type: ContentChild,
+                args: ['sendButton']
+            }], toolbarTemplate: [{
+                type: ContentChild,
+                args: ['toolbar']
+            }], textAreaTemplate: [{
+                type: ContentChild,
+                args: ['textArea']
+            }], audioRecorderTemplate: [{
+                type: ContentChild,
+                args: ['audioRecorder']
+            }], assistantMessageMarkdownRendererTemplate: [{
+                type: ContentChild,
+                args: ['assistantMessageMarkdownRenderer']
+            }], thumbsUpButtonTemplate: [{
+                type: ContentChild,
+                args: ['thumbsUpButton']
+            }], thumbsDownButtonTemplate: [{
+                type: ContentChild,
+                args: ['thumbsDownButton']
+            }], readAloudButtonTemplate: [{
+                type: ContentChild,
+                args: ['readAloudButton']
+            }], regenerateButtonTemplate: [{
+                type: ContentChild,
+                args: ['regenerateButton']
+            }], assistantMessageThumbsUp: [{
+                type: Output
+            }], assistantMessageThumbsDown: [{
+                type: Output
+            }], assistantMessageReadAloud: [{
+                type: Output
+            }], assistantMessageRegenerate: [{
+                type: Output
+            }], userMessageCopy: [{
+                type: Output
+            }], userMessageEdit: [{
+                type: Output
+            }], inputContainerSlotRef: [{
+                type: ViewChild,
+                args: ['inputContainerSlotRef', { read: ElementRef }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"copilot-chat-view.component.js","sourceRoot":"","sources":["../../../../src/components/chat/copilot-chat-view.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  Output,\n  EventEmitter,\n  ContentChild,\n  TemplateRef,\n  Type,\n  ViewChild,\n  ElementRef,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  ViewEncapsulation,\n  signal,\n  computed,\n  OnInit,\n  OnChanges,\n  OnDestroy,\n  AfterViewInit,\n  ViewContainerRef,\n  effect\n} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { CopilotSlotComponent } from '../../lib/slots/copilot-slot.component';\nimport { CopilotChatMessageViewComponent } from './copilot-chat-message-view.component';\nimport { CopilotChatInputComponent } from './copilot-chat-input.component';\nimport { CopilotChatViewScrollViewComponent } from './copilot-chat-view-scroll-view.component';\nimport { CopilotChatViewScrollToBottomButtonComponent } from './copilot-chat-view-scroll-to-bottom-button.component';\nimport { CopilotChatViewFeatherComponent } from './copilot-chat-view-feather.component';\nimport { CopilotChatViewInputContainerComponent } from './copilot-chat-view-input-container.component';\nimport { CopilotChatViewDisclaimerComponent } from './copilot-chat-view-disclaimer.component';\nimport { Message } from '@ag-ui/client';\nimport { cn } from '../../lib/utils';\nimport { ResizeObserverService } from '../../services/resize-observer.service';\nimport { CopilotChatViewHandlersService } from './copilot-chat-view-handlers.service';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\n/**\n * CopilotChatView component - Angular port of the React component.\n * A complete chat interface with message feed and input components.\n * \n * @example\n * ```html\n * <copilot-chat-view\n *   [messages]=\"messages\"\n *   [autoScroll]=\"true\"\n *   [messageViewProps]=\"{ assistantMessage: { onThumbsUp: handleThumbsUp } }\">\n * </copilot-chat-view>\n * ```\n */\n@Component({\n  selector: 'copilot-chat-view',\n  standalone: true,\n  imports: [\n    CommonModule,\n    CopilotSlotComponent,\n    CopilotChatMessageViewComponent,\n    CopilotChatInputComponent,\n    CopilotChatViewScrollViewComponent,\n    CopilotChatViewScrollToBottomButtonComponent,\n    CopilotChatViewFeatherComponent,\n    CopilotChatViewInputContainerComponent,\n    CopilotChatViewDisclaimerComponent\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  providers: [ResizeObserverService, CopilotChatViewHandlersService],\n  template: `\n    <!-- Custom layout template support (render prop pattern) -->\n    @if (customLayoutTemplate) {\n      <ng-container *ngTemplateOutlet=\"customLayoutTemplate; context: layoutContext()\"></ng-container>\n    } @else {\n      <!-- Default layout - exact React DOM structure -->\n      <div [class]=\"computedClass()\">\n        <!-- ScrollView -->\n        <copilot-chat-view-scroll-view\n          [autoScroll]=\"autoScrollSignal()\"\n          [inputContainerHeight]=\"inputContainerHeight()\"\n          [isResizing]=\"isResizing()\"\n          [messages]=\"messagesSignal()\"\n          [messageView]=\"messageViewSlot()\"\n          [messageViewClass]=\"messageViewClass\"\n          [scrollToBottomButton]=\"scrollToBottomButtonSlot()\"\n          [scrollToBottomButtonClass]=\"scrollToBottomButtonClass\"\n          [showCursor]=\"showCursorSignal()\"\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-view-scroll-view>\n\n        <!-- Feather effect -->\n        <copilot-slot\n          [slot]=\"featherSlot()\"\n          [context]=\"{ inputClass: featherClass }\"\n          [defaultComponent]=\"defaultFeatherComponent\">\n        </copilot-slot>\n\n        <!-- Input container -->\n        <copilot-slot\n          #inputContainerSlotRef\n          [slot]=\"inputContainerSlot()\"\n          [context]=\"inputContainerContext()\"\n          [defaultComponent]=\"defaultInputContainerComponent\">\n        </copilot-slot>\n      </div>\n    }\n  `\n})\nexport class CopilotChatViewComponent implements OnInit, OnChanges, AfterViewInit, OnDestroy {\n  // Core inputs matching React props\n  @Input() messages: Message[] = [];\n  @Input() autoScroll: boolean = true;\n  @Input() showCursor: boolean = false;\n  \n  // MessageView slot inputs\n  @Input() messageViewComponent?: Type<any>;\n  @Input() messageViewTemplate?: TemplateRef<any>;\n  @Input() messageViewClass?: string;\n  \n  // ScrollView slot inputs\n  @Input() scrollViewComponent?: Type<any>;\n  @Input() scrollViewTemplate?: TemplateRef<any>;\n  @Input() scrollViewClass?: string;\n  \n  // ScrollToBottomButton slot inputs\n  @Input() scrollToBottomButtonComponent?: Type<any>;\n  @Input() scrollToBottomButtonTemplate?: TemplateRef<any>;\n  @Input() scrollToBottomButtonClass?: string;\n  \n  // Input slot inputs\n  @Input() inputComponent?: Type<any>;\n  @Input() inputTemplate?: TemplateRef<any>;\n  \n  // InputContainer slot inputs\n  @Input() inputContainerComponent?: Type<any>;\n  @Input() inputContainerTemplate?: TemplateRef<any>;\n  @Input() inputContainerClass?: string;\n  \n  // Feather slot inputs\n  @Input() featherComponent?: Type<any>;\n  @Input() featherTemplate?: TemplateRef<any>;\n  @Input() featherClass?: string;\n  \n  // Disclaimer slot inputs\n  @Input() disclaimerComponent?: Type<any>;\n  @Input() disclaimerTemplate?: TemplateRef<any>;\n  @Input() disclaimerClass?: string;\n  @Input() disclaimerText?: string;\n  \n  // Custom layout template (render prop pattern)\n  @ContentChild('customLayout') customLayoutTemplate?: TemplateRef<any>;\n  \n  // Named template slots for deep customization\n  @ContentChild('sendButton') sendButtonTemplate?: TemplateRef<any>;\n  @ContentChild('toolbar') toolbarTemplate?: TemplateRef<any>;\n  @ContentChild('textArea') textAreaTemplate?: TemplateRef<any>;\n  @ContentChild('audioRecorder') audioRecorderTemplate?: TemplateRef<any>;\n  @ContentChild('assistantMessageMarkdownRenderer') assistantMessageMarkdownRendererTemplate?: TemplateRef<any>;\n  @ContentChild('thumbsUpButton') thumbsUpButtonTemplate?: TemplateRef<any>;\n  @ContentChild('thumbsDownButton') thumbsDownButtonTemplate?: TemplateRef<any>;\n  @ContentChild('readAloudButton') readAloudButtonTemplate?: TemplateRef<any>;\n  @ContentChild('regenerateButton') regenerateButtonTemplate?: TemplateRef<any>;\n  \n  // Output events for assistant message actions (bubbled from child components)\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  \n  // Output events for user message actions (if applicable)\n  @Output() userMessageCopy = new EventEmitter<{ message: Message }>();\n  @Output() userMessageEdit = new EventEmitter<{ message: Message }>();\n  \n  // ViewChild references\n  @ViewChild('inputContainerSlotRef', { read: ElementRef }) inputContainerSlotRef?: ElementRef;\n  \n  // Default components for slots\n  protected readonly defaultScrollViewComponent = CopilotChatViewScrollViewComponent;\n  protected readonly defaultScrollToBottomButtonComponent = CopilotChatViewScrollToBottomButtonComponent;\n  protected readonly defaultInputContainerComponent = CopilotChatViewInputContainerComponent;\n  protected readonly defaultFeatherComponent = CopilotChatViewFeatherComponent;\n  protected readonly defaultDisclaimerComponent = CopilotChatViewDisclaimerComponent;\n  \n  // Signals for reactive state\n  protected messagesSignal = signal<Message[]>([]);\n  protected autoScrollSignal = signal(true);\n  protected showCursorSignal = signal(false);\n  protected disclaimerTextSignal = signal<string | undefined>(undefined);\n  protected disclaimerClassSignal = signal<string | undefined>(undefined);\n  protected inputContainerHeight = signal<number>(0);\n  protected isResizing = signal<boolean>(false);\n  protected contentPaddingBottom = computed(() => this.inputContainerHeight() + 32);\n  \n  // Computed signals\n  protected computedClass = computed(() => cn('relative h-full'));\n  \n  // Slot resolution computed signals\n  protected messageViewSlot = computed(() => \n    this.messageViewTemplate || this.messageViewComponent\n  );\n  \n  protected scrollViewSlot = computed(() => \n    this.scrollViewTemplate || this.scrollViewComponent\n  );\n  \n  protected scrollToBottomButtonSlot = computed(() => \n    this.scrollToBottomButtonTemplate || this.scrollToBottomButtonComponent\n  );\n  \n  protected inputSlot = computed(() => \n    this.inputTemplate || this.inputComponent\n  );\n  \n  protected inputContainerSlot = computed(() => \n    this.inputContainerTemplate || this.inputContainerComponent\n  );\n  \n  protected featherSlot = computed(() => \n    this.featherTemplate || this.featherComponent\n  );\n  \n  protected disclaimerSlot = computed(() => \n    this.disclaimerTemplate || this.disclaimerComponent\n  );\n  \n  // Context objects for slots\n  protected scrollViewContext = computed(() => ({\n    autoScroll: this.autoScrollSignal(),\n    scrollToBottomButton: this.scrollToBottomButtonSlot(),\n    scrollToBottomButtonClass: this.scrollToBottomButtonClass,\n    inputContainerHeight: this.inputContainerHeight(),\n    isResizing: this.isResizing(),\n    messages: this.messagesSignal(),\n    messageView: this.messageViewSlot(),\n    messageViewClass: this.messageViewClass\n  }));\n  \n  // Removed scrollViewPropsComputed - no longer needed\n  \n  protected inputContainerContext = computed(() => ({\n    input: this.inputSlot(),\n    disclaimer: this.disclaimerSlot(),\n    disclaimerText: this.disclaimerTextSignal(),\n    disclaimerClass: this.disclaimerClassSignal(),\n    inputContainerClass: this.inputContainerClass\n  }));\n  \n  // Removed inputContainerPropsComputed - no longer needed\n  \n  // Layout context for custom templates (render prop pattern)\n  protected layoutContext = computed(() => ({\n    messageView: this.messageViewSlot(),\n    input: this.inputSlot(),\n    scrollView: this.scrollViewSlot(),\n    scrollToBottomButton: this.scrollToBottomButtonSlot(),\n    feather: this.featherSlot(),\n    inputContainer: this.inputContainerSlot(),\n    disclaimer: this.disclaimerSlot()\n  }));\n  \n  private destroy$ = new Subject<void>();\n  private resizeTimeoutRef?: number;\n  \n  constructor(\n    private resizeObserverService: ResizeObserverService,\n    private cdr: ChangeDetectorRef,\n    private handlers: CopilotChatViewHandlersService\n  ) {\n    // Set up effect to handle resize state timeout\n    effect(() => {\n      const resizing = this.isResizing();\n      if (resizing && this.resizeTimeoutRef) {\n        clearTimeout(this.resizeTimeoutRef);\n        this.resizeTimeoutRef = undefined;\n      }\n    });\n  }\n  \n  ngOnInit(): void {\n    // Initialize signals with input values\n    this.messagesSignal.set(this.messages);\n    this.autoScrollSignal.set(this.autoScroll);\n    this.showCursorSignal.set(this.showCursor);\n    this.disclaimerTextSignal.set(this.disclaimerText);\n    this.disclaimerClassSignal.set(this.disclaimerClass);\n\n    // Initialize handler availability in the view-scoped service\n    this.handlers.hasAssistantThumbsUpHandler.set(this.assistantMessageThumbsUp.observed);\n    this.handlers.hasAssistantThumbsDownHandler.set(this.assistantMessageThumbsDown.observed);\n    this.handlers.hasAssistantReadAloudHandler.set(this.assistantMessageReadAloud.observed);\n    this.handlers.hasAssistantRegenerateHandler.set(this.assistantMessageRegenerate.observed);\n    this.handlers.hasUserCopyHandler.set(this.userMessageCopy.observed);\n    this.handlers.hasUserEditHandler.set(this.userMessageEdit.observed);\n  }\n  \n  ngOnChanges(): void {\n    // Update signals when inputs change\n    this.messagesSignal.set(this.messages);\n    this.autoScrollSignal.set(this.autoScroll);\n    this.showCursorSignal.set(this.showCursor);\n    this.disclaimerTextSignal.set(this.disclaimerText);\n    this.disclaimerClassSignal.set(this.disclaimerClass);\n\n    // Keep handler availability in sync\n    this.handlers.hasAssistantThumbsUpHandler.set(this.assistantMessageThumbsUp.observed);\n    this.handlers.hasAssistantThumbsDownHandler.set(this.assistantMessageThumbsDown.observed);\n    this.handlers.hasAssistantReadAloudHandler.set(this.assistantMessageReadAloud.observed);\n    this.handlers.hasAssistantRegenerateHandler.set(this.assistantMessageRegenerate.observed);\n    this.handlers.hasUserCopyHandler.set(this.userMessageCopy.observed);\n    this.handlers.hasUserEditHandler.set(this.userMessageEdit.observed);\n  }\n  \n  ngAfterViewInit(): void {\n    // Don't set a default height - measure it dynamically\n    \n    // Set up input container height monitoring\n    const measureAndObserve = () => {\n      if (!this.inputContainerSlotRef || !this.inputContainerSlotRef.nativeElement) {\n        return false;\n      }\n      \n      // The slot ref points to the copilot-slot element\n      // We need to find the actual input container component inside it\n      const slotElement = this.inputContainerSlotRef.nativeElement;\n      const componentElement = slotElement.querySelector('copilot-chat-view-input-container');\n      \n      if (!componentElement) {\n        return false;\n      }\n      \n      // Look for the absolute positioned div that contains the input\n      let innerDiv = componentElement.querySelector('div.absolute') as HTMLElement;\n      \n      // If not found by class, try first child\n      if (!innerDiv) {\n        innerDiv = componentElement.firstElementChild as HTMLElement;\n      }\n      \n      if (!innerDiv) {\n        return false;\n      }\n      \n      // Measure the actual height\n      const measuredHeight = innerDiv.offsetHeight;\n      \n      if (measuredHeight === 0) {\n        return false;\n      }\n      \n      // Success! Set the initial height\n      this.inputContainerHeight.set(measuredHeight);\n      this.cdr.detectChanges();\n      \n      // Create an ElementRef wrapper for ResizeObserver\n      const innerDivRef = new ElementRef(innerDiv);\n      \n      // Set up ResizeObserver to track changes\n      this.resizeObserverService.observeElement(innerDivRef, 0, 250)\n        .pipe(takeUntil(this.destroy$))\n        .subscribe(state => {\n          const newHeight = state.height;\n          \n          if (newHeight !== this.inputContainerHeight() && newHeight > 0) {\n            this.inputContainerHeight.set(newHeight);\n            this.isResizing.set(true);\n            this.cdr.detectChanges();\n            \n            // Clear existing timeout\n            if (this.resizeTimeoutRef) {\n              clearTimeout(this.resizeTimeoutRef);\n            }\n            \n            // Set isResizing to false after a short delay\n            this.resizeTimeoutRef = window.setTimeout(() => {\n              this.isResizing.set(false);\n              this.resizeTimeoutRef = undefined;\n              this.cdr.detectChanges();\n            }, 250);\n          }\n        });\n      \n      return true;\n    };\n    \n    // Try to measure immediately\n    if (!measureAndObserve()) {\n      // If failed, retry with increasing delays\n      let attempts = 0;\n      const maxAttempts = 10;\n      \n      const retry = () => {\n        attempts++;\n        if (measureAndObserve()) {\n          // Successfully measured\n        } else if (attempts < maxAttempts) {\n          // Exponential backoff: 50ms, 100ms, 200ms, 400ms, etc.\n          const delay = 50 * Math.pow(2, Math.min(attempts - 1, 4));\n          setTimeout(retry, delay);\n        } else {\n          // Failed to measure after max attempts\n        }\n      };\n      \n      // Start retry with first delay\n      setTimeout(retry, 50);\n    }\n  }\n  \n  ngOnDestroy(): void {\n    if (this.resizeTimeoutRef) {\n      clearTimeout(this.resizeTimeoutRef);\n    }\n    this.destroy$.next();\n    this.destroy$.complete();\n  }\n}\n"]}

package/dist/esm2022/components/chat/copilot-chat-view.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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