@savvagent/angular 1.0.1

package/dist/esm2022/module.mjs

@@ -0,0 +1,75 @@
+import { NgModule } from '@angular/core';
+import { SavvagentService, SAVVAGENT_CONFIG } from './service';
+import * as i0 from "@angular/core";
+/**
+ * Angular module for Savvagent feature flags.
+ *
+ * @example
+ * ```typescript
+ * // app.module.ts
+ * import { SavvagentModule } from '@savvagent/angular';
+ *
+ * @NgModule({
+ *   imports: [
+ *     SavvagentModule.forRoot({
+ *       config: {
+ *         apiKey: 'sdk_your_api_key',
+ *         baseUrl: 'https://api.savvagent.com'
+ *       },
+ *       defaultContext: {
+ *         applicationId: 'my-app',
+ *         environment: 'production',
+ *         userId: 'user-123'
+ *       }
+ *     })
+ *   ]
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // For standalone components (Angular 14+)
+ * import { SavvagentModule } from '@savvagent/angular';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     importProvidersFrom(
+ *       SavvagentModule.forRoot({
+ *         config: { apiKey: 'sdk_...' }
+ *       })
+ *     )
+ *   ]
+ * });
+ * ```
+ */
+export class SavvagentModule {
+    /**
+     * Configure the Savvagent module with API key and default context.
+     *
+     * @param savvagentConfig - Configuration including API key and optional default context
+     * @returns Module with providers
+     */
+    static forRoot(savvagentConfig) {
+        return {
+            ngModule: SavvagentModule,
+            providers: [
+                {
+                    provide: SAVVAGENT_CONFIG,
+                    useValue: savvagentConfig
+                },
+                SavvagentService
+            ]
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SavvagentModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: SavvagentModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SavvagentModule, providers: [SavvagentService] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SavvagentModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [SavvagentService]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/savvagent-angular.mjs

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

package/dist/esm2022/service.mjs

@@ -0,0 +1,473 @@
+import { Injectable, Inject, InjectionToken, Optional } from '@angular/core';
+import { BehaviorSubject, from, of, Subject } from 'rxjs';
+import { map, takeUntil, catchError, distinctUntilChanged } from 'rxjs/operators';
+import { FlagClient } from '@savvagent/sdk';
+import * as i0 from "@angular/core";
+/**
+ * Injection token for Savvagent configuration
+ */
+export const SAVVAGENT_CONFIG = new InjectionToken('SAVVAGENT_CONFIG');
+/**
+ * Angular service for Savvagent feature flags.
+ * Provides reactive flag evaluation using RxJS Observables.
+ *
+ * @example
+ * ```typescript
+ * // In your component
+ * @Component({...})
+ * export class MyComponent {
+ *   newFeature$ = this.savvagent.flag$('new-feature');
+ *
+ *   constructor(private savvagent: SavvagentService) {}
+ * }
+ *
+ * // In your template
+ * <div *ngIf="(newFeature$ | async)?.value">
+ *   New feature content!
+ * </div>
+ * ```
+ */
+export class SavvagentService {
+    client = null;
+    destroy$ = new Subject();
+    isReady$ = new BehaviorSubject(false);
+    defaultContext = {};
+    flagSubjects = new Map();
+    constructor(config) {
+        if (config) {
+            this.initialize(config);
+        }
+    }
+    /**
+     * Initialize the Savvagent client with configuration.
+     * Call this if not using the SAVVAGENT_CONFIG injection token.
+     *
+     * @param savvagentConfig - Configuration including API key and default context
+     *
+     * @example
+     * ```typescript
+     * @Component({...})
+     * export class AppComponent implements OnInit {
+     *   constructor(private savvagent: SavvagentService) {}
+     *
+     *   ngOnInit() {
+     *     this.savvagent.initialize({
+     *       config: { apiKey: 'sdk_...' },
+     *       defaultContext: {
+     *         applicationId: 'my-app',
+     *         environment: 'development',
+     *         userId: 'user-123'
+     *       }
+     *     });
+     *   }
+     * }
+     * ```
+     */
+    initialize(savvagentConfig) {
+        if (this.client) {
+            console.warn('[Savvagent] Client already initialized. Call close() first to reinitialize.');
+            return;
+        }
+        try {
+            this.client = new FlagClient(savvagentConfig.config);
+            // Convert DefaultFlagContext to FlagContext format (camelCase to snake_case)
+            if (savvagentConfig.defaultContext) {
+                this.defaultContext = {
+                    application_id: savvagentConfig.defaultContext.applicationId,
+                    environment: savvagentConfig.defaultContext.environment,
+                    organization_id: savvagentConfig.defaultContext.organizationId,
+                    user_id: savvagentConfig.defaultContext.userId,
+                    anonymous_id: savvagentConfig.defaultContext.anonymousId,
+                    session_id: savvagentConfig.defaultContext.sessionId,
+                    language: savvagentConfig.defaultContext.language,
+                    attributes: savvagentConfig.defaultContext.attributes,
+                };
+            }
+            this.isReady$.next(true);
+            // Subscribe to override changes to re-evaluate all active flags
+            this.client.onOverrideChange(() => {
+                this.reEvaluateAllFlags();
+            });
+        }
+        catch (error) {
+            console.error('[Savvagent] Failed to initialize client:', error);
+            savvagentConfig.config.onError?.(error);
+        }
+    }
+    /**
+     * Observable that emits true when the client is ready.
+     */
+    get ready$() {
+        return this.isReady$.asObservable();
+    }
+    /**
+     * Check if the client is ready.
+     */
+    get isReady() {
+        return this.isReady$.value;
+    }
+    /**
+     * Get the underlying FlagClient instance for advanced use cases.
+     */
+    get flagClient() {
+        return this.client;
+    }
+    /**
+     * Merge default context with per-call context.
+     */
+    mergeContext(context) {
+        return {
+            ...this.defaultContext,
+            ...context,
+            attributes: {
+                ...this.defaultContext.attributes,
+                ...context?.attributes,
+            },
+        };
+    }
+    /**
+     * Get a reactive Observable for a feature flag.
+     * Automatically updates when the flag value changes.
+     *
+     * @param flagKey - The feature flag key to evaluate
+     * @param options - Configuration options
+     * @returns Observable of flag evaluation state
+     *
+     * @example
+     * ```typescript
+     * // In your component
+     * newFeature$ = this.savvagent.flag$('new-feature', {
+     *   defaultValue: false,
+     *   realtime: true,
+     *   context: { attributes: { plan: 'pro' } }
+     * });
+     *
+     * // In template
+     * <ng-container *ngIf="newFeature$ | async as flag">
+     *   <app-loading *ngIf="flag.loading"></app-loading>
+     *   <app-new-feature *ngIf="flag.value"></app-new-feature>
+     *   <app-old-feature *ngIf="!flag.value && !flag.loading"></app-old-feature>
+     * </ng-container>
+     * ```
+     */
+    flag$(flagKey, options = {}) {
+        const { context, defaultValue = false, realtime = true } = options;
+        const mergedContext = this.mergeContext(context);
+        const cacheKey = this.getCacheKey(flagKey, mergedContext);
+        // Check if we already have a subject for this flag+context
+        if (!this.flagSubjects.has(cacheKey)) {
+            const subject = new BehaviorSubject({
+                value: defaultValue,
+                loading: true,
+                error: null,
+                result: null,
+            });
+            this.flagSubjects.set(cacheKey, subject);
+            // Initial evaluation
+            this.evaluateAndEmit(flagKey, mergedContext, defaultValue, subject);
+            // Set up real-time subscription if enabled
+            if (realtime && this.client) {
+                const unsubscribe = this.client.subscribe(flagKey, () => {
+                    this.evaluateAndEmit(flagKey, mergedContext, defaultValue, subject);
+                });
+                // Clean up subscription when subject is complete
+                subject.pipe(takeUntil(this.destroy$)).subscribe({
+                    complete: () => unsubscribe(),
+                });
+            }
+        }
+        return this.flagSubjects.get(cacheKey).asObservable().pipe(takeUntil(this.destroy$), distinctUntilChanged((a, b) => a.value === b.value &&
+            a.loading === b.loading &&
+            a.error === b.error));
+    }
+    /**
+     * Generate a cache key for a flag+context combination.
+     */
+    getCacheKey(flagKey, context) {
+        return `${flagKey}:${JSON.stringify(context)}`;
+    }
+    /**
+     * Evaluate a flag and emit the result to a subject.
+     */
+    async evaluateAndEmit(flagKey, context, defaultValue, subject) {
+        if (!this.client) {
+            subject.next({
+                value: defaultValue,
+                loading: false,
+                error: new Error('Savvagent client not initialized'),
+                result: null,
+            });
+            return;
+        }
+        try {
+            const result = await this.client.evaluate(flagKey, context);
+            subject.next({
+                value: result.value,
+                loading: false,
+                error: null,
+                result,
+            });
+        }
+        catch (error) {
+            subject.next({
+                value: defaultValue,
+                loading: false,
+                error: error,
+                result: null,
+            });
+        }
+    }
+    /**
+     * Re-evaluate all active flag subscriptions.
+     * Called when overrides change.
+     */
+    reEvaluateAllFlags() {
+        this.flagSubjects.forEach((subject, cacheKey) => {
+            const [flagKey, contextJson] = cacheKey.split(':', 2);
+            const context = JSON.parse(contextJson || '{}');
+            const currentValue = subject.value;
+            this.evaluateAndEmit(flagKey, context, currentValue.value, subject);
+        });
+    }
+    /**
+     * Get a flag value as a simple Observable<boolean>.
+     * Useful when you only need the value without loading/error states.
+     *
+     * @param flagKey - The feature flag key to evaluate
+     * @param options - Configuration options
+     * @returns Observable of boolean flag value
+     *
+     * @example
+     * ```typescript
+     * isFeatureEnabled$ = this.savvagent.flagValue$('my-feature');
+     *
+     * // In template
+     * <button *ngIf="isFeatureEnabled$ | async">New Button</button>
+     * ```
+     */
+    flagValue$(flagKey, options = {}) {
+        return this.flag$(flagKey, options).pipe(map((result) => result.value), distinctUntilChanged());
+    }
+    /**
+     * Evaluate a feature flag once (non-reactive).
+     * For reactive updates, use flag$() instead.
+     *
+     * @param flagKey - The feature flag key to evaluate
+     * @param context - Optional context for targeting
+     * @returns Promise with detailed evaluation result
+     *
+     * @example
+     * ```typescript
+     * async checkFeature() {
+     *   const result = await this.savvagent.evaluate('new-feature');
+     *   if (result.value) {
+     *     // Feature is enabled
+     *   }
+     * }
+     * ```
+     */
+    async evaluate(flagKey, context) {
+        if (!this.client) {
+            throw new Error('Savvagent client not initialized');
+        }
+        return this.client.evaluate(flagKey, this.mergeContext(context));
+    }
+    /**
+     * Check if a feature flag is enabled (non-reactive).
+     *
+     * @param flagKey - The feature flag key to evaluate
+     * @param context - Optional context for targeting
+     * @returns Promise<boolean>
+     */
+    async isEnabled(flagKey, context) {
+        if (!this.client) {
+            return false;
+        }
+        return this.client.isEnabled(flagKey, this.mergeContext(context));
+    }
+    /**
+     * Execute code conditionally based on flag value.
+     *
+     * @param flagKey - The flag key to check
+     * @param callback - Function to execute if flag is enabled
+     * @param context - Optional context for targeting
+     *
+     * @example
+     * ```typescript
+     * await this.savvagent.withFlag('analytics-enabled', async () => {
+     *   await this.analytics.track('page_view');
+     * });
+     * ```
+     */
+    async withFlag(flagKey, callback, context) {
+        if (!this.client) {
+            return null;
+        }
+        return this.client.withFlag(flagKey, callback, this.mergeContext(context));
+    }
+    /**
+     * Track an error with flag context.
+     *
+     * @param flagKey - The flag key associated with the error
+     * @param error - The error that occurred
+     * @param context - Optional context
+     */
+    trackError(flagKey, error, context) {
+        this.client?.trackError(flagKey, error, this.mergeContext(context));
+    }
+    /**
+     * Set the user ID for logged-in users.
+     *
+     * @param userId - The user ID (or null to clear)
+     */
+    setUserId(userId) {
+        this.client?.setUserId(userId);
+    }
+    /**
+     * Get the current user ID.
+     */
+    getUserId() {
+        return this.client?.getUserId() || null;
+    }
+    /**
+     * Get the current anonymous ID.
+     */
+    getAnonymousId() {
+        return this.client?.getAnonymousId() || null;
+    }
+    /**
+     * Set a custom anonymous ID.
+     */
+    setAnonymousId(id) {
+        this.client?.setAnonymousId(id);
+    }
+    // =====================
+    // Local Override Methods
+    // =====================
+    /**
+     * Set a local override for a flag.
+     * Overrides take precedence over server values.
+     *
+     * @param flagKey - The flag key to override
+     * @param value - The override value
+     */
+    setOverride(flagKey, value) {
+        this.client?.setOverride(flagKey, value);
+    }
+    /**
+     * Clear a local override for a flag.
+     */
+    clearOverride(flagKey) {
+        this.client?.clearOverride(flagKey);
+    }
+    /**
+     * Clear all local overrides.
+     */
+    clearAllOverrides() {
+        this.client?.clearAllOverrides();
+    }
+    /**
+     * Check if a flag has a local override.
+     */
+    hasOverride(flagKey) {
+        return this.client?.hasOverride(flagKey) || false;
+    }
+    /**
+     * Get the override value for a flag.
+     */
+    getOverride(flagKey) {
+        return this.client?.getOverride(flagKey);
+    }
+    /**
+     * Get all current overrides.
+     */
+    getOverrides() {
+        return this.client?.getOverrides() || {};
+    }
+    /**
+     * Set multiple overrides at once.
+     */
+    setOverrides(overrides) {
+        this.client?.setOverrides(overrides);
+    }
+    // =====================
+    // Flag Discovery Methods
+    // =====================
+    /**
+     * Get all flags for the application.
+     *
+     * @param environment - Environment to evaluate (default: 'development')
+     * @returns Observable of flag definitions
+     */
+    getAllFlags$(environment = 'development') {
+        if (!this.client) {
+            return of([]);
+        }
+        return from(this.client.getAllFlags(environment)).pipe(catchError((error) => {
+            console.error('[Savvagent] Failed to fetch all flags:', error);
+            return of([]);
+        }));
+    }
+    /**
+     * Get all flags for the application (Promise-based).
+     */
+    async getAllFlags(environment = 'development') {
+        if (!this.client) {
+            return [];
+        }
+        return this.client.getAllFlags(environment);
+    }
+    /**
+     * Get enterprise-scoped flags only.
+     */
+    async getEnterpriseFlags(environment = 'development') {
+        if (!this.client) {
+            return [];
+        }
+        return this.client.getEnterpriseFlags(environment);
+    }
+    // =====================
+    // Cache & Connection
+    // =====================
+    /**
+     * Clear the flag cache.
+     */
+    clearCache() {
+        this.client?.clearCache();
+    }
+    /**
+     * Check if real-time connection is active.
+     */
+    isRealtimeConnected() {
+        return this.client?.isRealtimeConnected() || false;
+    }
+    /**
+     * Close the client and cleanup resources.
+     */
+    close() {
+        this.client?.close();
+        this.client = null;
+        this.isReady$.next(false);
+        this.flagSubjects.forEach((subject) => subject.complete());
+        this.flagSubjects.clear();
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.close();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SavvagentService, deps: [{ token: SAVVAGENT_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SavvagentService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SavvagentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [SAVVAGENT_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../src/service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy, Inject, InjectionToken, Optional } from '@angular/core';\nimport { BehaviorSubject, Observable, from, of, Subject } from 'rxjs';\nimport { map, takeUntil, catchError, distinctUntilChanged } from 'rxjs/operators';\nimport { FlagClient, FlagClientConfig, FlagContext, FlagEvaluationResult, FlagDefinition } from '@savvagent/sdk';\n\n/**\n * Default context values that apply to all flag evaluations\n * Per SDK Developer Guide: https://docs.savvagent.com/sdk-developer-guide\n */\nexport interface DefaultFlagContext {\n  /** Application ID for application-scoped flags */\n  applicationId?: string;\n  /** Environment (development, staging, production) */\n  environment?: string;\n  /** Organization ID for multi-tenant apps */\n  organizationId?: string;\n  /** Default user ID (required for percentage rollouts) */\n  userId?: string;\n  /** Default anonymous ID (alternative to userId for anonymous users) */\n  anonymousId?: string;\n  /** Session ID as fallback identifier */\n  sessionId?: string;\n  /** User's language code (e.g., \"en\", \"es\") */\n  language?: string;\n  /** Default attributes for targeting */\n  attributes?: Record<string, any>;\n}\n\n/**\n * Configuration for the Savvagent Angular service\n */\nexport interface SavvagentConfig {\n  /** SDK API key configuration */\n  config: FlagClientConfig;\n  /** Default context values applied to all flag evaluations */\n  defaultContext?: DefaultFlagContext;\n}\n\n/**\n * Injection token for Savvagent configuration\n */\nexport const SAVVAGENT_CONFIG = new InjectionToken<SavvagentConfig>('SAVVAGENT_CONFIG');\n\n/**\n * Result from flag evaluation as an Observable\n */\nexport interface FlagObservableResult {\n  /** Current flag value */\n  value: boolean;\n  /** Whether the flag is currently being evaluated */\n  loading: boolean;\n  /** Error if evaluation failed */\n  error: Error | null;\n  /** Detailed evaluation result */\n  result: FlagEvaluationResult | null;\n}\n\n/**\n * Options for flag evaluation\n */\nexport interface FlagOptions {\n  /** Context for flag evaluation (user_id, attributes, etc.) */\n  context?: FlagContext;\n  /** Default value to use while loading or on error */\n  defaultValue?: boolean;\n  /** Enable real-time updates for this flag */\n  realtime?: boolean;\n}\n\n/**\n * Angular service for Savvagent feature flags.\n * Provides reactive flag evaluation using RxJS Observables.\n *\n * @example\n * ```typescript\n * // In your component\n * @Component({...})\n * export class MyComponent {\n *   newFeature$ = this.savvagent.flag$('new-feature');\n *\n *   constructor(private savvagent: SavvagentService) {}\n * }\n *\n * // In your template\n * <div *ngIf=\"(newFeature$ | async)?.value\">\n *   New feature content!\n * </div>\n * ```\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class SavvagentService implements OnDestroy {\n  private client: FlagClient | null = null;\n  private destroy$ = new Subject<void>();\n  private isReady$ = new BehaviorSubject<boolean>(false);\n  private defaultContext: FlagContext = {};\n  private flagSubjects = new Map<string, BehaviorSubject<FlagObservableResult>>();\n\n  constructor(\n    @Optional() @Inject(SAVVAGENT_CONFIG) config?: SavvagentConfig\n  ) {\n    if (config) {\n      this.initialize(config);\n    }\n  }\n\n  /**\n   * Initialize the Savvagent client with configuration.\n   * Call this if not using the SAVVAGENT_CONFIG injection token.\n   *\n   * @param savvagentConfig - Configuration including API key and default context\n   *\n   * @example\n   * ```typescript\n   * @Component({...})\n   * export class AppComponent implements OnInit {\n   *   constructor(private savvagent: SavvagentService) {}\n   *\n   *   ngOnInit() {\n   *     this.savvagent.initialize({\n   *       config: { apiKey: 'sdk_...' },\n   *       defaultContext: {\n   *         applicationId: 'my-app',\n   *         environment: 'development',\n   *         userId: 'user-123'\n   *       }\n   *     });\n   *   }\n   * }\n   * ```\n   */\n  initialize(savvagentConfig: SavvagentConfig): void {\n    if (this.client) {\n      console.warn('[Savvagent] Client already initialized. Call close() first to reinitialize.');\n      return;\n    }\n\n    try {\n      this.client = new FlagClient(savvagentConfig.config);\n\n      // Convert DefaultFlagContext to FlagContext format (camelCase to snake_case)\n      if (savvagentConfig.defaultContext) {\n        this.defaultContext = {\n          application_id: savvagentConfig.defaultContext.applicationId,\n          environment: savvagentConfig.defaultContext.environment,\n          organization_id: savvagentConfig.defaultContext.organizationId,\n          user_id: savvagentConfig.defaultContext.userId,\n          anonymous_id: savvagentConfig.defaultContext.anonymousId,\n          session_id: savvagentConfig.defaultContext.sessionId,\n          language: savvagentConfig.defaultContext.language,\n          attributes: savvagentConfig.defaultContext.attributes,\n        };\n      }\n\n      this.isReady$.next(true);\n\n      // Subscribe to override changes to re-evaluate all active flags\n      this.client.onOverrideChange(() => {\n        this.reEvaluateAllFlags();\n      });\n    } catch (error) {\n      console.error('[Savvagent] Failed to initialize client:', error);\n      savvagentConfig.config.onError?.(error as Error);\n    }\n  }\n\n  /**\n   * Observable that emits true when the client is ready.\n   */\n  get ready$(): Observable<boolean> {\n    return this.isReady$.asObservable();\n  }\n\n  /**\n   * Check if the client is ready.\n   */\n  get isReady(): boolean {\n    return this.isReady$.value;\n  }\n\n  /**\n   * Get the underlying FlagClient instance for advanced use cases.\n   */\n  get flagClient(): FlagClient | null {\n    return this.client;\n  }\n\n  /**\n   * Merge default context with per-call context.\n   */\n  private mergeContext(context?: FlagContext): FlagContext {\n    return {\n      ...this.defaultContext,\n      ...context,\n      attributes: {\n        ...this.defaultContext.attributes,\n        ...context?.attributes,\n      },\n    };\n  }\n\n  /**\n   * Get a reactive Observable for a feature flag.\n   * Automatically updates when the flag value changes.\n   *\n   * @param flagKey - The feature flag key to evaluate\n   * @param options - Configuration options\n   * @returns Observable of flag evaluation state\n   *\n   * @example\n   * ```typescript\n   * // In your component\n   * newFeature$ = this.savvagent.flag$('new-feature', {\n   *   defaultValue: false,\n   *   realtime: true,\n   *   context: { attributes: { plan: 'pro' } }\n   * });\n   *\n   * // In template\n   * <ng-container *ngIf=\"newFeature$ | async as flag\">\n   *   <app-loading *ngIf=\"flag.loading\"></app-loading>\n   *   <app-new-feature *ngIf=\"flag.value\"></app-new-feature>\n   *   <app-old-feature *ngIf=\"!flag.value && !flag.loading\"></app-old-feature>\n   * </ng-container>\n   * ```\n   */\n  flag$(flagKey: string, options: FlagOptions = {}): Observable<FlagObservableResult> {\n    const { context, defaultValue = false, realtime = true } = options;\n    const mergedContext = this.mergeContext(context);\n    const cacheKey = this.getCacheKey(flagKey, mergedContext);\n\n    // Check if we already have a subject for this flag+context\n    if (!this.flagSubjects.has(cacheKey)) {\n      const subject = new BehaviorSubject<FlagObservableResult>({\n        value: defaultValue,\n        loading: true,\n        error: null,\n        result: null,\n      });\n      this.flagSubjects.set(cacheKey, subject);\n\n      // Initial evaluation\n      this.evaluateAndEmit(flagKey, mergedContext, defaultValue, subject);\n\n      // Set up real-time subscription if enabled\n      if (realtime && this.client) {\n        const unsubscribe = this.client.subscribe(flagKey, () => {\n          this.evaluateAndEmit(flagKey, mergedContext, defaultValue, subject);\n        });\n\n        // Clean up subscription when subject is complete\n        subject.pipe(takeUntil(this.destroy$)).subscribe({\n          complete: () => unsubscribe(),\n        });\n      }\n    }\n\n    return this.flagSubjects.get(cacheKey)!.asObservable().pipe(\n      takeUntil(this.destroy$),\n      distinctUntilChanged((a, b) =>\n        a.value === b.value &&\n        a.loading === b.loading &&\n        a.error === b.error\n      )\n    );\n  }\n\n  /**\n   * Generate a cache key for a flag+context combination.\n   */\n  private getCacheKey(flagKey: string, context: FlagContext): string {\n    return `${flagKey}:${JSON.stringify(context)}`;\n  }\n\n  /**\n   * Evaluate a flag and emit the result to a subject.\n   */\n  private async evaluateAndEmit(\n    flagKey: string,\n    context: FlagContext,\n    defaultValue: boolean,\n    subject: BehaviorSubject<FlagObservableResult>\n  ): Promise<void> {\n    if (!this.client) {\n      subject.next({\n        value: defaultValue,\n        loading: false,\n        error: new Error('Savvagent client not initialized'),\n        result: null,\n      });\n      return;\n    }\n\n    try {\n      const result = await this.client.evaluate(flagKey, context);\n      subject.next({\n        value: result.value,\n        loading: false,\n        error: null,\n        result,\n      });\n    } catch (error) {\n      subject.next({\n        value: defaultValue,\n        loading: false,\n        error: error as Error,\n        result: null,\n      });\n    }\n  }\n\n  /**\n   * Re-evaluate all active flag subscriptions.\n   * Called when overrides change.\n   */\n  private reEvaluateAllFlags(): void {\n    this.flagSubjects.forEach((subject, cacheKey) => {\n      const [flagKey, contextJson] = cacheKey.split(':', 2);\n      const context = JSON.parse(contextJson || '{}');\n      const currentValue = subject.value;\n      this.evaluateAndEmit(flagKey, context, currentValue.value, subject);\n    });\n  }\n\n  /**\n   * Get a flag value as a simple Observable<boolean>.\n   * Useful when you only need the value without loading/error states.\n   *\n   * @param flagKey - The feature flag key to evaluate\n   * @param options - Configuration options\n   * @returns Observable of boolean flag value\n   *\n   * @example\n   * ```typescript\n   * isFeatureEnabled$ = this.savvagent.flagValue$('my-feature');\n   *\n   * // In template\n   * <button *ngIf=\"isFeatureEnabled$ | async\">New Button</button>\n   * ```\n   */\n  flagValue$(flagKey: string, options: FlagOptions = {}): Observable<boolean> {\n    return this.flag$(flagKey, options).pipe(\n      map((result) => result.value),\n      distinctUntilChanged()\n    );\n  }\n\n  /**\n   * Evaluate a feature flag once (non-reactive).\n   * For reactive updates, use flag$() instead.\n   *\n   * @param flagKey - The feature flag key to evaluate\n   * @param context - Optional context for targeting\n   * @returns Promise with detailed evaluation result\n   *\n   * @example\n   * ```typescript\n   * async checkFeature() {\n   *   const result = await this.savvagent.evaluate('new-feature');\n   *   if (result.value) {\n   *     // Feature is enabled\n   *   }\n   * }\n   * ```\n   */\n  async evaluate(flagKey: string, context?: FlagContext): Promise<FlagEvaluationResult> {\n    if (!this.client) {\n      throw new Error('Savvagent client not initialized');\n    }\n    return this.client.evaluate(flagKey, this.mergeContext(context));\n  }\n\n  /**\n   * Check if a feature flag is enabled (non-reactive).\n   *\n   * @param flagKey - The feature flag key to evaluate\n   * @param context - Optional context for targeting\n   * @returns Promise<boolean>\n   */\n  async isEnabled(flagKey: string, context?: FlagContext): Promise<boolean> {\n    if (!this.client) {\n      return false;\n    }\n    return this.client.isEnabled(flagKey, this.mergeContext(context));\n  }\n\n  /**\n   * Execute code conditionally based on flag value.\n   *\n   * @param flagKey - The flag key to check\n   * @param callback - Function to execute if flag is enabled\n   * @param context - Optional context for targeting\n   *\n   * @example\n   * ```typescript\n   * await this.savvagent.withFlag('analytics-enabled', async () => {\n   *   await this.analytics.track('page_view');\n   * });\n   * ```\n   */\n  async withFlag<T>(\n    flagKey: string,\n    callback: () => T | Promise<T>,\n    context?: FlagContext\n  ): Promise<T | null> {\n    if (!this.client) {\n      return null;\n    }\n    return this.client.withFlag(flagKey, callback, this.mergeContext(context));\n  }\n\n  /**\n   * Track an error with flag context.\n   *\n   * @param flagKey - The flag key associated with the error\n   * @param error - The error that occurred\n   * @param context - Optional context\n   */\n  trackError(flagKey: string, error: Error, context?: FlagContext): void {\n    this.client?.trackError(flagKey, error, this.mergeContext(context));\n  }\n\n  /**\n   * Set the user ID for logged-in users.\n   *\n   * @param userId - The user ID (or null to clear)\n   */\n  setUserId(userId: string | null): void {\n    this.client?.setUserId(userId);\n  }\n\n  /**\n   * Get the current user ID.\n   */\n  getUserId(): string | null {\n    return this.client?.getUserId() || null;\n  }\n\n  /**\n   * Get the current anonymous ID.\n   */\n  getAnonymousId(): string | null {\n    return this.client?.getAnonymousId() || null;\n  }\n\n  /**\n   * Set a custom anonymous ID.\n   */\n  setAnonymousId(id: string): void {\n    this.client?.setAnonymousId(id);\n  }\n\n  // =====================\n  // Local Override Methods\n  // =====================\n\n  /**\n   * Set a local override for a flag.\n   * Overrides take precedence over server values.\n   *\n   * @param flagKey - The flag key to override\n   * @param value - The override value\n   */\n  setOverride(flagKey: string, value: boolean): void {\n    this.client?.setOverride(flagKey, value);\n  }\n\n  /**\n   * Clear a local override for a flag.\n   */\n  clearOverride(flagKey: string): void {\n    this.client?.clearOverride(flagKey);\n  }\n\n  /**\n   * Clear all local overrides.\n   */\n  clearAllOverrides(): void {\n    this.client?.clearAllOverrides();\n  }\n\n  /**\n   * Check if a flag has a local override.\n   */\n  hasOverride(flagKey: string): boolean {\n    return this.client?.hasOverride(flagKey) || false;\n  }\n\n  /**\n   * Get the override value for a flag.\n   */\n  getOverride(flagKey: string): boolean | undefined {\n    return this.client?.getOverride(flagKey);\n  }\n\n  /**\n   * Get all current overrides.\n   */\n  getOverrides(): Record<string, boolean> {\n    return this.client?.getOverrides() || {};\n  }\n\n  /**\n   * Set multiple overrides at once.\n   */\n  setOverrides(overrides: Record<string, boolean>): void {\n    this.client?.setOverrides(overrides);\n  }\n\n  // =====================\n  // Flag Discovery Methods\n  // =====================\n\n  /**\n   * Get all flags for the application.\n   *\n   * @param environment - Environment to evaluate (default: 'development')\n   * @returns Observable of flag definitions\n   */\n  getAllFlags$(environment: string = 'development'): Observable<FlagDefinition[]> {\n    if (!this.client) {\n      return of([]);\n    }\n    return from(this.client.getAllFlags(environment)).pipe(\n      catchError((error) => {\n        console.error('[Savvagent] Failed to fetch all flags:', error);\n        return of([]);\n      })\n    );\n  }\n\n  /**\n   * Get all flags for the application (Promise-based).\n   */\n  async getAllFlags(environment: string = 'development'): Promise<FlagDefinition[]> {\n    if (!this.client) {\n      return [];\n    }\n    return this.client.getAllFlags(environment);\n  }\n\n  /**\n   * Get enterprise-scoped flags only.\n   */\n  async getEnterpriseFlags(environment: string = 'development'): Promise<FlagDefinition[]> {\n    if (!this.client) {\n      return [];\n    }\n    return this.client.getEnterpriseFlags(environment);\n  }\n\n  // =====================\n  // Cache & Connection\n  // =====================\n\n  /**\n   * Clear the flag cache.\n   */\n  clearCache(): void {\n    this.client?.clearCache();\n  }\n\n  /**\n   * Check if real-time connection is active.\n   */\n  isRealtimeConnected(): boolean {\n    return this.client?.isRealtimeConnected() || false;\n  }\n\n  /**\n   * Close the client and cleanup resources.\n   */\n  close(): void {\n    this.client?.close();\n    this.client = null;\n    this.isReady$.next(false);\n    this.flagSubjects.forEach((subject) => subject.complete());\n    this.flagSubjects.clear();\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$.next();\n    this.destroy$.complete();\n    this.close();\n  }\n}\n"]}