@copilotkitnext/angular 0.0.9-alpha.3 → 0.0.10

package/dist/esm2022/lib/directives/stick-to-bottom.mjs

@@ -0,0 +1,170 @@
+import { Directive, ElementRef, inject, input, output, } from "@angular/core";
+import { ScrollPosition } from "../scroll-position";
+import { ResizeObserverService } from "../resize-observer";
+import { Subject } from "rxjs";
+import { takeUntil, debounceTime, filter, distinctUntilChanged, } from "rxjs/operators";
+import * as i0 from "@angular/core";
+/**
+ * Directive for implementing stick-to-bottom scroll behavior
+ * Similar to the React use-stick-to-bottom library
+ *
+ * @example
+ * ```html
+ * <div copilotStickToBottom
+ *      [enabled]="true"
+ *      [threshold]="10"
+ *      [initialBehavior]="'smooth'"
+ *      [resizeBehavior]="'smooth'"
+ *      (isAtBottomChange)="onBottomChange($event)">
+ *   <!-- Content -->
+ * </div>
+ * ```
+ */
+export class StickToBottom {
+    enabled = input(true);
+    threshold = input(10);
+    initialBehavior = input("smooth");
+    resizeBehavior = input("smooth");
+    debounceMs = input(100);
+    isAtBottomChange = output();
+    scrollToBottomRequested = output();
+    elementRef = inject(ElementRef);
+    scrollService = inject(ScrollPosition);
+    resizeService = inject(ResizeObserverService);
+    destroy$ = new Subject();
+    contentElement;
+    wasAtBottom = true;
+    hasInitialized = false;
+    userHasScrolled = false;
+    ngOnInit() {
+        // Setup will happen in ngAfterViewInit
+    }
+    ngAfterViewInit() {
+        const element = this.elementRef.nativeElement;
+        // Find or create content wrapper
+        this.contentElement = element.querySelector("[data-stick-to-bottom-content]");
+        if (!this.contentElement) {
+            this.contentElement = element;
+        }
+        this.setupScrollMonitoring();
+        this.setupResizeMonitoring();
+        this.setupContentMutationObserver();
+        // Initial scroll to bottom if enabled
+        setTimeout(() => {
+            this.hasInitialized = true;
+            if (this.enabled()) {
+                this.scrollToBottom(this.initialBehavior());
+            }
+        }, 0);
+    }
+    setupScrollMonitoring() {
+        if (!this.enabled())
+            return;
+        const element = this.elementRef.nativeElement;
+        // Monitor scroll position
+        this.scrollService
+            .monitorScrollPosition(element, this.threshold())
+            .pipe(takeUntil(this.destroy$), debounceTime(this.debounceMs()), distinctUntilChanged((a, b) => a.isAtBottom === b.isAtBottom))
+            .subscribe((state) => {
+            const wasAtBottom = this.wasAtBottom;
+            this.wasAtBottom = state.isAtBottom;
+            // Detect user scroll
+            if (!state.isAtBottom && wasAtBottom && this.hasInitialized) {
+                this.userHasScrolled = true;
+            }
+            else if (state.isAtBottom) {
+                this.userHasScrolled = false;
+            }
+            // Emit change
+            this.isAtBottomChange.emit(state.isAtBottom);
+        });
+    }
+    setupResizeMonitoring() {
+        if (!this.enabled() || !this.contentElement)
+            return;
+        // Monitor content resize
+        this.resizeService
+            .observeElement(this.contentElement, 0, 250)
+            .pipe(takeUntil(this.destroy$), filter(() => this.enabled() && !this.userHasScrolled))
+            .subscribe((state) => {
+            // Auto-scroll on resize if we were at bottom
+            if (this.wasAtBottom && !state.isResizing) {
+                this.scrollToBottom(this.resizeBehavior());
+            }
+        });
+        // Monitor container resize
+        const element = this.elementRef.nativeElement;
+        this.resizeService
+            .observeElement(element, 0, 250)
+            .pipe(takeUntil(this.destroy$), filter(() => this.enabled() && !this.userHasScrolled && this.wasAtBottom))
+            .subscribe(() => {
+            // Adjust scroll on container resize
+            this.scrollToBottom(this.resizeBehavior());
+        });
+    }
+    setupContentMutationObserver() {
+        if (!this.enabled() || !this.contentElement)
+            return;
+        const mutationObserver = new MutationObserver(() => {
+            if (this.enabled() && this.wasAtBottom && !this.userHasScrolled) {
+                // Content changed, scroll to bottom if we were there
+                requestAnimationFrame(() => {
+                    this.scrollToBottom(this.resizeBehavior());
+                });
+            }
+        });
+        mutationObserver.observe(this.contentElement, {
+            childList: true,
+            subtree: true,
+            characterData: true,
+        });
+        // Cleanup on destroy
+        this.destroy$.subscribe(() => {
+            mutationObserver.disconnect();
+        });
+    }
+    /**
+     * Public method to scroll to bottom
+     * Can be called from parent component
+     */
+    scrollToBottom(behavior = "smooth") {
+        const element = this.elementRef.nativeElement;
+        const smooth = behavior === "smooth";
+        this.scrollService.scrollToBottom(element, smooth);
+        this.userHasScrolled = false;
+        this.scrollToBottomRequested.emit();
+    }
+    /**
+     * Check if currently at bottom
+     */
+    isAtBottom() {
+        return this.scrollService.isAtBottom(this.elementRef.nativeElement, this.threshold());
+    }
+    /**
+     * Get current scroll state
+     */
+    getScrollState() {
+        const element = this.elementRef.nativeElement;
+        return {
+            scrollTop: element.scrollTop,
+            scrollHeight: element.scrollHeight,
+            clientHeight: element.clientHeight,
+            isAtBottom: this.isAtBottom(),
+        };
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StickToBottom, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.13", type: StickToBottom, isStandalone: true, selector: "[copilotStickToBottom]", inputs: { enabled: { classPropertyName: "enabled", publicName: "enabled", isSignal: true, isRequired: false, transformFunction: null }, threshold: { classPropertyName: "threshold", publicName: "threshold", isSignal: true, isRequired: false, transformFunction: null }, initialBehavior: { classPropertyName: "initialBehavior", publicName: "initialBehavior", isSignal: true, isRequired: false, transformFunction: null }, resizeBehavior: { classPropertyName: "resizeBehavior", publicName: "resizeBehavior", isSignal: true, isRequired: false, transformFunction: null }, debounceMs: { classPropertyName: "debounceMs", publicName: "debounceMs", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { isAtBottomChange: "isAtBottomChange", scrollToBottomRequested: "scrollToBottomRequested" }, providers: [ScrollPosition, ResizeObserverService], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StickToBottom, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: "[copilotStickToBottom]",
+                    providers: [ScrollPosition, ResizeObserverService],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stick-to-bottom.js","sourceRoot":"","sources":["../../../../src/lib/directives/stick-to-bottom.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  ElementRef,\n  OnInit,\n  OnDestroy,\n  AfterViewInit,\n  inject,\n  input,\n  output,\n} from \"@angular/core\";\nimport { ScrollPosition } from \"../scroll-position\";\nimport { ResizeObserverService } from \"../resize-observer\";\nimport { Subject } from \"rxjs\";\nimport {\n  takeUntil,\n  debounceTime,\n  filter,\n  distinctUntilChanged,\n} from \"rxjs/operators\";\n\nexport type ScrollBehavior = \"smooth\" | \"instant\" | \"auto\";\n\n/**\n * Directive for implementing stick-to-bottom scroll behavior\n * Similar to the React use-stick-to-bottom library\n *\n * @example\n * ```html\n * <div copilotStickToBottom\n *      [enabled]=\"true\"\n *      [threshold]=\"10\"\n *      [initialBehavior]=\"'smooth'\"\n *      [resizeBehavior]=\"'smooth'\"\n *      (isAtBottomChange)=\"onBottomChange($event)\">\n *   <!-- Content -->\n * </div>\n * ```\n */\n@Directive({\n  standalone: true,\n  selector: \"[copilotStickToBottom]\",\n  providers: [ScrollPosition, ResizeObserverService],\n})\nexport class StickToBottom implements OnInit, AfterViewInit, OnDestroy {\n  enabled = input<boolean>(true);\n  threshold = input<number>(10);\n  initialBehavior = input<ScrollBehavior>(\"smooth\");\n  resizeBehavior = input<ScrollBehavior>(\"smooth\");\n  debounceMs = input<number>(100);\n\n  isAtBottomChange = output<boolean>();\n  scrollToBottomRequested = output<void>();\n\n  private elementRef = inject(ElementRef);\n  private scrollService = inject(ScrollPosition);\n  private resizeService = inject(ResizeObserverService);\n\n  private destroy$ = new Subject<void>();\n  private contentElement?: HTMLElement;\n  private wasAtBottom = true;\n  private hasInitialized = false;\n  private userHasScrolled = false;\n\n  ngOnInit(): void {\n    // Setup will happen in ngAfterViewInit\n  }\n\n  ngAfterViewInit(): void {\n    const element = this.elementRef.nativeElement as HTMLElement;\n\n    // Find or create content wrapper\n    this.contentElement = element.querySelector(\n      \"[data-stick-to-bottom-content]\"\n    ) as HTMLElement;\n    if (!this.contentElement) {\n      this.contentElement = element;\n    }\n\n    this.setupScrollMonitoring();\n    this.setupResizeMonitoring();\n    this.setupContentMutationObserver();\n\n    // Initial scroll to bottom if enabled\n    setTimeout(() => {\n      this.hasInitialized = true;\n      if (this.enabled()) {\n        this.scrollToBottom(this.initialBehavior());\n      }\n    }, 0);\n  }\n\n  private setupScrollMonitoring(): void {\n    if (!this.enabled()) return;\n\n    const element = this.elementRef.nativeElement;\n\n    // Monitor scroll position\n    this.scrollService\n      .monitorScrollPosition(element, this.threshold())\n      .pipe(\n        takeUntil(this.destroy$),\n        debounceTime(this.debounceMs()),\n        distinctUntilChanged((a, b) => a.isAtBottom === b.isAtBottom)\n      )\n      .subscribe((state) => {\n        const wasAtBottom = this.wasAtBottom;\n        this.wasAtBottom = state.isAtBottom;\n\n        // Detect user scroll\n        if (!state.isAtBottom && wasAtBottom && this.hasInitialized) {\n          this.userHasScrolled = true;\n        } else if (state.isAtBottom) {\n          this.userHasScrolled = false;\n        }\n\n        // Emit change\n        this.isAtBottomChange.emit(state.isAtBottom);\n      });\n  }\n\n  private setupResizeMonitoring(): void {\n    if (!this.enabled() || !this.contentElement) return;\n\n    // Monitor content resize\n    this.resizeService\n      .observeElement(this.contentElement, 0, 250)\n      .pipe(\n        takeUntil(this.destroy$),\n        filter(() => this.enabled() && !this.userHasScrolled)\n      )\n      .subscribe((state) => {\n        // Auto-scroll on resize if we were at bottom\n        if (this.wasAtBottom && !state.isResizing) {\n          this.scrollToBottom(this.resizeBehavior());\n        }\n      });\n\n    // Monitor container resize\n    const element = this.elementRef.nativeElement;\n    this.resizeService\n      .observeElement(element, 0, 250)\n      .pipe(\n        takeUntil(this.destroy$),\n        filter(\n          () => this.enabled() && !this.userHasScrolled && this.wasAtBottom\n        )\n      )\n      .subscribe(() => {\n        // Adjust scroll on container resize\n        this.scrollToBottom(this.resizeBehavior());\n      });\n  }\n\n  private setupContentMutationObserver(): void {\n    if (!this.enabled() || !this.contentElement) return;\n\n    const mutationObserver = new MutationObserver(() => {\n      if (this.enabled() && this.wasAtBottom && !this.userHasScrolled) {\n        // Content changed, scroll to bottom if we were there\n        requestAnimationFrame(() => {\n          this.scrollToBottom(this.resizeBehavior());\n        });\n      }\n    });\n\n    mutationObserver.observe(this.contentElement, {\n      childList: true,\n      subtree: true,\n      characterData: true,\n    });\n\n    // Cleanup on destroy\n    this.destroy$.subscribe(() => {\n      mutationObserver.disconnect();\n    });\n  }\n\n  /**\n   * Public method to scroll to bottom\n   * Can be called from parent component\n   */\n  public scrollToBottom(behavior: ScrollBehavior = \"smooth\"): void {\n    const element = this.elementRef.nativeElement;\n    const smooth = behavior === \"smooth\";\n\n    this.scrollService.scrollToBottom(element, smooth);\n    this.userHasScrolled = false;\n    this.scrollToBottomRequested.emit();\n  }\n\n  /**\n   * Check if currently at bottom\n   */\n  public isAtBottom(): boolean {\n    return this.scrollService.isAtBottom(\n      this.elementRef.nativeElement,\n      this.threshold()\n    );\n  }\n\n  /**\n   * Get current scroll state\n   */\n  public getScrollState() {\n    const element = this.elementRef.nativeElement;\n    return {\n      scrollTop: element.scrollTop,\n      scrollHeight: element.scrollHeight,\n      clientHeight: element.clientHeight,\n      isAtBottom: this.isAtBottom(),\n    };\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$.next();\n    this.destroy$.complete();\n  }\n}\n"]}

