dockview-core 7.0.4 → 8.1.0

package/dist/cjs/dockview/dockviewGroupPanelModel.d.ts

@@ -50,7 +50,7 @@ export interface DockviewGroupChangeEvent {
 /**
  * Payload for the group-level `onDidActivePanelChange`. Extends
  * {@link DockviewGroupChangeEvent} with the {@link DockviewOrigin} so it mirrors
- * the component-level `DockviewActivePanelChangeEvent` — both report whether the
+ * the component-level `DockviewActivePanelChangeEvent`. Both report whether the
  * change came from a user gesture or an API call.
  */
 export interface DockviewGroupActivePanelChangeEvent extends DockviewGroupChangeEvent {
@@ -96,6 +96,25 @@ export declare class DockviewWillDropEvent extends DockviewDidDropEvent {
 export interface IHeader {
     hidden: boolean;
     direction: DockviewHeaderDirection;
+    /** Register a predicate that keeps matching panels out of the overflow
+     *  dropdown (used by the PinnedTabs module). No-op default. */
+    setOverflowExclude(fn: (panelId: string) => boolean): void;
+    /** Register a predicate that forces matching panels into the overflow
+     *  dropdown regardless of horizontal fit (used by the MultiRowTabs module
+     *  for the surplus rows beyond `overflow.maxRows`). No-op default. */
+    setForcedOverflow(fn: (panelId: string) => boolean): void;
+    /** Re-evaluate the overflow dropdown now (e.g. after the exclusion set
+     *  changed). */
+    refreshOverflow(): void;
+    /** Enable/disable sticky-on-scroll for pinned tabs (PinnedTabs inline mode):
+     *  pinned tabs freeze to the left edge as the strip scrolls. No-op default. */
+    setPinnedSticky(enabled: boolean): void;
+    /** Register a resolver that clamps/redirects a header drop index (used by
+     *  the PinnedTabs module to enforce the pin boundary). Identity default. */
+    setDropIndexResolver(fn: (panelId: string, index: number) => number): void;
+    /** Mount (or clear, with `undefined`) a second tab row above the main strip
+     *  (PinnedTabs `separate-row` mode). The module owns the element. */
+    setPinnedRow(el: HTMLElement | undefined): void;
 }
 export type DockviewGroupPanelLocked = boolean | 'no-drop-target';
 export interface IDockviewGroupPanelModel extends IPanel {
@@ -115,6 +134,8 @@ export interface IDockviewGroupPanelModel extends IPanel {
     headerPosition: DockviewHeaderPosition;
     setActive(isActive: boolean): void;
     initialize(): void;
+    relayout(): void;
+    readonly tabsListElement: HTMLElement;
     isPanelActive: (panel: IDockviewPanel) => boolean;
     indexOf(panel: IDockviewPanel): number;
     openPanel(panel: IDockviewPanel, options?: {
@@ -164,7 +185,24 @@ export declare class DockviewGroupPanelModel extends CompositeDisposable impleme
     private _isGroupActive;
     private _locked;
     private _headerPosition;
+    private _headerDirection;
     private _location;
+    /**
+     * The header (`dv-tabs-and-actions-container`) extent along its occupied
+     * axis — `offsetHeight` for a top/bottom header, `offsetWidth` for a
+     * left/right one — which `contentDimensions` subtracts from the group box.
+     *
+     * This was read via `offset*` on *every* `layout()`. Because the read comes
+     * after the group's container styles were written, it forces a synchronous
+     * reflow, and with N groups a single window-resize frame flushed layout N
+     * times (measured: 24 forced reflows/frame at 24 groups, ~68% of resize
+     * cost). The extent only changes when the header's tabs change (add/remove/
+     * wrap), its axis flips, or it's hidden/shown — never during a plain
+     * resize — so we cache it and invalidate on exactly those signals (plus a
+     * `ResizeObserver` that also catches CSS/theme-driven height changes and
+     * display:none transitions). `undefined` means "dirty; measure on read".
+     */
+    private _cachedHeaderSize;
     private mostRecentlyUsed;
     private _overwriteRenderContainer;
     private _overwriteDropTargetContainer;
@@ -237,7 +275,7 @@ export declare class DockviewGroupPanelModel extends CompositeDisposable impleme
     get activePanel(): IDockviewPanel | undefined;
     /** DOM id of the content container (the group's tabpanel), referenced by each tab's `aria-controls`. */
     get contentContainerId(): string;
-    /** The group's content drop target — lets keyboard docking preview a drop here. */
+    /** The group's content drop target; lets keyboard docking preview a drop here. */
     get contentDropTarget(): Droptarget;
     get locked(): DockviewGroupPanelLocked;
     set locked(value: DockviewGroupPanelLocked);
@@ -247,6 +285,13 @@ export declare class DockviewGroupPanelModel extends CompositeDisposable impleme
     get isEmpty(): boolean;
     get hasWatermark(): boolean;
     get header(): IHeader;
+    /** The scrollable tab list element (`.dv-tabs-container`), exposed for the
+     *  multi-row wrap controller to measure rows / toggle the wrap class. */
+    get tabsListElement(): HTMLElement;
+    /** The panel whose tab owns `element` (the tab itself or a descendant of
+     *  it), or `undefined` when the target isn't a tab. The robust inverse of a
+     *  tab→panel lookup, with no positional/DOM-order assumptions. */
+    getPanelForTab(element: Element): IDockviewPanel | undefined;
     get isContentFocused(): boolean;
     get headerPosition(): DockviewHeaderPosition;
     set headerPosition(value: DockviewHeaderPosition);
@@ -342,6 +387,28 @@ export declare class DockviewGroupPanelModel extends CompositeDisposable impleme
     updateActions(element: HTMLElement | undefined): void;
     setActive(isGroupActive: boolean, force?: boolean): void;
     layout(width: number, height: number): void;
+    /**
+     * Re-run the group's layout with its current dimensions. Used to propagate a
+     * header-size change (e.g. a header that grew/shrank without the group box
+     * changing) down to the content + active panel.
+     */
+    relayout(): void;
+    /**
+     * The dimensions available to the content/panel: the group box minus the
+     * header along its axis. The header (`dv-tabs-and-actions-container`) is
+     * laid out top/bottom (subtract its height) or left/right (subtract its
+     * width); a hidden header has `display:none` so its `offset*` is 0 and
+     * nothing is subtracted.
+     */
+    /**
+     * Measure the header's extent along its occupied axis. This is the single
+     * forced-reflow read; it now runs only on a cache miss (first layout after
+     * a header change) and inside the header's ResizeObserver — not on every
+     * layout frame.
+     */
+    private measureHeaderSize;
+    private invalidateHeaderSize;
+    private contentDimensions;
     private _removePanel;
     private doRemovePanel;
     private doAddPanel;
@@ -351,6 +418,13 @@ export declare class DockviewGroupPanelModel extends CompositeDisposable impleme
     private updateMru;
     private updateContainer;
     canDisplayOverlay(event: DragEvent | PointerEvent, position: Position, target: DockviewGroupDropLocation): boolean;
+    /**
+     * Whether a content drop at `position` is allowed: the locked rules, the
+     * shift-to-not-drop gesture, the same-component shortcut, then the
+     * `canDisplayOverlay` veto. The single source of truth for the content drop
+     * target (`content.ts`) and the compass cell gating (`canDropOnGroup`).
+     */
+    canDisplayContentOverlay(event: DragEvent | PointerEvent, position: Position): boolean;
     private handleDropEvent;
     updateDragAndDropState(): void;
     dispose(): void;

package/dist/cjs/dockview/dockviewPanel.d.ts

@@ -18,6 +18,8 @@ export interface IDockviewPanel extends IDisposable, IPanel {
     readonly minimumHeight?: number;
     readonly maximumWidth?: number;
     readonly maximumHeight?: number;
+    readonly isPinned: boolean;
+    setPinned(pinned: boolean): void;
     updateParentGroup(group: DockviewGroupPanel, options?: {
         skipSetActive?: boolean;
     }): void;
@@ -38,12 +40,14 @@ export declare class DockviewPanel extends CompositeDisposable implements IDockv
     private _params?;
     private _title;
     private _renderer;
+    private _pinned;
     private _minimumWidth;
     private _minimumHeight;
     private _maximumWidth;
     private _maximumHeight;
     get params(): Parameters | undefined;
     get title(): string | undefined;
+    get isPinned(): boolean;
     get group(): DockviewGroupPanel;
     get renderer(): DockviewPanelRenderer;
     get minimumWidth(): number | undefined;
@@ -57,6 +61,14 @@ export declare class DockviewPanel extends CompositeDisposable implements IDockv
     focus(): void;
     toJSON(): GroupviewPanelState;
     setTitle(title: string): void;
+    /**
+     * Low-level pinned-state mutation. Sets the flag and fires the panel-api
+     * event. The public, module-gated entry point is
+     * `panel.api.setPinned` → `DockviewComponent.setPanelPinned`, which decides
+     * whether pinning is active before reaching here; this method itself does
+     * not gate, so the ordering module and serialization can drive it directly.
+     */
+    setPinned(pinned: boolean): void;
     setRenderer(renderer: DockviewPanelRenderer): void;
     update(event: PanelUpdateEvent): void;
     updateFromStateModel(state: GroupviewPanelState): void;

package/dist/cjs/dockview/dockviewShell.d.ts

@@ -10,31 +10,45 @@ export interface EdgeGroupOptions {
     collapsedSize?: number;
     collapsed?: boolean;
 }
+/**
+ * Options accepted by `api.addEdgeGroup`. Extends the shell's geometry options
+ * with per-group presentation flags the component (not the shell) owns.
+ */
+export interface AddEdgeGroupOptions extends EdgeGroupOptions {
+    /**
+     * Opt this edge group in/out of auto-hide (pinnable tool-window) behaviour,
+     * overriding the global `autoHideEdgeGroups` option. Requires the
+     * auto-hide module to have any effect. Leave unset to inherit the global.
+     */
+    autoHide?: boolean;
+    /**
+     * When true, this edge group tears itself down to zero footprint once
+     * emptied (instead of collapsing to a strip). This is the behaviour used
+     * by drag-revealed edges.
+     */
+    autoReveal?: boolean;
+}
+export interface SerializedEdgeGroup {
+    size: number;
+    visible: boolean;
+    collapsed?: boolean;
+    group?: unknown;
+    /** Per-group auto-hide override (drag-revealed / co-existence). Absent =
+     *  inherit the global `autoHideEdgeGroups` option. */
+    autoHide?: boolean;
+    /** Per-group "tear down to zero footprint when emptied" flag. */
+    autoReveal?: boolean;
+    /** User-configured geometry constraints (as passed to `addEdgeGroup`), so
+     *  they survive the auto-create fromJSON path. Absent = use the defaults. */
+    minimumSize?: number;
+    maximumSize?: number;
+    collapsedSize?: number;
+}
 export interface SerializedEdgeGroups {
-    top?: {
-        size: number;
-        visible: boolean;
-        collapsed?: boolean;
-        group?: unknown;
-    };
-    bottom?: {
-        size: number;
-        visible: boolean;
-        collapsed?: boolean;
-        group?: unknown;
-    };
-    left?: {
-        size: number;
-        visible: boolean;
-        collapsed?: boolean;
-        group?: unknown;
-    };
-    right?: {
-        size: number;
-        visible: boolean;
-        collapsed?: boolean;
-        group?: unknown;
-    };
+    top?: SerializedEdgeGroup;
+    bottom?: SerializedEdgeGroup;
+    left?: SerializedEdgeGroup;
+    right?: SerializedEdgeGroup;
 }
 /**
  * Minimal interface for a edge group host.
@@ -73,6 +87,13 @@ export declare class EdgeGroupView implements IView {
     get isCollapsed(): boolean;
     get lastExpandedSize(): number;
     get collapsedSize(): number;
+    /** The user-configured (pre-gap) geometry constraints, for serialization.
+     *  These are the raw values passed to `addEdgeGroup`, unlike the effective
+     *  `minimumSize`/`maximumSize`/`collapsedSize` getters, which fold in the
+     *  theme gap and collapse-locking. */
+    get configuredMinimumSize(): number | undefined;
+    get configuredMaximumSize(): number;
+    get configuredCollapsedSize(): number;
     constructor(options: EdgeGroupOptions, group: IEdgeGroupHost, orientation: 'horizontal' | 'vertical', gapAdd?: number);
     /**
      * Watch the group's tab strip so the collapsed size follows the live tab
@@ -143,6 +164,9 @@ export declare class ShellManager implements IDisposable {
     isEdgeGroupVisible(position: EdgeGroupPosition): boolean;
     setEdgeGroupCollapsed(position: EdgeGroupPosition, collapsed: boolean): void;
     isEdgeGroupCollapsed(position: EdgeGroupPosition): boolean;
+    /** The size an edge group expands to (its pre-collapse size), used to size
+     *  the auto-hide peek overlay. */
+    getEdgeGroupExpandedSize(position: EdgeGroupPosition): number;
     private _getView;
     toJSON(): SerializedEdgeGroups;
     fromJSON(data: SerializedEdgeGroups): void;

package/dist/cjs/dockview/edgeGroupService.d.ts

@@ -19,11 +19,27 @@ export interface IEdgeGroupService extends IDisposable {
     entries(): IterableIterator<[EdgeGroupPosition, DockviewGroupPanel]>;
     includes(group: DockviewGroupPanel): boolean;
     findPositionOf(group: DockviewGroupPanel): EdgeGroupPosition | undefined;
+    /**
+     * Per-group auto-hide opt-in. `undefined` means "unset", so callers should
+     * fall back to the global `autoHideEdgeGroups` option. This lets a static
+     * edge group and an auto-hiding one co-exist in the same layout.
+     */
+    setAutoHide(group: DockviewGroupPanel, value: boolean | undefined): void;
+    isAutoHide(group: DockviewGroupPanel): boolean | undefined;
+    /**
+     * Per-group "auto-reveal" flag. When set, an edge group tears itself down
+     * to zero footprint when emptied (instead of collapsing to a strip). This
+     * is the state used by drag-revealed edges.
+     */
+    setAutoReveal(group: DockviewGroupPanel, value: boolean): void;
+    isAutoReveal(group: DockviewGroupPanel): boolean;
     disposeAll(): void;
 }
 export declare class EdgeGroupService implements IEdgeGroupService {
     private readonly _edgeGroups;
     private readonly _edgeGroupDisposables;
+    private readonly _autoHide;
+    private readonly _autoReveal;
     add(position: EdgeGroupPosition, group: DockviewGroupPanel, autoCollapseDisposable: IDisposable): void;
     remove(position: EdgeGroupPosition): void;
     get(position: EdgeGroupPosition): DockviewGroupPanel | undefined;
@@ -32,6 +48,10 @@ export declare class EdgeGroupService implements IEdgeGroupService {
     entries(): IterableIterator<[EdgeGroupPosition, DockviewGroupPanel]>;
     includes(group: DockviewGroupPanel): boolean;
     findPositionOf(group: DockviewGroupPanel): EdgeGroupPosition | undefined;
+    setAutoHide(group: DockviewGroupPanel, value: boolean | undefined): void;
+    isAutoHide(group: DockviewGroupPanel): boolean | undefined;
+    setAutoReveal(group: DockviewGroupPanel, value: boolean): void;
+    isAutoReveal(group: DockviewGroupPanel): boolean;
     disposeAll(): void;
     dispose(): void;
 }

package/dist/cjs/dockview/events.d.ts

@@ -28,6 +28,12 @@ export declare class DockviewWillShowOverlayLocationEvent implements IDockviewEv
     /** Narrow with `instanceof DragEvent` before reading `dataTransfer`. */
     get nativeEvent(): DragEvent | PointerEvent;
     get position(): Position;
+    /** The resolved cell was marked `edge` (an outer "dock to the whole layout"
+     *  cell). See {@link DroptargetEvent.edge}. */
+    get edge(): boolean;
+    /** The resolved cell docks as a dedicated edge group (display hint). See
+     *  {@link PositionResolverResult.edgeGroup}. */
+    get edgeGroup(): boolean;
     get defaultPrevented(): boolean;
     get panel(): IDockviewPanel | undefined;
     get api(): DockviewApi;

package/dist/cjs/dockview/liveRegionService.d.ts

@@ -6,7 +6,7 @@ import { DockviewLayoutMutationEvent, DockviewMaximizedGroupChangeEvent } from '
 import { DockviewComponentOptions } from './options';
 /**
  * The narrow surface the {@link LiveRegionService} needs from the host
- * (the `DockviewComponent`) — somewhere to mount the region and the layout
+ * (the `DockviewComponent`): somewhere to mount the region and the layout
  * events to narrate. `onWill/onDidMutateLayout` are used to suppress the
  * bulk-load / clear burst (one transaction, not N panel announcements).
  */
@@ -20,11 +20,15 @@ export interface ILiveRegionHost {
     readonly onDidMaximizedGroupChange: Event<DockviewMaximizedGroupChangeEvent>;
     readonly onDidAddGroup: Event<DockviewGroupPanel>;
     readonly onDidRemoveGroup: Event<DockviewGroupPanel>;
+    /** Live popout windows + a signal when that set changes, so the service can
+     *  mount a live region inside each popout document and route to it. */
+    getPopoutWindows(): Window[];
+    readonly onDidChangePopouts: Event<void>;
 }
 export interface ILiveRegionService extends IDisposable {
     /**
-     * Announce a message to assistive technology via the live region. The
-     * shared sink — the accessibility module writes keyboard-docking
+     * Announce a message to assistive technology via the live region. This
+     * is the shared sink: the accessibility module writes keyboard-docking
      * narration here too, so all announcements use one region.
      */
     announce(message: string, politeness?: 'polite' | 'assertive'): void;
@@ -40,11 +44,20 @@ export interface ILiveRegionService extends IDisposable {
  */
 export declare class LiveRegionService extends CompositeDisposable implements ILiveRegionService {
     private readonly _host;
-    private readonly _polite;
-    private readonly _assertive;
+    private readonly _mainWindow;
+    /** One live-region pair per window (main + each popout document). */
+    private readonly _regions;
     private _suppressDepth;
     private readonly _locationSubs;
     constructor(host: ILiveRegionHost);
+    /** Create a live region in every popout document that lacks one, and remove
+     *  regions for popouts that have closed. The main window's pair is permanent. */
+    private _syncPopoutRegions;
+    private _disposeRegions;
+    /** Route announcements to the live region of the window that currently has
+     *  focus, so a screen-reader user in a popout hears them, falling back to
+     *  the main window. */
+    private _focusedRegions;
     private _trackLocation;
     announce(message: string, politeness?: 'polite' | 'assertive'): void;
     private _announce;