@pillar-ai/angular 0.1.11

package/dist/esm2022/lib/pillar-panel.component.mjs

@@ -0,0 +1,80 @@
+/**
+ * PillarPanelComponent
+ * Renders the Pillar help panel at a custom location in the DOM
+ */
+import { Component, ViewChild, inject, effect, input, ChangeDetectionStrategy, } from '@angular/core';
+import { PillarService } from './pillar.service';
+import * as i0 from "@angular/core";
+/**
+ * Renders the Pillar help panel at a custom location in the DOM.
+ * Use this when you want to control where the panel is rendered instead of
+ * having it automatically appended to document.body.
+ *
+ * **Important**: When using this component, set `panel.container: 'manual'` in your
+ * Pillar configuration to prevent automatic mounting.
+ *
+ * @example
+ * ```typescript
+ * // app.config.ts
+ * function initPillar() {
+ *   const pillar = inject(PillarService);
+ *   return () => pillar.init({
+ *     productKey: 'your-product-key',
+ *     config: { panel: { container: 'manual' } }
+ *   });
+ * }
+ *
+ * // layout.component.ts
+ * @Component({
+ *   selector: 'app-layout',
+ *   standalone: true,
+ *   imports: [PillarPanelComponent],
+ *   template: `
+ *     <div class="layout">
+ *       <app-sidebar />
+ *       <pillar-panel class="help-panel-container" />
+ *       <main>
+ *         <router-outlet />
+ *       </main>
+ *     </div>
+ *   `,
+ * })
+ * export class LayoutComponent {}
+ * ```
+ */
+export class PillarPanelComponent {
+    containerRef;
+    pillarService = inject(PillarService);
+    hasMounted = false;
+    effectRef = null;
+    /**
+     * Optional class to add to the container element.
+     * Use host binding for styling instead if possible.
+     */
+    containerClass = input('');
+    ngAfterViewInit() {
+        // Use effect to react to isReady signal changes
+        this.effectRef = effect(() => {
+            const isReady = this.pillarService.isReady();
+            if (isReady && !this.hasMounted && this.containerRef?.nativeElement) {
+                this.pillarService.mountPanelTo(this.containerRef.nativeElement);
+                this.hasMounted = true;
+            }
+        });
+    }
+    ngOnDestroy() {
+        // Effect is automatically cleaned up when component is destroyed
+        // Panel cleanup is handled by PillarService
+        this.effectRef?.destroy();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PillarPanelComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "17.3.12", type: PillarPanelComponent, isStandalone: true, selector: "pillar-panel", inputs: { containerClass: { classPropertyName: "containerClass", publicName: "containerClass", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "containerRef", first: true, predicate: ["container"], descendants: true, static: true }], ngImport: i0, template: '<div #container data-pillar-panel-container></div>', isInline: true, styles: [":host{display:block}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PillarPanelComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'pillar-panel', standalone: true, template: '<div #container data-pillar-panel-container></div>', changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { containerRef: [{
+                type: ViewChild,
+                args: ['container', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/pillar.service.mjs

@@ -0,0 +1,308 @@
+/**
+ * PillarService
+ * Angular service that initializes and manages the Pillar SDK
+ */
+import { Injectable, NgZone, signal, computed, inject, createComponent, ApplicationRef, EnvironmentInjector, } from '@angular/core';
+import { Pillar, } from '@pillar-ai/sdk';
+import * as i0 from "@angular/core";
+export class PillarService {
+    ngZone = inject(NgZone);
+    appRef = inject(ApplicationRef);
+    environmentInjector = inject(EnvironmentInjector);
+    // Internal state
+    _pillar = signal(null);
+    cleanupFns = [];
+    cardRefs = new Map();
+    onTaskCallback = null;
+    registeredCards = null;
+    // Public signals
+    state = signal('uninitialized');
+    isReady = computed(() => this.state() === 'ready');
+    isPanelOpen = signal(false);
+    /**
+     * Get the Pillar SDK instance.
+     */
+    getInstance() {
+        return this._pillar();
+    }
+    /**
+     * Initialize the Pillar SDK.
+     * Call this in your app's initialization (e.g., APP_INITIALIZER).
+     *
+     * @param initConfig - Configuration options
+     */
+    async init(initConfig) {
+        const { productKey, helpCenter, config, onTask, cards } = initConfig;
+        // Support both productKey (new) and helpCenter (deprecated)
+        const resolvedKey = productKey ?? helpCenter;
+        if (helpCenter && !productKey) {
+            console.warn('[Pillar Angular] "helpCenter" is deprecated. Use "productKey" instead.');
+        }
+        // Store callbacks for later use
+        this.onTaskCallback = onTask ?? null;
+        this.registeredCards = cards ?? null;
+        try {
+            // Pillar is a singleton - check if already initialized
+            const existingInstance = Pillar.getInstance();
+            if (existingInstance) {
+                // Reuse existing instance (preserves chat history, panel state, etc.)
+                this._pillar.set(existingInstance);
+                this.state.set(existingInstance.state);
+                this.subscribeToEvents(existingInstance);
+                this.registerCards(existingInstance);
+                return;
+            }
+            // Initialize new instance
+            const instance = await Pillar.init({
+                productKey: resolvedKey,
+                ...config,
+            });
+            this.ngZone.run(() => {
+                this._pillar.set(instance);
+                this.state.set(instance.state);
+            });
+            this.subscribeToEvents(instance);
+            this.registerCards(instance);
+        }
+        catch (error) {
+            console.error('[Pillar Angular] Failed to initialize:', error);
+            this.ngZone.run(() => {
+                this.state.set('error');
+            });
+            throw error;
+        }
+    }
+    /**
+     * Subscribe to SDK events and sync to Angular signals.
+     */
+    subscribeToEvents(instance) {
+        // Panel open/close events
+        const unsubOpen = instance.on('panel:open', () => {
+            this.ngZone.run(() => {
+                this.isPanelOpen.set(true);
+            });
+        });
+        this.cleanupFns.push(unsubOpen);
+        const unsubClose = instance.on('panel:close', () => {
+            this.ngZone.run(() => {
+                this.isPanelOpen.set(false);
+            });
+        });
+        this.cleanupFns.push(unsubClose);
+        // State change events
+        const unsubReady = instance.on('ready', () => {
+            this.ngZone.run(() => {
+                this.state.set('ready');
+            });
+        });
+        this.cleanupFns.push(unsubReady);
+        const unsubError = instance.on('error', () => {
+            this.ngZone.run(() => {
+                this.state.set('error');
+            });
+        });
+        this.cleanupFns.push(unsubError);
+        // Task execution events
+        if (this.onTaskCallback) {
+            const callback = this.onTaskCallback;
+            const unsubTask = instance.on('task:execute', (task) => {
+                this.ngZone.run(() => {
+                    callback(task);
+                });
+            });
+            this.cleanupFns.push(unsubTask);
+        }
+    }
+    /**
+     * Register custom card components.
+     */
+    registerCards(instance) {
+        if (!this.registeredCards)
+            return;
+        Object.entries(this.registeredCards).forEach(([cardType, CardComponent]) => {
+            const unsubscribe = instance.registerCard(cardType, (container, data, callbacks) => {
+                // Create an Angular component dynamically
+                const componentRef = createComponent(CardComponent, {
+                    environmentInjector: this.environmentInjector,
+                });
+                // Set inputs
+                componentRef.setInput('data', data);
+                componentRef.setInput('onConfirm', callbacks.onConfirm);
+                componentRef.setInput('onCancel', callbacks.onCancel);
+                componentRef.setInput('onStateChange', callbacks.onStateChange);
+                // Attach to the application
+                this.appRef.attachView(componentRef.hostView);
+                // Append to container
+                container.appendChild(componentRef.location.nativeElement);
+                this.cardRefs.set(container, componentRef);
+                // Return cleanup function
+                return () => {
+                    const ref = this.cardRefs.get(container);
+                    if (ref) {
+                        this.appRef.detachView(ref.hostView);
+                        ref.destroy();
+                        this.cardRefs.delete(container);
+                    }
+                };
+            });
+            this.cleanupFns.push(unsubscribe);
+        });
+    }
+    /**
+     * Open the help panel.
+     */
+    open(options) {
+        this._pillar()?.open(options);
+    }
+    /**
+     * Close the help panel.
+     */
+    close() {
+        this._pillar()?.close();
+    }
+    /**
+     * Toggle the help panel.
+     */
+    toggle() {
+        this._pillar()?.toggle();
+    }
+    /**
+     * Open a specific article.
+     */
+    openArticle(slug) {
+        this._pillar()?.open({ article: slug });
+    }
+    /**
+     * Open a specific category.
+     */
+    async openCategory(slug) {
+        this._pillar()?.navigate('category', { slug });
+    }
+    /**
+     * Perform a search.
+     */
+    search(query) {
+        this._pillar()?.open({ search: query });
+    }
+    /**
+     * Navigate to a specific view.
+     */
+    navigate(view, params) {
+        this._pillar()?.navigate(view, params);
+    }
+    /**
+     * Update the panel theme at runtime.
+     */
+    setTheme(theme) {
+        this._pillar()?.setTheme(theme);
+    }
+    /**
+     * Enable or disable the text selection "Ask AI" popover.
+     */
+    setTextSelectionEnabled(enabled) {
+        this._pillar()?.setTextSelectionEnabled(enabled);
+    }
+    /**
+     * Subscribe to SDK events.
+     */
+    on(event, callback) {
+        const pillar = this._pillar();
+        if (!pillar) {
+            return () => { };
+        }
+        // Wrap callback to run in Angular zone
+        const wrappedCallback = (data) => {
+            this.ngZone.run(() => callback(data));
+        };
+        return pillar.on(event, wrappedCallback);
+    }
+    /**
+     * Register a task handler.
+     */
+    onTask(taskName, handler) {
+        const pillar = this._pillar();
+        if (!pillar) {
+            return () => { };
+        }
+        // Wrap handler to run in Angular zone
+        const wrappedHandler = (data) => {
+            this.ngZone.run(() => handler(data));
+        };
+        return pillar.onTask(taskName, wrappedHandler);
+    }
+    /**
+     * Define a tool with metadata and handler.
+     * Returns an unsubscribe function to remove the tool.
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = pillarService.defineTool({
+     *   name: 'add_to_cart',
+     *   description: 'Add a product to the shopping cart',
+     *   inputSchema: {
+     *     type: 'object',
+     *     properties: {
+     *       productId: { type: 'string' },
+     *       quantity: { type: 'number' },
+     *     },
+     *     required: ['productId', 'quantity'],
+     *   },
+     *   execute: async ({ productId, quantity }) => {
+     *     await this.cartService.add(productId, quantity);
+     *     return { content: [{ type: 'text', text: 'Added to cart' }] };
+     *   },
+     * });
+     *
+     * // Later, to unregister:
+     * unsubscribe();
+     * ```
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    defineTool(schema) {
+        const pillar = this._pillar();
+        if (!pillar) {
+            console.warn('[Pillar Angular] Cannot define tool - SDK not initialized');
+            return () => { };
+        }
+        // Wrap execute to run in Angular zone
+        const wrappedSchema = {
+            ...schema,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            execute: async (input) => {
+                return this.ngZone.run(() => schema.execute(input));
+            },
+        };
+        return pillar.defineTool(wrappedSchema);
+    }
+    /**
+     * Mount the panel to a specific container element.
+     * Used for manual panel placement with PillarPanelComponent.
+     */
+    mountPanelTo(container) {
+        this._pillar()?.mountPanelTo(container);
+    }
+    /**
+     * Cleanup resources.
+     * Note: We intentionally don't call Pillar.destroy() here to preserve
+     * conversation history across route changes. Call Pillar.destroy()
+     * explicitly if you need to fully reset the SDK.
+     */
+    ngOnDestroy() {
+        // Run all cleanup functions
+        this.cleanupFns.forEach((cleanup) => cleanup());
+        this.cleanupFns.length = 0;
+        // Destroy all card component refs
+        this.cardRefs.forEach((ref) => {
+            this.appRef.detachView(ref.hostView);
+            ref.destroy();
+        });
+        this.cardRefs.clear();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PillarService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PillarService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PillarService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pillar.service.js","sourceRoot":"","sources":["../../../src/lib/pillar.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * PillarService\n * Angular service that initializes and manages the Pillar SDK\n */\n\nimport {\n  Injectable,\n  NgZone,\n  signal,\n  computed,\n  inject,\n  createComponent,\n  ApplicationRef,\n  EnvironmentInjector,\n  type Type,\n} from '@angular/core';\nimport {\n  Pillar,\n  type CardCallbacks,\n  type PillarConfig,\n  type PillarEvents,\n  type PillarState,\n  type TaskExecutePayload,\n  type ThemeConfig,\n  type ToolSchema,\n} from '@pillar-ai/sdk';\nimport type { CardComponent, PillarInitConfig } from './types';\n\n@Injectable({ providedIn: 'root' })\nexport class PillarService {\n  private readonly ngZone = inject(NgZone);\n  private readonly appRef = inject(ApplicationRef);\n  private readonly environmentInjector = inject(EnvironmentInjector);\n\n  // Internal state\n  private readonly _pillar = signal<Pillar | null>(null);\n  private readonly cleanupFns: Array<() => void> = [];\n  private readonly cardRefs: Map<HTMLElement, any> = new Map();\n  private onTaskCallback: ((task: TaskExecutePayload) => void) | null = null;\n  private registeredCards: Record<string, CardComponent> | null = null;\n\n  // Public signals\n  readonly state = signal<PillarState>('uninitialized');\n  readonly isReady = computed(() => this.state() === 'ready');\n  readonly isPanelOpen = signal(false);\n\n  /**\n   * Get the Pillar SDK instance.\n   */\n  getInstance(): Pillar | null {\n    return this._pillar();\n  }\n\n  /**\n   * Initialize the Pillar SDK.\n   * Call this in your app's initialization (e.g., APP_INITIALIZER).\n   *\n   * @param initConfig - Configuration options\n   */\n  async init(initConfig: PillarInitConfig): Promise<void> {\n    const { productKey, helpCenter, config, onTask, cards } = initConfig;\n\n    // Support both productKey (new) and helpCenter (deprecated)\n    const resolvedKey = productKey ?? helpCenter;\n\n    if (helpCenter && !productKey) {\n      console.warn(\n        '[Pillar Angular] \"helpCenter\" is deprecated. Use \"productKey\" instead.'\n      );\n    }\n\n    // Store callbacks for later use\n    this.onTaskCallback = onTask ?? null;\n    this.registeredCards = cards ?? null;\n\n    try {\n      // Pillar is a singleton - check if already initialized\n      const existingInstance = Pillar.getInstance();\n      if (existingInstance) {\n        // Reuse existing instance (preserves chat history, panel state, etc.)\n        this._pillar.set(existingInstance);\n        this.state.set(existingInstance.state);\n        this.subscribeToEvents(existingInstance);\n        this.registerCards(existingInstance);\n        return;\n      }\n\n      // Initialize new instance\n      const instance = await Pillar.init({\n        productKey: resolvedKey,\n        ...config,\n      });\n\n      this.ngZone.run(() => {\n        this._pillar.set(instance);\n        this.state.set(instance.state);\n      });\n\n      this.subscribeToEvents(instance);\n      this.registerCards(instance);\n    } catch (error) {\n      console.error('[Pillar Angular] Failed to initialize:', error);\n      this.ngZone.run(() => {\n        this.state.set('error');\n      });\n      throw error;\n    }\n  }\n\n  /**\n   * Subscribe to SDK events and sync to Angular signals.\n   */\n  private subscribeToEvents(instance: Pillar): void {\n    // Panel open/close events\n    const unsubOpen = instance.on('panel:open', () => {\n      this.ngZone.run(() => {\n        this.isPanelOpen.set(true);\n      });\n    });\n    this.cleanupFns.push(unsubOpen);\n\n    const unsubClose = instance.on('panel:close', () => {\n      this.ngZone.run(() => {\n        this.isPanelOpen.set(false);\n      });\n    });\n    this.cleanupFns.push(unsubClose);\n\n    // State change events\n    const unsubReady = instance.on('ready', () => {\n      this.ngZone.run(() => {\n        this.state.set('ready');\n      });\n    });\n    this.cleanupFns.push(unsubReady);\n\n    const unsubError = instance.on('error', () => {\n      this.ngZone.run(() => {\n        this.state.set('error');\n      });\n    });\n    this.cleanupFns.push(unsubError);\n\n    // Task execution events\n    if (this.onTaskCallback) {\n      const callback = this.onTaskCallback;\n      const unsubTask = instance.on('task:execute', (task) => {\n        this.ngZone.run(() => {\n          callback(task);\n        });\n      });\n      this.cleanupFns.push(unsubTask);\n    }\n  }\n\n  /**\n   * Register custom card components.\n   */\n  private registerCards(instance: Pillar): void {\n    if (!this.registeredCards) return;\n\n    Object.entries(this.registeredCards).forEach(([cardType, CardComponent]) => {\n      const unsubscribe = instance.registerCard(\n        cardType,\n        (container, data, callbacks: CardCallbacks) => {\n          // Create an Angular component dynamically\n          const componentRef = createComponent(CardComponent as Type<any>, {\n            environmentInjector: this.environmentInjector,\n          });\n\n          // Set inputs\n          componentRef.setInput('data', data);\n          componentRef.setInput('onConfirm', callbacks.onConfirm);\n          componentRef.setInput('onCancel', callbacks.onCancel);\n          componentRef.setInput('onStateChange', callbacks.onStateChange);\n\n          // Attach to the application\n          this.appRef.attachView(componentRef.hostView);\n\n          // Append to container\n          container.appendChild(componentRef.location.nativeElement);\n          this.cardRefs.set(container, componentRef);\n\n          // Return cleanup function\n          return () => {\n            const ref = this.cardRefs.get(container);\n            if (ref) {\n              this.appRef.detachView(ref.hostView);\n              ref.destroy();\n              this.cardRefs.delete(container);\n            }\n          };\n        }\n      );\n\n      this.cleanupFns.push(unsubscribe);\n    });\n  }\n\n  /**\n   * Open the help panel.\n   */\n  open(options?: {\n    view?: string;\n    article?: string;\n    search?: string;\n    focusInput?: boolean;\n  }): void {\n    this._pillar()?.open(options);\n  }\n\n  /**\n   * Close the help panel.\n   */\n  close(): void {\n    this._pillar()?.close();\n  }\n\n  /**\n   * Toggle the help panel.\n   */\n  toggle(): void {\n    this._pillar()?.toggle();\n  }\n\n  /**\n   * Open a specific article.\n   */\n  openArticle(slug: string): void {\n    this._pillar()?.open({ article: slug });\n  }\n\n  /**\n   * Open a specific category.\n   */\n  async openCategory(slug: string): Promise<void> {\n    this._pillar()?.navigate('category', { slug });\n  }\n\n  /**\n   * Perform a search.\n   */\n  search(query: string): void {\n    this._pillar()?.open({ search: query });\n  }\n\n  /**\n   * Navigate to a specific view.\n   */\n  navigate(view: string, params?: Record<string, string>): void {\n    this._pillar()?.navigate(view, params);\n  }\n\n  /**\n   * Update the panel theme at runtime.\n   */\n  setTheme(theme: Partial<ThemeConfig>): void {\n    this._pillar()?.setTheme(theme);\n  }\n\n  /**\n   * Enable or disable the text selection \"Ask AI\" popover.\n   */\n  setTextSelectionEnabled(enabled: boolean): void {\n    this._pillar()?.setTextSelectionEnabled(enabled);\n  }\n\n  /**\n   * Subscribe to SDK events.\n   */\n  on<K extends keyof PillarEvents>(\n    event: K,\n    callback: (data: PillarEvents[K]) => void\n  ): () => void {\n    const pillar = this._pillar();\n    if (!pillar) {\n      return () => {};\n    }\n\n    // Wrap callback to run in Angular zone\n    const wrappedCallback = (data: PillarEvents[K]) => {\n      this.ngZone.run(() => callback(data));\n    };\n\n    return pillar.on(event, wrappedCallback);\n  }\n\n  /**\n   * Register a task handler.\n   */\n  onTask(\n    taskName: string,\n    handler: (data: Record<string, unknown>) => void\n  ): () => void {\n    const pillar = this._pillar();\n    if (!pillar) {\n      return () => {};\n    }\n\n    // Wrap handler to run in Angular zone\n    const wrappedHandler = (data: Record<string, unknown>) => {\n      this.ngZone.run(() => handler(data));\n    };\n\n    return pillar.onTask(taskName, wrappedHandler);\n  }\n\n  /**\n   * Define a tool with metadata and handler.\n   * Returns an unsubscribe function to remove the tool.\n   *\n   * @example\n   * ```typescript\n   * const unsubscribe = pillarService.defineTool({\n   *   name: 'add_to_cart',\n   *   description: 'Add a product to the shopping cart',\n   *   inputSchema: {\n   *     type: 'object',\n   *     properties: {\n   *       productId: { type: 'string' },\n   *       quantity: { type: 'number' },\n   *     },\n   *     required: ['productId', 'quantity'],\n   *   },\n   *   execute: async ({ productId, quantity }) => {\n   *     await this.cartService.add(productId, quantity);\n   *     return { content: [{ type: 'text', text: 'Added to cart' }] };\n   *   },\n   * });\n   *\n   * // Later, to unregister:\n   * unsubscribe();\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  defineTool(schema: ToolSchema<any>): () => void {\n    const pillar = this._pillar();\n    if (!pillar) {\n      console.warn('[Pillar Angular] Cannot define tool - SDK not initialized');\n      return () => {};\n    }\n\n    // Wrap execute to run in Angular zone\n    const wrappedSchema = {\n      ...schema,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      execute: async (input: any) => {\n        return this.ngZone.run(() => schema.execute(input));\n      },\n    };\n\n    return pillar.defineTool(wrappedSchema);\n  }\n\n  /**\n   * Mount the panel to a specific container element.\n   * Used for manual panel placement with PillarPanelComponent.\n   */\n  mountPanelTo(container: HTMLElement): void {\n    this._pillar()?.mountPanelTo(container);\n  }\n\n  /**\n   * Cleanup resources.\n   * Note: We intentionally don't call Pillar.destroy() here to preserve\n   * conversation history across route changes. Call Pillar.destroy()\n   * explicitly if you need to fully reset the SDK.\n   */\n  ngOnDestroy(): void {\n    // Run all cleanup functions\n    this.cleanupFns.forEach((cleanup) => cleanup());\n    this.cleanupFns.length = 0;\n\n    // Destroy all card component refs\n    this.cardRefs.forEach((ref) => {\n      this.appRef.detachView(ref.hostView);\n      ref.destroy();\n    });\n    this.cardRefs.clear();\n  }\n}\n"]}

package/dist/esm2022/lib/types.mjs

@@ -0,0 +1,5 @@
+/**
+ * Shared types for Pillar Angular SDK
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/pillar-ai-angular.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGlsbGFyLWFpLWFuZ3VsYXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcGlsbGFyLWFpLWFuZ3VsYXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/dist/esm2022/public-api.mjs

@@ -0,0 +1,67 @@
+/**
+ * @pillar-ai/angular - Angular bindings for Pillar SDK
+ *
+ * @example
+ * ```typescript
+ * // app.config.ts
+ * import { ApplicationConfig, APP_INITIALIZER, inject } from '@angular/core';
+ * import { PillarService } from '@pillar-ai/angular';
+ *
+ * function initPillar() {
+ *   const pillar = inject(PillarService);
+ *   return () => pillar.init({ productKey: 'your-product-key' });
+ * }
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     { provide: APP_INITIALIZER, useFactory: initPillar, multi: true },
+ *   ],
+ * };
+ *
+ * // help-button.component.ts
+ * import { Component } from '@angular/core';
+ * import { injectPillar } from '@pillar-ai/angular';
+ *
+ * @Component({
+ *   selector: 'app-help-button',
+ *   standalone: true,
+ *   template: `
+ *     <button (click)="toggle()">
+ *       {{ isPanelOpen() ? 'Close Help' : 'Get Help' }}
+ *     </button>
+ *   `,
+ * })
+ * export class HelpButtonComponent {
+ *   private pillar = injectPillar();
+ *   isPanelOpen = this.pillar.isPanelOpen;
+ *   toggle = this.pillar.toggle;
+ * }
+ *
+ * // Custom panel placement example:
+ * // layout.component.ts
+ * import { Component } from '@angular/core';
+ * import { PillarPanelComponent } from '@pillar-ai/angular';
+ *
+ * @Component({
+ *   selector: 'app-layout',
+ *   standalone: true,
+ *   imports: [PillarPanelComponent],
+ *   template: `
+ *     <div class="layout">
+ *       <pillar-panel class="custom-panel" />
+ *       <main>Your content</main>
+ *     </div>
+ *   `,
+ * })
+ * export class LayoutComponent {}
+ * ```
+ */
+// Service
+export { PillarService } from './lib/pillar.service';
+// Components
+export { PillarPanelComponent } from './lib/pillar-panel.component';
+// Inject functions
+export { injectPillar } from './lib/inject-pillar';
+export { injectHelpPanel } from './lib/inject-help-panel';
+export { injectPillarTool, injectPillarAction } from './lib/inject-pillar-tool';
+//# sourceMappingURL=data:application/json;base64,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