@savvagent/angular 1.0.1

package/coverage/sorter.js

@@ -0,0 +1,210 @@
+/* eslint-disable */
+var addSorting = (function() {
+    'use strict';
+    var cols,
+        currentSort = {
+            index: 0,
+            desc: false
+        };
+
+    // returns the summary table element
+    function getTable() {
+        return document.querySelector('.coverage-summary');
+    }
+    // returns the thead element of the summary table
+    function getTableHeader() {
+        return getTable().querySelector('thead tr');
+    }
+    // returns the tbody element of the summary table
+    function getTableBody() {
+        return getTable().querySelector('tbody');
+    }
+    // returns the th element for nth column
+    function getNthColumn(n) {
+        return getTableHeader().querySelectorAll('th')[n];
+    }
+
+    function onFilterInput() {
+        const searchValue = document.getElementById('fileSearch').value;
+        const rows = document.getElementsByTagName('tbody')[0].children;
+
+        // Try to create a RegExp from the searchValue. If it fails (invalid regex),
+        // it will be treated as a plain text search
+        let searchRegex;
+        try {
+            searchRegex = new RegExp(searchValue, 'i'); // 'i' for case-insensitive
+        } catch (error) {
+            searchRegex = null;
+        }
+
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            let isMatch = false;
+
+            if (searchRegex) {
+                // If a valid regex was created, use it for matching
+                isMatch = searchRegex.test(row.textContent);
+            } else {
+                // Otherwise, fall back to the original plain text search
+                isMatch = row.textContent
+                    .toLowerCase()
+                    .includes(searchValue.toLowerCase());
+            }
+
+            row.style.display = isMatch ? '' : 'none';
+        }
+    }
+
+    // loads the search box
+    function addSearchBox() {
+        var template = document.getElementById('filterTemplate');
+        var templateClone = template.content.cloneNode(true);
+        templateClone.getElementById('fileSearch').oninput = onFilterInput;
+        template.parentElement.appendChild(templateClone);
+    }
+
+    // loads all columns
+    function loadColumns() {
+        var colNodes = getTableHeader().querySelectorAll('th'),
+            colNode,
+            cols = [],
+            col,
+            i;
+
+        for (i = 0; i < colNodes.length; i += 1) {
+            colNode = colNodes[i];
+            col = {
+                key: colNode.getAttribute('data-col'),
+                sortable: !colNode.getAttribute('data-nosort'),
+                type: colNode.getAttribute('data-type') || 'string'
+            };
+            cols.push(col);
+            if (col.sortable) {
+                col.defaultDescSort = col.type === 'number';
+                colNode.innerHTML =
+                    colNode.innerHTML + '<span class="sorter"></span>';
+            }
+        }
+        return cols;
+    }
+    // attaches a data attribute to every tr element with an object
+    // of data values keyed by column name
+    function loadRowData(tableRow) {
+        var tableCols = tableRow.querySelectorAll('td'),
+            colNode,
+            col,
+            data = {},
+            i,
+            val;
+        for (i = 0; i < tableCols.length; i += 1) {
+            colNode = tableCols[i];
+            col = cols[i];
+            val = colNode.getAttribute('data-value');
+            if (col.type === 'number') {
+                val = Number(val);
+            }
+            data[col.key] = val;
+        }
+        return data;
+    }
+    // loads all row data
+    function loadData() {
+        var rows = getTableBody().querySelectorAll('tr'),
+            i;
+
+        for (i = 0; i < rows.length; i += 1) {
+            rows[i].data = loadRowData(rows[i]);
+        }
+    }
+    // sorts the table using the data for the ith column
+    function sortByIndex(index, desc) {
+        var key = cols[index].key,
+            sorter = function(a, b) {
+                a = a.data[key];
+                b = b.data[key];
+                return a < b ? -1 : a > b ? 1 : 0;
+            },
+            finalSorter = sorter,
+            tableBody = document.querySelector('.coverage-summary tbody'),
+            rowNodes = tableBody.querySelectorAll('tr'),
+            rows = [],
+            i;
+
+        if (desc) {
+            finalSorter = function(a, b) {
+                return -1 * sorter(a, b);
+            };
+        }
+
+        for (i = 0; i < rowNodes.length; i += 1) {
+            rows.push(rowNodes[i]);
+            tableBody.removeChild(rowNodes[i]);
+        }
+
+        rows.sort(finalSorter);
+
+        for (i = 0; i < rows.length; i += 1) {
+            tableBody.appendChild(rows[i]);
+        }
+    }
+    // removes sort indicators for current column being sorted
+    function removeSortIndicators() {
+        var col = getNthColumn(currentSort.index),
+            cls = col.className;
+
+        cls = cls.replace(/ sorted$/, '').replace(/ sorted-desc$/, '');
+        col.className = cls;
+    }
+    // adds sort indicators for current column being sorted
+    function addSortIndicators() {
+        getNthColumn(currentSort.index).className += currentSort.desc
+            ? ' sorted-desc'
+            : ' sorted';
+    }
+    // adds event listeners for all sorter widgets
+    function enableUI() {
+        var i,
+            el,
+            ithSorter = function ithSorter(i) {
+                var col = cols[i];
+
+                return function() {
+                    var desc = col.defaultDescSort;
+
+                    if (currentSort.index === i) {
+                        desc = !currentSort.desc;
+                    }
+                    sortByIndex(i, desc);
+                    removeSortIndicators();
+                    currentSort.index = i;
+                    currentSort.desc = desc;
+                    addSortIndicators();
+                };
+            };
+        for (i = 0; i < cols.length; i += 1) {
+            if (cols[i].sortable) {
+                // add the click event handler on the th so users
+                // dont have to click on those tiny arrows
+                el = getNthColumn(i).querySelector('.sorter').parentElement;
+                if (el.addEventListener) {
+                    el.addEventListener('click', ithSorter(i));
+                } else {
+                    el.attachEvent('onclick', ithSorter(i));
+                }
+            }
+        }
+    }
+    // adds sorting functionality to the UI
+    return function() {
+        if (!getTable()) {
+            return;
+        }
+        cols = loadColumns();
+        loadData();
+        addSearchBox();
+        addSortIndicators();
+        enableUI();
+    };
+})();
+
+window.addEventListener('load', addSorting);

