@launchdarkly/toolbar 1.6.0 → 2.2.0-beta.1

package/dist/core/ui/Toolbar/components/new/Interactive/SelectionModeBar.d.ts

@@ -0,0 +1 @@
+export declare function SelectionModeBar(): import("react").ReactPortal | null;

package/dist/core/ui/Toolbar/components/new/Interactive/SelectionOverlay.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function SelectionOverlay(): React.ReactPortal | null;

package/dist/core/ui/Toolbar/components/new/Interactive/WorkflowCard.d.ts

@@ -0,0 +1,13 @@
+import { type WorkflowType } from './workflowConfigs';
+/**
+ * Props for the WorkflowCard component.
+ * A workflow card allows users to generate AI prompts for common development tasks
+ * like wrapping elements in feature flags or adding click tracking.
+ */
+export interface WorkflowCardProps {
+    /** The type of workflow this card represents */
+    workflow: WorkflowType;
+    /** Whether the workflow card is disabled (shows "Coming Soon" badge) */
+    disabled?: boolean;
+}
+export declare function WorkflowCard({ workflow, disabled }: WorkflowCardProps): import("react/jsx-runtime").JSX.Element;

package/dist/core/ui/Toolbar/components/new/Interactive/WorkflowCard.module.css.d.ts

@@ -0,0 +1,27 @@
+export declare const card: string;
+export declare const cardHeader: string;
+export declare const iconContainer: string;
+export declare const cardContent: string;
+export declare const title: string;
+export declare const description: string;
+export declare const comingSoonBadge: string;
+export declare const inputGroup: string;
+export declare const inputLabel: string;
+export declare const input: string;
+export declare const actions: string;
+export declare const actionsDisabled: string;
+export declare const actionButton: string;
+export declare const actionIcon: string;
+export declare const ideIconWrapper: string;
+export declare const ideIconSvg: string;
+export declare const splitButtonContainer: string;
+export declare const splitButtonGroup: string;
+export declare const splitButtonMain: string;
+export declare const splitButtonDropdown: string;
+export declare const splitButtonDropdownOpen: string;
+export declare const splitButtonDropdownSuccess: string;
+export declare const dropdownMenu: string;
+export declare const dropdownItem: string;
+export declare const dropdownItemSelected: string;
+export declare const dropdownSeparator: string;
+export declare const preferredBadge: string;

package/dist/core/ui/Toolbar/components/new/Interactive/WorkflowSection.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export interface WorkflowSectionProps {
+    title: string;
+    children: React.ReactNode;
+}
+export declare function WorkflowSection({ title, children }: WorkflowSectionProps): import("react/jsx-runtime").JSX.Element;

package/dist/core/ui/Toolbar/components/new/Interactive/WorkflowSection.module.css.d.ts

@@ -0,0 +1,5 @@
+export declare const section: string;
+export declare const header: string;
+export declare const icon: string;
+export declare const title: string;
+export declare const cards: string;

package/dist/core/ui/Toolbar/components/new/Interactive/index.d.ts

@@ -0,0 +1,9 @@
+export { InteractiveContent } from './InteractiveContent';
+export { SelectionOverlay } from './SelectionOverlay';
+export { SelectionModeBar } from './SelectionModeBar';
+export { SelectedElementInfo } from './SelectedElementInfo';
+export { InteractiveWrapper } from './InteractiveWrapper';
+export { WorkflowCard } from './WorkflowCard';
+export { WorkflowSection } from './WorkflowSection';
+export { MCPSetupAlert } from './MCPSetupAlert';
+export { type WorkflowType } from './workflowConfigs';

package/dist/core/ui/Toolbar/components/new/Interactive/utils/elementUtils.d.ts

