@copilotkitnext/angular 0.0.2 → 0.0.5

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

@@ -0,0 +1,144 @@
+import { Component, Input, TemplateRef, ViewContainerRef, Inject, ChangeDetectionStrategy, 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 CopilotSlotComponent {
+    viewContainer;
+    cdr;
+    slot;
+    context;
+    defaultComponent;
+    outputs;
+    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
+        if (props) {
+            for (const key in props) {
+                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: CopilotSlotComponent, deps: [{ token: ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: CopilotSlotComponent, isStandalone: true, selector: "copilot-slot", inputs: { slot: "slot", context: "context", defaultComponent: "defaultComponent", outputs: "outputs" }, viewQueries: [{ propertyName: "slotContainer", first: true, predicate: ["slotContainer"], descendants: true, read: ViewContainerRef, static: true }], usesOnChanges: true, ngImport: i0, template: `
+    <!-- If slot template provided, render it -->
+    <ng-container *ngIf="slot && isTemplate(slot)"
+                  [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) -->
+    <ng-content *ngIf="!slot && !defaultComponent"></ng-content>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { 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: CopilotSlotComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'copilot-slot',
+                    standalone: true,
+                    imports: [CommonModule],
+                    template: `
+    <!-- If slot template provided, render it -->
+    <ng-container *ngIf="slot && isTemplate(slot)"
+                  [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) -->
+    <ng-content *ngIf="!slot && !defaultComponent"></ng-content>
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: () => [{ type: i0.ViewContainerRef, decorators: [{
+                    type: Inject,
+                    args: [ViewContainerRef]
+                }] }, { type: i0.ChangeDetectorRef }], propDecorators: { slot: [{
+                type: Input
+            }], context: [{
+                type: Input
+            }], defaultComponent: [{
+                type: Input
+            }], outputs: [{
+                type: Input
+            }], slotContainer: [{
+                type: ViewChild,
+                args: ['slotContainer', { read: ViewContainerRef, static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"copilot-slot.component.js","sourceRoot":"","sources":["../../../../src/lib/slots/copilot-slot.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  TemplateRef,\n  ViewContainerRef,\n  OnInit,\n  OnChanges,\n  SimpleChanges,\n  Inject,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\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  selector: 'copilot-slot',\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <!-- If slot template provided, render it -->\n    <ng-container *ngIf=\"slot && isTemplate(slot)\"\n                  [ngTemplateOutlet]=\"slot\"\n                  [ngTemplateOutletContext]=\"context || {}\">\n    </ng-container>\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    <ng-content *ngIf=\"!slot && !defaultComponent\"></ng-content>\n  `,\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class CopilotSlotComponent implements OnInit, OnChanges {\n  @Input() slot?: TemplateRef<any> | Type<any>;\n  @Input() context?: any;\n  @Input() defaultComponent?: Type<any>;\n  @Input() outputs?: Record<string, (event: any) => void>;\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\n    if (props) {\n      for (const key in props) {\n        const value = props[key];\n        this.componentRef.setInput(key, value);\n      }\n    }\n    \n    // Trigger change detection\n    if (this.componentRef.changeDetectorRef) {\n      this.componentRef.changeDetectorRef.detectChanges();\n    }\n  }\n}"]}

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

@@ -0,0 +1,6 @@
+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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

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

@@ -0,0 +1,222 @@
+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
+        for (const key in props) {
+            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({
+ *   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({
+ *   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 { SlotValue, RenderSlotOptions, SlotRegistryEntry, SLOT_CONFIG } 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 ? createComponent(\n    viewContainer,\n    defaultComponent,\n    props,\n    effectiveInjector,\n    outputs\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\n    for (const key in props) {\n      const value = props[key];\n      componentRef.setInput(key, value);\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/**\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 *   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 *   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}"]}

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQW1CLE1BQU0sTUFBTSxDQUFDO0FBQzdDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUV6Qzs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsRUFBRSxDQUFDLEdBQUcsTUFBb0I7SUFDeEMsT0FBTyxPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7QUFDL0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNsc3gsIHR5cGUgQ2xhc3NWYWx1ZSB9IGZyb20gJ2Nsc3gnO1xuaW1wb3J0IHsgdHdNZXJnZSB9IGZyb20gJ3RhaWx3aW5kLW1lcmdlJztcblxuLyoqXG4gKiBVdGlsaXR5IGZ1bmN0aW9uIHRvIG1lcmdlIFRhaWx3aW5kIENTUyBjbGFzc2VzXG4gKiBDb21iaW5lcyBjbHN4IGZvciBjb25kaXRpb25hbCBjbGFzc2VzIGFuZCB0YWlsd2luZC1tZXJnZSBmb3IgcHJvcGVyIFRhaWx3aW5kIGNsYXNzIG1lcmdpbmdcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNuKC4uLmlucHV0czogQ2xhc3NWYWx1ZVtdKSB7XG4gIHJldHVybiB0d01lcmdlKGNsc3goaW5wdXRzKSk7XG59Il19

package/dist/esm2022/services/resize-observer.service.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.service.js","sourceRoot":"","sources":["../../../src/services/resize-observer.service.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((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): { width: number; height: number } {\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(element: ElementRef<HTMLElement> | HTMLElement): 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}"]}