@launchdarkly/toolbar 0.11.1-beta.1 → 0.13.0-beta.1

package/dist/js/plugins/FlagOverridePlugin.js

@@ -0,0 +1,133 @@
+const DEFAULT_STORAGE_NAMESPACE = 'ld-flag-override';
+class FlagOverridePlugin {
+    debugOverride;
+    config;
+    ldClient = null;
+    constructor(config = {}){
+        this.config = {
+            storageNamespace: config.storageNamespace ?? DEFAULT_STORAGE_NAMESPACE
+        };
+    }
+    getMetadata() {
+        return {
+            name: 'FlagOverridePlugin'
+        };
+    }
+    getHooks(_metadata) {
+        return [];
+    }
+    register(ldClient) {
+        this.ldClient = ldClient;
+    }
+    registerDebug(debugOverride) {
+        this.debugOverride = debugOverride;
+        this.loadExistingOverrides();
+    }
+    loadExistingOverrides() {
+        if (!this.debugOverride) return;
+        const storage = this.getStorage();
+        if (!storage) return;
+        try {
+            for(let i = 0; i < storage.length; i++){
+                const key = storage.key(i);
+                if (!key?.startsWith(this.config.storageNamespace + ':')) continue;
+                const storedValue = storage.getItem(key);
+                if (storedValue) try {
+                    const value = JSON.parse(storedValue);
+                    const flagKey = key.replace(this.config.storageNamespace + ':', '');
+                    this.debugOverride.setOverride(flagKey, value);
+                } catch  {
+                    console.warn('flagOverridePlugin: Invalid stored value for', key);
+                    storage.removeItem(key);
+                }
+            }
+        } catch (error) {
+            console.error('flagOverridePlugin: Error loading existing overrides:', error);
+        }
+    }
+    setOverride(flagKey, value) {
+        if (!this.debugOverride) return void console.warn('flagOverridePlugin: Debug interface not available');
+        if (!flagKey || 'string' != typeof flagKey) return void console.error('flagOverridePlugin: Invalid flag key:', flagKey);
+        if (void 0 === value) return void console.error('flagOverridePlugin: Cannot set undefined value for flag override');
+        try {
+            this.persistOverride(flagKey, value);
+            this.debugOverride.setOverride(flagKey, value);
+        } catch (error) {
+            console.error('flagOverridePlugin: Failed to set override:', error);
+        }
+    }
+    removeOverride(flagKey) {
+        if (!this.debugOverride) return void console.warn('flagOverridePlugin: Debug interface not available');
+        if (!flagKey || 'string' != typeof flagKey) return void console.error('flagOverridePlugin: Invalid flag key:', flagKey);
+        try {
+            this.removePersistedOverride(flagKey);
+            this.debugOverride.removeOverride(flagKey);
+        } catch (error) {
+            console.error('flagOverridePlugin: Failed to remove override:', error);
+        }
+    }
+    clearAllOverrides() {
+        if (!this.debugOverride) return void console.warn('flagOverridePlugin: Debug interface not available');
+        try {
+            this.clearPersistedOverrides();
+            this.debugOverride.clearAllOverrides();
+        } catch (error) {
+            console.error('flagOverridePlugin: Failed to clear overrides:', error);
+        }
+    }
+    getAllOverrides() {
+        if (!this.debugOverride) {
+            console.warn('flagOverridePlugin: Debug interface not available');
+            return {};
+        }
+        try {
+            return this.debugOverride.getAllOverrides();
+        } catch (error) {
+            console.error('flagOverridePlugin: Failed to get overrides:', error);
+            return {};
+        }
+    }
+    getClient() {
+        return this.ldClient;
+    }
+    getStorage() {
+        if ('undefined' == typeof window) return null;
+        return window.localStorage;
+    }
+    persistOverride(flagKey, value) {
+        const storage = this.getStorage();
+        if (!storage) return;
+        try {
+            const storageKey = `${this.config.storageNamespace}:${flagKey}`;
+            storage.setItem(storageKey, JSON.stringify(value));
+        } catch (error) {
+            console.error('flagOverridePlugin: Failed to persist override:', error);
+        }
+    }
+    removePersistedOverride(flagKey) {
+        const storage = this.getStorage();
+        if (!storage) return;
+        try {
+            const storageKey = `${this.config.storageNamespace}:${flagKey}`;
+            storage.removeItem(storageKey);
+        } catch (error) {
+            console.error('flagOverridePlugin: Failed to remove persisted override:', error);
+        }
+    }
+    clearPersistedOverrides() {
+        const storage = this.getStorage();
+        if (!storage) return;
+        try {
+            const keysToRemove = [];
+            const prefix = this.config.storageNamespace + ':';
+            for(let i = 0; i < storage.length; i++){
+                const key = storage.key(i);
+                if (key?.startsWith(prefix)) keysToRemove.push(key);
+            }
+            keysToRemove.forEach((key)=>storage.removeItem(key));
+        } catch (error) {
+            console.error('flagOverridePlugin: Failed to clear persisted overrides:', error);
+        }
+    }
+}
+export { FlagOverridePlugin };