@@ -0,0 +1,56 @@
+export interface ElementAttribute {
+    name: string;
+    value: string;
+}
+export interface ElementInfo {
+    tagName: string;
+    id: string | null;
+    classes: string[];
+    textContent: string | null;
+    selector: string;
+    primaryIdentifier: string;
+    dataAttributes: ElementAttribute[];
+    htmlAttributes: ElementAttribute[];
+    dimensions: {
+        width: number;
+        height: number;
+    };
+}
+/**
+ * Checks if an element is part of the LaunchDarkly toolbar or selection UI.
+ * This is used to prevent selecting toolbar elements during element selection mode.
+ *
+ * @param element - The DOM element to check, or null
+ * @returns true if the element is part of the toolbar or selection UI, false otherwise
+ */
+export declare function isToolbarElement(element: Element | null): boolean;
+/**
+ * Generates a CSS selector path for an element.
+ * Creates a readable selector path up to 4 levels deep, prioritizing IDs for uniqueness.
+ *
+ * @param element - The DOM element to generate a selector for
+ * @returns A CSS selector string (e.g., "div#container > button.submit-btn:nth-of-type(2)")
+ */
+export declare function getElementSelector(element: Element): string;
+/**
+ * Gets a short display path for the element (for the hover tag).
+ * Returns a simplified identifier showing tag name, ID, or first few classes.
+ *
+ * @param element - The DOM element to get the display path for
+ * @returns A short identifier string (e.g., "button#submit" or "div.container.header")
+ */
+export declare function getElementDisplayPath(element: Element): string;
+/**
+ * Extracts all relevant information about an element
+ * @param element - The DOM element to extract information from
+ * @returns ElementInfo object containing element details
+ * @throws Error if element is null, undefined, or not an instance of Element
+ */
+export declare function getElementInfo(element: Element): ElementInfo;
+/**
+ * Gets the bounding rect of an element relative to the viewport
+ * @param element - The DOM element to get the bounding rect for
+ * @returns DOMRect object with element position and dimensions
+ * @throws Error if element is null, undefined, or not an instance of Element
+ */
+export declare function getElementRect(element: Element): DOMRect;

package/dist/core/ui/Toolbar/components/new/Interactive/utils/ideLinks.d.ts

@@ -0,0 +1,58 @@
+import { PreferredIde } from '../../../../utils/localStorage';
+export interface IdeConfig {
+    id: PreferredIde;
+    label: string;
+    icon: 'cursor' | 'windsurf' | 'vscode' | 'github-copilot';
+}
+export declare const IDE_CONFIGS: IdeConfig[];
+/**
+ * Minify a prompt for URL encoding by removing unnecessary whitespace
+ * while preserving the actual content and readability.
+ * This can reduce URL length by 40-60%.
+ */
+export declare function minifyPromptForUrl(prompt: string): string;
+/**
+ * Open Cursor IDE with the prompt in composer
+ * Cursor uses cursor://anysphere.cursor-deeplink/prompt?text=<encoded_prompt>
+ * @returns true if the protocol handler was likely successful
+ */
+export declare function openInCursor(prompt: string): boolean;
+/**
+ * Open Windsurf IDE with the prompt
+ * Windsurf uses windsurf://cascade?prompt=<encoded_prompt>
+ * @returns true if the protocol handler was likely successful, false if blocked
+ */
+export declare function openInWindsurf(prompt: string): boolean;
+/**
+ * Open VS Code with the prompt
+ * VS Code doesn't have a direct prompt protocol, so we just open it
+ * and the user will need to paste the prompt
+ * @returns true if the protocol handler was likely successful, false if blocked
+ */
+export declare function openInVSCode(_prompt: string): boolean;
+/**
+ * Open GitHub Copilot with the prompt
+ * GitHub Copilot uses https://github.com/copilot/agents?prompt=<encoded_prompt>
+ * Uses minified prompt, and if still too long, the caller should provide a condensed version.
+ * @param prompt - The prompt to use (should be condensed if full prompt is too long)
+ * @returns true if the link was opened successfully
+ */
+export declare function openInGitHubCopilot(prompt: string): boolean;
+/**
+ * Get the URL length for a prompt (after minification and encoding)
+ * Useful for debugging URL length issues
+ */
+export declare function getGitHubCopilotUrlLength(prompt: string): number;
+/**
+ * Open the specified IDE with the prompt
+ * @returns true if the protocol handler was likely successful, false if blocked
+ */
+export declare function openInIde(prompt: string, ide: PreferredIde): boolean;
+/**
+ * Copy prompt to clipboard and open in the specified IDE
+ * @param prompt - Full prompt to copy to clipboard
+ * @param ide - The IDE to open
+ * @param urlPrompt - Optional condensed prompt for URL-based IDEs (GitHub Copilot). If not provided, uses full prompt.
+ * @returns true if both copy and IDE open were successful, false otherwise
+ */
+export declare function copyAndOpenInIde(prompt: string, ide: PreferredIde, urlPrompt?: string): Promise<boolean>;