package/dist/esm2022/lib/directives/tooltip.mjs

@@ -0,0 +1,217 @@
+import { Directive, Input, ElementRef, HostListener, inject, ViewContainerRef, } from "@angular/core";
+import { Overlay, OverlayPositionBuilder, } from "@angular/cdk/overlay";
+import { ComponentPortal } from "@angular/cdk/portal";
+import { Component, ChangeDetectionStrategy, } from "@angular/core";
+import * as i0 from "@angular/core";
+export class TooltipContent {
+    cdr;
+    text = "";
+    _position = "below";
+    get position() {
+        return this._position;
+    }
+    set position(value) {
+        this._position = value;
+        this.cdr.markForCheck();
+    }
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TooltipContent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: TooltipContent, isStandalone: true, selector: "copilot-tooltip-content", ngImport: i0, template: `
+    <div class="copilot-tooltip-wrapper" [attr.data-position]="position">
+      <div class="copilot-tooltip">
+        {{ text }}
+      </div>
+      <div class="copilot-tooltip-arrow"></div>
+    </div>
+  `, isInline: true, styles: [".copilot-tooltip-wrapper{position:relative;display:inline-block;animation:fadeIn .15s ease-in-out}.copilot-tooltip{background-color:#1a1a1a;color:#fff;padding:6px 10px;border-radius:6px;font-size:12px;font-weight:500;white-space:nowrap;max-width:200px;box-shadow:0 2px 8px #00000026}.copilot-tooltip-arrow{position:absolute;width:0;height:0;border-style:solid}.copilot-tooltip-wrapper[data-position=below] .copilot-tooltip-arrow{top:-4px;left:50%;transform:translate(-50%);border-width:0 4px 4px 4px;border-color:transparent transparent #1a1a1a transparent}.copilot-tooltip-wrapper[data-position=above] .copilot-tooltip-arrow{bottom:-4px;left:50%;transform:translate(-50%);border-width:4px 4px 0 4px;border-color:#1a1a1a transparent transparent transparent}.copilot-tooltip-wrapper[data-position=left] .copilot-tooltip-arrow{right:-4px;top:50%;transform:translateY(-50%);border-width:4px 0 4px 4px;border-color:transparent transparent transparent #1a1a1a}.copilot-tooltip-wrapper[data-position=right] .copilot-tooltip-arrow{left:-4px;top:50%;transform:translateY(-50%);border-width:4px 4px 4px 0;border-color:transparent #1a1a1a transparent transparent}@keyframes fadeIn{0%{opacity:0;transform:translateY(2px)}to{opacity:1;transform:translateY(0)}}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TooltipContent, decorators: [{
+            type: Component,
+            args: [{ selector: "copilot-tooltip-content", standalone: true, template: `
+    <div class="copilot-tooltip-wrapper" [attr.data-position]="position">
+      <div class="copilot-tooltip">
+        {{ text }}
+      </div>
+      <div class="copilot-tooltip-arrow"></div>
+    </div>
+  `, changeDetection: ChangeDetectionStrategy.OnPush, styles: [".copilot-tooltip-wrapper{position:relative;display:inline-block;animation:fadeIn .15s ease-in-out}.copilot-tooltip{background-color:#1a1a1a;color:#fff;padding:6px 10px;border-radius:6px;font-size:12px;font-weight:500;white-space:nowrap;max-width:200px;box-shadow:0 2px 8px #00000026}.copilot-tooltip-arrow{position:absolute;width:0;height:0;border-style:solid}.copilot-tooltip-wrapper[data-position=below] .copilot-tooltip-arrow{top:-4px;left:50%;transform:translate(-50%);border-width:0 4px 4px 4px;border-color:transparent transparent #1a1a1a transparent}.copilot-tooltip-wrapper[data-position=above] .copilot-tooltip-arrow{bottom:-4px;left:50%;transform:translate(-50%);border-width:4px 4px 0 4px;border-color:#1a1a1a transparent transparent transparent}.copilot-tooltip-wrapper[data-position=left] .copilot-tooltip-arrow{right:-4px;top:50%;transform:translateY(-50%);border-width:4px 0 4px 4px;border-color:transparent transparent transparent #1a1a1a}.copilot-tooltip-wrapper[data-position=right] .copilot-tooltip-arrow{left:-4px;top:50%;transform:translateY(-50%);border-width:4px 4px 4px 0;border-color:transparent #1a1a1a transparent transparent}@keyframes fadeIn{0%{opacity:0;transform:translateY(2px)}to{opacity:1;transform:translateY(0)}}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }] });
+export class CopilotTooltip {
+    tooltipText = "";
+    tooltipPosition = "below";
+    tooltipDelay = 500; // milliseconds
+    overlay = inject(Overlay);
+    overlayPositionBuilder = inject(OverlayPositionBuilder);
+    elementRef = inject(ElementRef);
+    viewContainerRef = inject(ViewContainerRef);
+    overlayRef;
+    tooltipTimeout;
+    originalTitle;
+    onMouseEnter() {
+        if (!this.tooltipText)
+            return;
+        // Store and remove native title to prevent OS tooltip
+        const element = this.elementRef.nativeElement;
+        if (element.hasAttribute("title")) {
+            this.originalTitle = element.getAttribute("title");
+            element.removeAttribute("title");
+        }
+        // Clear any existing timeout
+        if (this.tooltipTimeout) {
+            clearTimeout(this.tooltipTimeout);
+        }
+        // Set timeout to show tooltip after delay
+        this.tooltipTimeout = window.setTimeout(() => {
+            this.show();
+        }, this.tooltipDelay);
+    }
+    onMouseLeave() {
+        // Clear timeout if mouse leaves before tooltip shows
+        if (this.tooltipTimeout) {
+            clearTimeout(this.tooltipTimeout);
+            this.tooltipTimeout = undefined;
+        }
+        // Restore original title if it existed
+        if (this.originalTitle !== undefined) {
+            this.elementRef.nativeElement.setAttribute("title", this.originalTitle);
+            this.originalTitle = undefined;
+        }
+        // Hide tooltip if it's showing
+        this.hide();
+    }
+    show() {
+        if (this.overlayRef) {
+            return;
+        }
+        // Create overlay
+        const positionStrategy = this.overlayPositionBuilder
+            .flexibleConnectedTo(this.elementRef)
+            .withPositions(this.getPositions())
+            .withPush(false);
+        this.overlayRef = this.overlay.create({
+            positionStrategy,
+            scrollStrategy: this.overlay.scrollStrategies.close(),
+            hasBackdrop: false,
+        });
+        // Create component portal and attach
+        const portal = new ComponentPortal(TooltipContent, this.viewContainerRef);
+        const componentRef = this.overlayRef.attach(portal);
+        componentRef.instance.text = this.tooltipText;
+        // Detect actual position after overlay is positioned
+        setTimeout(() => {
+            if (this.overlayRef && this.elementRef.nativeElement) {
+                const tooltipRect = this.overlayRef.overlayElement.getBoundingClientRect();
+                const elementRect = this.elementRef.nativeElement.getBoundingClientRect();
+                let actualPosition = "below";
+                // Determine actual position based on relative positions
+                if (tooltipRect.bottom <= elementRect.top) {
+                    actualPosition = "above";
+                }
+                else if (tooltipRect.top >= elementRect.bottom) {
+                    actualPosition = "below";
+                }
+                else if (tooltipRect.right <= elementRect.left) {
+                    actualPosition = "left";
+                }
+                else if (tooltipRect.left >= elementRect.right) {
+                    actualPosition = "right";
+                }
+                componentRef.instance.position = actualPosition;
+            }
+        }, 0);
+    }
+    hide() {
+        if (this.overlayRef) {
+            this.overlayRef.dispose();
+            this.overlayRef = undefined;
+        }
+    }
+    getPositions() {
+        const positions = {
+            above: [
+                {
+                    originX: "center",
+                    originY: "top",
+                    overlayX: "center",
+                    overlayY: "bottom",
+                    offsetY: -12,
+                },
+            ],
+            below: [
+                {
+                    originX: "center",
+                    originY: "bottom",
+                    overlayX: "center",
+                    overlayY: "top",
+                    offsetY: 12,
+                },
+            ],
+            left: [
+                {
+                    originX: "start",
+                    originY: "center",
+                    overlayX: "end",
+                    overlayY: "center",
+                    offsetX: -12,
+                },
+            ],
+            right: [
+                {
+                    originX: "end",
+                    originY: "center",
+                    overlayX: "start",
+                    overlayY: "center",
+                    offsetX: 12,
+                },
+            ],
+        };
+        // Prefer below position, but use above as fallback
+        const primary = positions[this.tooltipPosition] || positions.below;
+        // For below position, add above as first fallback
+        const fallbacks = this.tooltipPosition === "below"
+            ? [
+                ...(positions.above || []),
+                ...(positions.left || []),
+                ...(positions.right || []),
+            ]
+            : Object.values(positions)
+                .filter((p) => p !== primary)
+                .flat();
+        return [...(primary || []), ...fallbacks];
+    }
+    ngOnDestroy() {
+        if (this.tooltipTimeout) {
+            clearTimeout(this.tooltipTimeout);
+        }
+        // Restore original title if it existed
+        if (this.originalTitle !== undefined) {
+            this.elementRef.nativeElement.setAttribute("title", this.originalTitle);
+        }
+        this.hide();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotTooltip, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: CopilotTooltip, isStandalone: true, selector: "[copilotTooltip]", inputs: { tooltipText: ["copilotTooltip", "tooltipText"], tooltipPosition: "tooltipPosition", tooltipDelay: "tooltipDelay" }, host: { listeners: { "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotTooltip, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[copilotTooltip]",
+                    standalone: true,
+                }]
+        }], propDecorators: { tooltipText: [{
+                type: Input,
+                args: ["copilotTooltip"]
+            }], tooltipPosition: [{
+                type: Input
+            }], tooltipDelay: [{
+                type: Input
+            }], onMouseEnter: [{
+                type: HostListener,
+                args: ["mouseenter"]
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ["mouseleave"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.js","sourceRoot":"","sources":["../../../../src/lib/directives/tooltip.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  Input,\n  ElementRef,\n  HostListener,\n  OnDestroy,\n  inject,\n  ViewContainerRef,\n} from \"@angular/core\";\nimport {\n  Overlay,\n  OverlayRef,\n  OverlayPositionBuilder,\n  ConnectedPosition,\n} from \"@angular/cdk/overlay\";\nimport { ComponentPortal } from \"@angular/cdk/portal\";\nimport {\n  Component,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n} from \"@angular/core\";\n\n@Component({\n  selector: \"copilot-tooltip-content\",\n  standalone: true,\n  template: `\n    <div class=\"copilot-tooltip-wrapper\" [attr.data-position]=\"position\">\n      <div class=\"copilot-tooltip\">\n        {{ text }}\n      </div>\n      <div class=\"copilot-tooltip-arrow\"></div>\n    </div>\n  `,\n  styles: [\n    `\n      .copilot-tooltip-wrapper {\n        position: relative;\n        display: inline-block;\n        animation: fadeIn 0.15s ease-in-out;\n      }\n\n      .copilot-tooltip {\n        background-color: #1a1a1a;\n        color: white;\n        padding: 6px 10px;\n        border-radius: 6px;\n        font-size: 12px;\n        font-weight: 500;\n        white-space: nowrap;\n        max-width: 200px;\n        box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);\n      }\n\n      .copilot-tooltip-arrow {\n        position: absolute;\n        width: 0;\n        height: 0;\n        border-style: solid;\n      }\n\n      /* Arrow for tooltip below element (arrow points up to tooltip) */\n      .copilot-tooltip-wrapper[data-position=\"below\"] .copilot-tooltip-arrow {\n        top: -4px;\n        left: 50%;\n        transform: translateX(-50%);\n        border-width: 0 4px 4px 4px;\n        border-color: transparent transparent #1a1a1a transparent;\n      }\n\n      /* Arrow for tooltip above element (arrow points down to element) */\n      .copilot-tooltip-wrapper[data-position=\"above\"] .copilot-tooltip-arrow {\n        bottom: -4px;\n        left: 50%;\n        transform: translateX(-50%);\n        border-width: 4px 4px 0 4px;\n        border-color: #1a1a1a transparent transparent transparent;\n      }\n\n      /* Arrow for tooltip to the left */\n      .copilot-tooltip-wrapper[data-position=\"left\"] .copilot-tooltip-arrow {\n        right: -4px;\n        top: 50%;\n        transform: translateY(-50%);\n        border-width: 4px 0 4px 4px;\n        border-color: transparent transparent transparent #1a1a1a;\n      }\n\n      /* Arrow for tooltip to the right */\n      .copilot-tooltip-wrapper[data-position=\"right\"] .copilot-tooltip-arrow {\n        left: -4px;\n        top: 50%;\n        transform: translateY(-50%);\n        border-width: 4px 4px 4px 0;\n        border-color: transparent #1a1a1a transparent transparent;\n      }\n\n      @keyframes fadeIn {\n        from {\n          opacity: 0;\n          transform: translateY(2px);\n        }\n        to {\n          opacity: 1;\n          transform: translateY(0);\n        }\n      }\n    `,\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class TooltipContent {\n  text = \"\";\n  private _position: \"above\" | \"below\" | \"left\" | \"right\" = \"below\";\n\n  get position(): \"above\" | \"below\" | \"left\" | \"right\" {\n    return this._position;\n  }\n\n  set position(value: \"above\" | \"below\" | \"left\" | \"right\") {\n    this._position = value;\n    this.cdr.markForCheck();\n  }\n\n  constructor(private cdr: ChangeDetectorRef) {}\n}\n\n@Directive({\n  selector: \"[copilotTooltip]\",\n  standalone: true,\n})\nexport class CopilotTooltip implements OnDestroy {\n  @Input(\"copilotTooltip\") tooltipText = \"\";\n  @Input() tooltipPosition: \"above\" | \"below\" | \"left\" | \"right\" = \"below\";\n  @Input() tooltipDelay = 500; // milliseconds\n\n  private overlay = inject(Overlay);\n  private overlayPositionBuilder = inject(OverlayPositionBuilder);\n  private elementRef = inject(ElementRef);\n  private viewContainerRef = inject(ViewContainerRef);\n\n  private overlayRef?: OverlayRef;\n  private tooltipTimeout?: number;\n  private originalTitle?: string;\n\n  @HostListener(\"mouseenter\")\n  onMouseEnter(): void {\n    if (!this.tooltipText) return;\n\n    // Store and remove native title to prevent OS tooltip\n    const element = this.elementRef.nativeElement;\n    if (element.hasAttribute(\"title\")) {\n      this.originalTitle = element.getAttribute(\"title\");\n      element.removeAttribute(\"title\");\n    }\n\n    // Clear any existing timeout\n    if (this.tooltipTimeout) {\n      clearTimeout(this.tooltipTimeout);\n    }\n\n    // Set timeout to show tooltip after delay\n    this.tooltipTimeout = window.setTimeout(() => {\n      this.show();\n    }, this.tooltipDelay);\n  }\n\n  @HostListener(\"mouseleave\")\n  onMouseLeave(): void {\n    // Clear timeout if mouse leaves before tooltip shows\n    if (this.tooltipTimeout) {\n      clearTimeout(this.tooltipTimeout);\n      this.tooltipTimeout = undefined;\n    }\n\n    // Restore original title if it existed\n    if (this.originalTitle !== undefined) {\n      this.elementRef.nativeElement.setAttribute(\"title\", this.originalTitle);\n      this.originalTitle = undefined;\n    }\n\n    // Hide tooltip if it's showing\n    this.hide();\n  }\n\n  private show(): void {\n    if (this.overlayRef) {\n      return;\n    }\n\n    // Create overlay\n    const positionStrategy = this.overlayPositionBuilder\n      .flexibleConnectedTo(this.elementRef)\n      .withPositions(this.getPositions())\n      .withPush(false);\n\n    this.overlayRef = this.overlay.create({\n      positionStrategy,\n      scrollStrategy: this.overlay.scrollStrategies.close(),\n      hasBackdrop: false,\n    });\n\n    // Create component portal and attach\n    const portal = new ComponentPortal(TooltipContent, this.viewContainerRef);\n    const componentRef = this.overlayRef.attach(portal);\n    componentRef.instance.text = this.tooltipText;\n\n    // Detect actual position after overlay is positioned\n    setTimeout(() => {\n      if (this.overlayRef && this.elementRef.nativeElement) {\n        const tooltipRect =\n          this.overlayRef.overlayElement.getBoundingClientRect();\n        const elementRect =\n          this.elementRef.nativeElement.getBoundingClientRect();\n\n        let actualPosition: \"above\" | \"below\" | \"left\" | \"right\" = \"below\";\n\n        // Determine actual position based on relative positions\n        if (tooltipRect.bottom <= elementRect.top) {\n          actualPosition = \"above\";\n        } else if (tooltipRect.top >= elementRect.bottom) {\n          actualPosition = \"below\";\n        } else if (tooltipRect.right <= elementRect.left) {\n          actualPosition = \"left\";\n        } else if (tooltipRect.left >= elementRect.right) {\n          actualPosition = \"right\";\n        }\n\n        componentRef.instance.position = actualPosition;\n      }\n    }, 0);\n  }\n\n  private hide(): void {\n    if (this.overlayRef) {\n      this.overlayRef.dispose();\n      this.overlayRef = undefined;\n    }\n  }\n\n  private getPositions(): ConnectedPosition[] {\n    const positions: Record<string, ConnectedPosition[]> = {\n      above: [\n        {\n          originX: \"center\",\n          originY: \"top\",\n          overlayX: \"center\",\n          overlayY: \"bottom\",\n          offsetY: -12,\n        },\n      ],\n      below: [\n        {\n          originX: \"center\",\n          originY: \"bottom\",\n          overlayX: \"center\",\n          overlayY: \"top\",\n          offsetY: 12,\n        },\n      ],\n      left: [\n        {\n          originX: \"start\",\n          originY: \"center\",\n          overlayX: \"end\",\n          overlayY: \"center\",\n          offsetX: -12,\n        },\n      ],\n      right: [\n        {\n          originX: \"end\",\n          originY: \"center\",\n          overlayX: \"start\",\n          overlayY: \"center\",\n          offsetX: 12,\n        },\n      ],\n    };\n\n    // Prefer below position, but use above as fallback\n    const primary = positions[this.tooltipPosition] || positions.below;\n    // For below position, add above as first fallback\n    const fallbacks =\n      this.tooltipPosition === \"below\"\n        ? [\n            ...(positions.above || []),\n            ...(positions.left || []),\n            ...(positions.right || []),\n          ]\n        : Object.values(positions)\n            .filter((p) => p !== primary)\n            .flat();\n\n    return [...(primary || []), ...fallbacks];\n  }\n\n  ngOnDestroy(): void {\n    if (this.tooltipTimeout) {\n      clearTimeout(this.tooltipTimeout);\n    }\n    // Restore original title if it existed\n    if (this.originalTitle !== undefined) {\n      this.elementRef.nativeElement.setAttribute(\"title\", this.originalTitle);\n    }\n    this.hide();\n  }\n}\n"]}

package/dist/esm2022/lib/human-in-the-loop.mjs

@@ -0,0 +1,19 @@
+import { Injectable } from "@angular/core";
+import { filter, lastValueFrom, Subject, take } from "rxjs";
+import * as i0 from "@angular/core";
+export class HumanInTheLoop {
+    results = new Subject();
+    addResult(toolCallId, toolName, result) {
+        this.results.next({ toolCallId, toolName, result });
+    }
+    onResult(toolCallId, toolName) {
+        return lastValueFrom(this.results.pipe(filter((result) => result.toolCallId === toolCallId && result.toolName === toolName), take(1)));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HumanInTheLoop, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HumanInTheLoop, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HumanInTheLoop, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/render-tool-calls.mjs

@@ -0,0 +1,131 @@
+import { NgComponentOutlet } from "@angular/common";
+import { Component, inject, input } from "@angular/core";
+import { CopilotKit } from "./copilotkit";
+import { partialJSONParse } from "@copilotkitnext/shared";
+import { HumanInTheLoop } from "./human-in-the-loop";
+import * as i0 from "@angular/core";
+export class RenderToolCalls {
+    #copilotKit = inject(CopilotKit);
+    #hitl = inject(HumanInTheLoop);
+    message = input.required();
+    messages = input.required();
+    isLoading = input(false);
+    pickRenderer(name) {
+        const messageAgentId = this.message()
+            .agentId;
+        const renderers = this.#copilotKit.toolCallRenderConfigs();
+        const clientTools = this.#copilotKit.clientToolCallRenderConfigs();
+        const humanInTheLoopTools = this.#copilotKit.humanInTheLoopToolRenderConfigs();
+        const renderer = renderers.find((candidate) => candidate.name === name &&
+            (candidate.agentId === undefined ||
+                candidate.agentId === messageAgentId));
+        if (renderer)
+            return { type: "renderer", config: renderer };
+        const clientTool = clientTools.find((candidate) => candidate.name === name &&
+            (candidate.agentId === undefined ||
+                candidate.agentId === messageAgentId));
+        if (clientTool)
+            return { type: "clientTool", config: clientTool };
+        const humanInTheLoopTool = humanInTheLoopTools.find((candidate) => candidate.name === name &&
+            (candidate.agentId === undefined ||
+                candidate.agentId === messageAgentId));
+        if (humanInTheLoopTool)
+            return { type: "humanInTheLoopTool", config: humanInTheLoopTool };
+        const starRenderer = renderers.find((candidate) => candidate.name === "*");
+        if (starRenderer)
+            return { type: "renderer", config: starRenderer };
+        return undefined;
+    }
+    buildToolCall(toolCall) {
+        const args = partialJSONParse(toolCall.function.arguments);
+        const message = this.#getToolMessage(toolCall.id);
+        if (message) {
+            return {
+                args,
+                status: "complete",
+                result: message.content,
+            };
+        }
+        else if (this.isLoading()) {
+            return {
+                args,
+                status: "in-progress",
+                result: undefined,
+            };
+        }
+        else {
+            return {
+                args,
+                status: "executing",
+                result: undefined,
+            };
+        }
+    }
+    buildHumanInTheLoopToolCall(toolCall) {
+        const args = partialJSONParse(toolCall.function.arguments);
+        const message = this.#getToolMessage(toolCall.id);
+        if (message) {
+            return {
+                args,
+                status: "complete",
+                result: message.content,
+            };
+        }
+        else if (this.isLoading()) {
+            return {
+                args,
+                status: "in-progress",
+                result: undefined,
+            };
+        }
+        else {
+            return {
+                args,
+                status: "executing",
+                result: undefined,
+                respond: (result) => {
+                    this.#hitl.addResult(toolCall.id, toolCall.function.name, result);
+                },
+            };
+        }
+    }
+    #getToolMessage(toolCallId) {
+        return this.messages().find((m) => m.role === "tool" && m.toolCallId === toolCallId);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RenderToolCalls, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: RenderToolCalls, isStandalone: true, selector: "copilot-render-tool-calls", inputs: { message: { classPropertyName: "message", publicName: "message", isSignal: true, isRequired: true, transformFunction: null }, messages: { classPropertyName: "messages", publicName: "messages", isSignal: true, isRequired: true, transformFunction: null }, isLoading: { classPropertyName: "isLoading", publicName: "isLoading", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+    @for (toolCall of message().toolCalls ?? []; track toolCall.id) {
+      @let renderConfig = pickRenderer(toolCall.function.name);
+      @if (renderConfig && renderConfig.type !== "humanInTheLoopTool") {
+        <ng-container
+          *ngComponentOutlet="
+            renderConfig.config.component;
+            inputs: { toolCall: buildToolCall(toolCall) }
+          "
+        />
+      }
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RenderToolCalls, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "copilot-render-tool-calls",
+                    standalone: true,
+                    imports: [NgComponentOutlet],
+                    template: `
+    @for (toolCall of message().toolCalls ?? []; track toolCall.id) {
+      @let renderConfig = pickRenderer(toolCall.function.name);
+      @if (renderConfig && renderConfig.type !== "humanInTheLoopTool") {
+        <ng-container
+          *ngComponentOutlet="
+            renderConfig.config.component;
+            inputs: { toolCall: buildToolCall(toolCall) }
+          "
+        />
+      }
+    }
+  `,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"render-tool-calls.js","sourceRoot":"","sources":["../../../src/lib/render-tool-calls.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgComponentOutlet } from \"@angular/common\";\nimport { Component, inject, input } from \"@angular/core\";\nimport { AssistantMessage, Message, ToolCall } from \"@ag-ui/client\";\nimport { CopilotKit } from \"./copilotkit\";\nimport {\n  FrontendToolConfig,\n  HumanInTheLoopToolCall,\n  HumanInTheLoopConfig,\n  AngularToolCall,\n  RenderToolCallConfig,\n} from \"./tools\";\nimport { partialJSONParse } from \"@copilotkitnext/shared\";\nimport { HumanInTheLoop } from \"./human-in-the-loop\";\n\ntype RendererToolCallHandler = {\n  type: \"renderer\";\n  config: RenderToolCallConfig;\n};\ntype ClientToolCallHandler = {\n  type: \"clientTool\";\n  config: FrontendToolConfig;\n};\ntype HumanInTheLoopToolCallHandler = {\n  type: \"humanInTheLoopTool\";\n  config: HumanInTheLoopConfig;\n};\n\ntype ToolCallHandler =\n  | RendererToolCallHandler\n  | ClientToolCallHandler\n  | HumanInTheLoopToolCallHandler;\n\n@Component({\n  selector: \"copilot-render-tool-calls\",\n  standalone: true,\n  imports: [NgComponentOutlet],\n  template: `\n    @for (toolCall of message().toolCalls ?? []; track toolCall.id) {\n      @let renderConfig = pickRenderer(toolCall.function.name);\n      @if (renderConfig && renderConfig.type !== \"humanInTheLoopTool\") {\n        <ng-container\n          *ngComponentOutlet=\"\n            renderConfig.config.component;\n            inputs: { toolCall: buildToolCall(toolCall) }\n          \"\n        />\n      }\n    }\n  `,\n})\nexport class RenderToolCalls {\n  readonly #copilotKit = inject(CopilotKit);\n  readonly #hitl = inject(HumanInTheLoop);\n  readonly message = input.required<AssistantMessage>();\n  readonly messages = input.required<Message[]>();\n  readonly isLoading = input<boolean>(false);\n\n  protected pickRenderer(name: string): ToolCallHandler | undefined {\n    type AssistantMessageWithAgent = AssistantMessage & {\n      agentId?: string;\n    };\n    const messageAgentId = (this.message() as AssistantMessageWithAgent)\n      .agentId;\n    const renderers = this.#copilotKit.toolCallRenderConfigs();\n    const clientTools = this.#copilotKit.clientToolCallRenderConfigs();\n    const humanInTheLoopTools =\n      this.#copilotKit.humanInTheLoopToolRenderConfigs();\n\n    const renderer = renderers.find(\n      (candidate) =>\n        candidate.name === name &&\n        (candidate.agentId === undefined ||\n          candidate.agentId === messageAgentId)\n    );\n\n    if (renderer) return { type: \"renderer\", config: renderer };\n\n    const clientTool = clientTools.find(\n      (candidate) =>\n        candidate.name === name &&\n        (candidate.agentId === undefined ||\n          candidate.agentId === messageAgentId)\n    );\n    if (clientTool) return { type: \"clientTool\", config: clientTool };\n\n    const humanInTheLoopTool = humanInTheLoopTools.find(\n      (candidate) =>\n        candidate.name === name &&\n        (candidate.agentId === undefined ||\n          candidate.agentId === messageAgentId)\n    );\n    if (humanInTheLoopTool)\n      return { type: \"humanInTheLoopTool\", config: humanInTheLoopTool };\n\n    const starRenderer = renderers.find((candidate) => candidate.name === \"*\");\n    if (starRenderer) return { type: \"renderer\", config: starRenderer };\n\n    return undefined;\n  }\n\n  protected buildToolCall<Args extends Record<string, unknown>>(\n    toolCall: ToolCall\n  ): AngularToolCall<Args> {\n    const args = partialJSONParse(toolCall.function.arguments);\n    const message = this.#getToolMessage(toolCall.id);\n\n    if (message) {\n      return {\n        args,\n        status: \"complete\",\n        result: message.content!,\n      };\n    } else if (this.isLoading()) {\n      return {\n        args,\n        status: \"in-progress\",\n        result: undefined,\n      };\n    } else {\n      return {\n        args,\n        status: \"executing\",\n        result: undefined,\n      };\n    }\n  }\n\n  protected buildHumanInTheLoopToolCall<Args extends Record<string, unknown>>(\n    toolCall: ToolCall\n  ): HumanInTheLoopToolCall<Args> {\n    const args = partialJSONParse(toolCall.function.arguments);\n    const message = this.#getToolMessage(toolCall.id);\n\n    if (message) {\n      return {\n        args,\n        status: \"complete\",\n        result: message.content!,\n      };\n    } else if (this.isLoading()) {\n      return {\n        args,\n        status: \"in-progress\",\n        result: undefined,\n      };\n    } else {\n      return {\n        args,\n        status: \"executing\",\n        result: undefined,\n        respond: (result) => {\n          this.#hitl.addResult(toolCall.id, toolCall.function.name, result);\n        },\n      };\n    }\n  }\n\n  #getToolMessage(toolCallId: string): Message | undefined {\n    return this.messages().find(\n      (m) => m.role === \"tool\" && m.toolCallId === toolCallId\n    );\n  }\n}\n"]}