react-dockable-desktop 4.3.0 → 5.1.0

package/dist/index.d.cts

@@ -90,6 +90,8 @@ interface WindowManagerProps {
     taskbarVisibility?: TaskbarVisibility;
     /** Custom context menu renderer. Defaults to the built-in `DefaultContextMenuAdapter`. */
     contextMenuAdapter?: ContextMenuAdapter;
+    /** Enables the library's own transitions/animations (tab hover, dock preview, etc.). Never affects the consumer's own page. @default true */
+    animations?: boolean;
 }
 declare const WindowManager: React$1.FC<WindowManagerProps>;
 
@@ -108,6 +110,30 @@ interface BuiltInPanelEvents {
     'panel:restored': {
         id: string;
     };
+    /**
+     * Fires whenever something `saveLayout()` would capture changes — open/close/minimize/restore,
+     * and an `openPanel` `dedupeKey` redirect. Coalesces those into one signal for autosave-style
+     * consumers, so they don't need to subscribe to four separate events. Does **not** cover a
+     * `registerStateProvider` callback's return value changing on its own — that's a pull, there's
+     * no way to observe it changing without the panel separately notifying — nor resize/split-ratio
+     * drag/dock-rearrange, which have no hooks yet.
+     */
+    'layout:changed': Record<string, never>;
+    /**
+     * Fires from inside `saveLayout()` itself, only when that specific call excluded at least one
+     * panel (a panel whose current `props` — static or from a `registerStateProvider` — failed
+     * {@link isSerializable}). A passive `PanelInfo.serializable` flag alone isn't enough for this:
+     * nobody may be polling it at the exact moment a save happens and something silently drops out
+     * (e.g. a floating window rendering data from a live class instance). This is deliberately just
+     * a signal, not a UI opinion — decide for yourself whether that becomes a toast, a console
+     * warning, or nothing.
+     */
+    'layout:panels-excluded': {
+        panels: {
+            id: string;
+            component: string;
+        }[];
+    };
 }
 /** Per-panel definition supplied to WorkspaceClient constructor. */
 interface PanelDefinition {
@@ -142,6 +168,13 @@ interface WorkspaceClientConfig {
      * outer edge. Range 0.1–0.9. Default: 0.2.
      */
     defaultEdgeSplitRatio?: number;
+    /**
+     * Starting z-index for floating windows and the library's own chrome overlays
+     * (context menu, toolbar flyout, modal stack, toast, workspace edge zones),
+     * all of which shift together via `--rdd-z-base`. Set this above/below a host
+     * app's own modal z-index range to control stacking against it. Default: 1000.
+     */
+    zIndexBase?: number;
 }
 /**
  * WorkspaceClient is the central configuration and imperative API object for
@@ -181,7 +214,7 @@ declare class WorkspaceClient<TUserEvents extends Record<string, unknown> = Reco
     /** Serialised layout to restore on mount, or null to start with an empty canvas. */
     readonly initialState: string | null;
     /** Non-rendering configuration forwarded to the provider. */
-    readonly config: Pick<WorkspaceClientConfig, 'formatMessage' | 'predefinedMessages' | 'dir' | 'defaultSplitRatio' | 'defaultEdgeSplitRatio'>;
+    readonly config: Pick<WorkspaceClientConfig, 'formatMessage' | 'predefinedMessages' | 'dir' | 'defaultSplitRatio' | 'defaultEdgeSplitRatio' | 'zIndexBase'>;
     private _actions;
     private _initialized;
     /** Calls queued before _connect() fires — replayed in order on first connect. */
@@ -219,9 +252,54 @@ declare class WorkspaceClient<TUserEvents extends Record<string, unknown> = Reco
     isOpen(id: string): boolean;
     /** Returns the IDs of all currently open panels. */
     getOpenPanelIds(): string[];
+    /** Finds an already-open panel of the given component with a matching `dedupeKey` (set via
+     * `openPanel`'s `dedupeKey` option). Returns `null` if none is open. */
+    findPanelId(component: string, dedupeKey: string): string | null;
     saveLayout(): string;
     loadLayout(json: string): boolean;
     setDirection(dir: 'ltr' | 'rtl'): void;
+    /** Updates the split-size fractions at the given grid path. */
+    updateSplitSizes(path: number[], sizes: number[]): void;
+    /** Updates position/size/anchor of a floating panel. */
+    updateFloatingPosition(id: string, updates: Partial<Pick<FloatingWindow, 'x' | 'y' | 'width' | 'height' | 'anchor'>>): void;
+    /** @internal Drives the drag-in-progress visual state; normally only the library's own drag UI calls this. */
+    setDraggedPanelId(id: string | null): void;
+    /** Docks a panel into an existing leaf group at the given drop position. */
+    dockPanelToGroup(id: string, targetLeafId: string, position: DropPosition): void;
+    /** Reorders a panel's tab within its leaf group. */
+    movePanelOrder(panelId: string, targetLeafId: string, targetIndex: number): void;
+    /** Closes an entire leaf group (all of its tabs) at once. */
+    closeLeafGroup(leafId: string): void;
+    /** Registers a guard that can veto closing the given panel. */
+    registerCloseGuard(id: string, guard: () => boolean | Promise<boolean>): void;
+    /** Removes a previously registered close guard. */
+    unregisterCloseGuard(id: string): void;
+    /** Registers a callback reporting a panel's current restorable state, pulled fresh on every
+     * `saveLayout()` call — see {@link BuiltInPanelEvents}'s `'layout:panels-excluded'` doc and
+     * `FormContainerContract.registerStateProvider`. */
+    registerStateProvider(id: string, provider: () => unknown): void;
+    /** Removes a previously registered state provider. */
+    unregisterStateProvider(id: string): void;
+    /** Sets/clears a panel's dirty (unsaved changes) flag. */
+    setPanelDirty(id: string, dirty: boolean, options?: DirtyStateOptions): void;
+    /** Updates a panel's displayed title. */
+    updatePanelTitle(id: string, title: string | ContextMenuPredefinedMessage): void;
+    /**
+     * Requests that a panel close, honoring its dirty flag and any registered close guard.
+     * Resolves once the close (or user cancellation) has been resolved.
+     *
+     * @remarks If called before the provider mounts, the request is queued and this
+     * returns an already-resolved promise immediately — the caller can't observe the
+     * eventual outcome of a queued call, only that the request was accepted.
+     */
+    requestClosePanel(id: string, options?: {
+        force?: boolean;
+        onConfirm?: (opts?: DirtyStateOptions) => Promise<boolean>;
+    }): Promise<void>;
+    /** Docks a panel to one of the workspace's outer edges. */
+    dockPanelToWorkspaceEdge(id: string, position: SplitDirection): void;
+    /** Shows a context menu using the app's configured ContextMenuAdapter. */
+    showContextMenu(options: ShowContextMenuOptions): void;
     publish<K extends keyof (TUserEvents & BuiltInPanelEvents)>(event: K, data: (TUserEvents & BuiltInPanelEvents)[K]): void;
     subscribe<K extends keyof (TUserEvents & BuiltInPanelEvents)>(event: K, callback: (data: (TUserEvents & BuiltInPanelEvents)[K]) => void): () => void;
     /** Subscribe to panel open events. Fires only for newly created panels. */
@@ -232,6 +310,16 @@ declare class WorkspaceClient<TUserEvents extends Record<string, unknown> = Reco
     onPanelMinimize(callback: (id: string) => void): () => void;
     /** Subscribe to panel restore events. */
     onPanelRestore(callback: (id: string) => void): () => void;
+    /** Subscribe to the coalesced layout-change signal — see {@link BuiltInPanelEvents}'s
+     * `'layout:changed'` doc for exactly what it covers (and doesn't). */
+    onLayoutChanged(callback: () => void): () => void;
+    /** Subscribe to notification that a `saveLayout()` call excluded one or more panels because
+     * their current props weren't serializable — see {@link BuiltInPanelEvents}'s
+     * `'layout:panels-excluded'` doc. */
+    onPanelsExcluded(callback: (panels: {
+        id: string;
+        component: string;
+    }[]) => void): () => void;
 }
 
 /**
@@ -489,6 +577,51 @@ interface PanelInfo {
     dirty?: boolean;
     /** Custom options applied to the automatic unsaved changes modal. */
     dirtyOptions?: DirtyStateOptions;
