@copilotkitnext/angular 0.0.0-max-changeset-20260109174803

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

@@ -0,0 +1,235 @@
+import { TemplateRef, inject, } from "@angular/core";
+import { SLOT_CONFIG, } from "./slot.types";
+/**
+ * Renders a slot value into a ViewContainerRef.
+ * This is the core utility for slot rendering.
+ *
+ * @param viewContainer - The ViewContainerRef to render into
+ * @param options - Options for rendering the slot
+ * @returns The created component or embedded view reference
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent {
+ *   @ViewChild('container', { read: ViewContainerRef }) container!: ViewContainerRef;
+ *
+ *   renderButton() {
+ *     renderSlot(this.container, {
+ *       slot: this.buttonOverride,
+ *       defaultComponent: DefaultButton,
+ *       props: { text: 'Click me' },
+ *       outputs: { click: (event) => this.handleClick(event) }
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export function renderSlot(viewContainer, options) {
+    const { slot, defaultComponent, props, injector, outputs } = options;
+    viewContainer.clear();
+    const effectiveSlot = slot ?? defaultComponent;
+    const effectiveInjector = injector ?? viewContainer.injector;
+    if (effectiveSlot instanceof TemplateRef) {
+        // TemplateRef: render template
+        return viewContainer.createEmbeddedView(effectiveSlot, {
+            $implicit: props ?? {},
+            props: props ?? {},
+        });
+    }
+    else if (isComponentType(effectiveSlot)) {
+        // Component type - wrap in try/catch for safety
+        try {
+            return createComponent(viewContainer, effectiveSlot, props, effectiveInjector, outputs);
+        }
+        catch (error) {
+            console.warn("Failed to create component:", effectiveSlot, error);
+            // Fall through to default component
+        }
+    }
+    // Default: render default component if provided
+    return defaultComponent
+        ? createComponent(viewContainer, defaultComponent, props, effectiveInjector, outputs)
+        : null;
+}
+/**
+ * Creates a component and applies properties.
+ */
+function createComponent(viewContainer, component, props, injector, outputs) {
+    const componentRef = viewContainer.createComponent(component, {
+        injector,
+    });
+    if (props) {
+        // Apply props using setInput, but only for declared inputs
+        const cmpDef = component.ɵcmp;
+        const declaredInputs = new Set(Object.keys(cmpDef?.inputs ?? {}));
+        if (declaredInputs.has("props")) {
+            componentRef.setInput("props", props);
+        }
+        else {
+            for (const key in props) {
+                if (declaredInputs.has(key)) {
+                    const value = props[key];
+                    componentRef.setInput(key, value);
+                }
+            }
+        }
+    }
+    if (outputs) {
+        // Wire up output event handlers with proper cleanup
+        const instance = componentRef.instance;
+        const subscriptions = [];
+        for (const [eventName, handler] of Object.entries(outputs)) {
+            if (instance[eventName]?.subscribe) {
+                const subscription = instance[eventName].subscribe(handler);
+                subscriptions.push(subscription);
+            }
+        }
+        // Register cleanup on component destroy
+        componentRef.onDestroy(() => {
+            subscriptions.forEach((sub) => sub.unsubscribe());
+        });
+    }
+    // Trigger change detection
+    componentRef.changeDetectorRef.detectChanges();
+    return componentRef;
+}
+/**
+ * Checks if a value is a component type.
+ * Simplified check - rely on try/catch for actual validation.
+ */
+export function isComponentType(value) {
+    // Arrow functions and regular functions without a prototype are not components
+    return typeof value === "function" && !!value.prototype;
+}
+/**
+ * Checks if a value is a valid slot value.
+ */
+export function isSlotValue(value) {
+    return value instanceof TemplateRef || isComponentType(value);
+}
+/**
+ * Normalizes a slot value to a consistent format.
+ */
+export function normalizeSlotValue(value, defaultComponent) {
+    if (!value) {
+        return { component: defaultComponent };
+    }
+    if (value instanceof TemplateRef) {
+        return { template: value };
+    }
+    if (isComponentType(value)) {
+        return { component: value };
+    }
+    return { component: defaultComponent };
+}
+/**
+ * Creates a slot configuration map for a component.
+ *
+ * @example
+ * ```typescript
+ * const slots = createSlotConfig({
+    standalone: true,
+*   sendButton: CustomSendButton,
+ *   toolbar: 'custom-toolbar-class',
+ *   footer: footerTemplate
+ * }, {
+ *   sendButton: DefaultSendButton,
+ *   toolbar: DefaultToolbar,
+ *   footer: DefaultFooter
+ * });
+ * ```
+ */
+export function createSlotConfig(overrides, defaults) {
+    const config = new Map();
+    for (const key in defaults) {
+        const override = overrides[key];
+        const defaultComponent = defaults[key];
+        config.set(key, normalizeSlotValue(override, defaultComponent));
+    }
+    return config;
+}
+/**
+ * Provides slot configuration to child components via DI.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+  standalone: true,
+*   providers: [
+ *     provideSlots({
+ *       sendButton: CustomSendButton,
+ *       toolbar: CustomToolbar
+ *     })
+ *   ]
+ * })
+ * ```
+ */
+export function provideSlots(slots) {
+    const slotMap = new Map();
+    // Only accept component types in DI (templates lack view context)
+    for (const [key, value] of Object.entries(slots)) {
+        if (isComponentType(value)) {
+            slotMap.set(key, { component: value });
+        }
+    }
+    return {
+        provide: SLOT_CONFIG,
+        useValue: slotMap,
+    };
+}
+/**
+ * Gets slot configuration from DI.
+ * Must be called within an injection context.
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent {
+ *   slots = getSlotConfig();
+ *
+ *   ngOnInit() {
+ *     const sendButton = this.slots?.get('sendButton');
+ *   }
+ * }
+ * ```
+ */
+export function getSlotConfig() {
+    return inject(SLOT_CONFIG, { optional: true });
+}
+/**
+ * Creates a render function for a specific slot.
+ * Useful for creating reusable slot renderers.
+ *
+ * @example
+ * ```typescript
+ * const renderSendButton = createSlotRenderer(
+ *   DefaultSendButton,
+ *   'sendButton'
+ * );
+ *
+ * // Later in template
+ * renderSendButton(this.viewContainer, this.sendButtonOverride);
+ * ```
+ */
+export function createSlotRenderer(defaultComponent, slotName) {
+    // Get config in the injection context when the renderer is created
+    const config = slotName ? getSlotConfig() : null;
+    return (viewContainer, slot, props, outputs) => {
+        // Check DI for overrides if slot name provided
+        if (slotName && !slot && config) {
+            const entry = config.get(slotName);
+            if (entry) {
+                if (entry.component)
+                    slot = entry.component;
+                else if (entry.template)
+                    slot = entry.template;
+            }
+        }
+        return renderSlot(viewContainer, {
+            slot,
+            defaultComponent,
+            props,
+            outputs,
+        });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slot.utils.js","sourceRoot":"","sources":["../../../../src/lib/slots/slot.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Type,\n  TemplateRef,\n  ViewContainerRef,\n  ComponentRef,\n  EmbeddedViewRef,\n  Injector,\n  inject,\n} from \"@angular/core\";\nimport {\n  SlotValue,\n  RenderSlotOptions,\n  SlotRegistryEntry,\n  SLOT_CONFIG,\n} from \"./slot.types\";\n\n/**\n * Renders a slot value into a ViewContainerRef.\n * This is the core utility for slot rendering.\n *\n * @param viewContainer - The ViewContainerRef to render into\n * @param options - Options for rendering the slot\n * @returns The created component or embedded view reference\n *\n * @example\n * ```typescript\n * export class MyComponent {\n *   @ViewChild('container', { read: ViewContainerRef }) container!: ViewContainerRef;\n *\n *   renderButton() {\n *     renderSlot(this.container, {\n *       slot: this.buttonOverride,\n *       defaultComponent: DefaultButton,\n *       props: { text: 'Click me' },\n *       outputs: { click: (event) => this.handleClick(event) }\n *     });\n *   }\n * }\n * ```\n */\nexport function renderSlot<T = any>(\n  viewContainer: ViewContainerRef,\n  options: RenderSlotOptions<T>\n): ComponentRef<T> | EmbeddedViewRef<T> | null {\n  const { slot, defaultComponent, props, injector, outputs } = options;\n\n  viewContainer.clear();\n\n  const effectiveSlot = slot ?? defaultComponent;\n  const effectiveInjector = injector ?? viewContainer.injector;\n\n  if (effectiveSlot instanceof TemplateRef) {\n    // TemplateRef: render template\n    return viewContainer.createEmbeddedView(effectiveSlot, {\n      $implicit: props ?? {},\n      props: props ?? {},\n    } as any);\n  } else if (isComponentType(effectiveSlot)) {\n    // Component type - wrap in try/catch for safety\n    try {\n      return createComponent(\n        viewContainer,\n        effectiveSlot as Type<T>,\n        props,\n        effectiveInjector,\n        outputs\n      );\n    } catch (error) {\n      console.warn(\"Failed to create component:\", effectiveSlot, error);\n      // Fall through to default component\n    }\n  }\n\n  // Default: render default component if provided\n  return defaultComponent\n    ? createComponent(\n        viewContainer,\n        defaultComponent,\n        props,\n        effectiveInjector,\n        outputs\n      )\n    : null;\n}\n\n/**\n * Creates a component and applies properties.\n */\nfunction createComponent<T>(\n  viewContainer: ViewContainerRef,\n  component: Type<T>,\n  props?: Partial<T>,\n  injector?: Injector,\n  outputs?: Record<string, (event: any) => void>\n): ComponentRef<T> {\n  const componentRef = viewContainer.createComponent(component, {\n    injector,\n  });\n\n  if (props) {\n    // Apply props using setInput, but only for declared inputs\n    const cmpDef: any = (component as any).ɵcmp;\n    const declaredInputs = new Set<string>(Object.keys(cmpDef?.inputs ?? {}));\n\n    if (declaredInputs.has(\"props\")) {\n      componentRef.setInput(\"props\", props as any);\n    } else {\n      for (const key in props) {\n        if (declaredInputs.has(key)) {\n          const value = (props as any)[key];\n          componentRef.setInput(key, value);\n        }\n      }\n    }\n  }\n\n  if (outputs) {\n    // Wire up output event handlers with proper cleanup\n    const instance = componentRef.instance as any;\n    const subscriptions: any[] = [];\n\n    for (const [eventName, handler] of Object.entries(outputs)) {\n      if (instance[eventName]?.subscribe) {\n        const subscription = instance[eventName].subscribe(handler);\n        subscriptions.push(subscription);\n      }\n    }\n\n    // Register cleanup on component destroy\n    componentRef.onDestroy(() => {\n      subscriptions.forEach((sub) => sub.unsubscribe());\n    });\n  }\n\n  // Trigger change detection\n  componentRef.changeDetectorRef.detectChanges();\n\n  return componentRef;\n}\n\n/**\n * Checks if a value is a component type.\n * Simplified check - rely on try/catch for actual validation.\n */\nexport function isComponentType(value: any): boolean {\n  // Arrow functions and regular functions without a prototype are not components\n  return typeof value === \"function\" && !!value.prototype;\n}\n\n/**\n * Checks if a value is a valid slot value.\n */\nexport function isSlotValue(value: any): value is SlotValue {\n  return value instanceof TemplateRef || isComponentType(value);\n}\n\n/**\n * Normalizes a slot value to a consistent format.\n */\nexport function normalizeSlotValue<T = any>(\n  value: SlotValue<T> | undefined,\n  defaultComponent: Type<T> | undefined\n): SlotRegistryEntry<T> {\n  if (!value) {\n    return { component: defaultComponent };\n  }\n\n  if (value instanceof TemplateRef) {\n    return { template: value };\n  }\n\n  if (isComponentType(value)) {\n    return { component: value as Type<T> };\n  }\n\n  return { component: defaultComponent };\n}\n\n/**\n * Creates a slot configuration map for a component.\n * \n * @example\n * ```typescript\n * const slots = createSlotConfig({\n    standalone: true,\n*   sendButton: CustomSendButton,\n *   toolbar: 'custom-toolbar-class',\n *   footer: footerTemplate\n * }, {\n *   sendButton: DefaultSendButton,\n *   toolbar: DefaultToolbar,\n *   footer: DefaultFooter\n * });\n * ```\n */\nexport function createSlotConfig<T extends Record<string, Type<any>>>(\n  overrides: Partial<Record<keyof T, SlotValue>>,\n  defaults: T\n): Map<keyof T, SlotRegistryEntry> {\n  const config = new Map<keyof T, SlotRegistryEntry>();\n\n  for (const key in defaults) {\n    const override = overrides[key];\n    const defaultComponent = defaults[key];\n    config.set(key, normalizeSlotValue(override, defaultComponent));\n  }\n\n  return config;\n}\n\n/**\n * Provides slot configuration to child components via DI.\n * \n * @example\n * ```typescript\n * @Component({\n  standalone: true,\n*   providers: [\n *     provideSlots({\n *       sendButton: CustomSendButton,\n *       toolbar: CustomToolbar\n *     })\n *   ]\n * })\n * ```\n */\nexport function provideSlots(slots: Record<string, Type<any>>) {\n  const slotMap = new Map<string, SlotRegistryEntry>();\n\n  // Only accept component types in DI (templates lack view context)\n  for (const [key, value] of Object.entries(slots)) {\n    if (isComponentType(value)) {\n      slotMap.set(key, { component: value as Type<any> });\n    }\n  }\n\n  return {\n    provide: SLOT_CONFIG,\n    useValue: slotMap,\n  };\n}\n\n/**\n * Gets slot configuration from DI.\n * Must be called within an injection context.\n *\n * @example\n * ```typescript\n * export class MyComponent {\n *   slots = getSlotConfig();\n *\n *   ngOnInit() {\n *     const sendButton = this.slots?.get('sendButton');\n *   }\n * }\n * ```\n */\nexport function getSlotConfig(): ReadonlyMap<string, SlotRegistryEntry> | null {\n  return inject(SLOT_CONFIG, { optional: true });\n}\n\n/**\n * Creates a render function for a specific slot.\n * Useful for creating reusable slot renderers.\n *\n * @example\n * ```typescript\n * const renderSendButton = createSlotRenderer(\n *   DefaultSendButton,\n *   'sendButton'\n * );\n *\n * // Later in template\n * renderSendButton(this.viewContainer, this.sendButtonOverride);\n * ```\n */\nexport function createSlotRenderer<T>(\n  defaultComponent: Type<T>,\n  slotName?: string\n) {\n  // Get config in the injection context when the renderer is created\n  const config = slotName ? getSlotConfig() : null;\n\n  return (\n    viewContainer: ViewContainerRef,\n    slot?: SlotValue<T>,\n    props?: Partial<T>,\n    outputs?: Record<string, (event: any) => void>\n  ) => {\n    // Check DI for overrides if slot name provided\n    if (slotName && !slot && config) {\n      const entry = config.get(slotName);\n      if (entry) {\n        if (entry.component) slot = entry.component;\n        else if (entry.template) slot = entry.template;\n      }\n    }\n\n    return renderSlot(viewContainer, {\n      slot,\n      defaultComponent,\n      props,\n      outputs,\n    });\n  };\n}\n"]}