package/dist/README.md

@@ -0,0 +1,484 @@
+# @savvagent/angular
+
+Angular SDK for Savvagent - AI-powered feature flags that prevent production incidents.
+
+## Installation
+
+```bash
+npm install @savvagent/angular
+# or
+pnpm add @savvagent/angular
+# or
+yarn add @savvagent/angular
+```
+
+## Quick Start
+
+### 1. Import SavvagentModule in your app
+
+```typescript
+// app.module.ts
+import { SavvagentModule } from '@savvagent/angular';
+
+@NgModule({
+  imports: [
+    SavvagentModule.forRoot({
+      config: {
+        apiKey: 'sdk_your_api_key_here',
+        applicationId: 'your-app-id', // Optional: for application-scoped flags
+        enableRealtime: true, // Enable real-time flag updates
+      },
+      defaultContext: {
+        environment: 'production',
+        userId: 'user-123', // Optional: set default user
+      }
+    })
+  ]
+})
+export class AppModule {}
+```
+
+### 2. Use SavvagentService in your components
+
+```typescript
+import { Component } from '@angular/core';
+import { SavvagentService } from '@savvagent/angular';
+
+@Component({
+  selector: 'app-my-feature',
+  template: `
+    <ng-container *ngIf="newFeature$ | async as flag">
+      <app-spinner *ngIf="flag.loading"></app-spinner>
+      <app-new-checkout *ngIf="flag.value"></app-new-checkout>
+      <app-old-checkout *ngIf="!flag.value && !flag.loading"></app-old-checkout>
+    </ng-container>
+  `
+})
+export class MyFeatureComponent {
+  newFeature$ = this.savvagent.flag$('new-checkout-flow', {
+    defaultValue: false,
+    realtime: true,
+  });
+
+  constructor(private savvagent: SavvagentService) {}
+}
+```
+
+## Standalone Components (Angular 14+)
+
+For standalone components, you can use `importProvidersFrom`:
+
+```typescript
+// main.ts
+import { bootstrapApplication } from '@angular/platform-browser';
+import { importProvidersFrom } from '@angular/core';
+import { SavvagentModule } from '@savvagent/angular';
+import { AppComponent } from './app/app.component';
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    importProvidersFrom(
+      SavvagentModule.forRoot({
+        config: { apiKey: 'sdk_your_api_key' }
+      })
+    )
+  ]
+});
+```
+
+## API Reference
+
+### `SavvagentModule`
+
+Angular module that configures the Savvagent SDK.
+
+#### `SavvagentModule.forRoot(config)`
+
+Configure the module with your API key and default context.
+
+```typescript
+interface SavvagentConfig {
+  config: FlagClientConfig;
+  defaultContext?: DefaultFlagContext;
+}
+
+interface FlagClientConfig {
+  /** SDK API key (starts with sdk_) */
+  apiKey: string;
+  /** Application ID for application-scoped flags */
+  applicationId?: string;
+  /** Base URL for the Savvagent API */
+  baseUrl?: string;
+  /** Enable real-time flag updates via SSE (default: true) */
+  enableRealtime?: boolean;
+  /** Cache TTL in milliseconds (default: 60000) */
+  cacheTtl?: number;
+  /** Enable telemetry tracking (default: true) */
+  enableTelemetry?: boolean;
+  /** Default flag values when evaluation fails */
+  defaults?: Record<string, boolean>;
+  /** Custom error handler */
+  onError?: (error: Error) => void;
+}
+
+interface DefaultFlagContext {
+  applicationId?: string;
+  environment?: string;
+  organizationId?: string;
+  userId?: string;
+  anonymousId?: string;
+  sessionId?: string;
+  language?: string;
+  attributes?: Record<string, any>;
+}
+```
+
+### `SavvagentService`
+
+Injectable service that provides all feature flag functionality.
+
+#### Properties
+
+- `ready$: Observable<boolean>` - Observable that emits true when the client is ready
+- `isReady: boolean` - Check if the client is ready synchronously
+- `flagClient: FlagClient | null` - Access the underlying FlagClient for advanced use cases
+
+#### `flag$(flagKey, options)`
+
+Get a reactive Observable for a feature flag with automatic updates.
+
+```typescript
+interface FlagOptions {
+  /** Context for flag evaluation (user_id, attributes, etc.) */
+  context?: FlagContext;
+  /** Default value to use while loading or on error */
+  defaultValue?: boolean;
+  /** Enable real-time updates for this flag (default: true) */
+  realtime?: boolean;
+}
+
+interface FlagObservableResult {
+  /** Current flag value */
+  value: boolean;
+  /** Whether the flag is currently being evaluated */
+  loading: boolean;
+  /** Error if evaluation failed */
+  error: Error | null;
+  /** Detailed evaluation result */
+  result: FlagEvaluationResult | null;
+}
+```
+
+**Example:**
+
+```typescript
+@Component({
+  template: `
+    <ng-container *ngIf="betaFeature$ | async as flag">
+      <div *ngIf="flag.loading">Loading...</div>
+      <div *ngIf="flag.error">Error: {{ flag.error.message }}</div>
+      <app-beta *ngIf="flag.value"></app-beta>
+      <app-standard *ngIf="!flag.value && !flag.loading"></app-standard>
+    </ng-container>
+  `
+})
+export class MyComponent {
+  betaFeature$ = this.savvagent.flag$('beta-feature', {
+    context: {
+      user_id: this.userId,
+      attributes: { plan: 'pro' }
+    },
+    defaultValue: false,
+    realtime: true
+  });
+
+  constructor(private savvagent: SavvagentService) {}
+}
+```
+
+#### `flagValue$(flagKey, options)`
+
+Get just the boolean value as an Observable. Useful when you don't need loading/error states.
+
+```typescript
+@Component({
+  template: `
+    <button *ngIf="isFeatureEnabled$ | async">New Button</button>
+  `
+})
+export class SimpleComponent {
+  isFeatureEnabled$ = this.savvagent.flagValue$('my-feature');
+
+  constructor(private savvagent: SavvagentService) {}
+}
+```
+
+#### `evaluate(flagKey, context)`
+
+Evaluate a feature flag once (non-reactive).
+
+```typescript
+async checkFeature() {
+  const result = await this.savvagent.evaluate('new-feature');
+  console.log(result.value, result.reason);
+}
+```
+
+#### `isEnabled(flagKey, context)`
+
+Simple boolean check if a flag is enabled.
+
+```typescript
+async doSomething() {
+  if (await this.savvagent.isEnabled('feature-flag')) {
+    // Feature is enabled
+  }
+}
+```
+
+#### `withFlag(flagKey, callback, context)`
+
+Execute code conditionally based on flag value.
+
+```typescript
+async trackPageView() {
+  await this.savvagent.withFlag('analytics-enabled', async () => {
+    await this.analytics.track('page_view');
+  });
+}
+```
+
+#### `trackError(flagKey, error, context)`
+
+Track errors with flag context for AI-powered analysis.
+
+```typescript
+handleError(error: Error) {
+  this.savvagent.trackError('new-payment-flow', error);
+}
+```
+
+#### User Management
+
+```typescript
+// Set user ID for logged-in users
+setUserId(userId: string | null): void;
+getUserId(): string | null;
+
+// Anonymous ID management
+getAnonymousId(): string | null;
+setAnonymousId(id: string): void;
+```
+
+#### Local Overrides
+
+For development and testing:
+
+```typescript
+// Set override (takes precedence over server values)
+setOverride(flagKey: string, value: boolean): void;
+
+// Clear overrides
+clearOverride(flagKey: string): void;
+clearAllOverrides(): void;
+
+// Check overrides
+hasOverride(flagKey: string): boolean;
+getOverride(flagKey: string): boolean | undefined;
+getOverrides(): Record<string, boolean>;
+
+// Set multiple overrides
+setOverrides(overrides: Record<string, boolean>): void;
+```
+
+#### Flag Discovery
+
+```typescript
+// Get all flags (returns Observable)
+getAllFlags$(environment?: string): Observable<FlagDefinition[]>;
+
+// Get all flags (Promise-based)
+getAllFlags(environment?: string): Promise<FlagDefinition[]>;
+
+// Get enterprise-scoped flags only
+getEnterpriseFlags(environment?: string): Promise<FlagDefinition[]>;
+```
+
+#### Cache & Connection
+
+```typescript
+clearCache(): void;
+isRealtimeConnected(): boolean;
+close(): void;
+```
+
+## Advanced Examples
+
+### User Targeting
+
+```typescript
+@Component({...})
+export class UserFeatureComponent implements OnInit {
+  premiumFeature$!: Observable<FlagObservableResult>;
+
+  constructor(
+    private savvagent: SavvagentService,
+    private auth: AuthService
+  ) {}
+
+  ngOnInit() {
+    this.premiumFeature$ = this.savvagent.flag$('premium-features', {
+      context: {
+        user_id: this.auth.userId,
+        attributes: {
+          plan: this.auth.userPlan,
+          signupDate: this.auth.signupDate
+        }
+      }
+    });
+  }
+}
+```
+
+### Dynamic Initialization
+
+If you need to initialize the service after getting user data:
+
+```typescript
+@Component({...})
+export class AppComponent implements OnInit {
+  constructor(
+    private savvagent: SavvagentService,
+    private auth: AuthService
+  ) {}
+
+  ngOnInit() {
+    // Wait for auth, then initialize
+    this.auth.user$.pipe(take(1)).subscribe(user => {
+      this.savvagent.initialize({
+        config: {
+          apiKey: environment.savvagentApiKey
+        },
+        defaultContext: {
+          userId: user?.id,
+          environment: environment.name
+        }
+      });
+    });
+  }
+}
+```
+
+### Error Tracking
+
+```typescript
+@Component({...})
+export class PaymentComponent {
+  constructor(private savvagent: SavvagentService) {}
+
+  async processPayment() {
+    try {
+      const result = await this.paymentService.process();
+      return result;
+    } catch (error) {
+      // Error is correlated with flag changes
+      this.savvagent.trackError('new-payment-flow', error as Error);
+      throw error;
+    }
+  }
+}
+```
+
+### A/B Testing
+
+```typescript
+@Component({
+  template: `
+    <app-checkout-a *ngIf="!(variantB$ | async)"></app-checkout-a>
+    <app-checkout-b *ngIf="variantB$ | async"></app-checkout-b>
+  `
+})
+export class ABTestComponent {
+  variantB$ = this.savvagent.flagValue$('checkout-variant-b', {
+    context: {
+      user_id: this.userId // Consistent assignment per user
+    }
+  });
+
+  constructor(private savvagent: SavvagentService) {}
+}
+```
+
+### Development Override Panel
+
+```typescript
+@Component({
+  selector: 'app-flag-overrides',
+  template: `
+    <div *ngFor="let flag of flags$ | async">
+      <label>
+        <input
+          type="checkbox"
+          [checked]="savvagent.getOverride(flag.key) ?? flag.enabled"
+          (change)="toggleOverride(flag.key, $event)"
+        />
+        {{ flag.key }}
+      </label>
+      <button (click)="clearOverride(flag.key)">Reset</button>
+    </div>
+  `
+})
+export class FlagOverridesComponent implements OnInit {
+  flags$ = this.savvagent.getAllFlags$('development');
+
+  constructor(public savvagent: SavvagentService) {}
+
+  toggleOverride(flagKey: string, event: Event) {
+    const checked = (event.target as HTMLInputElement).checked;
+    this.savvagent.setOverride(flagKey, checked);
+  }
+
+  clearOverride(flagKey: string) {
+    this.savvagent.clearOverride(flagKey);
+  }
+}
+```
+
+## TypeScript Support
+
+This package is written in TypeScript and provides full type definitions.
+
+```typescript
+import type {
+  FlagClientConfig,
+  FlagContext,
+  FlagEvaluationResult,
+  FlagDefinition,
+  SavvagentConfig,
+  DefaultFlagContext,
+  FlagObservableResult,
+  FlagOptions,
+} from '@savvagent/angular';
+```
+
+## Best Practices
+
+1. **Import SavvagentModule.forRoot() in your root module** to ensure a single instance of the service.
+
+2. **Use the `defaultValue` option** to provide a safe fallback while flags are loading.
+
+3. **Enable real-time updates** for flags that change frequently or require immediate propagation.
+
+4. **Track errors** in new features to leverage Savvagent's AI-powered error correlation.
+
+5. **Use user context** for targeted rollouts based on user attributes, location, or behavior.
+
+6. **Handle loading states** gracefully using the async pipe and conditional rendering.
+
+7. **Use `flagValue$`** when you only need the boolean value without loading/error states.
+
+8. **Clean up subscriptions** - the service handles cleanup automatically on destroy, but use `takeUntil` or similar patterns in components for long-lived subscriptions.
+
+## License
+
+MIT