+    /** Custom per-instance data passed via `openPanel(id, component, { props })`. Unconstrained —
+     *  any value is accepted, but only a value that passes {@link isSerializable} is actually
+     *  included in {@link WindowActions.saveLayout}'s output. See {@link PanelInfo.serializable}. */
+    props?: Record<string, unknown>;
+    /** Whether this panel's current `props` can round-trip through `saveLayout()`/`loadLayout()`.
+     *  Computed automatically — `true` when no `props` were passed, or when they were and passed
+     *  {@link isSerializable}. A panel with `serializable: false` still renders and works normally;
+     *  it's simply excluded from the next `saveLayout()` call (and pruned from `gridRoot`/
+     *  `floating`/`minimized` in that saved snapshot) rather than corrupting or throwing. */
+    serializable: boolean;
+    /** Optional dedup key. If another open panel of the same `component` already has this exact
+     *  key, `openPanel` focuses that existing panel instead of creating a new one — see
+     *  {@link WindowActions.openPanel}'s `dedupeKey` option and {@link WindowActions.findPanelId}. */
+    dedupeKey?: string;
+}
+/**
+ * Options accepted by {@link WindowActions.openPanel}.
+ */
+interface OpenPanelOptions<P extends object = Record<string, unknown>> {
+    /** Override the panel tab/window title. Accepts a plain string or an i18n message descriptor. */
+    title?: string | ContextMenuPredefinedMessage;
+    /** Initial placement: `'floating'`, `'docked'` (default when a grid exists), or `'tabbed'`. */
+    initialTarget?: 'floating' | 'docked' | 'tabbed';
+    /** Pin the new floating window to a workspace corner on creation. Has no effect when
+     *  `initialTarget` is `'docked'` or `'tabbed'`. */
+    anchor?: FloatAnchor | null;
+    /** Set `state.activePanelId` to this panel. @default true */
+    focus?: boolean;
+    /**
+     * Custom per-instance data spread onto the panel component alongside `panelId`, matching
+     * `openModal`/`openLeftPanel`/`openRightPanel`'s already-unconstrained `props` argument — no
+     * type restriction here either. Whether a specific value round-trips through `saveLayout()` is
+     * a runtime fact, not a type-level guarantee: see {@link PanelInfo.serializable} and the
+     * `'layout:panels-excluded'` event.
+     */
+    props?: P;
+    /**
+     * If set, and another currently-open panel of the same `component` already has this exact
+     * `dedupeKey`, that existing panel is focused instead of opening a new one — the `id`/`props`
+     * passed to *this* call are ignored in that case, the same way re-opening an already-open exact
+     * `id` already focuses it instead of duplicating it. Use this when multiple call sites might
+     * not agree on the same literal `id` for what is semantically the same entity (e.g. "the panel
+     * for the document at this path"). See also {@link WindowActions.findPanelId}.
+     */
+    dedupeKey?: string;
 }
 /**
  * Global window manager state tree representing grid nodes, windows, and panels.
@@ -547,6 +680,8 @@ interface WindowActions {
      * @param options.initialTarget - Initial placement: `'floating'`, `'docked'` (default when a grid exists), or `'tabbed'`.
      * @param options.anchor - Pin the new floating window to a workspace corner on creation. Has no effect when `initialTarget` is `'docked'` or `'tabbed'`.
      * @param options.focus - Set `state.activePanelId` to this panel. @default true
+     * @param options.props - Custom per-instance data spread onto the component alongside `panelId`. Unconstrained, like `openModal`/`openLeftPanel`/`openRightPanel`'s `props` — see {@link PanelInfo.serializable} for what determines whether it survives `saveLayout()`.
+     * @param options.dedupeKey - If another open panel of the same `component` already has this key, that panel is focused instead of opening a new one.
      * @example
      * ```ts
      * // Open floating and pin to the top-right corner:
@@ -554,14 +689,15 @@ interface WindowActions {
      *
      * // Open in the background without stealing focus:
      * actions.openPanel('prefetch', 'report', { focus: false });
+     *
+     * // Open with per-instance data, deduped by document path:
+     * actions.openPanel(crypto.randomUUID(), 'document', {
+     *   props: { path: '/notes/todo.md' },
+     *   dedupeKey: '/notes/todo.md',
+     * });
      * ```
      */