package/dist/esm2022/lib/tools.mjs

@@ -0,0 +1,31 @@
+import { DestroyRef, Injector, inject } from "@angular/core";
+import { CopilotKit } from "./copilotkit";
+export function registerRenderToolCall(renderToolCall) {
+    const copilotKit = inject(CopilotKit);
+    const destroyRef = inject(DestroyRef);
+    copilotKit.addRenderToolCall(renderToolCall);
+    destroyRef.onDestroy(() => {
+        copilotKit.removeTool(renderToolCall.name, renderToolCall.agentId);
+    });
+}
+export function registerFrontendTool(frontendTool) {
+    const injector = inject(Injector);
+    const destroyRef = inject(DestroyRef);
+    const copilotKit = inject(CopilotKit);
+    copilotKit.addFrontendTool({
+        ...frontendTool,
+        injector,
+    });
+    destroyRef.onDestroy(() => {
+        copilotKit.removeTool(frontendTool.name);
+    });
+}
+export function registerHumanInTheLoop(humanInTheLoop) {
+    const destroyRef = inject(DestroyRef);
+    const copilotKit = inject(CopilotKit);
+    copilotKit.addHumanInTheLoop(humanInTheLoop);
+    destroyRef.onDestroy(() => {
+        copilotKit.removeTool(humanInTheLoop.name);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/utils.mjs

@@ -0,0 +1,10 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+/**
+ * Utility function to merge Tailwind CSS classes
+ * Combines clsx for conditional classes and tailwind-merge for proper Tailwind class merging
+ */
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQW1CLE1BQU0sTUFBTSxDQUFDO0FBQzdDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUV6Qzs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsRUFBRSxDQUFDLEdBQUcsTUFBb0I7SUFDeEMsT0FBTyxPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7QUFDL0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNsc3gsIHR5cGUgQ2xhc3NWYWx1ZSB9IGZyb20gXCJjbHN4XCI7XG5pbXBvcnQgeyB0d01lcmdlIH0gZnJvbSBcInRhaWx3aW5kLW1lcmdlXCI7XG5cbi8qKlxuICogVXRpbGl0eSBmdW5jdGlvbiB0byBtZXJnZSBUYWlsd2luZCBDU1MgY2xhc3Nlc1xuICogQ29tYmluZXMgY2xzeCBmb3IgY29uZGl0aW9uYWwgY2xhc3NlcyBhbmQgdGFpbHdpbmQtbWVyZ2UgZm9yIHByb3BlciBUYWlsd2luZCBjbGFzcyBtZXJnaW5nXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjbiguLi5pbnB1dHM6IENsYXNzVmFsdWVbXSkge1xuICByZXR1cm4gdHdNZXJnZShjbHN4KGlucHV0cykpO1xufVxuIl19

package/dist/esm2022/public-api.mjs

@@ -0,0 +1,48 @@
+export * from "./lib/config";
+export * from "./lib/copilotkit";
+export * from "./lib/tools";
+export * from "./lib/render-tool-calls";
+export * from "./lib/agent";
+export * from "./lib/chat-config";
+export * from "./lib/chat-state";
+export * from "./lib/scroll-position";
+export * from "./lib/resize-observer";
+export * from "./lib/utils";
+export * from "./lib/agent-context";
+export * from "./lib/slots";
+export * from "./lib/directives/copilotkit-agent-context";
+export * from "./lib/directives/stick-to-bottom";
+export * from "./lib/directives/tooltip";
+export * from "./lib/components/chat/copilot-chat";
+export * from "./lib/components/chat/copilot-chat-assistant-message";
+export * from "./lib/components/chat/copilot-chat-assistant-message-buttons";
+export * from "./lib/components/chat/copilot-chat-assistant-message-renderer";
+export * from "./lib/components/chat/copilot-chat-assistant-message-toolbar";
+export * from "./lib/components/chat/copilot-chat-assistant-message.types";
+export * from "./lib/components/chat/copilot-chat-audio-recorder";
+export * from "./lib/components/chat/copilot-chat-buttons";
+export * from "./lib/components/chat/copilot-chat-input";
+export * from "./lib/components/chat/copilot-chat-input-defaults";
+export * from "./lib/components/chat/copilot-chat-input.types";
+export * from "./lib/components/chat/copilot-chat-message-view";
+export * from "./lib/components/chat/copilot-chat-message-view-cursor";
+export * from "./lib/components/chat/copilot-chat-message-view.types";
+export * from "./lib/components/chat/copilot-chat-textarea";
+export * from "./lib/components/chat/copilot-chat-tool-calls-view";
+export * from "./lib/components/chat/copilot-chat-toolbar";
+export * from "./lib/components/chat/copilot-chat-tools-menu";
+export * from "./lib/components/chat/copilot-chat-user-message";
+export * from "./lib/components/chat/copilot-chat-user-message-branch-navigation";
+export * from "./lib/components/chat/copilot-chat-user-message-buttons";
+export * from "./lib/components/chat/copilot-chat-user-message-renderer";
+export * from "./lib/components/chat/copilot-chat-user-message-toolbar";
+export * from "./lib/components/chat/copilot-chat-user-message.types";
+export * from "./lib/components/chat/copilot-chat-view";
+export * from "./lib/components/chat/copilot-chat-view-disclaimer";
+export * from "./lib/components/chat/copilot-chat-view-feather";
+export * from "./lib/components/chat/copilot-chat-view-handlers";
+export * from "./lib/components/chat/copilot-chat-view-input-container";
+export * from "./lib/components/chat/copilot-chat-view-scroll-to-bottom-button";
+export * from "./lib/components/chat/copilot-chat-view-scroll-view";
+export * from "./lib/components/chat/copilot-chat-view.types";
+//# sourceMappingURL=data:application/json;base64,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