@copilotkitnext/angular 0.0.9-alpha.3 → 0.0.11

package/dist/esm2022/lib/resize-observer.mjs

@@ -0,0 +1,152 @@
+import { Injectable, ElementRef } from "@angular/core";
+import { Subject, BehaviorSubject } from "rxjs";
+import { debounceTime, takeUntil, distinctUntilChanged } from "rxjs/operators";
+import * as i0 from "@angular/core";
+export class ResizeObserverService {
+    ngZone;
+    destroy$ = new Subject();
+    observers = new Map();
+    resizeStates = new Map();
+    resizeTimeouts = new Map();
+    constructor(ngZone) {
+        this.ngZone = ngZone;
+    }
+    /**
+     * Observe element resize with debouncing and resizing state
+     * @param element Element to observe
+     * @param debounceMs Debounce time (default 250ms)
+     * @param resizingDurationMs How long to show "isResizing" state (default 250ms)
+     */
+    observeElement(element, debounceMs = 0, resizingDurationMs = 250) {
+        const el = element instanceof ElementRef ? element.nativeElement : element;
+        // Return existing observer if already observing
+        if (this.resizeStates.has(el)) {
+            return this.resizeStates.get(el).asObservable();
+        }
+        // Create new subject for this element
+        const resizeState$ = new BehaviorSubject({
+            width: el.offsetWidth,
+            height: el.offsetHeight,
+            isResizing: false,
+        });
+        this.resizeStates.set(el, resizeState$);
+        // Create ResizeObserver
+        const resizeObserver = new ResizeObserver((entries) => {
+            if (entries.length === 0)
+                return;
+            const entry = entries[0];
+            if (!entry)
+                return;
+            const { width, height } = entry.contentRect;
+            this.ngZone.run(() => {
+                // Clear existing timeout
+                const existingTimeout = this.resizeTimeouts.get(el);
+                if (existingTimeout) {
+                    clearTimeout(existingTimeout);
+                }
+                // Update state with isResizing = true
+                resizeState$.next({
+                    width,
+                    height,
+                    isResizing: true,
+                });
+                // Set timeout to clear isResizing flag
+                if (resizingDurationMs > 0) {
+                    const timeout = window.setTimeout(() => {
+                        resizeState$.next({
+                            width,
+                            height,
+                            isResizing: false,
+                        });
+                        this.resizeTimeouts.delete(el);
+                    }, resizingDurationMs);
+                    this.resizeTimeouts.set(el, timeout);
+                }
+                else {
+                    // If no duration, immediately set isResizing to false
+                    resizeState$.next({
+                        width,
+                        height,
+                        isResizing: false,
+                    });
+                }
+            });
+        });
+        // Start observing
+        resizeObserver.observe(el);
+        this.observers.set(el, resizeObserver);
+        // Return observable with debouncing if specified
+        const observable = resizeState$.asObservable().pipe(debounceMs > 0 ? debounceTime(debounceMs) : (source) => source, distinctUntilChanged((a, b) => a.width === b.width &&
+            a.height === b.height &&
+            a.isResizing === b.isResizing), takeUntil(this.destroy$));
+        return observable;
+    }
+    /**
+     * Stop observing an element
+     * @param element Element to stop observing
+     */
+    unobserve(element) {
+        const el = element instanceof ElementRef ? element.nativeElement : element;
+        // Clear timeout if exists
+        const timeout = this.resizeTimeouts.get(el);
+        if (timeout) {
+            clearTimeout(timeout);
+            this.resizeTimeouts.delete(el);
+        }
+        // Disconnect observer
+        const observer = this.observers.get(el);
+        if (observer) {
+            observer.disconnect();
+            this.observers.delete(el);
+        }
+        // Complete and remove subject
+        const subject = this.resizeStates.get(el);
+        if (subject) {
+            subject.complete();
+            this.resizeStates.delete(el);
+        }
+    }
+    /**
+     * Get current size of element
+     * @param element Element to measure
+     */
+    getCurrentSize(element) {
+        const el = element instanceof ElementRef ? element.nativeElement : element;
+        return {
+            width: el.offsetWidth,
+            height: el.offsetHeight,
+        };
+    }
+    /**
+     * Get current resize state of element
+     * @param element Element to check
+     */
+    getCurrentState(element) {
+        const el = element instanceof ElementRef ? element.nativeElement : element;
+        const subject = this.resizeStates.get(el);
+        return subject ? subject.value : null;
+    }
+    ngOnDestroy() {
+        // Clear all timeouts
+        this.resizeTimeouts.forEach((timeout) => clearTimeout(timeout));
+        this.resizeTimeouts.clear();
+        // Disconnect all observers
+        this.observers.forEach((observer) => observer.disconnect());
+        this.observers.clear();
+        // Complete all subjects
+        this.resizeStates.forEach((subject) => subject.complete());
+        this.resizeStates.clear();
+        // Complete destroy subject
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ResizeObserverService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ResizeObserverService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ResizeObserverService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: () => [{ type: i0.NgZone }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resize-observer.js","sourceRoot":"","sources":["../../../src/lib/resize-observer.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, ElementRef, NgZone, OnDestroy } from \"@angular/core\";\nimport { Observable, Subject, BehaviorSubject } from \"rxjs\";\nimport { debounceTime, takeUntil, distinctUntilChanged } from \"rxjs/operators\";\n\nexport interface ResizeState {\n  width: number;\n  height: number;\n  isResizing: boolean;\n}\n\n@Injectable({\n  providedIn: \"root\",\n})\nexport class ResizeObserverService implements OnDestroy {\n  private destroy$ = new Subject<void>();\n  private observers = new Map<HTMLElement, ResizeObserver>();\n  private resizeStates = new Map<HTMLElement, BehaviorSubject<ResizeState>>();\n  private resizeTimeouts = new Map<HTMLElement, number>();\n\n  constructor(private ngZone: NgZone) {}\n\n  /**\n   * Observe element resize with debouncing and resizing state\n   * @param element Element to observe\n   * @param debounceMs Debounce time (default 250ms)\n   * @param resizingDurationMs How long to show \"isResizing\" state (default 250ms)\n   */\n  observeElement(\n    element: ElementRef<HTMLElement> | HTMLElement,\n    debounceMs: number = 0,\n    resizingDurationMs: number = 250\n  ): Observable<ResizeState> {\n    const el = element instanceof ElementRef ? element.nativeElement : element;\n\n    // Return existing observer if already observing\n    if (this.resizeStates.has(el)) {\n      return this.resizeStates.get(el)!.asObservable();\n    }\n\n    // Create new subject for this element\n    const resizeState$ = new BehaviorSubject<ResizeState>({\n      width: el.offsetWidth,\n      height: el.offsetHeight,\n      isResizing: false,\n    });\n\n    this.resizeStates.set(el, resizeState$);\n\n    // Create ResizeObserver\n    const resizeObserver = new ResizeObserver((entries) => {\n      if (entries.length === 0) return;\n\n      const entry = entries[0];\n      if (!entry) return;\n\n      const { width, height } = entry.contentRect;\n\n      this.ngZone.run(() => {\n        // Clear existing timeout\n        const existingTimeout = this.resizeTimeouts.get(el);\n        if (existingTimeout) {\n          clearTimeout(existingTimeout);\n        }\n\n        // Update state with isResizing = true\n        resizeState$.next({\n          width,\n          height,\n          isResizing: true,\n        });\n\n        // Set timeout to clear isResizing flag\n        if (resizingDurationMs > 0) {\n          const timeout = window.setTimeout(() => {\n            resizeState$.next({\n              width,\n              height,\n              isResizing: false,\n            });\n            this.resizeTimeouts.delete(el);\n          }, resizingDurationMs);\n\n          this.resizeTimeouts.set(el, timeout);\n        } else {\n          // If no duration, immediately set isResizing to false\n          resizeState$.next({\n            width,\n            height,\n            isResizing: false,\n          });\n        }\n      });\n    });\n\n    // Start observing\n    resizeObserver.observe(el);\n    this.observers.set(el, resizeObserver);\n\n    // Return observable with debouncing if specified\n    const observable = resizeState$.asObservable().pipe(\n      debounceMs > 0 ? debounceTime(debounceMs) : (source) => source,\n      distinctUntilChanged(\n        (a, b) =>\n          a.width === b.width &&\n          a.height === b.height &&\n          a.isResizing === b.isResizing\n      ),\n      takeUntil(this.destroy$)\n    );\n\n    return observable;\n  }\n\n  /**\n   * Stop observing an element\n   * @param element Element to stop observing\n   */\n  unobserve(element: ElementRef<HTMLElement> | HTMLElement): void {\n    const el = element instanceof ElementRef ? element.nativeElement : element;\n\n    // Clear timeout if exists\n    const timeout = this.resizeTimeouts.get(el);\n    if (timeout) {\n      clearTimeout(timeout);\n      this.resizeTimeouts.delete(el);\n    }\n\n    // Disconnect observer\n    const observer = this.observers.get(el);\n    if (observer) {\n      observer.disconnect();\n      this.observers.delete(el);\n    }\n\n    // Complete and remove subject\n    const subject = this.resizeStates.get(el);\n    if (subject) {\n      subject.complete();\n      this.resizeStates.delete(el);\n    }\n  }\n\n  /**\n   * Get current size of element\n   * @param element Element to measure\n   */\n  getCurrentSize(element: ElementRef<HTMLElement> | HTMLElement): {\n    width: number;\n    height: number;\n  } {\n    const el = element instanceof ElementRef ? element.nativeElement : element;\n    return {\n      width: el.offsetWidth,\n      height: el.offsetHeight,\n    };\n  }\n\n  /**\n   * Get current resize state of element\n   * @param element Element to check\n   */\n  getCurrentState(\n    element: ElementRef<HTMLElement> | HTMLElement\n  ): ResizeState | null {\n    const el = element instanceof ElementRef ? element.nativeElement : element;\n    const subject = this.resizeStates.get(el);\n    return subject ? subject.value : null;\n  }\n\n  ngOnDestroy(): void {\n    // Clear all timeouts\n    this.resizeTimeouts.forEach((timeout) => clearTimeout(timeout));\n    this.resizeTimeouts.clear();\n\n    // Disconnect all observers\n    this.observers.forEach((observer) => observer.disconnect());\n    this.observers.clear();\n\n    // Complete all subjects\n    this.resizeStates.forEach((subject) => subject.complete());\n    this.resizeStates.clear();\n\n    // Complete destroy subject\n    this.destroy$.next();\n    this.destroy$.complete();\n  }\n}\n"]}

