@launchdarkly/toolbar 0.26.0 → 1.0.1-beta.1

package/cdn/toolbar.min.js.LICENSE.txt

@@ -0,0 +1,59 @@
+/**
+ * @license React
+ * react-dom-client.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * react-dom.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * react.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * scheduler.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * use-sync-external-store-shim.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */

package/dist/core/context/Providers.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+interface Props {
+    children: ReactNode;
+    portalMount: HTMLElement;
+    reactMount: HTMLElement;
+    shadowRoot: ShadowRoot;
+}
+export default function Providers(props: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/context/ReactMountContext.d.ts

@@ -0,0 +1,2 @@
+declare const ReactMountContext: import("react").Context<HTMLElement>;
+export default ReactMountContext;

package/dist/core/context/ShadowRootContext.d.ts

@@ -0,0 +1,2 @@
+declare const ShadowRootContext: import("react").Context<ShadowRoot>;
+export default ShadowRootContext;

package/dist/core/context/defaultConfig.d.ts

@@ -0,0 +1,3 @@
+import { InitializationConfig } from '../../types';
+declare const defaultConfig: InitializationConfig;
+export default defaultConfig;

package/dist/core/index.d.ts

@@ -0,0 +1,8 @@
+import { InitializationConfig } from '../types';
+import './globals.css';
+export type Cleanup = () => void;
+export declare function init(config: InitializationConfig): Cleanup;
+declare const LaunchDarklyToolbar: {
+    init: typeof init;
+};
+export default LaunchDarklyToolbar;

package/dist/core/mount.d.ts

@@ -0,0 +1,2 @@
+import { InitializationConfig } from '../types';
+export default function mount(rootNode: HTMLElement, config: InitializationConfig): () => void;

package/dist/{ui → core/ui}/Toolbar/LaunchDarklyToolbar.d.ts

@@ -1,10 +1,11 @@
 import { ToolbarMode, ToolbarPosition } from './types/toolbar';
-import type { IEventInterceptionPlugin, IFlagOverridePlugin } from '../../types/plugin';
+import { IEventInterceptionPlugin, IFlagOverridePlugin } from '../../../types';
 export interface LdToolbarProps {
     mode: ToolbarMode;
     baseUrl: string;
     flagOverridePlugin?: IFlagOverridePlugin;
     eventInterceptionPlugin?: IEventInterceptionPlugin;
+    domId: string;
 }
 export declare function LdToolbar(props: LdToolbarProps): import("react/jsx-runtime").JSX.Element;
 export interface LaunchDarklyToolbarProps {
@@ -15,5 +16,6 @@ export interface LaunchDarklyToolbarProps {
     eventInterceptionPlugin?: IEventInterceptionPlugin;
     pollIntervalInMs?: number;
     position?: ToolbarPosition;
+    domId: string;
 }
 export declare function LaunchDarklyToolbar(props: LaunchDarklyToolbarProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/{ui → core/ui}/Toolbar/TabContent/EventsTabContent.d.ts

@@ -1,4 +1,4 @@
-import type { IEventInterceptionPlugin } from '../../../types/plugin';
+import { IEventInterceptionPlugin } from '../../../../types';
 interface EventsTabContentProps {
     baseUrl: string;
     eventInterceptionPlugin?: IEventInterceptionPlugin;

package/dist/{ui → core/ui}/Toolbar/TabContent/FlagSdkOverrideTabContent.d.ts

@@ -1,4 +1,4 @@
-import type { IFlagOverridePlugin } from '../../../types/plugin';
+import { IFlagOverridePlugin } from '../../../../types';
 interface FlagSdkOverrideTabContentProps {
     flagOverridePlugin?: IFlagOverridePlugin;
     reloadOnFlagChangeIsEnabled: boolean;

package/dist/{ui → core/ui}/Toolbar/components/ExpandedToolbarContent.d.ts

@@ -1,6 +1,6 @@
 import React, { Dispatch, SetStateAction } from 'react';
 import { ActiveTabId, ToolbarMode } from '../types';
-import type { IFlagOverridePlugin, IEventInterceptionPlugin } from '../../../types/plugin';
+import { IEventInterceptionPlugin, IFlagOverridePlugin } from '../../../../types';
 interface ExpandedToolbarContentProps {
     activeTab: ActiveTabId;
     slideDirection: number;

package/dist/{ui → core/ui}/Toolbar/components/TabContentRenderer.d.ts

@@ -1,5 +1,5 @@
 import { TabId, ToolbarMode } from '../types';
-import type { IFlagOverridePlugin, IEventInterceptionPlugin } from '../../../types/plugin';
+import { IEventInterceptionPlugin, IFlagOverridePlugin } from '../../../../types';
 interface TabContentRendererProps {
     activeTab: TabId;
     baseUrl: string;

package/dist/{ui → core/ui}/Toolbar/context/FlagSdkOverrideProvider.d.ts

@@ -1,4 +1,4 @@
-import type { IFlagOverridePlugin } from '../../../types/plugin';
+import { IFlagOverridePlugin } from '../../../../types';
 interface LocalFlag {
     key: string;
     name: string;

package/dist/{ui → core/ui}/Toolbar/hooks/useEvents.d.ts

@@ -1,5 +1,4 @@
-import type { ProcessedEvent } from '../../../types/events';
-import { IEventInterceptionPlugin } from '../../../types/plugin';
+import { IEventInterceptionPlugin, ProcessedEvent } from '../../../../types';
 interface EventStats {
     totalEvents: number;
     eventsByKind: Record<string, number>;

package/dist/{ui → core/ui}/Toolbar/hooks/useToolbarState.d.ts

@@ -2,6 +2,7 @@ import { Dispatch, SetStateAction } from 'react';
 import { ActiveTabId } from '../types';
 export interface UseToolbarStateProps {
     defaultActiveTab: ActiveTabId;
+    domId: string;
 }
 export interface UseToolbarStateReturn {
     isExpanded: boolean;

package/dist/core/utils/hydrateConfig.d.ts

@@ -0,0 +1,2 @@
+import { InitializationConfig } from '../../types';
+export default function hydrateProps(config: InitializationConfig): InitializationConfig;

package/dist/{js/plugins/index.js → index.cjs}

@@ -1,135 +1,64 @@
-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);
-        }
-    }
+"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 ('undefined' != 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__, {
+    isValidEventKind: ()=>isValidEventKind,
+    ANALYTICS_EVENT_PREFIX: ()=>ANALYTICS_EVENT_PREFIX,
+    EventInterceptionPlugin: ()=>EventInterceptionPlugin,
+    FlagOverridePlugin: ()=>FlagOverridePlugin,
+    TOOLBAR_POSITIONS: ()=>TOOLBAR_POSITIONS,
+    useLaunchDarklyToolbar: ()=>useLaunchDarklyToolbar,
+    isValidEventCategory: ()=>isValidEventCategory
+});
+const ANALYTICS_EVENT_PREFIX = 'ld.toolbar';
+const VALID_EVENT_KINDS = [
+    'identify',
+    'feature',
+    'custom',
+    'debug',
+    'summary',
+    'diagnostic'
+];
+const VALID_EVENT_CATEGORIES = [
+    'flag',
+    'custom',
+    'identify',
+    'debug'
+];
+function isValidEventKind(kind) {
+    return VALID_EVENT_KINDS.includes(kind);
+}
+function isValidEventCategory(category) {
+    return VALID_EVENT_CATEGORIES.includes(category);
 }
+const TOOLBAR_POSITIONS = [
+    'top-left',
+    'top-right',
+    'bottom-left',
+    'bottom-right'
+];
 const DEFAULT_MAX_EVENTS = 100;
 class EventStore {
     events = [];
@@ -366,7 +295,6 @@ class AfterEvaluationHook {
         };
     }
 }
-const ANALYTICS_EVENT_PREFIX = 'ld.toolbar';
 class EventInterceptionPlugin {
     afterTrackHook;
     afterIdentifyHook;
@@ -441,4 +369,221 @@ class EventInterceptionPlugin {
         this.eventStore.destroy();
     }
 }
-export { EventInterceptionPlugin, FlagOverridePlugin };
+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 external_react_namespaceObject = require("react");
+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 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) 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 = JSON.parse('{"rE":"1.0.1-beta.1"}');
+function useLaunchDarklyToolbar(args) {
+    const { toolbarBundleUrl, enabled, ...initConfig } = args;
+    const configRef = (0, external_react_namespaceObject.useRef)(null);
+    const url = toolbarBundleUrl ?? versionToCdn(package_namespaceObject.rE);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (false === enabled) return;
+        if (null === configRef.current) configRef.current = initConfig;
+    }, [
+        enabled,
+        initConfig
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (false === enabled || null === configRef.current) return;
+        const controller = new AbortController();
+        let cleanup = ()=>{};
+        lazyLoadToolbar(controller.signal, url).then((importedToolbar)=>{
+            if (null === configRef.current) return;
+            cleanup = importedToolbar.init(configRef.current);
+        });
+        return ()=>{
+            controller.abort();
+            cleanup();
+        };
+    }, [
+        enabled,
+        url
+    ]);
+}
+function versionToCdn(version = 'latest') {
+    return `https://unpkg.com/@launchdarkly/toolbar@${version}/cdn/toolbar.min.js`;
+}
+exports.ANALYTICS_EVENT_PREFIX = __webpack_exports__.ANALYTICS_EVENT_PREFIX;
+exports.EventInterceptionPlugin = __webpack_exports__.EventInterceptionPlugin;
+exports.FlagOverridePlugin = __webpack_exports__.FlagOverridePlugin;
+exports.TOOLBAR_POSITIONS = __webpack_exports__.TOOLBAR_POSITIONS;
+exports.isValidEventCategory = __webpack_exports__.isValidEventCategory;
+exports.isValidEventKind = __webpack_exports__.isValidEventKind;
+exports.useLaunchDarklyToolbar = __webpack_exports__.useLaunchDarklyToolbar;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ANALYTICS_EVENT_PREFIX",
+    "EventInterceptionPlugin",
+    "FlagOverridePlugin",
+    "TOOLBAR_POSITIONS",
+    "isValidEventCategory",
+    "isValidEventKind",
+    "useLaunchDarklyToolbar"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+//# sourceMappingURL=index.cjs.map