package/dist/esm2022/index.mjs

@@ -0,0 +1,15 @@
+/**
+ * @savvagent/angular - Angular SDK for Savvagent feature flags
+ *
+ * This package provides Angular services and modules for easy integration
+ * of Savvagent feature flags into Angular applications.
+ *
+ * @packageDocumentation
+ */
+// Module
+export { SavvagentModule } from './module';
+// Service and types
+export { SavvagentService, SAVVAGENT_CONFIG } from './service';
+// Re-export FlagClient for advanced use cases
+export { FlagClient } from '@savvagent/sdk';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUVILFNBQVM7QUFDVCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBRTNDLG9CQUFvQjtBQUNwQixPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxXQUFXLENBQUM7QUF1Qi9ELDhDQUE4QztBQUM5QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBzYXZ2YWdlbnQvYW5ndWxhciAtIEFuZ3VsYXIgU0RLIGZvciBTYXZ2YWdlbnQgZmVhdHVyZSBmbGFnc1xuICpcbiAqIFRoaXMgcGFja2FnZSBwcm92aWRlcyBBbmd1bGFyIHNlcnZpY2VzIGFuZCBtb2R1bGVzIGZvciBlYXN5IGludGVncmF0aW9uXG4gKiBvZiBTYXZ2YWdlbnQgZmVhdHVyZSBmbGFncyBpbnRvIEFuZ3VsYXIgYXBwbGljYXRpb25zLlxuICpcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvblxuICovXG5cbi8vIE1vZHVsZVxuZXhwb3J0IHsgU2F2dmFnZW50TW9kdWxlIH0gZnJvbSAnLi9tb2R1bGUnO1xuXG4vLyBTZXJ2aWNlIGFuZCB0eXBlc1xuZXhwb3J0IHsgU2F2dmFnZW50U2VydmljZSwgU0FWVkFHRU5UX0NPTkZJRyB9IGZyb20gJy4vc2VydmljZSc7XG5leHBvcnQgdHlwZSB7XG4gIFNhdnZhZ2VudENvbmZpZyxcbiAgRGVmYXVsdEZsYWdDb250ZXh0LFxuICBGbGFnT2JzZXJ2YWJsZVJlc3VsdCxcbiAgRmxhZ09wdGlvbnMsXG59IGZyb20gJy4vc2VydmljZSc7XG5cbi8vIFJlLWV4cG9ydCB0eXBlcyBmcm9tIGNvcmUgU0RLXG5leHBvcnQgdHlwZSB7XG4gIEZsYWdDbGllbnRDb25maWcsXG4gIEZsYWdDb250ZXh0LFxuICBGbGFnRXZhbHVhdGlvblJlc3VsdCxcbiAgRXZhbHVhdGlvbkV2ZW50LFxuICBFcnJvckV2ZW50LFxuICBGbGFnVXBkYXRlRXZlbnQsXG4gIEZsYWdEZWZpbml0aW9uLFxuICBGbGFnTGlzdFJlc3BvbnNlLFxuICAvLyBHZW5lcmF0ZWQgQVBJIHR5cGVzIGZvciBhZHZhbmNlZCB1c2Vyc1xuICBBcGlUeXBlcyxcbiAgY29tcG9uZW50cyxcbn0gZnJvbSAnQHNhdnZhZ2VudC9zZGsnO1xuXG4vLyBSZS1leHBvcnQgRmxhZ0NsaWVudCBmb3IgYWR2YW5jZWQgdXNlIGNhc2VzXG5leHBvcnQgeyBGbGFnQ2xpZW50IH0gZnJvbSAnQHNhdnZhZ2VudC9zZGsnO1xuIl19