@visulima/dev-toolbar 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/toolbar/app-manager.d.ts

@@ -1,95 +1,104 @@
 import type { DevToolbarApp, DevToolbarAppState } from "../types/app.d.ts";
 /**
- * App manager for handling app lifecycle
+ * Manages the lifecycle of all registered dev-toolbar apps.
  */
-export declare class AppManager {
+declare class AppManager {
     private apps;
     private activeAppId;
     private initializedApps;
     private appCanvases;
     /**
-     * Register an app
-     * @param app App definition
-     * @param builtIn Whether this is a built-in app
+     * Registers an app with the toolbar.
+     * @param app App definition.
+     * @param builtIn Whether this is a built-in app.
      */
     registerApp(app: DevToolbarApp, builtIn?: boolean): void;
     /**
-     * Unregister an app
-     * @param appId App ID
+     * Unregisters an app and calls its destroy hook if initialized.
+     * @param appId App ID to unregister.
      */
     unregisterApp(appId: string): Promise<void>;
     /**
-     * Get an app by ID
-     * @param appId App ID
-     * @returns App state or undefined
+     * Returns the app state for a given ID.
+     * @param appId App ID to look up.
+     * @returns App state or undefined.
      */
     getApp(appId: string): DevToolbarAppState | undefined;
     /**
-     * Get all apps
-     * @returns Array of app states
+     * Returns all registered app states.
      */
     getAllApps(): DevToolbarAppState[];
     /**
-     * Get active app
-     * @returns Active app state or undefined
+     * Returns the currently active app state, or undefined if none is active.
      */
     getActiveApp(): DevToolbarAppState | undefined;
     /**
-     * Toggle app active state
-     * @param appId App ID
-     * @returns Whether toggle was successful
+     * Toggles the active state of an app.
+     * @param appId App ID to toggle.
+     * @returns Whether the toggle was successful.
      */
     toggleApp(appId: string): Promise<boolean>;
     /**
-     * Check if an app has been initialized
-     * @returns True when the app's init() has already been called
+     * Directly sets the active state of an action button without invoking callbacks.
+     * Use this to deactivate a button from outside the toolbar (e.g. after async work).
+     * @param appId The unique identifier of the app whose active state to change.
+     * @param active New active state.
+     */
+    setAppActive(appId: string, active: boolean): void;
+    /**
+     * Returns whether an app has already had its init() called.
+     * @param appId App ID to check.
      */
     isAppInitialized(appId: string): boolean;
     /**
-     * Mark an app as initialized
-     * @returns void
+     * Marks an app as having been initialized.
+     * @param appId App ID to mark.
      */
     markAppInitialized(appId: string): void;
     /**
-     * Open an app
-     * @param appId App ID
-     * @returns Whether open was successful
+     * Opens an app and initializes it if necessary.
+     * @param appId App ID to open.
+     * @returns Whether the open was successful.
      */
     openApp(appId: string): Promise<boolean>;
     /**
-     * Close an app
-     * @param appId App ID
-     * @returns Whether close was successful
+     * Closes an active app.
+     * @param appId App ID to close.
+     * @returns Whether the close was successful.
      */
     closeApp(appId: string): Promise<boolean>;
     /**
-     * Set app notification
-     * @param appId App ID
-     * @param state Notification state
-     * @param level Notification level
+     * Sets a notification for an app.
+     * @param appId The unique identifier of the app to notify.
+     * @param state Whether the notification is currently visible.
+     * @param level The severity level of the notification badge.
      */
     setNotification(appId: string, state: boolean, level?: "info" | "warning" | "error"): void;
     /**
-     * Clear app notification
-     * @param appId App ID
+     * Clears the notification for an app.
+     * @param appId The unique identifier of the app whose notification to clear.
      */
     clearNotification(appId: string): void;
     /**
-     * Get app canvas element
-     * @param appId App ID
-     * @returns Canvas element with shadow root or null
+     * Returns the canvas element and shadow root for an app.
+     * @param appId The unique identifier of the app whose canvas to retrieve.
+     * @returns Canvas element with shadow root or undefined.
      */
     getAppCanvas(appId: string): {
         element: HTMLElement;
         shadowRoot: ShadowRoot;
-    } | null;
+    } | undefined;
     /**
-     * Set app canvas element (called by toolbar component)
-     * @param appId App ID
-     * @param canvas Canvas with shadow root
+     * Stores the canvas element and shadow root for an app.
+     * @param appId The unique identifier of the app whose canvas to store.
+     * @param canvas The canvas object containing the host element and its shadow root.
+     * @param canvas.element The host HTMLElement that wraps the app's shadow DOM.
+     * @param canvas.shadowRoot The ShadowRoot attached to the canvas element.
      */
     setAppCanvas(appId: string, canvas: {
         element: HTMLElement;
         shadowRoot: ShadowRoot;
     }): void;
 }
