@pillar-ai/angular 0.1.11

package/dist/README.md

@@ -0,0 +1,357 @@
+# @pillar-ai/angular
+
+Angular SDK for the [Pillar](https://trypillar.com) open-source AI copilot — embed a product assistant in your Angular app that executes tasks, not just answers questions. [GitHub](https://github.com/pillarhq/pillar) · [Docs](https://trypillar.com/docs)
+
+[![npm version](https://img.shields.io/npm/v/@pillar-ai/angular)](https://www.npmjs.com/package/@pillar-ai/angular)
+[![npm downloads](https://img.shields.io/npm/dm/@pillar-ai/angular)](https://www.npmjs.com/package/@pillar-ai/angular)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue)](https://www.typescriptlang.org/)
+
+## What is Pillar?
+
+Pillar is a product copilot for SaaS and web applications. Users say what they want, and Pillar uses your UI to make it happen — navigating pages, pre-filling forms, and calling your APIs.
+
+For example, a user could ask:
+
+> "Close the Walmart deal as won in Salesforce and notify implementation"
+
+> "Create a P1 bug in Linear for the checkout crash and add it to this sprint"
+
+> "How do I set up a webhook in Stripe?"
+
+Pillar understands the intent, builds a multi-step plan, and executes it client-side with the user's session.
+
+## Requirements
+
+- Angular 17.0.0 or higher
+- `@pillar-ai/sdk` (installed automatically as a dependency)
+
+## Installation
+
+```bash
+npm install @pillar-ai/angular
+```
+
+## Quick Start
+
+### 1. Initialize Pillar in your app config
+
+```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 },
+  ],
+};
+```
+
+### 2. Use Pillar in your components
+
+```typescript
+// 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;
+}
+```
+
+## API Reference
+
+### PillarService
+
+Injectable service that manages the Pillar SDK lifecycle.
+
+```typescript
+import { PillarService } from '@pillar-ai/angular';
+
+@Component({...})
+export class MyComponent {
+  constructor(private pillarService: PillarService) {}
+}
+```
+
+#### Methods
+
+| Method | Description |
+|--------|-------------|
+| `init(config)` | Initialize the SDK with your product key |
+| `open(options?)` | Open the help panel |
+| `close()` | Close the help panel |
+| `toggle()` | Toggle the help panel |
+| `openArticle(slug)` | Open a specific article |
+| `openCategory(slug)` | Navigate to a category |
+| `search(query)` | Open search with a query |
+| `navigate(view, params?)` | Navigate to a specific view |
+| `setTheme(theme)` | Update the panel theme |
+| `setTextSelectionEnabled(enabled)` | Toggle text selection popover |
+| `on(event, callback)` | Subscribe to SDK events |
+| `onTask(taskName, handler)` | Register a task handler |
+
+#### Signals
+
+| Signal | Type | Description |
+|--------|------|-------------|
+| `state` | `WritableSignal<PillarState>` | Current SDK state |
+| `isReady` | `Signal<boolean>` | Whether SDK is ready |
+| `isPanelOpen` | `WritableSignal<boolean>` | Whether panel is open |
+
+### injectPillar()
+
+Angular injection function for accessing the Pillar SDK with full functionality.
+
+```typescript
+import { injectPillar } from '@pillar-ai/angular';
+
+@Component({...})
+export class MyComponent {
+  private pillar = injectPillar();
+
+  handleHelp() {
+    this.pillar.open({ view: 'chat' });
+  }
+}
+```
+
+### injectHelpPanel()
+
+Simplified injection function focused on panel controls.
+
+```typescript
+import { injectHelpPanel } from '@pillar-ai/angular';
+
+@Component({...})
+export class HelpMenuComponent {
+  private panel = injectHelpPanel();
+
+  isOpen = this.panel.isOpen;
+  toggle = this.panel.toggle;
+  openChat = this.panel.openChat;
+}
+```
+
+### PillarPanelComponent
+
+Standalone component for custom panel placement.
+
+```typescript
+import { PillarPanelComponent } from '@pillar-ai/angular';
+
+@Component({
+  selector: 'app-layout',
+  standalone: true,
+  imports: [PillarPanelComponent],
+  template: `
+    <div class="layout">
+      <pillar-panel class="help-panel" />
+      <main>
+        <router-outlet />
+      </main>
+    </div>
+  `,
+})
+export class LayoutComponent {}
+```
+
+**Important**: When using `PillarPanelComponent`, set `panel.container: 'manual'` in your config:
+
+```typescript
+pillar.init({
+  productKey: 'your-product-key',
+  config: { panel: { container: 'manual' } }
+});
+```
+
+## Advanced Usage
+
+### Type-Safe Task Handlers
+
+Define your actions and get full TypeScript support:
+
+```typescript
+// lib/pillar/actions.ts
+import { defineActions } from '@pillar-ai/sdk';
+
+export const actions = defineActions({
+  invite_member: {
+    description: 'Invite a team member',
+    data: {
+      email: { type: 'string', description: 'Email address' },
+      role: { type: 'string', description: 'Member role' },
+    },
+  },
+});
+```
+
+```typescript
+// my.component.ts
+import { Component, OnInit, OnDestroy } from '@angular/core';
+import { injectPillar } from '@pillar-ai/angular';
+import { actions } from './lib/pillar/actions';
+
+@Component({...})
+export class MyComponent implements OnInit, OnDestroy {
+  private pillar = injectPillar<typeof actions>();
+  private unsubscribe?: () => void;
+
+  ngOnInit() {
+    // TypeScript knows the exact shape of data
+    this.unsubscribe = this.pillar.onTask('invite_member', (data) => {
+      console.log(data.email); // ✓ Typed as string
+      console.log(data.role);  // ✓ Typed as string
+    });
+  }
+
+  ngOnDestroy() {
+    this.unsubscribe?.();
+  }
+}
+```
+
+### Custom Card Components
+
+Render custom Angular components for inline UI actions:
+
+```typescript
+// invite-card.component.ts
+import { Component, input } from '@angular/core';
+import type { CardComponentProps } from '@pillar-ai/angular';
+
+@Component({
+  selector: 'app-invite-card',
+  standalone: true,
+  template: `
+    <div class="invite-card">
+      <h3>Invite Team Members</h3>
+      <input [(ngModel)]="email" placeholder="Email address" />
+      <button (click)="confirm()">Send Invite</button>
+      <button (click)="cancel()">Cancel</button>
+    </div>
+  `,
+})
+export class InviteCardComponent implements CardComponentProps {
+  data = input.required<Record<string, unknown>>();
+  onConfirm = input.required<(data?: Record<string, unknown>) => void>();
+  onCancel = input.required<() => void>();
+  onStateChange = input<(state: 'loading' | 'success' | 'error', message?: string) => void>();
+
+  email = '';
+
+  confirm() {
+    this.onConfirm()({ email: this.email });
+  }
+
+  cancel() {
+    this.onCancel()();
+  }
+}
+```
+
+```typescript
+// app.config.ts
+pillar.init({
+  productKey: 'your-product-key',
+  cards: {
+    invite_member: InviteCardComponent,
+  },
+});
+```
+
+### Theme Synchronization
+
+Sync Pillar's theme with your app's dark mode:
+
+```typescript
+@Component({...})
+export class ThemeToggleComponent {
+  private pillar = injectPillar();
+
+  toggleDarkMode(isDark: boolean) {
+    this.pillar.setTheme({ mode: isDark ? 'dark' : 'light' });
+  }
+}
+```
+
+### Subscribe to Events
+
+```typescript
+@Component({...})
+export class AnalyticsComponent implements OnInit, OnDestroy {
+  private pillar = injectPillar();
+  private unsubscribes: (() => void)[] = [];
+
+  ngOnInit() {
+    this.unsubscribes.push(
+      this.pillar.on('panel:open', () => {
+        analytics.track('help_panel_opened');
+      }),
+      this.pillar.on('task:execute', (task) => {
+        analytics.track('task_executed', { name: task.name });
+      })
+    );
+  }
+
+  ngOnDestroy() {
+    this.unsubscribes.forEach(unsub => unsub());
+  }
+}
+```
+
+## Configuration Options
+
+```typescript
+interface PillarInitConfig {
+  /** Your product key from app.trypillar.com */
+  productKey: string;
+
+  /** Additional SDK configuration */
+  config?: {
+    panel?: {
+      /** Panel placement: 'auto' | 'manual' */
+      container?: string;
+      /** Use Shadow DOM for style isolation */
+      useShadowDOM?: boolean;
+    };
+    theme?: {
+      /** Theme mode: 'light' | 'dark' | 'auto' */
+      mode?: string;
+      /** Custom colors */
+      colors?: {
+        primary?: string;
+        // ... other color options
+      };
+    };
+    // ... other options
+  };
+
+  /** Global task handler */
+  onTask?: (task: TaskExecutePayload) => void;
+
+  /** Custom card components */
+  cards?: Record<string, Type<any>>;
+}
+```
+
+## License
+
+MIT

package/dist/esm2022/lib/inject-help-panel.mjs

@@ -0,0 +1,59 @@
+/**
+ * injectHelpPanel Function
+ * Angular injection helper for panel-specific controls
+ */
+import { inject, computed } from '@angular/core';
+import { PillarService } from './pillar.service';
+/**
+ * Angular injection function for panel-specific controls.
+ * Provides a simplified API focused on panel operations.
+ *
+ * Must be called within an injection context (constructor, field initializer, or inject()).
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   selector: 'app-help-menu',
+ *   standalone: true,
+ *   template: `
+ *     <div>
+ *       <button (click)="toggle()">
+ *         {{ isOpen() ? 'Close' : 'Help' }}
+ *       </button>
+ *       <button (click)="openChat()">Ask AI</button>
+ *     </div>
+ *   `,
+ * })
+ * export class HelpMenuComponent {
+ *   private panel = injectHelpPanel();
+ *   isOpen = this.panel.isOpen;
+ *   toggle = this.panel.toggle;
+ *   openChat = this.panel.openChat;
+ * }
+ * ```
+ */
+export function injectHelpPanel() {
+    const service = inject(PillarService);
+    const openSearch = (query) => {
+        if (query) {
+            service.search(query);
+        }
+        else {
+            service.open({ view: 'search' });
+        }
+    };
+    const openChat = () => {
+        service.navigate('chat');
+    };
+    return {
+        isOpen: computed(() => service.isPanelOpen()),
+        open: service.open.bind(service),
+        close: service.close.bind(service),
+        toggle: service.toggle.bind(service),
+        openArticle: service.openArticle.bind(service),
+        openCategory: service.openCategory.bind(service),
+        openSearch,
+        openChat,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/inject-pillar-tool.mjs

@@ -0,0 +1,111 @@
+/**
+ * injectPillarTool Function
+ * Angular-idiomatic injection helper for registering Pillar tools
+ *
+ * Register one or more tools with co-located metadata and handlers.
+ * Tools are registered when called and automatically unregistered
+ * when the component is destroyed.
+ *
+ * @example Single tool
+ * ```typescript
+ * import { Component } from '@angular/core';
+ * import { injectPillarTool } from '@pillar-ai/angular';
+ *
+ * @Component({
+ *   selector: 'app-cart-button',
+ *   standalone: true,
+ *   template: `<button>Cart</button>`,
+ * })
+ * export class CartButtonComponent {
+ *   constructor() {
+ *     injectPillarTool({
+ *       name: 'add_to_cart',
+ *       description: 'Add a product to the shopping cart',
+ *       inputSchema: {
+ *         type: 'object',
+ *         properties: {
+ *           productId: { type: 'string', description: 'Product ID' },
+ *           quantity: { type: 'number', description: 'Quantity to add' },
+ *         },
+ *         required: ['productId', 'quantity'],
+ *       },
+ *       execute: async ({ productId, quantity }) => {
+ *         await cartApi.add(productId, quantity);
+ *         return { content: [{ type: 'text', text: 'Added to cart' }] };
+ *       },
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @example Multiple tools
+ * ```typescript
+ * import { Component } from '@angular/core';
+ * import { injectPillarTool } from '@pillar-ai/angular';
+ *
+ * @Component({
+ *   selector: 'app-billing-page',
+ *   standalone: true,
+ *   template: `<div>Billing Content</div>`,
+ * })
+ * export class BillingPageComponent {
+ *   constructor() {
+ *     injectPillarTool([
+ *       {
+ *         name: 'get_current_plan',
+ *         description: 'Get the current billing plan',
+ *         execute: async () => ({ plan: 'pro', price: 29 }),
+ *       },
+ *       {
+ *         name: 'upgrade_plan',
+ *         description: 'Upgrade to a higher plan',
+ *         inputSchema: {
+ *           type: 'object',
+ *           properties: { planId: { type: 'string' } },
+ *           required: ['planId'],
+ *         },
+ *         execute: async ({ planId }) => {
+ *           await billingApi.upgrade(planId);
+ *           return { content: [{ type: 'text', text: 'Upgraded!' }] };
+ *         },
+ *       },
+ *     ]);
+ *   }
+ * }
+ * ```
+ */
+import { inject, DestroyRef } from '@angular/core';
+import { PillarService } from './pillar.service';
+/**
+ * Register one or more Pillar tools with co-located metadata and handlers.
+ *
+ * The tools are registered when this function is called and automatically
+ * unregistered when the component is destroyed. Must be called within
+ * an injection context (constructor, field initializer, or inject()).
+ *
+ * @param schemaOrSchemas - Single tool schema or array of tool schemas
+ */
+export function injectPillarTool(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+schemaOrSchemas) {
+    const service = inject(PillarService);
+    const destroyRef = inject(DestroyRef);
+    // Normalize to array for consistent handling
+    const schemas = Array.isArray(schemaOrSchemas)
+        ? schemaOrSchemas
+        : [schemaOrSchemas];
+    // Track unsubscribe functions
+    const unsubscribes = [];
+    // Register all tools
+    schemas.forEach((schema) => {
+        const unsub = service.defineTool(schema);
+        unsubscribes.push(unsub);
+    });
+    // Cleanup on destroy
+    destroyRef.onDestroy(() => {
+        unsubscribes.forEach((unsub) => unsub());
+    });
+}
+/** @deprecated Use injectPillarTool instead */
+export const injectPillarAction = injectPillarTool;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5qZWN0LXBpbGxhci10b29sLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi9pbmplY3QtcGlsbGFyLXRvb2wudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQTJFRztBQUVILE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRW5ELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVqRDs7Ozs7Ozs7R0FRRztBQUNILE1BQU0sVUFBVSxnQkFBZ0I7QUFDOUIsOERBQThEO0FBQzlELGVBQW9EO0lBRXBELE1BQU0sT0FBTyxHQUFHLE1BQU0sQ0FBQyxhQUFhLENBQUMsQ0FBQztJQUN0QyxNQUFNLFVBQVUsR0FBRyxNQUFNLENBQUMsVUFBVSxDQUFDLENBQUM7SUFFdEMsNkNBQTZDO0lBQzdDLE1BQU0sT0FBTyxHQUFHLEtBQUssQ0FBQyxPQUFPLENBQUMsZUFBZSxDQUFDO1FBQzVDLENBQUMsQ0FBQyxlQUFlO1FBQ2pCLENBQUMsQ0FBQyxDQUFDLGVBQWUsQ0FBQyxDQUFDO0lBRXRCLDhCQUE4QjtJQUM5QixNQUFNLFlBQVksR0FBc0IsRUFBRSxDQUFDO0lBRTNDLHFCQUFxQjtJQUNyQixPQUFPLENBQUMsT0FBTyxDQUFDLENBQUMsTUFBTSxFQUFFLEVBQUU7UUFDekIsTUFBTSxLQUFLLEdBQUcsT0FBTyxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUN6QyxZQUFZLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzNCLENBQUMsQ0FBQyxDQUFDO0lBRUgscUJBQXFCO0lBQ3JCLFVBQVUsQ0FBQyxTQUFTLENBQUMsR0FBRyxFQUFFO1FBQ3hCLFlBQVksQ0FBQyxPQUFPLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLEtBQUssRUFBRSxDQUFDLENBQUM7SUFDM0MsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDO0FBRUQsK0NBQStDO0FBQy9DLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBpbmplY3RQaWxsYXJUb29sIEZ1bmN0aW9uXG4gKiBBbmd1bGFyLWlkaW9tYXRpYyBpbmplY3Rpb24gaGVscGVyIGZvciByZWdpc3RlcmluZyBQaWxsYXIgdG9vbHNcbiAqXG4gKiBSZWdpc3RlciBvbmUgb3IgbW9yZSB0b29scyB3aXRoIGNvLWxvY2F0ZWQgbWV0YWRhdGEgYW5kIGhhbmRsZXJzLlxuICogVG9vbHMgYXJlIHJlZ2lzdGVyZWQgd2hlbiBjYWxsZWQgYW5kIGF1dG9tYXRpY2FsbHkgdW5yZWdpc3RlcmVkXG4gKiB3aGVuIHRoZSBjb21wb25lbnQgaXMgZGVzdHJveWVkLlxuICpcbiAqIEBleGFtcGxlIFNpbmdsZSB0b29sXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBpbXBvcnQgeyBDb21wb25lbnQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbiAqIGltcG9ydCB7IGluamVjdFBpbGxhclRvb2wgfSBmcm9tICdAcGlsbGFyLWFpL2FuZ3VsYXInO1xuICpcbiAqIEBDb21wb25lbnQoe1xuICogICBzZWxlY3RvcjogJ2FwcC1jYXJ0LWJ1dHRvbicsXG4gKiAgIHN0YW5kYWxvbmU6IHRydWUsXG4gKiAgIHRlbXBsYXRlOiBgPGJ1dHRvbj5DYXJ0PC9idXR0b24+YCxcbiAqIH0pXG4gKiBleHBvcnQgY2xhc3MgQ2FydEJ1dHRvbkNvbXBvbmVudCB7XG4gKiAgIGNvbnN0cnVjdG9yKCkge1xuICogICAgIGluamVjdFBpbGxhclRvb2woe1xuICogICAgICAgbmFtZTogJ2FkZF90b19jYXJ0JyxcbiAqICAgICAgIGRlc2NyaXB0aW9uOiAnQWRkIGEgcHJvZHVjdCB0byB0aGUgc2hvcHBpbmcgY2FydCcsXG4gKiAgICAgICBpbnB1dFNjaGVtYToge1xuICogICAgICAgICB0eXBlOiAnb2JqZWN0JyxcbiAqICAgICAgICAgcHJvcGVydGllczoge1xuICogICAgICAgICAgIHByb2R1Y3RJZDogeyB0eXBlOiAnc3RyaW5nJywgZGVzY3JpcHRpb246ICdQcm9kdWN0IElEJyB9LFxuICogICAgICAgICAgIHF1YW50aXR5OiB7IHR5cGU6ICdudW1iZXInLCBkZXNjcmlwdGlvbjogJ1F1YW50aXR5IHRvIGFkZCcgfSxcbiAqICAgICAgICAgfSxcbiAqICAgICAgICAgcmVxdWlyZWQ6IFsncHJvZHVjdElkJywgJ3F1YW50aXR5J10sXG4gKiAgICAgICB9LFxuICogICAgICAgZXhlY3V0ZTogYXN5bmMgKHsgcHJvZHVjdElkLCBxdWFudGl0eSB9KSA9PiB7XG4gKiAgICAgICAgIGF3YWl0IGNhcnRBcGkuYWRkKHByb2R1Y3RJZCwgcXVhbnRpdHkpO1xuICogICAgICAgICByZXR1cm4geyBjb250ZW50OiBbeyB0eXBlOiAndGV4dCcsIHRleHQ6ICdBZGRlZCB0byBjYXJ0JyB9XSB9O1xuICogICAgICAgfSxcbiAqICAgICB9KTtcbiAqICAgfVxuICogfVxuICogYGBgXG4gKlxuICogQGV4YW1wbGUgTXVsdGlwbGUgdG9vbHNcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIGltcG9ydCB7IENvbXBvbmVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuICogaW1wb3J0IHsgaW5qZWN0UGlsbGFyVG9vbCB9IGZyb20gJ0BwaWxsYXItYWkvYW5ndWxhcic7XG4gKlxuICogQENvbXBvbmVudCh7XG4gKiAgIHNlbGVjdG9yOiAnYXBwLWJpbGxpbmctcGFnZScsXG4gKiAgIHN0YW5kYWxvbmU6IHRydWUsXG4gKiAgIHRlbXBsYXRlOiBgPGRpdj5CaWxsaW5nIENvbnRlbnQ8L2Rpdj5gLFxuICogfSlcbiAqIGV4cG9ydCBjbGFzcyBCaWxsaW5nUGFnZUNvbXBvbmVudCB7XG4gKiAgIGNvbnN0cnVjdG9yKCkge1xuICogICAgIGluamVjdFBpbGxhclRvb2woW1xuICogICAgICAge1xuICogICAgICAgICBuYW1lOiAnZ2V0X2N1cnJlbnRfcGxhbicsXG4gKiAgICAgICAgIGRlc2NyaXB0aW9uOiAnR2V0IHRoZSBjdXJyZW50IGJpbGxpbmcgcGxhbicsXG4gKiAgICAgICAgIGV4ZWN1dGU6IGFzeW5jICgpID0+ICh7IHBsYW46ICdwcm8nLCBwcmljZTogMjkgfSksXG4gKiAgICAgICB9LFxuICogICAgICAge1xuICogICAgICAgICBuYW1lOiAndXBncmFkZV9wbGFuJyxcbiAqICAgICAgICAgZGVzY3JpcHRpb246ICdVcGdyYWRlIHRvIGEgaGlnaGVyIHBsYW4nLFxuICogICAgICAgICBpbnB1dFNjaGVtYToge1xuICogICAgICAgICAgIHR5cGU6ICdvYmplY3QnLFxuICogICAgICAgICAgIHByb3BlcnRpZXM6IHsgcGxhbklkOiB7IHR5cGU6ICdzdHJpbmcnIH0gfSxcbiAqICAgICAgICAgICByZXF1aXJlZDogWydwbGFuSWQnXSxcbiAqICAgICAgICAgfSxcbiAqICAgICAgICAgZXhlY3V0ZTogYXN5bmMgKHsgcGxhbklkIH0pID0+IHtcbiAqICAgICAgICAgICBhd2FpdCBiaWxsaW5nQXBpLnVwZ3JhZGUocGxhbklkKTtcbiAqICAgICAgICAgICByZXR1cm4geyBjb250ZW50OiBbeyB0eXBlOiAndGV4dCcsIHRleHQ6ICdVcGdyYWRlZCEnIH1dIH07XG4gKiAgICAgICAgIH0sXG4gKiAgICAgICB9LFxuICogICAgIF0pO1xuICogICB9XG4gKiB9XG4gKiBgYGBcbiAqL1xuXG5pbXBvcnQgeyBpbmplY3QsIERlc3Ryb3lSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB0eXBlIHsgVG9vbFNjaGVtYSB9IGZyb20gJ0BwaWxsYXItYWkvc2RrJztcbmltcG9ydCB7IFBpbGxhclNlcnZpY2UgfSBmcm9tICcuL3BpbGxhci5zZXJ2aWNlJztcblxuLyoqXG4gKiBSZWdpc3RlciBvbmUgb3IgbW9yZSBQaWxsYXIgdG9vbHMgd2l0aCBjby1sb2NhdGVkIG1ldGFkYXRhIGFuZCBoYW5kbGVycy5cbiAqXG4gKiBUaGUgdG9vbHMgYXJlIHJlZ2lzdGVyZWQgd2hlbiB0aGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBhbmQgYXV0b21hdGljYWxseVxuICogdW5yZWdpc3RlcmVkIHdoZW4gdGhlIGNvbXBvbmVudCBpcyBkZXN0cm95ZWQuIE11c3QgYmUgY2FsbGVkIHdpdGhpblxuICogYW4gaW5qZWN0aW9uIGNvbnRleHQgKGNvbnN0cnVjdG9yLCBmaWVsZCBpbml0aWFsaXplciwgb3IgaW5qZWN0KCkpLlxuICpcbiAqIEBwYXJhbSBzY2hlbWFPclNjaGVtYXMgLSBTaW5nbGUgdG9vbCBzY2hlbWEgb3IgYXJyYXkgb2YgdG9vbCBzY2hlbWFzXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpbmplY3RQaWxsYXJUb29sKFxuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLWV4cGxpY2l0LWFueVxuICBzY2hlbWFPclNjaGVtYXM6IFRvb2xTY2hlbWE8YW55PiB8IFRvb2xTY2hlbWE8YW55PltdXG4pOiB2b2lkIHtcbiAgY29uc3Qgc2VydmljZSA9IGluamVjdChQaWxsYXJTZXJ2aWNlKTtcbiAgY29uc3QgZGVzdHJveVJlZiA9IGluamVjdChEZXN0cm95UmVmKTtcblxuICAvLyBOb3JtYWxpemUgdG8gYXJyYXkgZm9yIGNvbnNpc3RlbnQgaGFuZGxpbmdcbiAgY29uc3Qgc2NoZW1hcyA9IEFycmF5LmlzQXJyYXkoc2NoZW1hT3JTY2hlbWFzKVxuICAgID8gc2NoZW1hT3JTY2hlbWFzXG4gICAgOiBbc2NoZW1hT3JTY2hlbWFzXTtcblxuICAvLyBUcmFjayB1bnN1YnNjcmliZSBmdW5jdGlvbnNcbiAgY29uc3QgdW5zdWJzY3JpYmVzOiBBcnJheTwoKSA9PiB2b2lkPiA9IFtdO1xuXG4gIC8vIFJlZ2lzdGVyIGFsbCB0b29sc1xuICBzY2hlbWFzLmZvckVhY2goKHNjaGVtYSkgPT4ge1xuICAgIGNvbnN0IHVuc3ViID0gc2VydmljZS5kZWZpbmVUb29sKHNjaGVtYSk7XG4gICAgdW5zdWJzY3JpYmVzLnB1c2godW5zdWIpO1xuICB9KTtcblxuICAvLyBDbGVhbnVwIG9uIGRlc3Ryb3lcbiAgZGVzdHJveVJlZi5vbkRlc3Ryb3koKCkgPT4ge1xuICAgIHVuc3Vic2NyaWJlcy5mb3JFYWNoKCh1bnN1YikgPT4gdW5zdWIoKSk7XG4gIH0pO1xufVxuXG4vKiogQGRlcHJlY2F0ZWQgVXNlIGluamVjdFBpbGxhclRvb2wgaW5zdGVhZCAqL1xuZXhwb3J0IGNvbnN0IGluamVjdFBpbGxhckFjdGlvbiA9IGluamVjdFBpbGxhclRvb2w7XG4iXX0=

package/dist/esm2022/lib/inject-pillar.mjs

@@ -0,0 +1,79 @@
+/**
+ * injectPillar Function
+ * Angular-idiomatic injection helper for accessing Pillar SDK
+ */
+import { inject } from '@angular/core';
+import { PillarService } from './pillar.service';
+/**
+ * Angular injection function to access the Pillar SDK.
+ * Use this in components, directives, or services to interact with Pillar.
+ *
+ * Must be called within an injection context (constructor, field initializer, or inject()).
+ *
+ * @example Basic usage (untyped)
+ * ```typescript
+ * @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;
+ * }
+ * ```
+ *
+ * @example Type-safe onTask with action definitions
+ * ```typescript
+ * import { actions } from '@/lib/pillar/actions';
+ *
+ * @Component({...})
+ * export class MyComponent implements OnInit, OnDestroy {
+ *   private pillar = injectPillar<typeof actions>();
+ *   private unsubscribe?: () => void;
+ *
+ *   ngOnInit() {
+ *     // TypeScript knows data has the correct shape
+ *     this.unsubscribe = this.pillar.onTask('add_new_source', (data) => {
+ *       console.log(data.url); // ✓ Typed!
+ *     });
+ *   }
+ *
+ *   ngOnDestroy() {
+ *     this.unsubscribe?.();
+ *   }
+ * }
+ * ```
+ */
+export function injectPillar() {
+    const service = inject(PillarService);
+    // Create a type-safe wrapper around pillar.onTask
+    const onTask = (taskName, handler) => {
+        // Cast handler to match the SDK's expected type
+        // The runtime behavior is the same, this is just for type narrowing
+        return service.onTask(taskName, handler);
+    };
+    return {
+        pillar: () => service.getInstance(),
+        state: service.state,
+        isReady: service.isReady,
+        isPanelOpen: service.isPanelOpen,
+        open: service.open.bind(service),
+        close: service.close.bind(service),
+        toggle: service.toggle.bind(service),
+        openArticle: service.openArticle.bind(service),
+        openCategory: service.openCategory.bind(service),
+        search: service.search.bind(service),
+        navigate: service.navigate.bind(service),
+        setTheme: service.setTheme.bind(service),
+        setTextSelectionEnabled: service.setTextSelectionEnabled.bind(service),
+        on: service.on.bind(service),
+        onTask,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inject-pillar.js","sourceRoot":"","sources":["../../../src/lib/inject-pillar.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAOvC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAiEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,UAAU,YAAY;IAG1B,MAAM,OAAO,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;IAEtC,kDAAkD;IAClD,MAAM,MAAM,GAAG,CACb,QAAe,EACf,OAAwD,EAC1C,EAAE;QAChB,gDAAgD;QAChD,oEAAoE;QACpE,OAAO,OAAO,CAAC,MAAM,CACnB,QAAkB,EAClB,OAAkD,CACnD,CAAC;IACJ,CAAC,CAAC;IAEF,OAAO;QACL,MAAM,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,WAAW,EAAE;QACnC,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,WAAW,EAAE,OAAO,CAAC,WAAW;QAChC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;QAChC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC;QAClC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC;QACpC,WAAW,EAAE,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC;QAC9C,YAAY,EAAE,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC;QAChD,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC;QACpC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC;QACxC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC;QACxC,uBAAuB,EAAE,OAAO,CAAC,uBAAuB,CAAC,IAAI,CAAC,OAAO,CAAC;QACtE,EAAE,EAAE,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC;QAC5B,MAAM;KACP,CAAC;AACJ,CAAC","sourcesContent":["/**\n * injectPillar Function\n * Angular-idiomatic injection helper for accessing Pillar SDK\n */\n\nimport { inject } from '@angular/core';\nimport type {\n  SyncActionDefinitions,\n  ActionDefinitions,\n  ActionDataType,\n  ActionNames,\n} from '@pillar-ai/sdk';\nimport { PillarService } from './pillar.service';\n\n/**\n * Result type for injectPillar with type-safe onTask.\n *\n * @template TActions - The action definitions for type inference\n */\nexport interface InjectPillarResult<\n  TActions extends SyncActionDefinitions | ActionDefinitions = SyncActionDefinitions,\n> {\n  /** Get the Pillar SDK instance */\n  pillar: () => ReturnType<PillarService['getInstance']>;\n\n  /** Current SDK state */\n  state: PillarService['state'];\n\n  /** Whether the SDK is ready */\n  isReady: PillarService['isReady'];\n\n  /** Whether the panel is currently open */\n  isPanelOpen: PillarService['isPanelOpen'];\n\n  /** Open the help panel */\n  open: PillarService['open'];\n\n  /** Close the help panel */\n  close: PillarService['close'];\n\n  /** Toggle the help panel */\n  toggle: PillarService['toggle'];\n\n  /** Open a specific article */\n  openArticle: PillarService['openArticle'];\n\n  /** Open a specific category */\n  openCategory: PillarService['openCategory'];\n\n  /** Perform a search */\n  search: PillarService['search'];\n\n  /** Navigate to a specific view */\n  navigate: PillarService['navigate'];\n\n  /** Update the panel theme at runtime */\n  setTheme: PillarService['setTheme'];\n\n  /** Enable or disable the text selection \"Ask AI\" popover */\n  setTextSelectionEnabled: PillarService['setTextSelectionEnabled'];\n\n  /** Subscribe to SDK events */\n  on: PillarService['on'];\n\n  /**\n   * Type-safe task handler registration.\n   *\n   * @param taskName - The action name (autocompleted from your actions)\n   * @param handler - Handler function with typed data parameter\n   * @returns Unsubscribe function\n   */\n  onTask: <TName extends ActionNames<TActions>>(\n    taskName: TName,\n    handler: (data: ActionDataType<TActions, TName>) => void\n  ) => () => void;\n}\n\n/**\n * Angular injection function to access the Pillar SDK.\n * Use this in components, directives, or services to interact with Pillar.\n *\n * Must be called within an injection context (constructor, field initializer, or inject()).\n *\n * @example Basic usage (untyped)\n * ```typescript\n * @Component({\n *   selector: 'app-help-button',\n *   standalone: true,\n *   template: `\n *     <button (click)=\"toggle()\">\n *       {{ isPanelOpen() ? 'Close Help' : 'Get Help' }}\n *     </button>\n *   `,\n * })\n * export class HelpButtonComponent {\n *   private pillar = injectPillar();\n *   isPanelOpen = this.pillar.isPanelOpen;\n *   toggle = this.pillar.toggle;\n * }\n * ```\n *\n * @example Type-safe onTask with action definitions\n * ```typescript\n * import { actions } from '@/lib/pillar/actions';\n *\n * @Component({...})\n * export class MyComponent implements OnInit, OnDestroy {\n *   private pillar = injectPillar<typeof actions>();\n *   private unsubscribe?: () => void;\n *\n *   ngOnInit() {\n *     // TypeScript knows data has the correct shape\n *     this.unsubscribe = this.pillar.onTask('add_new_source', (data) => {\n *       console.log(data.url); // ✓ Typed!\n *     });\n *   }\n *\n *   ngOnDestroy() {\n *     this.unsubscribe?.();\n *   }\n * }\n * ```\n */\nexport function injectPillar<\n  TActions extends SyncActionDefinitions | ActionDefinitions = SyncActionDefinitions,\n>(): InjectPillarResult<TActions> {\n  const service = inject(PillarService);\n\n  // Create a type-safe wrapper around pillar.onTask\n  const onTask = <TName extends ActionNames<TActions>>(\n    taskName: TName,\n    handler: (data: ActionDataType<TActions, TName>) => void\n  ): (() => void) => {\n    // Cast handler to match the SDK's expected type\n    // The runtime behavior is the same, this is just for type narrowing\n    return service.onTask(\n      taskName as string,\n      handler as (data: Record<string, unknown>) => void\n    );\n  };\n\n  return {\n    pillar: () => service.getInstance(),\n    state: service.state,\n    isReady: service.isReady,\n    isPanelOpen: service.isPanelOpen,\n    open: service.open.bind(service),\n    close: service.close.bind(service),\n    toggle: service.toggle.bind(service),\n    openArticle: service.openArticle.bind(service),\n    openCategory: service.openCategory.bind(service),\n    search: service.search.bind(service),\n    navigate: service.navigate.bind(service),\n    setTheme: service.setTheme.bind(service),\n    setTextSelectionEnabled: service.setTextSelectionEnabled.bind(service),\n    on: service.on.bind(service),\n    onTask,\n  };\n}\n"]}