package/dist/core/ui/Toolbar/components/new/Interactive/utils/promptBuilder.d.ts

@@ -0,0 +1,26 @@
+import { ElementInfo } from './elementUtils';
+export interface FeatureFlagPromptOptions {
+    elementContext: string;
+    projectKey: string;
+    environmentKey?: string;
+    suggestedFlagKey?: string;
+    intent?: 'hide' | 'show' | 'replace' | 'experiment';
+}
+/**
+ * Builds context string from element info for AI prompts
+ */
+export declare function buildElementContext(elementInfo: ElementInfo): string;
+/**
+ * Builds a condensed prompt for URL-based delivery (under 8KB when encoded).
+ * Includes all essential steps but with less verbose examples.
+ */
+export declare function buildCondensedFeatureFlagPrompt(options: FeatureFlagPromptOptions): string;
+/**
+ * Builds a detailed prompt for an AI agent to wrap an element in a LaunchDarkly feature flag.
+ * This prompt is designed for agents with access to LaunchDarkly MCP tools.
+ */
+export declare function buildFeatureFlagAgentPrompt(options: FeatureFlagPromptOptions): string;
+/**
+ * Builds a prompt for adding click tracking to an element
+ */
+export declare function buildClickTrackingPrompt(elementInfo: ElementInfo, eventName: string): string;

package/dist/core/ui/Toolbar/components/new/Interactive/utils/throttle.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Throttles a function to execute at most once per specified delay.
+ * Ensures the function is called at regular intervals, useful for
+ * performance optimization of frequently triggered events like mousemove.
+ *
+ * @param func - The function to throttle
+ * @param delay - The delay in milliseconds between function calls
+ * @returns A throttled version of the function
+ */
+export declare function throttle<T extends (...args: any[]) => any>(func: T, delay: number): (...args: Parameters<T>) => void;

package/dist/core/ui/Toolbar/components/new/Interactive/workflowConfigs.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+import type { ElementInfo } from './utils/elementUtils';
+/**
+ * Available workflow types for the WorkflowCard component.
+ */
+export type WorkflowType = 'featureFlag' | 'clickTracking';
+/**
+ * Configuration for a single workflow type.
+ */
+export interface WorkflowConfig {
+    /** Icon to display in the card header */
+    icon: React.ReactNode;
+    /** Title of the workflow card */
+    title: string;
+    /** Description text explaining what the workflow does */
+    description: string;
+    /** Label for the input field */
+    inputLabel: string;
+    /** Placeholder text for the input field */
+    inputPlaceholder: string;
+    /**
+     * Builds the AI prompt given element info, project key, and user input.
+     */
+    buildPrompt: (elementInfo: ElementInfo, projectKey: string, inputValue: string) => string;
+    /**
+     * Optional function that builds a condensed version of the prompt for URL-based IDEs
+     * (like GitHub Copilot) where URL length is limited.
+     */
+    buildCondensedPrompt?: (elementInfo: ElementInfo, projectKey: string, inputValue: string) => string;
+}
+/**
+ * Registry of all available workflow configurations.
+ * Each workflow knows how to build its own prompts using element context.
+ */
+export declare const WORKFLOW_CONFIGS: Record<WorkflowType, WorkflowConfig>;
+export declare function getWorkflowConfig(type: WorkflowType): WorkflowConfig;

