dockview-core 8.2.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/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

@@ -951,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';