-    openPanel: (id: string, component: string, options?: {
-        title?: string | ContextMenuPredefinedMessage;
-        initialTarget?: 'floating' | 'docked' | 'tabbed';
-        anchor?: FloatAnchor | null;
-        focus?: boolean;
-    }) => void;
+    openPanel: <P extends object = Record<string, unknown>>(id: string, component: string, options?: OpenPanelOptions<P>) => void;
     /**
      * Closes a panel immediately, bypassing dirty-state close guards.
      * For guarded close, use {@link requestClosePanel}.
@@ -646,6 +782,15 @@ interface WindowActions {
      * @returns Array of panel instance IDs.
      */
     getOpenPanelIds: () => string[];
+    /**
+     * Finds the ID of an already-open panel of the given `component` with a matching `dedupeKey`
+     * (set via `openPanel`'s `dedupeKey` option). Uses a synchronous `stateRef` read — safe to
+     * call outside of render.
+     * @param component - Component key registered in the panel catalog.
+     * @param dedupeKey - The dedup key to search for.
+     * @returns The matching panel's ID, or `null` if none is open.
+     */
+    findPanelId: (component: string, dedupeKey: string) => string | null;
     /**
      * Serializes the entire workspace state to a JSON string.
      * Includes grid layout, floating window positions, minimized panels, and panel metadata.
@@ -712,6 +857,23 @@ interface WindowActions {
      * @param id - Panel instance ID.
      */
     unregisterCloseGuard: (id: string) => void;