package/dist/core/ui/Toolbar/components/new/Monitoring/EventsContent.d.ts

@@ -0,0 +1 @@
+export declare function EventsContent(): import("react/jsx-runtime").JSX.Element;

package/dist/core/ui/Toolbar/components/new/Monitoring/EventsContent.module.css.d.ts

@@ -0,0 +1,24 @@
+export declare const statsHeader: string;
+export declare const statsText: string;
+export declare const eventInfo: string;
+export declare const eventName: string;
+export declare const eventMeta: string;
+export declare const eventBadge: string;
+export declare const eventBadgeFeature: string;
+export declare const addButtonContainer: string;
+export declare const addButton: string;
+export declare const eventBadgeIdentify: string;
+export declare const eventBadgeCustom: string;
+export declare const eventBadgeDebug: string;
+export declare const eventBadgeSummary: string;
+export declare const eventBadgeDiagnostic: string;
+export declare const eventBadgeDefault: string;
+export declare const virtualContainer: string;
+export declare const virtualInner: string;
+export declare const virtualItem: string;
+export declare const liveTailContainer: string;
+export declare const liveTailIndicator: string;
+export declare const liveTailDot: string;
+export declare const liveTailText: string;
+export declare const liveTailSubtext: string;
+export declare const eventListItem: string;

package/dist/core/ui/Toolbar/components/new/SearchSection.d.ts

