dockview-core 8.1.0 → 8.3.0

package/dist/cjs/api/dockviewGroupPanelApi.d.ts

@@ -77,6 +77,13 @@ export interface DockviewGroupPanelApi extends GridviewPanelApi {
     isMaximized(): boolean;
     exitMaximized(): void;
     close(): void;
+    /**
+     * Resize this group, clamped by its constraints and the space available.
+     * An edge group is sized along its own axis only - `width` for
+     * `left`/`right`, `height` for `top`/`bottom` - and that size is the one
+     * it expands to, so a collapsed group keeps its strip until expanded.
+     */
+    setSize(event: SizeEvent): void;
     /**
      * Collapse this group (edge groups only). No-op for non-edge groups.
      */

package/dist/cjs/api/dockviewPanelApi.d.ts

@@ -101,5 +101,17 @@ export declare class DockviewPanelApiImpl extends GridviewPanelApiImpl implement
     maximize(): void;
     isMaximized(): boolean;
     exitMaximized(): void;
+    /**
+     * Report that this panel's location may have moved.
+     *
+     * A relocation touches the location more than once - the panel is
+     * reparented into the destination group, then that group is tagged with
+     * the location it ends up at - so the event is coalesced to the end of the
+     * enclosing layout mutation and reports where the panel actually settled.
+     * Firing each signal as it happened surfaced an intermediate `grid`
+     * location the panel was never in, at a point where it was in neither
+     * group's panel list. Outside a mutation this fires straight away.
+     */
+    private fireLocationChange;
     private setupGroupEventListeners;
 }

package/dist/cjs/dnd/dropTargetAnchorContainer.d.ts