package/dist/esm2022/lib/scroll-position.mjs

@@ -0,0 +1,124 @@
+import { Injectable, ElementRef } from "@angular/core";
+import { Subject, BehaviorSubject, fromEvent, merge, animationFrameScheduler, } from "rxjs";
+import { takeUntil, debounceTime, throttleTime, distinctUntilChanged, map, startWith, } from "rxjs/operators";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/scrolling";
+export class ScrollPosition {
+    scrollDispatcher;
+    viewportRuler;
+    ngZone;
+    destroy$ = new Subject();
+    scrollStateSubject = new BehaviorSubject({
+        isAtBottom: true,
+        scrollTop: 0,
+        scrollHeight: 0,
+        clientHeight: 0,
+    });
+    scrollState$ = this.scrollStateSubject.asObservable();
+    constructor(scrollDispatcher, viewportRuler, ngZone) {
+        this.scrollDispatcher = scrollDispatcher;
+        this.viewportRuler = viewportRuler;
+        this.ngZone = ngZone;
+    }
+    /**
+     * Monitor scroll position of an element
+     * @param element The element to monitor
+     * @param threshold Pixels from bottom to consider "at bottom" (default 10)
+     */
+    monitorScrollPosition(element, threshold = 10) {
+        const el = element instanceof ElementRef ? element.nativeElement : element;
+        // Create scroll observable
+        const scroll$ = merge(fromEvent(el, "scroll"), this.viewportRuler.change(150) // Monitor viewport changes
+        ).pipe(startWith(null), // Emit initial state
+        throttleTime(16, animationFrameScheduler, { trailing: true }), // ~60fps
+        map(() => this.getScrollState(el, threshold)), distinctUntilChanged((a, b) => a.isAtBottom === b.isAtBottom &&
+            a.scrollTop === b.scrollTop &&
+            a.scrollHeight === b.scrollHeight), takeUntil(this.destroy$));
+        // Subscribe and update subject
+        scroll$.subscribe((state) => {
+            this.scrollStateSubject.next(state);
+        });
+        return scroll$;
+    }
+    /**
+     * Scroll element to bottom with smooth animation
+     * @param element The element to scroll
+     * @param smooth Whether to use smooth scrolling
+     */
+    scrollToBottom(element, smooth = true) {
+        const el = element instanceof ElementRef ? element.nativeElement : element;
+        this.ngZone.runOutsideAngular(() => {
+            if (smooth && "scrollBehavior" in document.documentElement.style) {
+                el.scrollTo({
+                    top: el.scrollHeight,
+                    behavior: "smooth",
+                });
+            }
+            else {
+                el.scrollTop = el.scrollHeight;
+            }
+        });
+    }
+    /**
+     * Check if element is at bottom
+     * @param element The element to check
+     * @param threshold Pixels from bottom to consider "at bottom"
+     */
+    isAtBottom(element, threshold = 10) {
+        const el = element instanceof ElementRef ? element.nativeElement : element;
+        return this.getScrollState(el, threshold).isAtBottom;
+    }
+    /**
+     * Get current scroll state of element
+     */
+    getScrollState(element, threshold) {
+        const scrollTop = element.scrollTop;
+        const scrollHeight = element.scrollHeight;
+        const clientHeight = element.clientHeight;
+        const distanceFromBottom = scrollHeight - scrollTop - clientHeight;
+        const isAtBottom = distanceFromBottom <= threshold;
+        return {
+            isAtBottom,
+            scrollTop,
+            scrollHeight,
+            clientHeight,
+        };
+    }
+    /**
+     * Create a ResizeObserver for element size changes
+     * @param element The element to observe
+     * @param debounceMs Debounce time in milliseconds
+     */
+    observeResize(element, debounceMs = 250) {
+        const el = element instanceof ElementRef ? element.nativeElement : element;
+        const resize$ = new Subject();
+        const resizeObserver = new ResizeObserver((entries) => {
+            const entry = entries[0];
+            if (entry) {
+                this.ngZone.run(() => {
+                    resize$.next(entry);
+                });
+            }
+        });
+        resizeObserver.observe(el);
+        // Cleanup on destroy
+        this.destroy$.subscribe(() => {
+            resizeObserver.disconnect();
+        });
+        return resize$.pipe(debounceTime(debounceMs), takeUntil(this.destroy$));
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.scrollStateSubject.complete();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollPosition, deps: [{ token: i1.ScrollDispatcher }, { token: i1.ViewportRuler }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollPosition, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollPosition, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: () => [{ type: i1.ScrollDispatcher }, { type: i1.ViewportRuler }, { type: i0.NgZone }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scroll-position.js","sourceRoot":"","sources":["../../../src/lib/scroll-position.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, ElementRef, NgZone, OnDestroy } from \"@angular/core\";\nimport { ScrollDispatcher, ViewportRuler } from \"@angular/cdk/scrolling\";\nimport {\n  Observable,\n  Subject,\n  BehaviorSubject,\n  fromEvent,\n  merge,\n  animationFrameScheduler,\n} from \"rxjs\";\nimport {\n  takeUntil,\n  debounceTime,\n  throttleTime,\n  distinctUntilChanged,\n  map,\n  startWith,\n} from \"rxjs/operators\";\n\nexport interface ScrollState {\n  isAtBottom: boolean;\n  scrollTop: number;\n  scrollHeight: number;\n  clientHeight: number;\n}\n\n@Injectable({\n  providedIn: \"root\",\n})\nexport class ScrollPosition implements OnDestroy {\n  private destroy$ = new Subject<void>();\n  private scrollStateSubject = new BehaviorSubject<ScrollState>({\n    isAtBottom: true,\n    scrollTop: 0,\n    scrollHeight: 0,\n    clientHeight: 0,\n  });\n\n  public scrollState$ = this.scrollStateSubject.asObservable();\n\n  constructor(\n    private scrollDispatcher: ScrollDispatcher,\n    private viewportRuler: ViewportRuler,\n    private ngZone: NgZone\n  ) {}\n\n  /**\n   * Monitor scroll position of an element\n   * @param element The element to monitor\n   * @param threshold Pixels from bottom to consider \"at bottom\" (default 10)\n   */\n  monitorScrollPosition(\n    element: ElementRef<HTMLElement> | HTMLElement,\n    threshold: number = 10\n  ): Observable<ScrollState> {\n    const el = element instanceof ElementRef ? element.nativeElement : element;\n\n    // Create scroll observable\n    const scroll$ = merge(\n      fromEvent(el, \"scroll\"),\n      this.viewportRuler.change(150) // Monitor viewport changes\n    ).pipe(\n      startWith(null), // Emit initial state\n      throttleTime(16, animationFrameScheduler, { trailing: true }), // ~60fps\n      map(() => this.getScrollState(el, threshold)),\n      distinctUntilChanged(\n        (a, b) =>\n          a.isAtBottom === b.isAtBottom &&\n          a.scrollTop === b.scrollTop &&\n          a.scrollHeight === b.scrollHeight\n      ),\n      takeUntil(this.destroy$)\n    );\n\n    // Subscribe and update subject\n    scroll$.subscribe((state) => {\n      this.scrollStateSubject.next(state);\n    });\n\n    return scroll$;\n  }\n\n  /**\n   * Scroll element to bottom with smooth animation\n   * @param element The element to scroll\n   * @param smooth Whether to use smooth scrolling\n   */\n  scrollToBottom(\n    element: ElementRef<HTMLElement> | HTMLElement,\n    smooth: boolean = true\n  ): void {\n    const el = element instanceof ElementRef ? element.nativeElement : element;\n\n    this.ngZone.runOutsideAngular(() => {\n      if (smooth && \"scrollBehavior\" in document.documentElement.style) {\n        el.scrollTo({\n          top: el.scrollHeight,\n          behavior: \"smooth\",\n        });\n      } else {\n        el.scrollTop = el.scrollHeight;\n      }\n    });\n  }\n\n  /**\n   * Check if element is at bottom\n   * @param element The element to check\n   * @param threshold Pixels from bottom to consider \"at bottom\"\n   */\n  isAtBottom(\n    element: ElementRef<HTMLElement> | HTMLElement,\n    threshold: number = 10\n  ): boolean {\n    const el = element instanceof ElementRef ? element.nativeElement : element;\n    return this.getScrollState(el, threshold).isAtBottom;\n  }\n\n  /**\n   * Get current scroll state of element\n   */\n  public getScrollState(element: HTMLElement, threshold: number): ScrollState {\n    const scrollTop = element.scrollTop;\n    const scrollHeight = element.scrollHeight;\n    const clientHeight = element.clientHeight;\n    const distanceFromBottom = scrollHeight - scrollTop - clientHeight;\n    const isAtBottom = distanceFromBottom <= threshold;\n\n    return {\n      isAtBottom,\n      scrollTop,\n      scrollHeight,\n      clientHeight,\n    };\n  }\n\n  /**\n   * Create a ResizeObserver for element size changes\n   * @param element The element to observe\n   * @param debounceMs Debounce time in milliseconds\n   */\n  observeResize(\n    element: ElementRef<HTMLElement> | HTMLElement,\n    debounceMs: number = 250\n  ): Observable<ResizeObserverEntry> {\n    const el = element instanceof ElementRef ? element.nativeElement : element;\n    const resize$ = new Subject<ResizeObserverEntry>();\n\n    const resizeObserver = new ResizeObserver((entries) => {\n      const entry = entries[0];\n      if (entry) {\n        this.ngZone.run(() => {\n          resize$.next(entry);\n        });\n      }\n    });\n\n    resizeObserver.observe(el);\n\n    // Cleanup on destroy\n    this.destroy$.subscribe(() => {\n      resizeObserver.disconnect();\n    });\n\n    return resize$.pipe(debounceTime(debounceMs), takeUntil(this.destroy$));\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$.next();\n    this.destroy$.complete();\n    this.scrollStateSubject.complete();\n  }\n}\n"]}

package/dist/esm2022/lib/slots/copilot-slot.mjs

@@ -0,0 +1,156 @@
+import { Component, TemplateRef, ViewContainerRef, Inject, ChangeDetectionStrategy, input, ViewChild, } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { renderSlot } from "./slot.utils";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * @internal - This component is for internal use only.
+ * Simple slot component for rendering custom content or defaults.
+ * Supports templates and components only.
+ *
+ * @example
+ * ```html
+ * <!-- With template -->
+ * <copilot-slot [slot]="sendButtonTemplate" [context]="buttonContext">
+ *   <button class="default-btn">Default</button>
+ * </copilot-slot>
+ * ```
+ */
+export class CopilotSlot {
+    viewContainer;
+    cdr;
+    slot = input(undefined);
+    context = input(undefined);
+    defaultComponent = input(undefined);
+    outputs = input(undefined);
+    slotContainer;
+    componentRef;
+    constructor(viewContainer, cdr) {
+        this.viewContainer = viewContainer;
+        this.cdr = cdr;
+    }
+    ngOnInit() {
+        this.renderSlot();
+    }
+    ngOnChanges(changes) {
+        if (changes["slot"]) {
+            // Slot changed, need to re-render completely
+            this.renderSlot();
+        }
+        else if (changes["context"] && this.componentRef) {
+            // Just context changed, update existing component
+            this.updateComponentProps();
+            this.cdr.detectChanges();
+        }
+        else if (changes["context"]) {
+            // No component ref yet, render the slot
+            this.renderSlot();
+        }
+    }
+    isTemplate(value) {
+        return value instanceof TemplateRef;
+    }
+    renderSlot() {
+        // Skip if it's a template (handled by ngTemplateOutlet)
+        if (this.slot() && this.isTemplate(this.slot())) {
+            this.componentRef = null;
+            return;
+        }
+        // Clear previous content
+        this.slotContainer.clear();
+        this.componentRef = null;
+        // Skip if no slot and no default component
+        if (!this.slot() && !this.defaultComponent()) {
+            return;
+        }
+        // Use the utility to render other slot types
+        if (this.slot() || this.defaultComponent()) {
+            this.componentRef = renderSlot(this.slotContainer, {
+                slot: this.slot(),
+                defaultComponent: this.defaultComponent(),
+                props: this.context(),
+                outputs: this.outputs(),
+            });
+        }
+    }
+    updateComponentProps() {
+        if (!this.componentRef || !this.componentRef.instance) {
+            return;
+        }
+        const props = this.context();
+        // Update props using setInput, only for declared inputs
+        if (props) {
+            const ctor = this.componentRef.instance.constructor;
+            const cmpDef = ctor?.ɵcmp;
+            const declaredInputs = new Set(Object.keys(cmpDef?.inputs ?? {}));
+            if (declaredInputs.has("props")) {
+                this.componentRef.setInput("props", props);
+            }
+            else {
+                for (const key in props) {
+                    if (declaredInputs.has(key)) {
+                        const value = props[key];
+                        this.componentRef.setInput(key, value);
+                    }
+                }
+            }
+        }
+        // Trigger change detection
+        if (this.componentRef.changeDetectorRef) {
+            this.componentRef.changeDetectorRef.detectChanges();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotSlot, deps: [{ token: ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: CopilotSlot, isStandalone: true, selector: "copilot-slot", inputs: { slot: { classPropertyName: "slot", publicName: "slot", isSignal: true, isRequired: false, transformFunction: null }, context: { classPropertyName: "context", publicName: "context", isSignal: true, isRequired: false, transformFunction: null }, defaultComponent: { classPropertyName: "defaultComponent", publicName: "defaultComponent", isSignal: true, isRequired: false, transformFunction: null }, outputs: { classPropertyName: "outputs", publicName: "outputs", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "slotContainer", first: true, predicate: ["slotContainer"], descendants: true, read: ViewContainerRef, static: true }], usesOnChanges: true, ngImport: i0, template: `
+    <!-- If slot template provided, render it -->
+    @if (slot() && isTemplate(slot)) {
+      <ng-container
+        [ngTemplateOutlet]="slot"
+        [ngTemplateOutletContext]="context || {}"
+      >
+      </ng-container>
+    }
+
+    <!-- If not a template, we'll handle in code -->
+    <ng-container #slotContainer></ng-container>
+
+    <!-- Default content (only shown if no slot) -->
+    @if (!slot && !defaultComponent) {
+      <ng-content></ng-content>
+    }
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CopilotSlot, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    selector: "copilot-slot",
+                    imports: [CommonModule],
+                    template: `
+    <!-- If slot template provided, render it -->
+    @if (slot() && isTemplate(slot)) {
+      <ng-container
+        [ngTemplateOutlet]="slot"
+        [ngTemplateOutletContext]="context || {}"
+      >
+      </ng-container>
+    }
+
+    <!-- If not a template, we'll handle in code -->
+    <ng-container #slotContainer></ng-container>
+
+    <!-- Default content (only shown if no slot) -->
+    @if (!slot && !defaultComponent) {
+      <ng-content></ng-content>
+    }
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [{ type: i0.ViewContainerRef, decorators: [{
+                    type: Inject,
+                    args: [ViewContainerRef]
+                }] }, { type: i0.ChangeDetectorRef }], propDecorators: { slotContainer: [{
+                type: ViewChild,
+                args: ["slotContainer", { read: ViewContainerRef, static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"copilot-slot.js","sourceRoot":"","sources":["../../../../src/lib/slots/copilot-slot.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  TemplateRef,\n  ViewContainerRef,\n  OnInit,\n  OnChanges,\n  SimpleChanges,\n  Inject,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  input,\n  ViewChild,\n} from \"@angular/core\";\nimport { CommonModule } from \"@angular/common\";\nimport { renderSlot } from \"./slot.utils\";\nimport { Type } from \"@angular/core\";\n\n/**\n * @internal - This component is for internal use only.\n * Simple slot component for rendering custom content or defaults.\n * Supports templates and components only.\n *\n * @example\n * ```html\n * <!-- With template -->\n * <copilot-slot [slot]=\"sendButtonTemplate\" [context]=\"buttonContext\">\n *   <button class=\"default-btn\">Default</button>\n * </copilot-slot>\n * ```\n */\n@Component({\n  standalone: true,\n  selector: \"copilot-slot\",\n  imports: [CommonModule],\n  template: `\n    <!-- If slot template provided, render it -->\n    @if (slot() && isTemplate(slot)) {\n      <ng-container\n        [ngTemplateOutlet]=\"slot\"\n        [ngTemplateOutletContext]=\"context || {}\"\n      >\n      </ng-container>\n    }\n\n    <!-- If not a template, we'll handle in code -->\n    <ng-container #slotContainer></ng-container>\n\n    <!-- Default content (only shown if no slot) -->\n    @if (!slot && !defaultComponent) {\n      <ng-content></ng-content>\n    }\n  `,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class CopilotSlot implements OnInit, OnChanges {\n  slot = input<TemplateRef<any> | Type<any> | undefined>(undefined);\n  context = input<any | undefined>(undefined);\n  defaultComponent = input<Type<any> | undefined>(undefined);\n  outputs = input<Record<string, (event: any) => void> | undefined>(undefined);\n\n  @ViewChild(\"slotContainer\", { read: ViewContainerRef, static: true })\n  private slotContainer!: ViewContainerRef;\n\n  private componentRef?: any;\n\n  constructor(\n    @Inject(ViewContainerRef) private viewContainer: ViewContainerRef,\n    private cdr: ChangeDetectorRef\n  ) {}\n\n  ngOnInit(): void {\n    this.renderSlot();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes[\"slot\"]) {\n      // Slot changed, need to re-render completely\n      this.renderSlot();\n    } else if (changes[\"context\"] && this.componentRef) {\n      // Just context changed, update existing component\n      this.updateComponentProps();\n      this.cdr.detectChanges();\n    } else if (changes[\"context\"]) {\n      // No component ref yet, render the slot\n      this.renderSlot();\n    }\n  }\n\n  isTemplate(value: any): value is TemplateRef<any> {\n    return value instanceof TemplateRef;\n  }\n\n  private renderSlot(): void {\n    // Skip if it's a template (handled by ngTemplateOutlet)\n    if (this.slot() && this.isTemplate(this.slot())) {\n      this.componentRef = null;\n      return;\n    }\n\n    // Clear previous content\n    this.slotContainer.clear();\n    this.componentRef = null;\n\n    // Skip if no slot and no default component\n    if (!this.slot() && !this.defaultComponent()) {\n      return;\n    }\n\n    // Use the utility to render other slot types\n    if (this.slot() || this.defaultComponent()) {\n      this.componentRef = renderSlot(this.slotContainer, {\n        slot: this.slot(),\n        defaultComponent: this.defaultComponent()!,\n        props: this.context(),\n        outputs: this.outputs(),\n      });\n    }\n  }\n\n  private updateComponentProps(): void {\n    if (!this.componentRef || !this.componentRef.instance) {\n      return;\n    }\n\n    const props = this.context();\n\n    // Update props using setInput, only for declared inputs\n    if (props) {\n      const ctor = this.componentRef.instance.constructor as any;\n      const cmpDef: any = ctor?.ɵcmp;\n      const declaredInputs = new Set<string>(Object.keys(cmpDef?.inputs ?? {}));\n\n      if (declaredInputs.has(\"props\")) {\n        this.componentRef.setInput(\"props\", props);\n      } else {\n        for (const key in props) {\n          if (declaredInputs.has(key)) {\n            const value = props[key];\n            this.componentRef.setInput(key, value);\n          }\n        }\n      }\n    }\n\n    // Trigger change detection\n    if (this.componentRef.changeDetectorRef) {\n      this.componentRef.changeDetectorRef.detectChanges();\n    }\n  }\n}\n"]}

package/dist/esm2022/lib/slots/index.mjs

@@ -0,0 +1,4 @@
+export * from "./slot.types";
+export * from "./slot.utils";
+export { CopilotSlot } from "./copilot-slot";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3Nsb3RzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL3Nsb3QudHlwZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3Nsb3QudXRpbHNcIjtcbmV4cG9ydCB7IENvcGlsb3RTbG90IH0gZnJvbSBcIi4vY29waWxvdC1zbG90XCI7XG4iXX0=

package/dist/esm2022/lib/slots/slot.types.mjs

@@ -1,6 +1,6 @@
-import { InjectionToken } from '@angular/core';
+import { InjectionToken } from "@angular/core";
 /**
  * Injection token for slot configuration
  */
-export const SLOT_CONFIG = new InjectionToken('SLOT_CONFIG');
-//# sourceMappingURL=data:application/json;base64,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
+export const SLOT_CONFIG = new InjectionToken("SLOT_CONFIG");
+//# sourceMappingURL=data:application/json;base64,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