@launchdarkly/toolbar 2.1.4 → 2.2.0

package/dist/angular.cjs

@@ -0,0 +1,439 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    LaunchDarklyToolbarService: ()=>_LaunchDarklyToolbarService
+});
+const core_namespaceObject = require("@angular/core");
+function getWindow() {
+    return window;
+}
+async function lazyLoadToolbar(signal, url) {
+    const existing = getWindow().LaunchDarklyToolbar;
+    if (existing) return Promise.resolve(existing);
+    await lazyLoad(signal, url);
+    const toolbarModule = getWindow().LaunchDarklyToolbar;
+    if (!toolbarModule) throw new Error(`Unable to detect LaunchDarklyToolbar global from ${url}`);
+    return toolbarModule;
+}
+async function lazyLoad(signal, url) {
+    const existingScript = document.querySelector(`script[src="${url}"]`);
+    if (existingScript) {
+        if ('true' === existingScript.dataset.loaded) return Promise.resolve();
+        return new Promise((resolve, reject)=>{
+            existingScript.addEventListener('load', ()=>{
+                if (!signal.aborted) {
+                    existingScript.dataset.loaded = 'true';
+                    resolve();
+                }
+            });
+            existingScript.addEventListener('error', (error)=>{
+                if (!signal.aborted) reject(error);
+            });
+        });
+    }
+    const script = document.createElement("script");
+    script.src = url;
+    script.crossOrigin = 'anonymous';
+    script.referrerPolicy = 'origin';
+    const waitForLoad = new Promise((resolve, reject)=>{
+        script.addEventListener('load', ()=>{
+            if (!signal.aborted) {
+                script.dataset.loaded = 'true';
+                resolve();
+            }
+        });
+        script.addEventListener('error', (error)=>{
+            if (!signal.aborted) reject(error);
+        });
+    });
+    document.body.appendChild(script);
+    try {
+        await waitForLoad;
+    } catch (error) {
+        console.log(error);
+        throw new Error(`Could not load LaunchDarkly developer toolbar bundle from ${url}`);
+    }
+}
+var package_namespaceObject = {
+    rE: "2.2.0"
+};
+function applyDecs2203RFactory() {
+    function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+        return function(initializer) {
+            assertNotFinished(decoratorFinishedRef, "addInitializer");
+            assertCallable(initializer, "An initializer");
+            initializers.push(initializer);
+        };
+    }
+    function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+        var kindStr;
+        switch(kind){
+            case 1:
+                kindStr = "accessor";
+                break;
+            case 2:
+                kindStr = "method";
+                break;
+            case 3:
+                kindStr = "getter";
+                break;
+            case 4:
+                kindStr = "setter";
+                break;
+            default:
+                kindStr = "field";
+        }
+        var ctx = {
+            kind: kindStr,
+            name: isPrivate ? "#" + name : name,
+            static: isStatic,
+            private: isPrivate,
+            metadata: metadata
+        };
+        var decoratorFinishedRef = {
+            v: false
+        };
+        ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+        var get, set;
+        if (0 === kind) if (isPrivate) {
+            get = desc.get;
+            set = desc.set;
+        } else {
+            get = function() {
+                return this[name];
+            };
+            set = function(v) {
+                this[name] = v;
+            };
+        }
+        else if (2 === kind) get = function() {
+            return desc.value;
+        };
+        else {
+            if (1 === kind || 3 === kind) get = function() {
+                return desc.get.call(this);
+            };
+            if (1 === kind || 4 === kind) set = function(v) {
+                desc.set.call(this, v);
+            };
+        }
+        ctx.access = get && set ? {
+            get: get,
+            set: set
+        } : get ? {
+            get: get
+        } : {
+            set: set
+        };
+        try {
+            return dec(value, ctx);
+        } finally{
+            decoratorFinishedRef.v = true;
+        }
+    }
+    function assertNotFinished(decoratorFinishedRef, fnName) {
+        if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+    }
+    function assertCallable(fn, hint) {
+        if ("function" != typeof fn) throw new TypeError(hint + " must be a function");
+    }
+    function assertValidReturnValue(kind, value) {
+        var type = typeof value;
+        if (1 === kind) {
+            if ("object" !== type || null === value) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+            if (void 0 !== value.get) assertCallable(value.get, "accessor.get");
+            if (void 0 !== value.set) assertCallable(value.set, "accessor.set");
+            if (void 0 !== value.init) assertCallable(value.init, "accessor.init");
+        } else if ("function" !== type) {
+            var hint;
+            hint = 0 === kind ? "field" : 10 === kind ? "class" : "method";
+            throw new TypeError(hint + " decorators must return a function or void 0");
+        }
+    }
+    function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+        var decs = decInfo[0];
+        var desc, init, value;
+        if (isPrivate) desc = 0 === kind || 1 === kind ? {
+            get: decInfo[3],
+            set: decInfo[4]
+        } : 3 === kind ? {
+            get: decInfo[3]
+        } : 4 === kind ? {
+            set: decInfo[3]
+        } : {
+            value: decInfo[3]
+        };
+        else if (0 !== kind) desc = Object.getOwnPropertyDescriptor(base, name);
+        if (1 === kind) value = {
+            get: desc.get,
+            set: desc.set
+        };
+        else if (2 === kind) value = desc.value;
+        else if (3 === kind) value = desc.get;
+        else if (4 === kind) value = desc.set;
+        var newValue, get, set;
+        if ("function" == typeof decs) {
+            newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+            if (void 0 !== newValue) {
+                assertValidReturnValue(kind, newValue);
+                if (0 === kind) init = newValue;
+                else if (1 === kind) {
+                    init = newValue.init;
+                    get = newValue.get || value.get;
+                    set = newValue.set || value.set;
+                    value = {
+                        get: get,
+                        set: set
+                    };
+                } else value = newValue;
+            }
+        } else for(var i = decs.length - 1; i >= 0; i--){
+            var dec = decs[i];
+            newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+            if (void 0 !== newValue) {
+                assertValidReturnValue(kind, newValue);
+                var newInit;
+                if (0 === kind) newInit = newValue;
+                else if (1 === kind) {
+                    newInit = newValue.init;
+                    get = newValue.get || value.get;
+                    set = newValue.set || value.set;
+                    value = {
+                        get: get,
+                        set: set
+                    };
+                } else value = newValue;
+                if (void 0 !== newInit) if (void 0 === init) init = newInit;
+                else if ("function" == typeof init) init = [
+                    init,
+                    newInit
+                ];
+                else init.push(newInit);
+            }
+        }
+        if (0 === kind || 1 === kind) {
+            if (void 0 === init) init = function(instance, init) {
+                return init;
+            };
+            else if ("function" != typeof init) {
+                var ownInitializers = init;
+                init = function(instance, init) {
+                    var value = init;
+                    for(var i = 0; i < ownInitializers.length; i++)value = ownInitializers[i].call(instance, value);
+                    return value;
+                };
+            } else {
+                var originalInitializer = init;
+                init = function(instance, init) {
+                    return originalInitializer.call(instance, init);
+                };
+            }
+            ret.push(init);
+        }
+        if (0 !== kind) {
+            if (1 === kind) {
+                desc.get = value.get;
+                desc.set = value.set;
+            } else if (2 === kind) desc.value = value;
+            else if (3 === kind) desc.get = value;
+            else if (4 === kind) desc.set = value;
+            if (isPrivate) if (1 === kind) {
+                ret.push(function(instance, args) {
+                    return value.get.call(instance, args);
+                });
+                ret.push(function(instance, args) {
+                    return value.set.call(instance, args);
+                });
+            } else if (2 === kind) ret.push(value);
+            else ret.push(function(instance, args) {
+                return value.call(instance, args);
+            });
+            else Object.defineProperty(base, name, desc);
+        }
+    }
+    function applyMemberDecs(Class, decInfos, metadata) {
+        var ret = [];
+        var protoInitializers;
+        var staticInitializers;
+        var existingProtoNonFields = new Map();
+        var existingStaticNonFields = new Map();
+        for(var i = 0; i < decInfos.length; i++){
+            var decInfo = decInfos[i];
+            if (Array.isArray(decInfo)) {
+                var kind = decInfo[1];
+                var name = decInfo[2];
+                var isPrivate = decInfo.length > 3;
+                var isStatic = kind >= 5;
+                var base;
+                var initializers;
+                if (isStatic) {
+                    base = Class;
+                    kind -= 5;
+                    staticInitializers = staticInitializers || [];
+                    initializers = staticInitializers;
+                } else {
+                    base = Class.prototype;
+                    protoInitializers = protoInitializers || [];
+                    initializers = protoInitializers;
+                }
+                if (0 !== kind && !isPrivate) {
+                    var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+                    var existingKind = existingNonFields.get(name) || 0;
+                    if (true === existingKind || 3 === existingKind && 4 !== kind || 4 === existingKind && 3 !== kind) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+                    if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+                    else existingNonFields.set(name, true);
+                }
+                applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+            }
+        }
+        pushInitializers(ret, protoInitializers);
+        pushInitializers(ret, staticInitializers);
+        return ret;
+    }
+    function pushInitializers(ret, initializers) {
+        if (initializers) ret.push(function(instance) {
+            for(var i = 0; i < initializers.length; i++)initializers[i].call(instance);
+            return instance;
+        });
+    }
+    function applyClassDecs(targetClass, classDecs, metadata) {
+        if (classDecs.length > 0) {
+            var initializers = [];
+            var newClass = targetClass;
+            var name = targetClass.name;
+            for(var i = classDecs.length - 1; i >= 0; i--){
+                var decoratorFinishedRef = {
+                    v: false
+                };
+                try {
+                    var nextNewClass = classDecs[i](newClass, {
+                        kind: "class",
+                        name: name,
+                        addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+                        metadata
+                    });
+                } finally{
+                    decoratorFinishedRef.v = true;
+                }
+                if (void 0 !== nextNewClass) {
+                    assertValidReturnValue(10, nextNewClass);
+                    newClass = nextNewClass;
+                }
+            }
+            return [
+                defineMetadata(newClass, metadata),
+                function() {
+                    for(var i = 0; i < initializers.length; i++)initializers[i].call(newClass);
+                }
+            ];
+        }
+    }
+    function defineMetadata(Class, metadata) {
+        return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+            configurable: true,
+            enumerable: true,
+            value: metadata
+        });
+    }
+    return function(targetClass, memberDecs, classDecs, parentClass) {
+        if (void 0 !== parentClass) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+        var metadata = Object.create(void 0 === parentMetadata ? null : parentMetadata);
+        var e = applyMemberDecs(targetClass, memberDecs, metadata);
+        if (!classDecs.length) defineMetadata(targetClass, metadata);
+        return {
+            e: e,
+            get c () {
+                return applyClassDecs(targetClass, classDecs, metadata);
+            }
+        };
+    };
+}
+function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+    return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec, _initClass;
+let _LaunchDarklyToolbarService;
+_dec = (0, core_namespaceObject.Injectable)({
+    providedIn: 'root'
+});
+class LaunchDarklyToolbarService {
+    static{
+        ({ c: [_LaunchDarklyToolbarService, _initClass] } = _apply_decs_2203_r(this, [], [
+            _dec
+        ]));
+    }
+    cleanup;
+    abortController;
+    initialized = false;
+    async initialize(config) {
+        if (this.initialized) return void console.warn('[LaunchDarkly Toolbar] Already initialized. Call destroy() first to reinitialize.');
+        const { toolbarBundleUrl, enabled, ...initConfig } = config;
+        if (false === enabled) return;
+        this.initialized = true;
+        this.abortController = new AbortController();
+        const url = toolbarBundleUrl ?? this.versionToCdn(package_namespaceObject.rE);
+        try {
+            const toolbar = await lazyLoadToolbar(this.abortController.signal, url);
+            this.cleanup = toolbar.init(initConfig);
+        } catch (err) {
+            console.error('[LaunchDarkly Toolbar] Failed to initialize:', err);
+            this.initialized = false;
+            throw err;
+        }
+    }
+    ngOnDestroy() {
+        this.destroy();
+    }
+    destroy() {
+        if (this.abortController) {
+            this.abortController.abort();
+            this.abortController = void 0;
+        }
+        if (this.cleanup) {
+            this.cleanup();
+            this.cleanup = void 0;
+        }
+        this.initialized = false;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    versionToCdn(version = 'latest') {
+        return `https://unpkg.com/@launchdarkly/toolbar@${version}/cdn/toolbar.min.js`;
+    }
+    static{
+        _initClass();
+    }
+}
+exports.LaunchDarklyToolbarService = __webpack_exports__.LaunchDarklyToolbarService;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "LaunchDarklyToolbarService"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+//# sourceMappingURL=angular.cjs.map

package/dist/angular.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular.cjs","sources":["webpack/runtime/define_property_getters","webpack/runtime/has_own_property","webpack/runtime/make_namespace_object","../src/core/lazyLoadToolbar.ts","../src/angular/launchdarkly-toolbar.service.ts"],"sourcesContent":["__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n        }\n    }\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","import type { LaunchDarklyToolbar } from '../index';\n\ninterface WindowWithMaybeToolbar extends Window {\n  LaunchDarklyToolbar?: LaunchDarklyToolbar;\n}\n\nfunction getWindow(): WindowWithMaybeToolbar {\n  return window;\n}\n\nexport default async function lazyLoadToolbar(signal: AbortSignal, url: string): Promise<LaunchDarklyToolbar> {\n  const existing = getWindow().LaunchDarklyToolbar;\n\n  if (existing) {\n    return Promise.resolve(existing);\n  }\n\n  await lazyLoad(signal, url);\n\n  const toolbarModule = getWindow().LaunchDarklyToolbar;\n  if (!toolbarModule) {\n    throw new Error(`Unable to detect LaunchDarklyToolbar global from ${url}`);\n  }\n\n  return toolbarModule;\n}\n\nasync function lazyLoad(signal: AbortSignal, url: string): Promise<void> {\n  // Check if a script with this URL already exists\n  const existingScript = document.querySelector(`script[src=\"${url}\"]`) as HTMLScriptElement | null;\n\n  if (existingScript) {\n    // If script already exists and is loaded, return immediately\n    if (existingScript.dataset.loaded === 'true') {\n      return Promise.resolve();\n    }\n\n    // If script exists but is still loading, wait for it to complete\n    return new Promise<void>((resolve, reject) => {\n      existingScript.addEventListener('load', () => {\n        if (!signal.aborted) {\n          existingScript.dataset.loaded = 'true';\n          resolve();\n        }\n      });\n      existingScript.addEventListener('error', (error) => {\n        if (!signal.aborted) {\n          reject(error);\n        }\n      });\n    });\n  }\n\n  // Create new script element\n  const script = document.createElement('script');\n  script.src = url;\n  script.crossOrigin = 'anonymous';\n  script.referrerPolicy = 'origin';\n\n  const waitForLoad = new Promise<void>((resolve, reject) => {\n    script.addEventListener('load', () => {\n      if (!signal.aborted) {\n        script.dataset.loaded = 'true';\n        resolve();\n      }\n    });\n    script.addEventListener('error', (error) => {\n      if (!signal.aborted) {\n        reject(error);\n      }\n    });\n  });\n\n  document.body.appendChild(script);\n\n  try {\n    await waitForLoad;\n  } catch (error) {\n    console.log(error);\n    throw new Error(`Could not load LaunchDarkly developer toolbar bundle from ${url}`);\n  }\n}\n","import { Injectable, OnDestroy } from '@angular/core';\n\nimport lazyLoadToolbar from '../core/lazyLoadToolbar';\nimport type { InitializationConfig } from '../types';\nimport packageJson from '../../package.json';\n\n/**\n * Configuration options for the LaunchDarkly Toolbar service.\n * Extends the base InitializationConfig with Angular-specific options.\n */\nexport interface LaunchDarklyToolbarConfig extends InitializationConfig {\n  /**\n   * URL to load the toolbar bundle from.\n   * Use this when developing the toolbar itself locally.\n   *\n   * Example: `'http://localhost:5764/toolbar.min.js'`\n   *\n   * Default: CDN URL based on package version\n   */\n  toolbarBundleUrl?: string;\n\n  /**\n   * Whether the toolbar should be loaded and displayed.\n   *\n   * Default: `true`\n   */\n  enabled?: boolean;\n}\n\n/**\n * Injectable service for managing the LaunchDarkly Developer Toolbar in Angular applications.\n *\n * This service handles the lifecycle of the toolbar, including initialization,\n * lazy loading, and cleanup. It can be injected into any Angular component or service.\n *\n * @example\n * ```typescript\n * import { Component, OnInit } from '@angular/core';\n * import { LaunchDarklyToolbarService } from '@launchdarkly/toolbar/angular';\n * import { FlagOverridePlugin, EventInterceptionPlugin } from '@launchdarkly/toolbar/plugins';\n *\n * @Component({\n *   selector: 'app-root',\n *   standalone: true,\n *   providers: [LaunchDarklyToolbarService],\n *   template: '<router-outlet />'\n * })\n * export class AppComponent implements OnInit {\n *   private flagOverridePlugin = new FlagOverridePlugin();\n *   private eventInterceptionPlugin = new EventInterceptionPlugin();\n *\n *   constructor(private toolbarService: LaunchDarklyToolbarService) {}\n *\n *   ngOnInit() {\n *     this.toolbarService.initialize({\n *       flagOverridePlugin: this.flagOverridePlugin,\n *       eventInterceptionPlugin: this.eventInterceptionPlugin,\n *       enabled: true,\n *       position: 'bottom-right'\n *     });\n *   }\n * }\n * ```\n */\n@Injectable({\n  providedIn: 'root', // Singleton service across the application\n})\nexport default class LaunchDarklyToolbarService implements OnDestroy {\n  private cleanup?: () => void;\n  private abortController?: AbortController;\n  private initialized = false;\n\n  /**\n   * Initializes the LaunchDarkly Toolbar with the provided configuration.\n   *\n   * This method lazy-loads the toolbar bundle from either a custom URL or the CDN,\n   * then initializes it with the provided configuration.\n   *\n   * @param config - Configuration options for the toolbar\n   * @returns Promise that resolves when initialization is complete\n   *\n   * @throws {Error} If initialization fails or toolbar bundle cannot be loaded\n   */\n  async initialize(config: LaunchDarklyToolbarConfig): Promise<void> {\n    if (this.initialized) {\n      console.warn('[LaunchDarkly Toolbar] Already initialized. Call destroy() first to reinitialize.');\n      return;\n    }\n\n    const { toolbarBundleUrl, enabled, ...initConfig } = config;\n\n    if (enabled === false) {\n      return;\n    }\n\n    this.initialized = true;\n    this.abortController = new AbortController();\n    const url = toolbarBundleUrl ?? this.versionToCdn(packageJson.version);\n\n    try {\n      const toolbar = await lazyLoadToolbar(this.abortController.signal, url);\n      this.cleanup = toolbar.init(initConfig);\n    } catch (err) {\n      console.error('[LaunchDarkly Toolbar] Failed to initialize:', err);\n      this.initialized = false;\n      throw err;\n    }\n  }\n\n  /**\n   * Angular lifecycle hook called when the service is destroyed.\n   * Automatically cleans up the toolbar.\n   */\n  ngOnDestroy(): void {\n    this.destroy();\n  }\n\n  /**\n   * Manually destroys the toolbar and cleans up resources.\n   *\n   * This method:\n   * - Aborts any pending lazy-load requests\n   * - Calls the toolbar's cleanup function\n   * - Resets the initialized state\n   *\n   * After calling destroy(), you can call initialize() again to reinitialize.\n   */\n  destroy(): void {\n    if (this.abortController) {\n      this.abortController.abort();\n      this.abortController = undefined;\n    }\n    if (this.cleanup) {\n      this.cleanup();\n      this.cleanup = undefined;\n    }\n    this.initialized = false;\n  }\n\n  /**\n   * Checks if the toolbar has been initialized.\n   *\n   * @returns true if the toolbar is currently initialized, false otherwise\n   */\n  isInitialized(): boolean {\n    return this.initialized;\n  }\n\n  /**\n   * Generates the CDN URL for a specific toolbar version.\n   *\n   * @param version - Toolbar version (defaults to 'latest')\n   * @returns CDN URL for the toolbar bundle\n   */\n  private versionToCdn(version = 'latest'): string {\n    return `https://unpkg.com/@launchdarkly/toolbar@${version}/cdn/toolbar.min.js`;\n  }\n}\n"],"names":["__webpack_require__","definition","key","Object","obj","prop","Symbol","getWindow","window","lazyLoadToolbar","signal","url","existing","Promise","lazyLoad","toolbarModule","Error","existingScript","document","resolve","reject","error","script","waitForLoad","console","Injectable","_LaunchDarklyToolbarService","config","toolbarBundleUrl","enabled","initConfig","AbortController","packageJson","toolbar","err","undefined","version"],"mappings":"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"}

package/dist/angular.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Angular-specific exports for the LaunchDarkly Toolbar
+ *
+ * This entry point provides an Angular service for integrating
+ * the toolbar with Angular applications (14+).
+ *
+ * @example
+ * ```typescript
+ * // Standalone Component (Angular 14+)
+ * import { Component, OnInit } from '@angular/core';
+ * import { LaunchDarklyToolbarService } from '@launchdarkly/toolbar/angular';
+ * import { FlagOverridePlugin, EventInterceptionPlugin } from '@launchdarkly/toolbar/plugins';
+ *
+ * @Component({
+ *   selector: 'app-root',
+ *   standalone: true,
+ *   providers: [LaunchDarklyToolbarService],
+ *   template: '<router-outlet />'
+ * })
+ * export class AppComponent implements OnInit {
+ *   private flagOverridePlugin = new FlagOverridePlugin();
+ *   private eventInterceptionPlugin = new EventInterceptionPlugin();
+ *
+ *   constructor(private toolbarService: LaunchDarklyToolbarService) {}
+ *
+ *   ngOnInit() {
+ *     this.toolbarService.initialize({
+ *       flagOverridePlugin: this.flagOverridePlugin,
+ *       eventInterceptionPlugin: this.eventInterceptionPlugin,
+ *       enabled: true,
+ *       position: 'bottom-right'
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Module-based Component (Traditional)
+ * import { NgModule } from '@angular/core';
+ * import { LaunchDarklyToolbarService } from '@launchdarkly/toolbar/angular';
+ *
+ * @NgModule({
+ *   providers: [LaunchDarklyToolbarService],
+ *   // ... other module config
+ * })
+ * export class AppModule {}
+ * ```
+ */
+export { default as LaunchDarklyToolbarService } from './angular/launchdarkly-toolbar.service';
+export type { LaunchDarklyToolbarConfig } from './angular/launchdarkly-toolbar.service';

package/dist/index.cjs

@@ -553,7 +553,7 @@ async function lazyLoad(signal, url) {
     }
 }
 var package_namespaceObject = {
-    rE: "2.1.4"
+    rE: "2.2.0"
 };
 function useLaunchDarklyToolbar(args) {
     const { toolbarBundleUrl, enabled, ...initConfig } = args;
@@ -573,6 +573,8 @@ function useLaunchDarklyToolbar(args) {
         lazyLoadToolbar(controller.signal, url).then((importedToolbar)=>{
             if (null === configRef.current) return;
             cleanup = importedToolbar.init(configRef.current);
+        }).catch((error)=>{
+            console.error('[LaunchDarkly Toolbar] Failed to initialize:', error);
         });
         return ()=>{
             controller.abort();