@@ -0,0 +1,8 @@
+import { Dispatch, SetStateAction } from 'react';
+interface SearchSectionProps {
+    searchTerm: string;
+    onSearch: (searchTerm: string) => void;
+    setSearchIsExpanded: Dispatch<SetStateAction<boolean>>;
+}
+export declare function SearchSection(props: SearchSectionProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/ui/Toolbar/components/new/SearchSection.module.css.d.ts

@@ -0,0 +1,3 @@
+export declare const searchFieldWrapper: string;
+export declare const searchField: string;
+export declare const searchGroup: string;

package/dist/core/ui/Toolbar/components/new/Settings/ConnectionStatus.d.ts

@@ -0,0 +1,5 @@
+interface ConnectionStatusProps {
+    status: 'connected' | 'disconnected' | 'error';
+}
+export declare function ConnectionStatus({ status }: ConnectionStatusProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/ui/Toolbar/components/new/Settings/ConnectionStatus.module.css.d.ts

@@ -0,0 +1,6 @@
+export declare const container: string;
+export declare const text: string;
+export declare const dot: string;
+export declare const connected: string;
+export declare const disconnected: string;
+export declare const error: string;

package/dist/core/ui/Toolbar/components/new/Settings/EnvironmentSelector.d.ts

@@ -0,0 +1 @@
+export declare function EnvironmentSelector(): import("react/jsx-runtime").JSX.Element;

package/dist/core/ui/Toolbar/components/new/Settings/GeneralSettings.d.ts

@@ -0,0 +1 @@
+export declare function GeneralSettings(): import("react/jsx-runtime").JSX.Element;

package/dist/core/ui/Toolbar/components/new/Settings/LogoutButton.d.ts

@@ -0,0 +1 @@
+export declare function LogoutButton(): import("react/jsx-runtime").JSX.Element;

package/dist/core/ui/Toolbar/components/new/Settings/LogoutButton.module.css.d.ts

@@ -0,0 +1 @@
+export declare const button: string;

package/dist/core/ui/Toolbar/components/new/Settings/PositionSelector.d.ts

@@ -0,0 +1,6 @@
+import { ToolbarPosition } from '../../../types/toolbar';
+interface PositionSelectorProps {
+    currentPosition: ToolbarPosition;
+}
+export declare function PositionSelector({ currentPosition }: PositionSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/ui/Toolbar/components/new/Settings/ProjectSelector.d.ts

@@ -0,0 +1 @@
+export declare function ProjectSelector(): import("react/jsx-runtime").JSX.Element;

package/dist/core/ui/Toolbar/components/new/Settings/SettingsContent.d.ts

@@ -0,0 +1 @@
+export declare function SettingsContent(): import("react/jsx-runtime").JSX.Element;

package/dist/core/ui/Toolbar/components/new/Settings/SettingsContent.module.css.d.ts

@@ -0,0 +1,3 @@
+export declare const container: string;
+export declare const value: string;
+export declare const placeholder: string;

package/dist/core/ui/Toolbar/components/new/Settings/SettingsItem.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface SettingsItemProps {
+    label: string;
+    description?: string;
+    children: React.ReactNode;
+}
+export declare function SettingsItem({ label, description, children }: SettingsItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/ui/Toolbar/components/new/Settings/SettingsItem.module.css.d.ts

@@ -0,0 +1,6 @@
+export declare const item: string;
+export declare const info: string;
+export declare const label: string;
+export declare const description: string;
+export declare const control: string;
+export declare const switch_: string;

package/dist/core/ui/Toolbar/components/new/Settings/SettingsSection.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface SettingsSectionProps {
+    title: string;
+    children: React.ReactNode;
+}
+export declare function SettingsSection({ title, children }: SettingsSectionProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/ui/Toolbar/components/new/Settings/SettingsSection.module.css.d.ts

@@ -0,0 +1,3 @@
+export declare const section: string;
+export declare const title: string;
+export declare const content: string;

package/dist/core/ui/Toolbar/components/new/Settings/index.d.ts

@@ -0,0 +1,8 @@
+export * from './SettingsContent';
+export * from './GeneralSettings';
+export * from './SettingsSection';
+export * from './SettingsItem';
+export * from './ProjectSelector';
+export * from './PositionSelector';
+export * from './ConnectionStatus';
+export * from './LogoutButton';

package/dist/core/ui/Toolbar/components/new/SubtabDropdown.d.ts

@@ -0,0 +1,8 @@
+import { SubTab, TabConfig } from './types';
+interface SubtabDropdownProps {
+    subtabs: TabConfig[];
+    activeSubtab: SubTab | undefined;
+    onSelectSubtab: (subtab: SubTab) => void;
+}
+export declare function SubtabDropdown({ subtabs, activeSubtab, onSelectSubtab }: SubtabDropdownProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/ui/Toolbar/components/new/SubtabDropdown.module.css.d.ts

@@ -0,0 +1,10 @@
+export declare const container: string;
+export declare const trigger: string;
+export declare const triggerOpen: string;
+export declare const filterIcon: string;
+export declare const label: string;
+export declare const chevron: string;
+export declare const chevronIcon: string;
+export declare const menu: string;
+export declare const menuItem: string;
+export declare const menuItemActive: string;

package/dist/core/ui/Toolbar/components/new/TabBar.d.ts

@@ -0,0 +1 @@
+export declare function TabBar(): import("react/jsx-runtime").JSX.Element | null;

package/dist/core/ui/Toolbar/components/new/TabBar.module.css.d.ts

@@ -0,0 +1,4 @@
+export declare const container: string;
+export declare const tabs: string;
+export declare const tab: string;
+export declare const active: string;

package/dist/core/ui/Toolbar/components/new/Tooltip.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface TooltipProps {
+    content: string;
+    children: React.ReactNode;
+}
+export declare function Tooltip({ content, children }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/ui/Toolbar/components/new/Tooltip.module.css.d.ts

@@ -0,0 +1,2 @@
+export declare const container: string;
+export declare const tooltip: string;

package/dist/core/ui/Toolbar/components/new/context/ActiveSubtabProvider.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { SubTab } from '../types';
+interface ActiveSubtabContextValue {
+    activeSubtab: SubTab | undefined;
+    setActiveSubtab: (subtab: SubTab) => void;
+}
+export interface ActiveSubtabProviderProps {
+    children: ReactNode;
+}
+export declare function ActiveSubtabProvider({ children }: ActiveSubtabProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useActiveSubtabContext(): ActiveSubtabContextValue;
+export {};

package/dist/core/ui/Toolbar/components/new/context/FiltersProvider.d.ts

@@ -0,0 +1,41 @@
+import { ReactNode } from 'react';
+import { SubTab } from '../types';
+export interface FilterOption {
+    id: string;
+    label: string;
+    description?: string;
+}
+export interface SubtabFilterConfig {
+    subtab: SubTab;
+    options: FilterOption[];
+    defaultSelected: string[];
+    allowMultiple: boolean;
+}
+export declare const SUBTAB_FILTER_CONFIGS: Record<string, SubtabFilterConfig>;
+interface FiltersContextValue {
+    getActiveFilters: (subtab: SubTab) => Set<string>;
+    getFilterConfig: (subtab: SubTab) => SubtabFilterConfig | null;
+    toggleFilter: (subtab: SubTab, filterId: string) => void;
+    setFilters: (subtab: SubTab, filterIds: string[]) => void;
+    resetFilters: (subtab: SubTab) => void;
+    hasFilters: (subtab: SubTab) => boolean;
+    hasActiveNonDefaultFilters: (subtab: SubTab) => boolean;
+    isFilterOverlayOpen: boolean;
+    openFilterOverlay: () => void;
+    closeFilterOverlay: () => void;
+    toggleFilterOverlay: () => void;
+}
+interface FiltersProviderProps {
+    children: ReactNode;
+}
+export declare function FiltersProvider({ children }: FiltersProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useFilters(): FiltersContextValue;
+export declare function useSubtabFilters(subtab: SubTab): {
+    activeFilters: Set<string>;
+    config: SubtabFilterConfig | null;
+    toggle: (filterId: string) => void;
+    reset: () => void;
+    hasFilters: boolean;
+    hasActiveNonDefaultFilters: boolean;
+};
+export {};

package/dist/core/ui/Toolbar/components/new/context/TabSearchProvider.d.ts

@@ -0,0 +1,10 @@
+import { TabId } from '../../../types';
+type TabSearchContextType = {
+    searchTerms: Record<TabId, string>;
+    setSearchTerm: (tab: TabId, searchTerm: string) => void;
+};
+export declare function TabSearchProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useTabSearchContext(): TabSearchContextType;
+export {};

package/dist/core/ui/Toolbar/components/new/context/index.d.ts

@@ -0,0 +1,3 @@
+export { ActiveSubtabProvider, useActiveSubtabContext } from './ActiveSubtabProvider';
+export { TabSearchProvider, useTabSearchContext } from './TabSearchProvider';
+export { FiltersProvider, useFilters, useSubtabFilters, SUBTAB_FILTER_CONFIGS, type FilterOption, type SubtabFilterConfig, } from './FiltersProvider';

package/dist/core/ui/Toolbar/components/new/index.d.ts

@@ -0,0 +1,10 @@
+export * from './ExpandedToolbarContent';
+export * from './IconBar/IconBar';
+export * from './TabBar';
+export * from './ContentActions';
+export * from './Tooltip';
+export * from './ContentRenderer';
+export * from './context';
+export * from './types';
+export * from './Settings';
+export * from './FilterOverlay';

package/dist/core/ui/Toolbar/components/new/types.d.ts

@@ -0,0 +1,16 @@
+export type FlagsSubtab = 'flags' | 'context';
+export type MonitoringSubtab = 'events';
+export type SettingsSubtab = 'general';
+export type InteractiveSubtab = 'workflows';
+export type SubTab = FlagsSubtab | MonitoringSubtab | SettingsSubtab | InteractiveSubtab;
+export interface TabConfig {
+    id: string;
+    label: string;
+}
+export declare const TAB_SUBTABS_MAP: {
+    readonly flags: TabConfig[];
+    readonly monitoring: TabConfig[];
+    readonly settings: TabConfig[];
+    readonly interactive: TabConfig[];
+};
+export declare function getDefaultSubtab(mainTab: string): SubTab;

package/dist/core/ui/Toolbar/constants/virtualization.d.ts

@@ -1,4 +1,5 @@
 export declare const VIRTUALIZATION: {
     readonly ITEM_HEIGHT: 80;
     readonly OVERSCAN: 5;
+    readonly GAP: 12;
 };

package/dist/core/ui/Toolbar/context/DevServerProvider.d.ts

@@ -1,15 +1,11 @@
 import type { FC, ReactNode } from 'react';
 import { LdToolbarConfig, ToolbarState } from '../../../types/devServer';
 interface DevServerContextValue {
-    state: ToolbarState & {
-        availableProjects: string[];
-        currentProjectKey: string | null;
-    };
+    state: ToolbarState;
     setOverride: (flagKey: string, value: any) => Promise<void>;
     clearOverride: (flagKey: string) => Promise<void>;
     clearAllOverrides: () => Promise<void>;
     refresh: () => Promise<void>;
-    switchProject: (projectKey: string) => Promise<void>;
 }
 export declare const useDevServerContext: () => DevServerContextValue;
 export interface DevServerProviderProps {

package/dist/core/ui/Toolbar/context/ElementSelectionProvider.d.ts

@@ -0,0 +1,52 @@
+import { ReactNode } from 'react';
+import { ElementInfo } from '../components/new/Interactive/utils/elementUtils';
+/**
+ * Context value for element selection functionality.
+ * Provides state and actions for selecting DOM elements in the interactive mode.
+ */
+export interface ElementSelectionContextValue {
+    /** Whether the user is currently in element selection mode */
+    isSelecting: boolean;
+    /** The currently selected DOM element, or null if none selected */
+    selectedElement: HTMLElement | null;
+    /** Extracted information about the selected element */
+    selectedElementInfo: ElementInfo | null;
+    /** The element currently being hovered over during selection */
+    hoveredElement: HTMLElement | null;
+    /** Start element selection mode */
+    startSelection: () => void;
+    /** Exit element selection mode without selecting an element */
+    exitSelection: () => void;
+    /** Select an element and exit selection mode */
+    selectElement: (element: HTMLElement) => void;
+    /** Clear the current selection */
+    clearSelection: () => void;
+    /** Set the currently hovered element (used internally by SelectionOverlay) */
+    setHoveredElement: (element: HTMLElement | null) => void;
+}
+export interface ElementSelectionProviderProps {
+    /** Child components that will have access to the element selection context */
+    children: ReactNode;
+    /** Optional callback invoked when selection mode starts */
+    onSelectionStart?: () => void;
+    /** Optional callback invoked when selection mode ends (either by selecting or exiting) */
+    onSelectionEnd?: () => void;
+}
+/**
+ * Provider component that manages element selection state for the interactive mode.
+ * Wraps components that need access to element selection functionality.
+ *
+ * @param props - The provider props
+ * @param props.children - Child components
+ * @param props.onSelectionStart - Optional callback when selection starts
+ * @param props.onSelectionEnd - Optional callback when selection ends
+ */
+export declare function ElementSelectionProvider({ children, onSelectionStart, onSelectionEnd, }: ElementSelectionProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access the element selection context.
+ * Must be used within an ElementSelectionProvider.
+ *
+ * @returns The element selection context value
+ * @throws Error if used outside of ElementSelectionProvider
+ */
+export declare function useElementSelection(): ElementSelectionContextValue;