package/dist/js/plugins/index.js

@@ -0,0 +1,425 @@
+const DEFAULT_STORAGE_NAMESPACE = 'ld-flag-override';
+class FlagOverridePlugin {
+    debugOverride;
+    config;
+    ldClient = null;
+    constructor(config = {}){
+        this.config = {
+            storageNamespace: config.storageNamespace ?? DEFAULT_STORAGE_NAMESPACE
+        };
+    }
+    getMetadata() {
+        return {
+            name: 'FlagOverridePlugin'
+        };
+    }
+    getHooks(_metadata) {
+        return [];
+    }
+    register(ldClient) {
+        this.ldClient = ldClient;
+    }
+    registerDebug(debugOverride) {
+        this.debugOverride = debugOverride;
+        this.loadExistingOverrides();
+    }
+    loadExistingOverrides() {
+        if (!this.debugOverride) return;
+        const storage = this.getStorage();
+        if (!storage) return;
+        try {
+            for(let i = 0; i < storage.length; i++){
+                const key = storage.key(i);
+                if (!key?.startsWith(this.config.storageNamespace + ':')) continue;
+                const storedValue = storage.getItem(key);
+                if (storedValue) try {
+                    const value = JSON.parse(storedValue);
+                    const flagKey = key.replace(this.config.storageNamespace + ':', '');
+                    this.debugOverride.setOverride(flagKey, value);
+                } catch  {
+                    console.warn('flagOverridePlugin: Invalid stored value for', key);
+                    storage.removeItem(key);
+                }
+            }
+        } catch (error) {
+            console.error('flagOverridePlugin: Error loading existing overrides:', error);
+        }
+    }
+    setOverride(flagKey, value) {
+        if (!this.debugOverride) return void console.warn('flagOverridePlugin: Debug interface not available');
+        if (!flagKey || 'string' != typeof flagKey) return void console.error('flagOverridePlugin: Invalid flag key:', flagKey);
+        if (void 0 === value) return void console.error('flagOverridePlugin: Cannot set undefined value for flag override');
+        try {
+            this.persistOverride(flagKey, value);
+            this.debugOverride.setOverride(flagKey, value);
+        } catch (error) {
+            console.error('flagOverridePlugin: Failed to set override:', error);
+        }
+    }
+    removeOverride(flagKey) {
+        if (!this.debugOverride) return void console.warn('flagOverridePlugin: Debug interface not available');
+        if (!flagKey || 'string' != typeof flagKey) return void console.error('flagOverridePlugin: Invalid flag key:', flagKey);
+        try {
+            this.removePersistedOverride(flagKey);
+            this.debugOverride.removeOverride(flagKey);
+        } catch (error) {
+            console.error('flagOverridePlugin: Failed to remove override:', error);
+        }
+    }
+    clearAllOverrides() {
+        if (!this.debugOverride) return void console.warn('flagOverridePlugin: Debug interface not available');
+        try {
+            this.clearPersistedOverrides();
+            this.debugOverride.clearAllOverrides();
+        } catch (error) {
+            console.error('flagOverridePlugin: Failed to clear overrides:', error);
+        }
+    }
+    getAllOverrides() {
+        if (!this.debugOverride) {
+            console.warn('flagOverridePlugin: Debug interface not available');
+            return {};
+        }
+        try {
+            return this.debugOverride.getAllOverrides();
+        } catch (error) {
+            console.error('flagOverridePlugin: Failed to get overrides:', error);
+            return {};
+        }
+    }
+    getClient() {
+        return this.ldClient;
+    }
+    getStorage() {
+        if ('undefined' == typeof window) return null;
+        return window.localStorage;
+    }
+    persistOverride(flagKey, value) {
+        const storage = this.getStorage();
+        if (!storage) return;
+        try {
+            const storageKey = `${this.config.storageNamespace}:${flagKey}`;
+            storage.setItem(storageKey, JSON.stringify(value));
+        } catch (error) {
+            console.error('flagOverridePlugin: Failed to persist override:', error);
+        }
+    }
+    removePersistedOverride(flagKey) {
+        const storage = this.getStorage();
+        if (!storage) return;
+        try {
+            const storageKey = `${this.config.storageNamespace}:${flagKey}`;
+            storage.removeItem(storageKey);
+        } catch (error) {
+            console.error('flagOverridePlugin: Failed to remove persisted override:', error);
+        }
+    }
+    clearPersistedOverrides() {
+        const storage = this.getStorage();
+        if (!storage) return;
+        try {
+            const keysToRemove = [];
+            const prefix = this.config.storageNamespace + ':';
+            for(let i = 0; i < storage.length; i++){
+                const key = storage.key(i);
+                if (key?.startsWith(prefix)) keysToRemove.push(key);
+            }
+            keysToRemove.forEach((key)=>storage.removeItem(key));
+        } catch (error) {
+            console.error('flagOverridePlugin: Failed to clear persisted overrides:', error);
+        }
+    }
+}
+const MAX_EVENTS = 100;
+class EventStore {
+    events = [];
+    listeners = new Set();
+    addEvent(event) {
+        try {
+            this.events.push(event);
+            if (this.events.length > MAX_EVENTS) this.events.splice(0, this.events.length - MAX_EVENTS);
+            this.notifyListeners();
+        } catch (error) {
+            console.warn('Event store error:', error);
+        }
+    }
+    getEvents() {
+        return [
+            ...this.events
+        ];
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        listener();
+        return ()=>this.listeners.delete(listener);
+    }
+    clear() {
+        this.events = [];
+        this.notifyListeners();
+    }
+    destroy() {
+        this.listeners.clear();
+        this.events = [];
+    }
+    notifyListeners() {
+        this.listeners.forEach((listener)=>{
+            try {
+                listener();
+            } catch (error) {
+                console.warn('Listener error:', error);
+            }
+        });
+    }
+}
+class AfterTrackHook {
+    config;
+    idCounter = 0;
+    constructor(config = {}){
+        this.config = {
+            filter: config.filter,
+            onNewEvent: config.onNewEvent
+        };
+    }
+    getMetadata() {
+        return {
+            name: 'AfterTrackHook'
+        };
+    }
+    afterTrack(hookContext) {
+        try {
+            const syntheticContext = {
+                kind: 'custom',
+                key: hookContext.key,
+                context: hookContext.context,
+                data: hookContext.data,
+                metricValue: hookContext.metricValue,
+                creationDate: Date.now(),
+                url: 'undefined' != typeof window ? window.location.href : void 0
+            };
+            if (!this.shouldProcessEvent()) return;
+            const processedEvent = this.processEvent(syntheticContext);
+            this.config.onNewEvent?.(processedEvent);
+        } catch (error) {
+            console.warn('Event processing error in AfterTrackHook:', error);
+        }
+    }
+    shouldProcessEvent() {
+        const filter = this.config.filter;
+        if (!filter) return true;
+        return !(filter.kinds && !filter.kinds.includes('custom')) && !(filter.categories && !filter.categories.includes('custom'));
+    }
+    processEvent(context) {
+        const timestamp = Date.now();
+        this.idCounter = (this.idCounter + 1) % 999999;
+        const randomPart = Math.random().toString(36).substring(2, 8);
+        const id = `${context.kind}-${timestamp}-${this.idCounter.toString().padStart(6, '0')}-${randomPart}`;
+        return {
+            id,
+            kind: context.kind,
+            key: context.key,
+            timestamp,
+            context,
+            displayName: `Custom: ${context.key || 'unknown'}`,
+            category: 'custom',
+            metadata: this.extractMetadata(context)
+        };
+    }
+    extractMetadata(context) {
+        return {
+            data: context.data,
+            metricValue: context.metricValue,
+            url: context.url
+        };
+    }
+}
+class AfterIdentifyHook {
+    config;
+    idCounter = 0;
+    constructor(config = {}){
+        this.config = {
+            filter: config.filter,
+            onNewEvent: config.onNewEvent
+        };
+    }
+    getMetadata() {
+        return {
+            name: 'AfterIdentifyHook'
+        };
+    }
+    afterIdentify(hookContext, data, result) {
+        try {
+            if ('completed' !== result.status) return data;
+            const syntheticContext = {
+                kind: 'identify',
+                context: hookContext.context,
+                creationDate: Date.now(),
+                contextKind: this.determineContextKind(hookContext.context)
+            };
+            if (!this.shouldProcessEvent()) return data;
+            const processedEvent = this.processEvent(syntheticContext);
+            this.config.onNewEvent?.(processedEvent);
+        } catch (error) {
+            console.warn('Event processing error in AfterIdentifyHook:', error);
+        }
+        return data;
+    }
+    determineContextKind(context) {
+        if (context && 'object' == typeof context) {
+            if ('kind' in context && context.kind) return context.kind;
+            if (context.anonymous) return 'anonymousUser';
+        }
+        return 'user';
+    }
+    shouldProcessEvent() {
+        const filter = this.config.filter;
+        if (!filter) return true;
+        return !(filter.kinds && !filter.kinds.includes('identify')) && !(filter.categories && !filter.categories.includes('identify'));
+    }
+    processEvent(context) {
+        const timestamp = Date.now();
+        this.idCounter = (this.idCounter + 1) % 999999;
+        const randomPart = Math.random().toString(36).substring(2, 8);
+        const id = `${context.kind}-${timestamp}-${this.idCounter.toString().padStart(6, '0')}-${randomPart}`;
+        return {
+            id,
+            kind: context.kind,
+            key: context.key,
+            timestamp,
+            context,
+            displayName: `Identify: ${context.context?.key || 'anonymous'}`,
+            category: 'identify',
+            metadata: this.extractMetadata(context)
+        };
+    }
+    extractMetadata(context) {
+        return {
+            contextKind: context.contextKind
+        };
+    }
+}
+class AfterEvaluationHook {
+    config;
+    idCounter = 0;
+    constructor(config = {}){
+        this.config = {
+            filter: config.filter,
+            onNewEvent: config.onNewEvent
+        };
+    }
+    getMetadata() {
+        return {
+            name: 'AfterEvaluationHook'
+        };
+    }
+    afterEvaluation(hookContext, data, detail) {
+        try {
+            const syntheticContext = {
+                kind: 'feature',
+                key: hookContext.flagKey,
+                context: hookContext.context,
+                value: detail.value,
+                variation: detail.variationIndex,
+                default: hookContext.defaultValue,
+                reason: detail.reason,
+                creationDate: Date.now()
+            };
+            if (!this.shouldProcessEvent(syntheticContext)) return data;
+            const processedEvent = this.processEvent(syntheticContext);
+            this.config.onNewEvent?.(processedEvent);
+        } catch (error) {
+            console.warn('Event processing error in AfterEvaluationHook:', error);
+        }
+        return data;
+    }
+    shouldProcessEvent(context) {
+        const filter = this.config.filter;
+        if (!filter) return true;
+        return !(filter.kinds && !filter.kinds.includes('feature')) && !(filter.categories && !filter.categories.includes('flag')) && !(filter.flagKeys && context.key && !filter.flagKeys.includes(context.key));
+    }
+    processEvent(context) {
+        const timestamp = Date.now();
+        this.idCounter = (this.idCounter + 1) % 999999;
+        const randomPart = Math.random().toString(36).substring(2, 8);
+        const id = `${context.kind}-${timestamp}-${this.idCounter.toString().padStart(6, '0')}-${randomPart}`;
+        return {
+            id,
+            kind: context.kind,
+            key: context.key,
+            timestamp,
+            context,
+            displayName: `Flag: ${context.key || 'unknown'}`,
+            category: 'flag',
+            metadata: this.extractMetadata(context)
+        };
+    }
+    extractMetadata(context) {
+        return {
+            flagVersion: context.version,
+            variation: context.variation,
+            trackEvents: context.trackEvents,
+            reason: context.reason,
+            defaultValue: context.default
+        };
+    }
+}
+class EventInterceptionPlugin {
+    afterTrackHook;
+    afterIdentifyHook;
+    afterEvaluationHook;
+    eventStore;
+    config;
+    constructor(config = {}){
+        this.config = {
+            enableLogging: true,
+            ...config
+        };
+        this.eventStore = new EventStore();
+        const onNewEvent = (event)=>{
+            if (this.config.enableLogging) console.log('🎯 Event intercepted:', {
+                kind: event.kind,
+                key: event.key,
+                category: event.category,
+                displayName: event.displayName
+            });
+            this.eventStore.addEvent(event);
+        };
+        this.afterTrackHook = new AfterTrackHook({
+            filter: config.filter,
+            onNewEvent
+        });
+        this.afterIdentifyHook = new AfterIdentifyHook({
+            filter: config.filter,
+            onNewEvent
+        });
+        this.afterEvaluationHook = new AfterEvaluationHook({
+            filter: config.filter,
+            onNewEvent
+        });
+    }
+    getMetadata() {
+        return {
+            name: 'EventInterceptionPlugin'
+        };
+    }
+    getHooks(_metadata) {
+        return [
+            this.afterTrackHook,
+            this.afterIdentifyHook,
+            this.afterEvaluationHook
+        ];
+    }
+    register(_client) {}
+    getEvents() {
+        return this.eventStore.getEvents();
+    }
+    subscribe(listener) {
+        return this.eventStore.subscribe(listener);
+    }
+    clearEvents() {
+        this.eventStore.clear();
+    }
+    destroy() {
+        this.eventStore.destroy();
+    }
+}
+export { EventInterceptionPlugin, FlagOverridePlugin };