+export { AppManager };
+export default AppManager;

package/dist/toolbar/components/app-button.d.ts

@@ -11,8 +11,8 @@ interface AppButtonProps {
  * App button component — shown in the toolbar pill.
  * When an app declares a `tooltip` component, hovering the button shows a live
  * mini-canvas via AppTooltipOverlay (rendered outside overflow:hidden pill).
- * @param props - Component props
- * @param props.app - App state
+ * @param props Component props
+ * @param props.app App state
  * @returns Rendered button component
  */
 declare const AppButton: ({ app }: AppButtonProps) => ComponentChildren;

package/dist/toolbar/components/app-canvas.d.ts

@@ -1,8 +1,7 @@
-/** @jsxImportSource preact */
 import type { ComponentChildren } from "preact";
 import type { DevToolbarAppState } from "../../types/index.d.ts";
 interface DevPanelProps {
-    activeAppId: string | null;
+    activeAppId: string | undefined;
     apps: DevToolbarAppState[];
     onClose: () => void;
     onToggleApp: (appId: string) => Promise<void>;

package/dist/toolbar/components/app-tooltip-overlay.d.ts

@@ -1,4 +1,3 @@
-/** @jsxImportSource preact */
 import type { ComponentChildren } from "preact";
 interface AppTooltipOverlayProps {
     position: "bottom" | "left" | "right" | "top";

package/dist/toolbar/components/first-visit-hint.d.ts

@@ -7,9 +7,9 @@ interface FirstVisitHintProps {
 /**
  * First-visit hint overlay showing keyboard and interaction tips.
  * Appears ~600 ms after mount to let the toolbar pill animate in first.
- * @param props - Component props
- * @param props.onDismiss - Called after the dismiss animation completes
- * @param props.position - Current toolbar position (controls hint placement)
+ * @param props Component props
+ * @param props.onDismiss Called after the dismiss animation completes
+ * @param props.position Current toolbar position (controls hint placement)
  * @returns Rendered hint component
  */
 declare const FirstVisitHint: ({ onDismiss, position }: FirstVisitHintProps) => ComponentChildren;

package/dist/toolbar/components/pinned-tooltip-card.d.ts

@@ -1,4 +1,3 @@
-/** @jsxImportSource preact */
 import type { ComponentChildren } from "preact";
 import type { PinnedTooltip } from "../context/index.d.ts";
 interface PinnedTooltipCardProps {

package/dist/toolbar/components/toolbar-bar.d.ts

@@ -1,4 +1,3 @@
-/** @jsxImportSource preact */
 import type { ComponentChildren } from "preact";
 interface ToolbarBarProps {
     /**

package/dist/toolbar/components/toolbar-container.d.ts

@@ -5,7 +5,7 @@ interface ToolbarContainerProps {
     /**
      * Active app ID
      */
-    activeAppId: string | null;
+    activeAppId: string | undefined;
     /**
      * Initial apps
      */

package/dist/toolbar/components/vite-overlay-button.d.ts

@@ -1,11 +1,10 @@
-/** @jsxImportSource preact */
 import type { ComponentChildren } from "preact";
 /**
- * Shows a red error button in the toolbar when @visulima/vite-overlay errors exist.
+ * Shows a red error button in the toolbar when `@visulima/vite-overlay` errors exist.
  * Clicking toggles the vite-overlay panel visibility.
  *
  * Only rendered when:
- * - @visulima/vite-overlay is installed and active (window.ErrorOverlay is defined)
+ * - `@visulima/vite-overlay` is installed and active (window.ErrorOverlay is defined)
  * - At least one error is present in the history
  *
  * Renders with its own left separator so it stays visually grouped on the

package/dist/toolbar/context/index.d.ts

@@ -1,2 +1,2 @@
-export { ToolbarContext, useToolbarContext } from "./toolbar-context.d.ts";
 export type { PinnedTooltip, ToolbarContextState } from "./toolbar-context.d.ts";
+export { ToolbarContext, useToolbarContext } from "./toolbar-context.d.ts";

package/dist/toolbar/context/toolbar-context.d.ts

@@ -1,3 +1,4 @@
+/** @jsxImportSource preact */
 import { createContext } from "preact";
 import type { DevToolbarAppState, ToolbarPlacement } from "../../types/index.d.ts";
 /**
@@ -14,93 +15,93 @@ export interface PinnedTooltip {
     initialY: number;
 }
 /**
- * Toolbar context state
+ * Shared state and actions exposed by the ToolbarContext.
  */
 export interface ToolbarContextState {
+    /**
+     * Currently active app ID
+     */
+    activeAppId: string | undefined;
     /**
      * All registered apps
      */
     apps: DevToolbarAppState[];
     /**
-     * Currently active app ID
+     * Clears the notification badge for an app.
      */
-    activeAppId: string | null;
+    clearNotification: (appId: string) => void;
     /**
-     * Whether toolbar is visible
+     * Currently hovered app (has a tooltip component)
      */
-    isVisible: boolean;
+    hoveredApp: DevToolbarAppState | undefined;
     /**
-     * Toolbar placement on screen
+     * Viewport rect of the hovered app button (for tooltip positioning)
      */
-    placement: ToolbarPlacement;
+    hoveredAppRect: DOMRect | undefined;
     /**
      * Whether toolbar is being dragged
      */
     isDragging: boolean;
     /**
-     * Set toolbar visibility
-     */
-    setVisible: (visible: boolean) => void;
-    /**
-     * Set toolbar placement
+     * Whether toolbar is visible
      */
-    setPlacement: (placement: ToolbarPlacement) => void;
+    isVisible: boolean;
     /**
-     * Set dragging state
+     * Currently pinned tooltip cards
      */
-    setDragging: (dragging: boolean) => void;
+    pinnedTooltips: PinnedTooltip[];
     /**
-     * Register an app
+     * Pin a tooltip at the given viewport position.
+     * Multiple pins from the same app are allowed (each gets a unique id).
      */
-    registerApp: (app: DevToolbarAppState) => void;
+    pinTooltip: (app: DevToolbarAppState, x: number, y: number) => void;
     /**
-     * Unregister an app
+     * Toolbar placement on screen
      */
-    unregisterApp: (appId: string) => void;
+    placement: ToolbarPlacement;
     /**
-     * Toggle an app
+     * Registers an app with the toolbar.
      */
-    toggleApp: (appId: string) => Promise<void>;
+    registerApp: (app: DevToolbarAppState) => void;
     /**
-     * Set app notification
+     * Sets the dragging state.
      */
-    setNotification: (appId: string, state: boolean, level?: "info" | "warning" | "error") => void;
+    setDragging: (dragging: boolean) => void;
     /**
-     * Clear app notification
+     * Sets or clears the hovered app. Pass undefined to start the leave debounce.
      */
-    clearNotification: (appId: string) => void;
+    setHoveredApp: (app: DevToolbarAppState | undefined, rect?: DOMRect | undefined) => void;
     /**
-     * Currently hovered app (has a tooltip component)
+     * Sets a notification for an app.
      */
-    hoveredApp: DevToolbarAppState | null;
+    setNotification: (appId: string, state: boolean, level?: "info" | "warning" | "error") => void;
     /**
-     * Viewport rect of the hovered app button (for tooltip positioning)
+     * Sets the toolbar placement.
      */
-    hoveredAppRect: DOMRect | null;
+    setPlacement: (placement: ToolbarPlacement) => void;
     /**
-     * Set/clear the hovered app. Pass null to start the leave debounce.
+     * Sets toolbar visibility.
      */
-    setHoveredApp: (app: DevToolbarAppState | null, rect?: DOMRect | null) => void;
+    setVisible: (visible: boolean) => void;
     /**
-     * Currently pinned tooltip cards
+     * Toggles an app's active state.
      */
-    pinnedTooltips: PinnedTooltip[];
+    toggleApp: (appId: string) => Promise<void>;
     /**
-     * Pin a tooltip at the given viewport position.
-     * Multiple pins from the same app are allowed (each gets a unique id).
+     * Removes a pinned tooltip by its instance id.
      */
-    pinTooltip: (app: DevToolbarAppState, x: number, y: number) => void;
+    unpinTooltip: (id: string) => void;
     /**
-     * Remove a pinned tooltip by its instance id.
+     * Unregisters an app.
      */
-    unpinTooltip: (id: string) => void;
+    unregisterApp: (appId: string) => void;
 }
 /**
- * Toolbar context
+ * Preact context object that exposes the toolbar's shared state to all child components.
  */
-export declare const ToolbarContext: ReturnType<typeof createContext<ToolbarContextState | null>>;
+export declare const ToolbarContext: ReturnType<typeof createContext<ToolbarContextState | undefined>>;
 /**
- * Hook to access toolbar context
- * @throws Error if used outside ToolbarContext provider
+ * Accesses the toolbar context, throwing if used outside a provider.
+ * @throws Error if used outside ToolbarContext provider.
  */
 export declare const useToolbarContext: () => ToolbarContextState;

package/dist/toolbar/global-api.d.ts

@@ -1,13 +1,14 @@
 import type { VisulimaDevTools } from "../types/global-api.d.ts";
 import type { DevToolbarApp } from "../types/index.d.ts";
 /**
- * Global DevTools API implementation.
+ * Creates the global DevTools API implementation.
  */
 export declare const createGlobalAPI: (appManager: {
     clearNotification: (id: string) => void;
     getActiveApp: () => DevToolbarApp | undefined;
     getApps: () => DevToolbarApp[];
     registerApp: (app: DevToolbarApp) => void;
+    setAppActive: (id: string, active: boolean) => void;
     setNotification: (id: string, state: boolean, level?: "info" | "warning" | "error") => void;
     toggleApp: (id: string) => Promise<boolean>;
     unregisterApp: (id: string) => void;
@@ -17,7 +18,7 @@ export declare const createGlobalAPI: (appManager: {
     toggle: () => void;
 }) => VisulimaDevTools;
 /**
- * Setup global API on window object
- * @param api API instance
+ * Mounts the global API on the window object so it can be accessed from outside the toolbar.
+ * @param api API instance to expose globally.
  */
 export declare const setupGlobalAPI: (api: VisulimaDevTools) => void;

package/dist/toolbar/helpers.d.ts

@@ -1,6 +1,8 @@
 import type { ServerHelpers } from "../types/app.d.ts";
 /**
- * Create server helpers for apps
- * @returns Server helpers instance
+ * Creates server helpers that proxy RPC calls for use within app init().
+ * @returns Server helpers instance.
  */
-export declare const createServerHelpers: () => ServerHelpers;
+declare const createServerHelpers: () => ServerHelpers;
+export { createServerHelpers };
+export default createServerHelpers;

package/dist/toolbar/hooks/index.d.ts

@@ -1,10 +1,10 @@
 export { useApps } from "./use-apps.d.ts";
-export { useFrameState } from "./use-frame-state.d.ts";
 export type { DevToolsFrameState, UseFrameStateReturn } from "./use-frame-state.d.ts";
-export { usePanelVisible } from "./use-panel-visible.d.ts";
+export { useFrameState } from "./use-frame-state.d.ts";
 export type { UsePanelVisibleReturn } from "./use-panel-visible.d.ts";
-export { usePosition } from "./use-position.d.ts";
+export { usePanelVisible } from "./use-panel-visible.d.ts";
 export type { UsePositionReturn } from "./use-position.d.ts";
-export { useTheme } from "./use-theme.d.ts";
+export { usePosition } from "./use-position.d.ts";
 export type { Theme, UseThemeReturn } from "./use-theme.d.ts";
+export { useTheme } from "./use-theme.d.ts";
 export { useToolbar } from "./use-toolbar.d.ts";

package/dist/toolbar/hooks/use-apps.d.ts

@@ -1,9 +1,9 @@
 import type { DevToolbarAppState } from "../../types/index.d.ts";
 /**
- * Hook for app management - exposes context app methods directly
+ * Exposes app management methods from the toolbar context.
  */
-export declare const useApps: () => {
-    activeAppId: string | null;
+declare const useApps: () => {
+    activeAppId: string | undefined;
     apps: DevToolbarAppState[];
     clearNotification: (appId: string) => void;
     registerApp: (app: DevToolbarAppState) => void;
@@ -11,3 +11,5 @@ export declare const useApps: () => {
     toggleApp: (appId: string) => Promise<void>;
     unregisterApp: (appId: string) => void;
 };
+export { useApps };
+export default useApps;

package/dist/toolbar/hooks/use-frame-state.d.ts

@@ -1,17 +1,17 @@
 /**
  * Keyboard shortcut bindings
  */
-export interface KeyBindings {
-    /** Toggle toolbar panel open/closed */
-    toggle: string;
+interface KeyBindings {
     /** Close active app / panel */
     close: string;
+    /** Toggle toolbar panel open/closed */
+    toggle: string;
 }
-export declare const DEFAULT_KEYBINDINGS: KeyBindings;
+declare const DEFAULT_KEYBINDINGS: KeyBindings;
 /**
- * Frame state interface
+ * Persistent state for the devtools panel frame.
  */
-export interface DevToolsFrameState {
+interface DevToolsFrameState {
     /**
      * Close panel on outside click
      */
@@ -20,14 +20,14 @@ export interface DevToolsFrameState {
      * Panel height as viewport height percentage
      */
     height: number;
-    /**
-     * Whether DevTools panel is open in a Picture-in-Picture window
-     */
-    isPip: boolean;
     /**
      * Whether this is the first visit (used to show onboarding hint)
      */
     isFirstVisit: boolean;
+    /**
+     * Whether DevTools panel is open in a Picture-in-Picture window
+     */
+    isPip: boolean;
     /**
      * Keyboard shortcut bindings
      */
@@ -74,21 +74,27 @@ export interface DevToolsFrameState {
     width: number;
 }
 /**
- * Return type for useFrameState hook
+ * Default frame state - matches Vue DevTools exactly
+ */
+declare const DEFAULT_STATE: DevToolsFrameState;
+/**
+ * Return type for the useFrameState hook.
  */
-export interface UseFrameStateReturn {
+interface UseFrameStateReturn {
     /**
-     * Current frame state
+     * Current frame state.
      */
     state: DevToolsFrameState;
     /**
-     * Update state with partial values
+     * Updates state with partial values.
      */
     updateState: (value: Partial<DevToolsFrameState>) => void;
 }
 /**
- * Hook for frame state management.
+ * Manages the shared devtools frame state.
  * All callers share the same module-level state so position, open, and other
  * fields stay in sync regardless of how many times the hook is called.
  */
-export declare const useFrameState: () => UseFrameStateReturn;
+declare const useFrameState: () => UseFrameStateReturn;
+export type { DevToolsFrameState, KeyBindings, UseFrameStateReturn };
+export { DEFAULT_KEYBINDINGS, DEFAULT_STATE, useFrameState };

package/dist/toolbar/hooks/use-panel-visible.d.ts

@@ -1,21 +1,23 @@
 /**
- * Return type for usePanelVisible hook
+ * Return type for the usePanelVisible hook.
  */
-export interface UsePanelVisibleReturn {
+interface UsePanelVisibleReturn {
     /**
-     * Close panel
+     * Closes the panel.
      */
     closePanel: () => void;
     /**
-     * Whether panel is visible
+     * Whether the panel is currently visible.
      */
     panelVisible: boolean;
     /**
-     * Toggle panel visibility
+     * Toggles panel visibility, optionally forcing a specific state.
      */
     togglePanelVisible: (_?: unknown, newState?: boolean) => void;
 }
 /**
- * Hook for panel visibility management - converted from Vue DevTools usePanelVisible
+ * Manages panel visibility with keyboard shortcut support.
  */
-export declare const usePanelVisible: () => UsePanelVisibleReturn;
+declare const usePanelVisible: () => UsePanelVisibleReturn;
+export type { UsePanelVisibleReturn };
+export { usePanelVisible };

package/dist/toolbar/hooks/use-position.d.ts

@@ -1,8 +1,8 @@
 import type { RefObject } from "preact";
 /**
- * Return type for usePosition hook
+ * Return type for usePosition hook.
  */
-export interface UsePositionReturn {
+interface UsePositionReturn {
     anchorStyle: {
         left: string;
         top: string;
@@ -12,11 +12,13 @@ export interface UsePositionReturn {
     isDragging: boolean;
     isHidden: boolean;
     isVertical: boolean;
-    onPointerDown: (e: PointerEvent) => void;
+    onPointerDown: (event: PointerEvent) => void;
     panelStyle: Record<string, string>;
 }
 /**
- * Hook for position management - converted from Vue DevTools usePosition
+ * Manages the draggable toolbar position, converted from Vue DevTools usePosition.
  * @see https://github.com/vuejs/devtools/blob/main/packages/overlay/src/composables/position.ts
  */
-export declare const usePosition: (panelEl: RefObject<HTMLElement>) => UsePositionReturn;
+declare const usePosition: (panelElement: RefObject<HTMLElement>) => UsePositionReturn;
+export type { UsePositionReturn };
+export { usePosition };

package/dist/toolbar/hooks/use-theme.d.ts

@@ -1,13 +1,15 @@
-export type Theme = "light" | "dark" | "system";
-export interface UseThemeReturn {
+type Theme = "light" | "dark" | "system";
+interface UseThemeReturn {
     resolvedTheme: "light" | "dark";
     setTheme: (newTheme: Theme) => void;
     theme: Theme;
     toggleTheme: () => void;
 }
 /**
- * Hook for managing theme (light/dark mode).
+ * Manages the shared light/dark/system theme preference.
  * All callers share the same module-level state so theme changes propagate
  * to every component (ToolbarContainer, SettingsApp, etc.) immediately.
  */
-export declare const useTheme: () => UseThemeReturn;
+declare const useTheme: () => UseThemeReturn;
+export type { Theme, UseThemeReturn };
+export { useTheme };

package/dist/toolbar/hooks/use-toolbar.d.ts

@@ -1,8 +1,8 @@
 import type { ToolbarPlacement } from "../../types/index.d.ts";
 /**
- * Hook for toolbar visibility and placement - exposes context methods directly
+ * Exposes toolbar visibility and placement controls from the toolbar context.
  */
-export declare const useToolbar: () => {
+declare const useToolbar: () => {
     hide: () => void;
     isDragging: boolean;
     isVisible: boolean;
@@ -12,3 +12,5 @@ export declare const useToolbar: () => {
     show: () => void;
     toggle: () => void;
 };
+export { useToolbar };
+export default useToolbar;