+    /**
+     * Registers a callback reporting a docked/floating panel's *current* restorable state, pulled
+     * fresh every `saveLayout()` call — for panels whose props alone can't capture state they
+     * accumulate after opening (scroll position, an in-progress edit, a view-mode toggle). A panel
+     * that registers nothing keeps its static open-time `props` (or none). The returned value goes
+     * through the same {@link isSerializable} check as static props, re-evaluated on every save —
+     * a provider-backed panel's serializability can flip over its lifetime.
+     * @param id - Panel instance ID.
+     * @param provider - Called synchronously at each `saveLayout()`; return the current state (or
+     * `undefined` to fall back to the static `props` this panel was opened with).
+     */
+    registerStateProvider: (id: string, provider: () => unknown) => void;
+    /**
+     * Removes a previously registered state provider.
+     * @param id - Panel instance ID.
+     */
+    unregisterStateProvider: (id: string) => void;
     /**
      * Marks a panel as dirty (has unsaved changes). Dirty panels show a visual indicator
      * and the built-in close guard prompts the user before closing.
@@ -782,6 +944,19 @@ declare const useStyleClasses: () => StyleClasses;
  * ```
  */
 declare const useRegistry: () => PanelRegistryClass;
+/** The on-disk shape produced by `saveLayout()` and accepted by `loadLayout()`/`initialState`. */
+interface SerializedLayout {
+    /** Schema version — absent on layouts saved before this field was introduced (treated as 0). */
+    version?: number;
+    gridRoot: LayoutNode;
+    floating: FloatingWindow[];
+    minimized: {
+        id: string;
+        title: string | ContextMenuPredefinedMessage;
+        component: string;
+    }[];
+    panels: Record<string, PanelInfo>;
+}
 /**
  * Props for `<DockableDesktopProvider>` and `<WindowManagerProvider>`.
  * Also exported as `DockableDesktopProviderProps` for consumers who use
@@ -814,6 +989,13 @@ interface WindowManagerProviderProps {
     windowClass?: string;
     /** CSS class applied to the inner content area of floating panel windows. */
     windowBodyClass?: string;
+    /**
+     * Starting z-index for floating windows and the library's own chrome overlays
+     * (context menu, toolbar flyout, modal stack, toast, workspace edge zones),
+     * all of which shift together via `--rdd-z-base`. Set this above/below a host
+     * app's own modal z-index range to control stacking against it. @default 1000
+     */
+    zIndexBase?: number;
 }
 declare const WindowManagerProvider: React$1.FC<WindowManagerProviderProps>;
 declare function useWindowManagerState(): WindowState;