package/dist/plugins/EventInterceptionPlugin.d.ts

@@ -0,0 +1,30 @@
+import type { Hook, LDClient, LDPluginEnvironmentMetadata, LDPluginMetadata } from 'launchdarkly-js-client-sdk';
+import type { EventFilter, ProcessedEvent } from '../types/events';
+import type { IEventInterceptionPlugin } from '../types/plugin';
+/**
+ * Configuration options for the EventInterceptionPlugin
+ */
+export interface EventInterceptionPluginConfig {
+    /** Configuration for event filtering */
+    filter?: EventFilter;
+    /** Enable console logging for debugging */
+    enableLogging?: boolean;
+}
+/**
+ * Plugin dedicated to intercepting and processing LaunchDarkly events
+ */
+export declare class EventInterceptionPlugin implements IEventInterceptionPlugin {
+    private afterTrackHook;
+    private afterIdentifyHook;
+    private afterEvaluationHook;
+    private eventStore;
+    private config;
+    constructor(config?: EventInterceptionPluginConfig);
+    getMetadata(): LDPluginMetadata;
+    getHooks(_metadata: LDPluginEnvironmentMetadata): Hook[];
+    register(_client: LDClient): void;
+    getEvents(): ProcessedEvent[];
+    subscribe(listener: () => void): () => void;
+    clearEvents(): void;
+    destroy(): void;
+}