@@ -15,6 +15,12 @@ export declare class DropTargetAnchorContainer extends CompositeDisposable {
      * drag genuinely leaves to somewhere that doesn't re-render here.
      */
     private _pendingClear;
+    /**
+     * The element the live overlay was rendered for, `undefined` when nothing
+     * is showing. The container is shared by every drop target, so a caller
+     * tearing down only its own overlay must check this before `clear()`.
+     */
+    get renderedOutline(): HTMLElement | undefined;
     get disabled(): boolean;
     set disabled(value: boolean);
     private _cancelPendingClear;

package/dist/cjs/dockview/components/titlebar/tabReorderController.d.ts

@@ -142,6 +142,14 @@ export declare class TabReorderController extends CompositeDisposable {
      * zone, or into the void container; tears it down otherwise.
      */
     processDragLeave(related: Element | null): void;
+    /**
+     * Clear the anchored overlay only when this header is what rendered it.
+     * The container is shared with the group's content drop target, which
+     * renders into it on the same frame the cursor leaves the strip: the
+     * pointer backend calls `handleDragOver` on the new target before the
+     * global `onDragMove` that reaches us (#1612).
+     */
+    private clearHeaderAnchorOverlay;
     handleDragOver(event: {
         clientX: number;
         clientY?: number;

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

@@ -0,0 +1,62 @@
+import { DockviewGroupPanel } from './dockviewGroupPanel';
+import { IDockviewPanel } from './dockviewPanel';
+import { ITabGroup } from './tabGroup';
+import { IContextMenuHost, IContextMenuService } from './moduleContracts';
+export declare class ContextMenuController implements IContextMenuService {
+    private readonly accessor;
+    constructor(accessor: IContextMenuHost);
+    /**
+     * A single maximize/restore toggle whose label and behaviour track the
+     * group's live state: it reads *Restore* + calls `exitMaximized` when the
+     * group is maximized, otherwise *Maximize* + `maximize`. Only grid groups
+     * can be maximized, so the item is disabled for floating / popout panels
+     * that are not already maximized.
+     */
+    private buildMaximizeItem;
+    /**
+     * A single collapse/expand toggle whose label tracks the tab group's live
+     * state: *Expand* when the group is already collapsed, otherwise *Collapse*.
+     */
+    private buildCollapseItem;
+    /**
+     * Whether to auto-inject the built-in Pin/Unpin item at the top of the tab
+     * menu. True only when the PinnedTabs module is registered, pinning is
+     * enabled, and the app has not opted out via `pinnedTabs.contextMenuItem:
+     * false` (the item is on by default). This keeps pinning reachable from the
+     * menu without the app having to return `'pin'` from
+     * `getTabContextMenuItems` itself.
+     */
+    private _shouldInjectPin;
+    /**
+     * The tab menu items: the app's own items (if any) with the built-in
+     * `'pin'` item prepended when {@link _shouldInjectPin} applies, so the app
+     * keeps full control of its list, and pinning is added without disturbing
+     * it. Reuses the existing `'pin'` token rendering below.
+     */
+    private _resolveTabItems;
+    /**
+     * Render a custom `component` menu item and append it to `menuEl`. Builds
+     * the framework renderer via the host's `createContextMenuItemComponent`
+     * factory and initialises it. Shared by the tab menu and the chip menu,
+     * which differ only in `identity`: the tab menu passes the `panel`, the chip
+     * menu passes the `tabGroup`. No-op when no renderer could be created (no
+     * factory configured, or the factory declined the component).
+     */
+    private appendComponentItem;
+    /**
+     * The element for one built-in tab item, or `undefined` for a token this
+     * version doesn't know (an app on a newer typings version, or plain JS):
+     * an unrecognised token renders nothing rather than throwing.
+     */
+    private buildBuiltInTabItem;
+    /**
+     * Append one app-supplied item. A raw `element` is used as-is, a
+     * `component` goes through the framework renderer, and a `label` builds the
+     * default row; an item carrying none of the three renders nothing. Shared
+     * by both menus, which differ only in `identity`.
+     */
+    private appendConfigItem;
+    show(panel: IDockviewPanel, group: DockviewGroupPanel, event: MouseEvent): void;
+    showForChip(tabGroup: ITabGroup, group: DockviewGroupPanel, event: MouseEvent): void;
+}
+export declare const ContextMenuModule: import("./modules").DockviewModule<IContextMenuHost>;

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

@@ -111,6 +111,11 @@ export interface SerializedDockview {
 export interface MovePanelEvent {
     panel: IDockviewPanel;
     from: DockviewGroupPanel;
+    /**
+     * The group the panel now belongs to. Equal to `from` when the panel kept
+     * its group and the group itself was relocated.
+     */
+    to: DockviewGroupPanel;
 }
 type MoveGroupOptions = {
     from: {
@@ -345,6 +350,7 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     private readonly _onWillDrop;
     readonly onWillDrop: Event<DockviewWillDropEvent>;
     private _mutationDepth;
+    private readonly _pendingLocationChanges;
     private _origin;
     private _originDepth;
     private readonly _onWillMutateLayout;
@@ -856,6 +862,56 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
      * outermost mutation.
      */
     mutation<T>(kind: DockviewLayoutMutationKind, func: () => T): T;
+    /**
+     * `mutation()` for an operation whose work continues after the synchronous
+     * call returns. The transaction stays open until the returned promise
+     * settles, so everything the operation does - the group it adds, the panels
+     * it relocates - lands inside the bracket, matching the synchronous
+     * move / float paths.
+     */
+    private mutationAsync;
+    /**
+     * Open a transaction and return the function that closes it. Shared by the
+     * synchronous and asynchronous brackets; the returned function must be
+     * called exactly once.
+     *
+     * Both ends key off the depth counter reaching zero rather than off which
+     * bracket opened first. For synchronous nesting the two are the same thing
+     * - brackets close in the order they opened - but asynchronous transactions
+     * can *overlap* rather than nest (two `addPopoutGroup` calls in flight at
+     * once, or a restore staggering several), and there the first to open is
+     * not the last to close. Reporting on the opener would fire `didMutate`
+     * while the other transaction was still doing structural work, which is the
+     * very thing the async bracket exists to prevent. Overlapping transactions
+     * therefore report as one, tagged with the kind of the last to finish.
+     */
+    private openMutation;
+    /**
+     * Coalesce a panel's `onDidLocationChange` to the end of the enclosing
+     * transaction, or fire it immediately when no transaction is in flight.
+     *
+     * Relocating a panel touches its location twice: once as it is reparented
+     * into the destination group - which, when that group has just been created
+     * for a floating or popout window, has not been told where it lives yet -
+     * and once as the group is tagged with its final location. Reporting each
+     * signal as it happens therefore leaks an intermediate `grid` location the
+     * panel was never in, at a moment when it belongs to neither group's panel
+     * list and so is missing from `api.panels`.
+     *
+     * Deferring collapses those signals into a single event carrying the
+     * settled location. Note the signals are deliberately *not* compared
+     * against the panel's previous location: a panel can move between two
+     * floating windows without its location type changing, and this event is
+     * the only signal `OverlayRenderContainer` has to re-resolve the panel's
+     * z-index against its new host window.
+     */
+    deferLocationChange(key: object, fire: () => void): void;
+    /**
+     * Report every panel whose location moved during the transaction that has
+     * just closed. Each callback reads the panel's location at this point, so
+     * what it reports is where the panel ended up.
+     */
+    private flushLocationChanges;
     /**
      * The origin of the operation currently in progress (`'user'` by default).
      * Read inside a `mutation()` or active-panel change to learn whether the
@@ -877,6 +933,12 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
      * {@link DockviewOrigin}. Callers keep their own dedupe guards.
      */
     private fireActivePanelChange;
+    /**
+     * Announce that `panel` has finished relocating. Must be called once the
+     * move has settled: `to` is read from the panel's current group, so an
+     * early call would report the source group as the destination.
+     */
+    private fireDidMovePanel;
     moveGroupOrPanel(options: MoveGroupOrPanelOptions): void;
     private _doMoveGroupOrPanel;
     private moveTabGroupToGroup;
@@ -889,6 +951,14 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     private getNextGroupId;
     createGroup(options?: GroupOptions): DockviewGroupPanel;
     private createPanel;
+    /**
+     * Sizing for a group created by a drop next to `referenceLocation`: half
+     * of the group the overlay was drawn over, leaving its siblings alone, so
+     * the panel lands in the region the overlay indicated (#1612). Gridview
+     * rewrites the index to 0 when a cross-axis drop wraps the reference in a
+     * new branch, so one value serves both paths.
+     */
+    private dropSizing;
     private createGroupAtLocation;
     /**
      * Tag a group with the location and render / drop-target containers

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

@@ -139,6 +139,7 @@ export declare class ShellManager implements IDisposable {
     private _rightIndex;
     private readonly _disposables;
     private readonly _viewConfigs;
+    private readonly _pendingSizes;
     private _currentWidth;
     private _currentHeight;
     private _gap;
@@ -163,6 +164,20 @@ export declare class ShellManager implements IDisposable {
     setEdgeGroupVisible(position: EdgeGroupPosition, visible: boolean): void;
     isEdgeGroupVisible(position: EdgeGroupPosition): boolean;
     setEdgeGroupCollapsed(position: EdgeGroupPosition, collapsed: boolean): void;
+    /**
+     * Resize the edge group at `position` along its primary axis (width for
+     * `left`/`right`, height for `top`/`bottom`), clamped by the group's
+     * constraints and the space available. Where `groupApi.setSize` lands.
+     *
+     * The size becomes the group's expanded size, so a collapsed group keeps
+     * its strip and takes it on expand, and it survives a `toJSON` round-trip.
+     */
+    resizeEdgeGroup(position: EdgeGroupPosition, size: number): void;
+    /** A resize lands only on a visible view (a hidden one is pinned to zero)
+     *  whose splitview has extent to distribute. */
+    private _canResize;
+    private _resizeView;
+    private _flushPendingSizes;
     isEdgeGroupCollapsed(position: EdgeGroupPosition): boolean;
     /** The size an edge group expands to (its pre-collapse size), used to size
      *  the auto-hide peek overlay. */

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

@@ -156,8 +156,8 @@ export declare function logMissingModule(moduleName: string, reason?: string | s
  * case: calling `undo()` having never set the option at all.
  *
  * Interaction handlers are queries in this sense too: a right-click reaching an
- * absent ContextMenu module means the app never asked for one, so it stays
- * silent (`?.`) and the browser's own menu shows. Options are where intent is
+ * absent module means the app never asked for that feature, so it stays silent
+ * (`?.`) and the browser's own behaviour applies. Options are where intent is
  * declared; see `optionsModules.ts`.
  */
 export declare function assertModule<T>(service: T | undefined, moduleName: string, context?: string): T | undefined;

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

@@ -5,10 +5,9 @@
  *
  * This is the "declared intent" diagnostic. It fires when the user asks for a
  * feature via options, at construction and on every `updateOptions`. It
- * deliberately does *not* fire on user interaction: right-clicking without the
- * ContextMenu module stays silent (the browser's own menu shows), because the
- * `?.` service-slot call sites can't tell a missing module from a feature the
- * app never wanted.
+ * deliberately does *not* fire on user interaction: an interaction reaching an
+ * absent module stays silent, because the `?.` service-slot call sites can't
+ * tell a missing module from a feature the app never wanted.
  *
  * Rules are a flat list rather than a `Record<keyof DockviewOptions, ...>`
  * because dockview's options are nested and value-gated: `overflow.mode:

package/dist/cjs/gridview/baseComponentGridview.d.ts

@@ -2,7 +2,7 @@ import { Event, AsapEvent } from '../events';
 import { Gridview, IGridView } from './gridview';
 import { Position } from '../dnd/droptarget';
 import { IDisposable, IValueDisposable } from '../lifecycle';
-import { ISplitviewStyles, Orientation } from '../splitview/splitview';
+import { ISplitviewStyles, Orientation, Sizing } from '../splitview/splitview';
 import { IPanel } from '../panel/types';
 import { MovementOptions2 } from '../dockview/options';
 import { Resizable } from '../resizable';
@@ -95,7 +95,7 @@ export declare abstract class BaseGrid<T extends IGridPanelView> extends Resizab
     isMaximizedGroup(panel: T): boolean;
     exitMaximizedGroup(): void;
     hasMaximizedGroup(): boolean;
-    protected doAddGroup(group: T, location?: number[], size?: number, gridview?: Gridview): void;
+    protected doAddGroup(group: T, location?: number[], size?: number | Sizing, gridview?: Gridview): void;
     protected doRemoveGroup(group: T, options?: {
         skipActive?: boolean;
         skipDispose?: boolean;

package/dist/cjs/index.d.ts

@@ -59,6 +59,7 @@ export { type IDragGhostSpec } from './dnd/backend';
 export { LiveRegionModule } from './dockview/liveRegionService';
 export { AdvancedDnDModule, AdvancedDnDService, } from './dockview/advancedDnDService';
 export { TabGroupChipsModule, TabGroupChipsService, } from './dockview/tabGroupChipsService';
+export { ContextMenuController, ContextMenuModule, } from './dockview/contextMenuService';
 export { FloatingGroupModule } from './dockview/floatingGroupService';
 export { EdgeGroupModule } from './dockview/edgeGroupService';
 export { createCloseButton, createPinButton } from './svg';

package/dist/cjs/overlay/overlayRenderContainer.d.ts

@@ -12,8 +12,13 @@ export declare class OverlayRenderContainer extends CompositeDisposable {
     readonly accessor: DockviewComponent;
     private readonly map;
     private _disposed;
+    /**
+     * Monotonic for the container's lifetime, never per-entry: `detatch()`
+     * deletes the entry, so an entry-local counter would restart and let a
+     * superseded closure collide with a later `attach`.
+     */
+    private _generation;
     private readonly positionCache;
-    private readonly pendingUpdates;
     constructor(element: HTMLElement, accessor: DockviewComponent);
     updateAllPositions(): void;
     /**
@@ -24,6 +29,13 @@ export declare class OverlayRenderContainer extends CompositeDisposable {
      * the panel's visibility state. No-op if the panel isn't overlay-rendered.
      */
     repositionPanelOverlay(panelId: string, forceVisible?: boolean, clip?: DOMRect): void;
+    /**
+     * Drop the reposition frame queued for a panel, if any. A queued frame is
+     * bound to the reference container that was current when it was scheduled,
+     * so it must be discarded whenever that container stops being the one the
+     * overlay should track.
+     */
+    private cancelPendingUpdate;
     detatch(panel: IDockviewPanel): boolean;
     attach(options: {
         panel: IDockviewPanel;