@@ -994,6 +1176,26 @@ interface DockableDesktopProviderProps extends WindowManagerProviderProps {
  */
 declare const DockableDesktopProvider: React$1.FC<DockableDesktopProviderProps>;
 
+/**
+ * Recursively checks whether a value can round-trip through `JSON.stringify`/`JSON.parse`
+ * without silently losing information.
+ *
+ * Deliberately **not** a `JSON.stringify` try/catch — that call doesn't throw for the actual
+ * failure case this guards against: a function-valued property is simply dropped by
+ * `JSON.stringify`, not rejected. This walks the value tree instead, returning `false` as soon as
+ * it finds a function, symbol, `undefined`, React element, or any non-plain object (a class
+ * instance, `Map`, `Set`, `RegExp`, etc.).
+ *
+ * `Date` is treated as an explicit exception — serializable-enough, matching `JSON.stringify`'s
+ * own behavior — even though it doesn't round-trip back to a `Date` instance on parse. That's a
+ * smaller, more tolerable gotcha than a silently-vanishing function, so it's documented rather
+ * than treated as a disqualifying case.
+ *
+ * Used to decide whether a docked/floating panel's `props` can be included in
+ * `WorkspaceClient.saveLayout()`'s output — see {@link PanelInfo.serializable}.
+ */
+declare function isSerializable(value: unknown): boolean;
+
 /**
  * Options used when requesting to close a container.
  */
@@ -1014,6 +1216,17 @@ interface FormContainerContract {
     setDirty: (dirty: boolean, options?: DirtyStateOptions) => void;
     /** Register a custom close guard handler. Returning false or a promise resolving to false blocks closing. */
     onCloseRequested: (handler: () => boolean | Promise<boolean>) => (() => void);
+    /**
+     * Registers a callback reporting this panel's *current* restorable state, pulled fresh by
+     * `WorkspaceClient.saveLayout()` every time it's called — for panels whose static open-time
+     * props can't capture state accumulated after opening (scroll position, an in-progress edit, a
+     * view-mode toggle). Only meaningful for docked/floating panels — left/right side panels and
+     * modals already have a complete answer to this via `openLeftPanel`/`openRightPanel`/
+     * `openModal`'s own `props` argument plus `updateInstance`, so this is `undefined` there.
+     * The returned value must be synchronous — `saveLayout()` itself never returns a `Promise`.
+     * Return `undefined` to fall back to the static `props` this panel was opened with.
+     */
+    registerStateProvider?: (getState: () => unknown) => (() => void);
     /** Change the display title of the containing tab or window dynamically. */
     setTitle: (title: string | {
         id: string;
@@ -1073,6 +1286,17 @@ declare const FormContainerProvider: Provider<FormContainerContract>;
  * (resize, close, minimize, restore, activate, deactivate, container-type changes).
  */
 declare const useFormContainer: () => FormContainerContract;
+/**
+ * Reactive alternative to calling {@link FormContainerContract.getDimensions} yourself.
+ * Returns the panel's current `{ width, height }`, or `null` before it has been laid
+ * out, and re-renders whenever the panel's rendered box changes — including resizes
+ * caused by the workspace itself (a grid split being dragged, docking, floating, or
+ * tab activation), not just resizes of an element the panel created.
+ */
+declare const usePanelSize: () => {
+    width: number;
+    height: number;
+} | null;
 
 /** Unique string identifier for panel/modal instances. */
 type PanelInstanceId = string;
@@ -1280,7 +1504,7 @@ interface SidebarProps {
     /** Which side the activity bar and drawer appear on. Default: 'right' */
     position?: 'left' | 'right';
     tabs: SidebarTab[];
-    /** Initial drawer width in pixels. Default: 220 */
+    /** Initial drawer width in pixels. Default: 280 */
     defaultWidth?: number;
     /** Minimum drawer width in pixels during drag-resize. Default: 150 */
     minWidth?: number;
@@ -1302,8 +1526,6 @@ interface SidebarProps {
     onStripVisibilityChange?: (visible: boolean) => void;
     /** Main workspace content rendered alongside the sidebar. */
     children?: React$1.ReactNode;
-    /** @deprecated Use defaultWidth (number, pixels) instead. */
-    drawerWidth?: string;
 }
 /**
  * Imperative handle exposed by `<Sidebar ref={...}>`.
@@ -1344,14 +1566,14 @@ declare const Sidebar: React$1.ForwardRefExoticComponent<SidebarProps & React$1.
  * Returns sidebar control functions from anywhere inside a `<Sidebar>` tree,
  * including floating panels rendered via `{children}`.
  *
- * Returns a no-op object with a console warning when called outside a Sidebar.
+ * @throws Error if used outside of a {@link Sidebar}.
  */
 declare function useSidebar(): SidebarContextValue;
 /**
  * Returns tab-specific control functions for components rendered inside a
  * sidebar tab's `renderContent` tree.
  *
- * Returns a no-op object with a console warning when called outside tab content.
+ * @throws Error if used outside of a {@link Sidebar} tab's `renderContent` tree.
  */
 declare function useSidebarTab(): SidebarTabContextValue;
 
@@ -1380,7 +1602,7 @@ declare const ToolbarProvider: React$1.FC<{
  * Returns toolbar state and control functions from anywhere inside
  * a `<DockableDesktopProvider>` tree.
  *
- * Returns a no-op object with a console warning when called outside the provider.
+ * @throws Error if used outside of a {@link DockableDesktopProvider}.
  */
 declare function useToolbar(): ToolbarContextValue;
 
@@ -1417,8 +1639,8 @@ interface ToolbarRadioItem {
 /**
  * An independent on/off toggle modifier (e.g. snap-to-grid).
  *
- * Supports both uncontrolled mode (omit `active` — state lives in
- * ToolbarContext, keyed by `id`) and controlled mode (provide `active` —
+ * Supports both uncontrolled mode (omit `rdd-active` — state lives in
+ * ToolbarContext, keyed by `id`) and controlled mode (provide `rdd-active` —
  * the caller is the single source of truth and must update the prop in
  * response to `onToggle`). Controlled mode is what lets independent
  * instances of the same panel type report independent active state
@@ -1929,8 +2151,9 @@ declare const PanelContributionProvider: React$1.FC<{
  * `useMemo`/`useCallback`) to avoid republishing on every unrelated re-render.
  *
  * Contributions are only ever surfaced while this panel is `state.activePanelId` —
- * see `useActivePanelContribution()`. No-op outside a `PanelContributionProvider` tree.
+ * see `useActivePanelContribution()`.
  *
+ * @throws Error if used outside of a {@link PanelContributionProvider}.
  * @example
  * function MapPanel() {
  *   const [controller, setController] = useState<'pan' | 'draw' | 'measure'>('pan');
@@ -1950,6 +2173,8 @@ declare function usePanelContribution(contribution: PanelContribution): void;
  * via `usePanelContribution()`, or `null` if no panel is active or the active panel
  * hasn't contributed anything. Intended for the app shell to merge into its own
  * `<Toolbar items={...}>` / `<Sidebar tabs={...}>` calls.
+ *
+ * @throws Error if used outside of a {@link PanelContributionProvider}.
  */
 declare function useActivePanelContribution(): PanelContribution | null;
 /**
@@ -1975,4 +2200,83 @@ declare function useMergedToolbarItems(staticItems: ToolbarItem$1[]): ToolbarIte
  */
 declare function useMergedSidebarTabs(staticTabs: SidebarTab[], fallbackIcon?: React$1.ReactNode): SidebarTab[];
 
-export { type BuiltInPanelEvents, type ButtonVariant, type CloseOptions, ConfirmationForm, type ConfirmationFormProps, ContextMenu, type ContextMenuAdapter, type ContextMenuCheckbox, type ContextMenuHandle, type ContextMenuItem, type ContextMenuLabel, type ContextMenuPredefinedMessage, type ContextMenuProps, ContextMenuProvider, type ContextMenuSeparator, type ContextMenuSimpleItem, type ContextMenuSubMenu, DefaultContextMenuAdapter, DockableDesktopProvider, type DockableDesktopProviderProps, type DropPosition, type DropTarget, type FloatAnchor, type FloatingWindow, FormContainerContext, type FormContainerContract, FormContainerProvider, type LayoutGridNode, type LayoutLeafNode, type LayoutNode, LeftPanelRenderer, type ManagedWindowConfig, type MenuItemAction, type MessageFormatter, type ModalOptions, ModalStackRenderer, type PanelActions, type PanelContribution, PanelContributionProvider, type PanelDefinition, PanelFloatingWindow, type PanelFloatingWindowManagerHandle, type PanelFloatingWindowProps, type PanelInfo, type PanelInstance, type PanelInstanceId, PanelOverlayRoot, type PanelOverlayRootProps, PanelProvider, PanelRegistry, PanelRegistryClass, type PanelRegistryEntry, type PanelSidebarSection, type PanelState, type PanelTitle, PanelToolbar, ToolbarItem as PanelToolbarItem, type PanelToolbarProps, ToolbarSeparator as PanelToolbarSeparator, type PredefinedMessageKey, type ResolvedToastOptions, RightPanelRenderer, type SearchResult, type ShowContextMenuOptions, type SidePanelOptions, SidePanelRenderer, type SidePanelRendererProps, Sidebar, type SidebarContextValue, type SidebarHandle, type SidebarProps, type SidebarTab, type SidebarTabContextValue, type SplitDirection, type SplitOrientation, type StyleClasses, type TaskbarVisibility, type ToastAdapter, ToastContainer, type ToastContainerProps, type ToastFunction, type ToastOptions, type ToastPosition, type ToastPromiseMessages, type ToastType, Toolbar, type ToolbarActionItem, ToolbarButton, type ToolbarButtonProps, ToolbarCenter, type ToolbarContextValue, type ToolbarGroupEntry, type ToolbarGroupItem, type ToolbarGroupSubItem, type ToolbarHandle, type ToolbarItem$1 as ToolbarItem, type ToolbarPosition, type ToolbarProps, ToolbarProvider, type ToolbarRadioItem, ToolbarSearchInput, type ToolbarSearchInputProps, type ToolbarSeparator$1 as ToolbarSeparator, ToolbarSpacer, ToolbarToggle, type ToolbarToggleItem, type ToolbarToggleProps, type ToolbarVariant, type UsePanelFloatingWindowReturn, type WindowActions, WindowManager, type WindowManagerProps, WindowManagerProvider, type WindowManagerProviderProps, type WindowState, WorkspaceClient, type WorkspaceClientConfig, defaultPredefinedMessages, formatLabel, sidebarSectionToTab, toast, useActivePanelContribution, useFormContainer, useFormatMessage, useMergedSidebarTabs, useMergedToolbarItems, usePanelActions, usePanelContext, usePanelContextMenu, usePanelContribution, usePanelFloatingWindow, usePanelFloatingWindowManager, usePanelId, usePanelState, usePredefinedMessages, useRegistry, useShowContextMenu, useSidebar, useSidebarTab, useStyleClasses, useToolbar, useWindowManagerActions, useWindowManagerState };
+/**
+ * Shared pointer-drag-resize primitives.
+ *
+ * Extracted from four previously-independent implementations (the workspace grid
+ * split resizer, the sidebar drawer resizer, and two floating-window resize-handle
+ * implementations) that had quietly drifted apart in exactly the kind of detail
+ * (an inline-style property present in one and missing in the other) that once
+ * caused a real, user-visible bug. This file is the single place that mechanic now
+ * lives, so it can't drift again.
+ */
+interface PointerDragConfig<TStart> {
+    /** The element to capture the pointer on — normally the handle the user grabbed. */
+    element: HTMLElement;
+    pointerId: number;
+    /** The pointerdown event's clientX/clientY, used as the delta origin. */
+    startClientX: number;
+    startClientY: number;
+    /** Snapshot whatever state the caller needs at drag start (sizes, positions, ...). */
+    captureStart: () => TStart;
+    /** Called on every pointermove with the delta from the drag's start position. */
+    onMove: (dx: number, dy: number, start: TStart) => void;
+    /** Called once when the drag ends (pointerup or pointercancel). */
+    onEnd?: (start: TStart) => void;
+    /** Classes toggled on the given elements for the duration of the drag. */
+    activeClasses?: Array<{
+        el: HTMLElement;
+        classes: string[];
+    }>;
+}
+/**
+ * Starts a pointer-capture-based drag: captures the pointer on `element`, tracks
+ * movement via listeners scoped to that element's own lifetime (not `window`), and
+ * cleans up automatically on release or cancel.
+ */
+declare function startPointerDrag<TStart>(config: PointerDragConfig<TStart>): void;
+type ResizeDir = 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w' | 'nw';
+interface ResizeRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+interface ResizeConstraints {
+    minW: number;
+    minH: number;
+    /** Upper bound on width — only applies to eastward growth (dir includes 'e'). */
+    maxW?: number;
+    /** Upper bound on height — only applies to southward growth (dir includes 's'). */
+    maxH?: number;
+    /** Lower bound on the resulting x — only applies to westward growth (dir includes 'w'). */
+    minX?: number;
+    /** Lower bound on the resulting y — only applies to northward growth (dir includes 'n'). */
+    minY?: number;
+}
+/**
+ * Pure function computing the new rect for an 8-directional resize handle drag.
+ *
+ * `maxW`/`maxH` and `minX`/`minY` are independent, direction-scoped constraints
+ * rather than one "container bound" — a resize toward the fixed edge (e/s) is
+ * naturally bounded by a maximum dimension, while a resize toward the moving edge
+ * (w/n) is naturally bounded by a minimum position, and the two calling sites this
+ * was extracted from need different subsets of these (see WindowManager.tsx's
+ * `startResize`, which omits all four and lets a window grow unbounded and be
+ * dragged fully off-screen, vs. PanelOverlay.tsx's `handleResizePointerDown`, which
+ * supplies all four to keep windows within their container).
+ */
+declare function computeResizedRect(dir: ResizeDir, dx: number, dy: number, start: ResizeRect, constraints: ResizeConstraints): ResizeRect;
+
+/**
+ * Reactively reads the workspace's current `data-color-scheme` attribute
+ * (set on `document.documentElement` by `<WindowManager />`), returning
+ * `'dark'` or `'light'` and re-rendering whenever it changes.
+ *
+ * Useful for panel content that needs to react to the same scheme the
+ * workspace itself is using — e.g. swapping a map's tile layer or an
+ * embedded editor's theme to match.
+ */
+declare function useColorScheme(): 'dark' | 'light';
+
+export { type BuiltInPanelEvents, type ButtonVariant, type CloseOptions, ConfirmationForm, type ConfirmationFormProps, ContextMenu, type ContextMenuAdapter, type ContextMenuCheckbox, type ContextMenuHandle, type ContextMenuItem, type ContextMenuLabel, type ContextMenuPredefinedMessage, type ContextMenuProps, ContextMenuProvider, type ContextMenuSeparator, type ContextMenuSimpleItem, type ContextMenuSubMenu, DefaultContextMenuAdapter, DockableDesktopProvider, type DockableDesktopProviderProps, type DropPosition, type DropTarget, type FloatAnchor, type FloatingWindow, FormContainerContext, type FormContainerContract, FormContainerProvider, type LayoutGridNode, type LayoutLeafNode, type LayoutNode, LeftPanelRenderer, type ManagedWindowConfig, type MenuItemAction, type MessageFormatter, type ModalOptions, ModalStackRenderer, type OpenPanelOptions, type PanelActions, type PanelContribution, PanelContributionProvider, type PanelDefinition, PanelFloatingWindow, type PanelFloatingWindowManagerHandle, type PanelFloatingWindowProps, type PanelInfo, type PanelInstance, type PanelInstanceId, PanelOverlayRoot, type PanelOverlayRootProps, PanelProvider, PanelRegistry, PanelRegistryClass, type PanelRegistryEntry, type PanelSidebarSection, type PanelState, type PanelTitle, PanelToolbar, ToolbarItem as PanelToolbarItem, type PanelToolbarProps, ToolbarSeparator as PanelToolbarSeparator, type PointerDragConfig, type PredefinedMessageKey, type ResizeConstraints, type ResizeDir, type ResizeRect, type ResolvedToastOptions, RightPanelRenderer, type SearchResult, type SerializedLayout, type ShowContextMenuOptions, type SidePanelOptions, SidePanelRenderer, type SidePanelRendererProps, Sidebar, type SidebarContextValue, type SidebarHandle, type SidebarProps, type SidebarTab, type SidebarTabContextValue, type SplitDirection, type SplitOrientation, type StyleClasses, type TaskbarVisibility, type ToastAdapter, ToastContainer, type ToastContainerProps, type ToastFunction, type ToastOptions, type ToastPosition, type ToastPromiseMessages, type ToastType, Toolbar, type ToolbarActionItem, ToolbarButton, type ToolbarButtonProps, ToolbarCenter, type ToolbarContextValue, type ToolbarGroupEntry, type ToolbarGroupItem, type ToolbarGroupSubItem, type ToolbarHandle, type ToolbarItem$1 as ToolbarItem, type ToolbarPosition, type ToolbarProps, ToolbarProvider, type ToolbarRadioItem, ToolbarSearchInput, type ToolbarSearchInputProps, type ToolbarSeparator$1 as ToolbarSeparator, ToolbarSpacer, ToolbarToggle, type ToolbarToggleItem, type ToolbarToggleProps, type ToolbarVariant, type UsePanelFloatingWindowReturn, type WindowActions, WindowManager, type WindowManagerProps, WindowManagerProvider, type WindowManagerProviderProps, type WindowState, WorkspaceClient, type WorkspaceClientConfig, computeResizedRect, defaultPredefinedMessages, formatLabel, isSerializable, sidebarSectionToTab, startPointerDrag, toast, useActivePanelContribution, useColorScheme, useFormContainer, useFormatMessage, useMergedSidebarTabs, useMergedToolbarItems, usePanelActions, usePanelContext, usePanelContextMenu, usePanelContribution, usePanelFloatingWindow, usePanelFloatingWindowManager, usePanelId, usePanelSize, usePanelState, usePredefinedMessages, useRegistry, useShowContextMenu, useSidebar, useSidebarTab, useStyleClasses, useToolbar, useWindowManagerActions, useWindowManagerState };