package/dist/plugins/FlagOverridePlugin.d.ts

@@ -1,4 +1,5 @@
-import type { LDClient, LDPlugin, LDDebugOverride, LDPluginMetadata } from 'launchdarkly-js-client-sdk';
+import type { LDClient, LDDebugOverride, LDPluginMetadata, LDFlagSet, Hook, LDPluginEnvironmentMetadata } from 'launchdarkly-js-client-sdk';
+import type { IFlagOverridePlugin } from '../types/plugin';
 /**
  * Configuration options for the FlagOverridePlugin
  */
@@ -6,7 +7,7 @@ export type FlagOverridePluginConfig = {
     /** Namespace for localStorage keys. Defaults to 'ld-flag-override' */
     storageNamespace?: string;
 };
-export declare class FlagOverridePlugin implements LDPlugin {
+export declare class FlagOverridePlugin implements IFlagOverridePlugin {
     private debugOverride?;
     private config;
     private ldClient;
@@ -15,6 +16,10 @@ export declare class FlagOverridePlugin implements LDPlugin {
      * Returns plugin metadata
      */
     getMetadata(): LDPluginMetadata;
+    /**
+     * Returns the hooks for the plugin
+     */
+    getHooks(_metadata: LDPluginEnvironmentMetadata): Hook[];
     /**
      * Called when the plugin is registered with the LaunchDarkly client
      */
@@ -44,7 +49,7 @@ export declare class FlagOverridePlugin implements LDPlugin {
      * Returns all currently active feature flag overrides
      * @returns Record of flag keys to their override values
      */
-    getAllOverrides(): Record<string, unknown>;
+    getAllOverrides(): LDFlagSet;
     /**
      * Returns the LaunchDarkly client instance
      * @returns The LaunchDarkly client

package/dist/plugins/index.d.ts

@@ -1,2 +1,4 @@
 export { FlagOverridePlugin } from './FlagOverridePlugin';
 export type { FlagOverridePluginConfig } from './FlagOverridePlugin';
+export { EventInterceptionPlugin } from './EventInterceptionPlugin';
+export type { EventInterceptionPluginConfig } from './EventInterceptionPlugin';

package/dist/tests/hooks/AfterEvaluationHook.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/hooks/AfterIdentifyHook.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/hooks/AfterTrackHook.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/hooks/EventStore.test.d.ts

@@ -0,0 +1 @@
+export {};