dockview-core 7.0.4 → 8.1.0

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

@@ -6,19 +6,70 @@ export interface DroptargetEvent {
     readonly position: Position;
     /** Narrow with `instanceof DragEvent` before reading `dataTransfer`. */
     readonly nativeEvent: DragEvent | PointerEvent;
+    /**
+     * The resolved cell was marked `edge` by a {@link PositionResolver}: an
+     * "outer" cell that should dock against the whole layout, not this target.
+     * The target renders no overlay for it; the consumer routes the commit.
+     */
+    readonly edge?: boolean;
 }
 export declare class WillShowOverlayEvent extends DockviewEvent implements DroptargetEvent {
     private readonly options;
     get nativeEvent(): DragEvent | PointerEvent;
     get position(): Position;
+    /** See {@link DroptargetEvent.edge}. */
+    get edge(): boolean;
+    /** See {@link PositionResolverResult.edgeGroup}. A display hint; a consumer
+     *  (e.g. the DnD compass) can bow out of this cell. */
+    get edgeGroup(): boolean;
     constructor(options: {
         nativeEvent: DragEvent | PointerEvent;
         position: Position;
+        edge?: boolean;
+        edgeGroup?: boolean;
     });
 }
 export declare function directionToPosition(direction: Direction): Position;
 export declare function positionToDirection(position: Position): Direction;
 export type Position = 'top' | 'bottom' | 'left' | 'right' | 'center';
+/** The pointer location within a drop target, handed to a {@link PositionResolver}. */
+export interface PositionResolverArgs {
+    /** Pointer X within the target element (px from its left edge). */
+    readonly x: number;
+    /** Pointer Y within the target element (px from its top edge). */
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    /** The drop zones this target currently accepts. */
+    readonly zones: ReadonlySet<Position>;
+    /** The originating drag event (HTML5 or pointer backend). */
+    readonly event: DragEvent | PointerEvent;
+}
+export interface PositionResolverResult {
+    readonly position: Position;
+    /**
+     * Marks an outer / whole-layout-edge cell. The built-in drop overlay only
+     * reads `position`; consumers that route edge cells differently can read this.
+     */
+    readonly edge?: boolean;
+    /**
+     * Display hint: this cell docks as a dedicated edge group (not a grid-edge
+     * split). Purely advisory. A co-installed resolver's UI (e.g. the DnD
+     * compass) can suppress its own overlay for these cells so they don't
+     * double-render with the edge-group affordance.
+     */
+    readonly edgeGroup?: boolean;
+}
+/**
+ * Pluggable replacement for the built-in cursor-quadrant drop resolution.
+ * Supplied via {@link DroptargetOptions.positionResolver}, it maps a pointer
+ * location within a target to a drop {@link Position} (or `null` for no drop)
+ * instead of the default threshold-band quadrant. Both DnD backends consult the
+ * same resolver. When unset, the default quadrant behaviour applies unchanged.
+ */
+export interface PositionResolver {
+    resolve(args: PositionResolverArgs): PositionResolverResult | null;
+}
 export type CanDisplayOverlay = (dragEvent: DragEvent | PointerEvent, state: Position) => boolean;
 export type MeasuredValue = {
     value: number;
@@ -48,6 +99,15 @@ export interface DropTargetTargetModel {
     };
     exists(): boolean;
     clear(): void;
+    /**
+     * Clear the overlay on the next tick unless a {@link getElements} call (a
+     * target rendering into this container) cancels it first. Used by the HTML5
+     * backend on `dragleave`: clearing immediately would kill the overlay's
+     * slide between adjacent targets, but never clearing leaves the overlay
+     * behind when the drag leaves to somewhere that doesn't re-render here.
+     * Optional so lightweight/mocked target models need not implement it.
+     */
+    scheduleClear?(): void;
 }
 export interface DroptargetOptions {
     canDisplayOverlay: CanDisplayOverlay;
@@ -56,6 +116,13 @@ export interface DroptargetOptions {
     getOverrideTarget?: () => DropTargetTargetModel | undefined;
     className?: string;
     getOverlayOutline?: () => HTMLElement | null;
+    /**
+     * Supply a {@link PositionResolver} that overrides how a pointer location
+     * resolves to a drop {@link Position}. A lazy getter (like
+     * {@link getOverrideTarget}) so the source can change at runtime; returning
+     * `undefined` (the default) uses the built-in cursor-quadrant logic.
+     */
+    getPositionResolver?: () => PositionResolver | undefined;
 }
 /**
  * Backend-agnostic drop target. Both the HTML5 `Droptarget` and the pointer
@@ -76,6 +143,8 @@ export declare class Droptarget extends CompositeDisposable implements IDropTarg
     private targetElement;
     private overlayElement;
     private _state;
+    /** The current state was resolved as an `edge` cell (see DroptargetEvent). */
+    private _edge;
     private _acceptedTargetZonesSet;
     private readonly _onDrop;
     readonly onDrop: Event<DroptargetEvent>;
@@ -101,7 +170,32 @@ export declare class Droptarget extends CompositeDisposable implements IDropTarg
      */
     private isAlreadyUsed;
     private toggleClasses;
+    /**
+     * Resolve the drop {@link Position} for a pointer location: defer to an
+     * injected {@link PositionResolver} when present, otherwise the built-in
+     * cursor-quadrant logic (unchanged).
+     */
+    private resolvePosition;
     private calculateQuadrant;
+    /**
+     * Tear down whatever this target is showing, on any frame it resolves to no
+     * overlay. Two things make this more than `removeDropTarget`:
+     *
+     * - With `dndOverlayMounting: 'absolute'` the overlay lives in an anchor
+     *   container shared by every drop target in the component, and
+     *   `removeDropTarget` only owns the in-place dropzone — so the container
+     *   needs clearing explicitly or the last frame's highlight lingers.
+     * - It must only clear the container when this target actually put
+     *   something there. The root edge target sits over every group and
+     *   declines `center` on each frame in the middle of the layout purely so
+     *   the event falls through; clearing from there would destroy and rebuild
+     *   the group's overlay every frame, killing its move transition.
+     *
+     * Resetting `_state` unconditionally is the other half: a target that
+     * resolves to nothing must not stay latched, or a later drop commits a
+     * position the cursor left long ago.
+     */
+    private clearOwnOverlay;
     private removeDropTarget;
     /**
      * Render the drop overlay at `position` without a live drag, so keyboard

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

@@ -1,4 +1,5 @@
 export declare function addGhostImage(dataTransfer: DataTransfer, ghostElement: HTMLElement, options?: {
     x?: number;
     y?: number;
+    ownerDocument?: Document;
 }): void;

package/dist/cjs/dnd/pointer/longPress.d.ts

@@ -10,8 +10,8 @@ export interface LongPressOptions {
     onLongPress: (event: PointerEvent) => void;
 }
 /**
- * Passive — does not consume the pointer; movement past `tolerance`
- * cancels silently so a sibling `PointerDragSource` can take over.
+ * Doesn't consume the pointer; movement past `tolerance` cancels
+ * silently so a sibling `PointerDragSource` can take over.
  */
 export declare class LongPressDetector extends CompositeDisposable {
     private readonly element;

package/dist/cjs/dnd/pointer/pointerDragController.d.ts

@@ -9,13 +9,13 @@ export interface ActiveDrag {
     readonly source: HTMLElement;
 }
 /**
- * Singleton — only one pointer-driven drag active at a time.
+ * Only one pointer-driven drag can be active at a time.
  *
  * State is shared across every Dockview instance on the page. Targets
  * from instance B receive hit-tests from drags originating in instance A;
  * that's intentional for cross-instance drops since `LocalSelectionTransfer`
  * is also process-wide. The corollary is that every Tabs subscriber to
- * `onDragMove` fires for every pointer drag globally — each subscriber
+ * `onDragMove` fires for every pointer drag globally; each subscriber
  * hit-tests against its own DOM, so this is O(N) per pointermove where N
  * is the number of registered listeners across all instances.
  */
@@ -26,6 +26,9 @@ export declare class PointerDragController extends CompositeDisposable {
     /** Kept in sync with `_targets` so hit-testing is allocation-free. */
     private readonly _targetByElement;
     private _active;
+    /** The most recent pointer event of the active drag, used to build the
+     * drag-end event when a drag is cancelled (which carries no event). */
+    private _lastPointerEvent;
     private _currentTarget;
     private _dataDisposable;
     private _ghost;

package/dist/cjs/dnd/pointer/pointerDragSource.d.ts

@@ -18,7 +18,7 @@ export interface PointerDragSourceOptions {
      * hold for floating-group redock vs docked-group rearrange).
      */
     touchInitiationDelay?: number | (() => number);
-    /** Default 8px. May be a function — see `touchInitiationDelay`. */
+    /** Default 8px. May be a function; see `touchInitiationDelay`. */
     pressTolerance?: number | (() => number);
     /** Default true: mouse defers to HTML5; pointer path handles touch / pen only. */
     touchOnly?: boolean;

package/dist/cjs/dnd/pointer/pointerDropTarget.d.ts

@@ -1,6 +1,6 @@
 import { Event } from '../../events';
 import { CompositeDisposable } from '../../lifecycle';
-import { CanDisplayOverlay, DropTargetTargetModel, DroptargetEvent, DroptargetOverlayModel, IDropTarget, Position, WillShowOverlayEvent } from '../droptarget';
+import { CanDisplayOverlay, DropTargetTargetModel, DroptargetEvent, DroptargetOverlayModel, IDropTarget, Position, PositionResolver, WillShowOverlayEvent } from '../droptarget';
 export interface PointerDropTargetOptions {
     canDisplayOverlay: CanDisplayOverlay;
     acceptedTargetZones: Position[];
@@ -10,6 +10,12 @@ export interface PointerDropTargetOptions {
     /** Outline element for positioning; falls back to the drop element. */
     getOverlayOutline?: () => HTMLElement | null;
     className?: string;
+    /**
+     * Supply a {@link PositionResolver} that overrides how a pointer location
+     * resolves to a drop {@link Position}. A lazy getter so the source can
+     * change at runtime; `undefined` (default) uses the cursor-quadrant logic.
+     */
+    getPositionResolver?: () => PositionResolver | undefined;
 }
 /** Pointer-driven counterpart to `Droptarget` with identical visual output. */
 export declare class PointerDropTarget extends CompositeDisposable implements IDropTarget {
@@ -18,6 +24,7 @@ export declare class PointerDropTarget extends CompositeDisposable implements ID
     private _targetElement;
     private _overlayElement;
     private _state;
+    private _edge;
     private _acceptedTargetZonesSet;
     private readonly _onDrop;
     readonly onDrop: Event<DroptargetEvent>;
@@ -34,6 +41,28 @@ export declare class PointerDropTarget extends CompositeDisposable implements ID
     private _onDragOver;
     private _onDragLeave;
     private _onDropEvent;
+    /**
+     * Resolve the drop {@link Position}: defer to an injected
+     * {@link PositionResolver} when present, otherwise the built-in
+     * cursor-quadrant logic (unchanged). Shares the resolver with the HTML5
+     * backend.
+     */
+    private _resolvePosition;
     private _calculateQuadrant;
+    /**
+     * Tear down whatever this target is showing, on any frame it resolves to no
+     * overlay. Two things make this more than `_removeOverlay`:
+     *
+     * - With `dndOverlayMounting: 'absolute'` the overlay lives in an anchor
+     *   container shared by every drop target in the component, and
+     *   `_removeOverlay` only owns the in-place dropzone — so the container
+     *   needs clearing explicitly or the last frame's highlight lingers.
+     * - It must only clear the container when this target actually put
+     *   something there. The root edge target sits over every group and
+     *   declines `center` on each frame in the middle of the layout purely so
+     *   the event falls through; clearing from there would destroy and rebuild
+     *   the group's overlay every frame, killing its move transition.
+     */
+    private _clearOwnOverlay;
     private _removeOverlay;
 }

package/dist/cjs/dnd/pointer/pointerGhost.d.ts

@@ -9,7 +9,7 @@ export interface PointerGhostOptions {
     /** Default 0.8. */
     opacity?: number;
     /**
-     * Source element whose `ownerDocument.body` hosts the ghost — pass for
+     * Source element whose `ownerDocument.body` hosts the ghost. Pass it for
      * popout-window drags so the ghost renders in the popout's document.
      */
     owner?: Element;

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

@@ -16,6 +16,10 @@ export interface DockviewMessages {
     groupFloated(title: string): string;
     groupDocked(title: string): string;
     groupPoppedOut(title: string): string;
+    /** Accessible name for a tab's close button, qualified with the panel title. */
+    closeTab(title: string): string;
+    /** Accessible name for a tab's close button when the panel has no title. */
+    closeTabPlain(): string;
     /** Target phase: which group is highlighted, and how to proceed. */
     movePickTarget(source: string, target: string, current: number, total: number): string;
     /** Edge phase: which drop position is selected, and how to proceed. */
@@ -26,6 +30,8 @@ export interface DockviewMessages {
     moveCancelled(): string;
     /** A move the layout rejected. */
     moveNotAllowed(): string;
+    /** The panel was floated as a terminal move action. */
+    moveFloated(source: string): string;
 }
 export declare const DEFAULT_MESSAGES: DockviewMessages;
 /** Merge an app's partial overrides over the English defaults. */

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

@@ -0,0 +1,31 @@
+import { IDisposable } from '../lifecycle';
+import { IDragGhostSpec } from '../dnd/backend';
+import { DroptargetOverlayModel, Position } from '../dnd/droptarget';
+import { GroupDragEvent, TabDragEvent } from './components/titlebar/tabsContainer';
+import { DockviewWillDropEvent } from './dockviewGroupPanelModel';
+import { DockviewGroupPanel } from './dockviewGroupPanel';
+import { DockviewGroupDropLocation, DockviewWillShowOverlayLocationEvent } from './events';
+import { IAdvancedDnDHost, IAdvancedDnDService } from './moduleContracts';
+/**
+ * Owns the dispatch of the advanced drag-and-drop hooks: `onWillDragPanel`,
+ * `onWillDragGroup`, `onWillDrop` and `onWillShowOverlay`, forwarding each to
+ * the host's emitters so the public event shape is unchanged whether or not
+ * this module is registered.
+ *
+ * The service holds no drag state of its own. The gesture is driven by the
+ * DnD backends, and the per-group subscriptions live on the component's group
+ * lifecycle (so groups created mid-move are not missed).
+ */
+export declare class AdvancedDnDService implements IAdvancedDnDService {
+    private readonly host;
+    constructor(host: IAdvancedDnDHost);
+    dispatchWillDragPanel(event: TabDragEvent): void;
+    dispatchWillDragGroup(event: GroupDragEvent): void;
+    dispatchWillDrop(event: DockviewWillDropEvent): void;
+    dispatchWillShowOverlay(event: DockviewWillShowOverlayLocationEvent): void;
+    buildGroupDragGhost(group: DockviewGroupPanel): IDragGhostSpec | undefined;
+    resolveOverlayModel(location: DockviewGroupDropLocation, group?: DockviewGroupPanel): DroptargetOverlayModel | undefined;
+    showPreviewOverlay(group: DockviewGroupPanel, position: Position): IDisposable;
+    dispose(): void;
+}
+export declare const AdvancedDnDModule: import("./modules").DockviewModule<IAdvancedDnDHost>;

package/dist/cjs/dockview/components/panel/content.d.ts

@@ -40,7 +40,7 @@ export declare class ContentContainer extends CompositeDisposable implements ICo
     hide(): void;
     setLabelledBy(tabElementId: string | undefined): void;
     renderPanel(panel: IDockviewPanel, options?: {
-        asActive: boolean;
+        asActive?: boolean;
     }): void;
     openPanel(panel: IDockviewPanel): void;
     layout(_width: number, _height: number): void;

package/dist/cjs/dockview/components/tab/defaultTab.d.ts

@@ -5,6 +5,8 @@ export declare class DefaultTab extends CompositeDisposable implements ITabRende
     private readonly _content;
     private readonly action;
     private _title;
+    /** English defaults until `init` supplies the app's resolved catalog. */
+    private _messages;
     get element(): HTMLElement;
     constructor();
     init(params: GroupPanelPartInitParameters): void;

package/dist/cjs/dockview/components/tab/tab.d.ts

@@ -18,6 +18,7 @@ export declare class Tab extends CompositeDisposable {
     private readonly pointerDragSource;
     private readonly panelTransfer;
     private _direction;
+    private _pinIndicator;
     private readonly _onPointDown;
     readonly onPointerDown: Event<MouseEvent>;
     private readonly _onTabClick;
@@ -31,6 +32,7 @@ export declare class Tab extends CompositeDisposable {
     readonly onWillShowOverlay: Event<WillShowOverlayEvent>;
     get element(): HTMLElement;
     constructor(panel: IDockviewPanel, accessor: DockviewComponent, group: DockviewGroupPanel);
+    private _updatePinnedClasses;
     setActive(isActive: boolean): void;
     setContent(part: ITabRenderer): void;
     private _buildOverlayModel;

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

@@ -10,7 +10,7 @@ import { DockviewGroupPanel } from '../../dockviewGroupPanel';
  * group to redock it into the grid. The redock half is provided by the shared
  * {@link GroupDragSource}; the move half is owned by the overlay.
  *
- * The bar is intentionally contentless — styling is driven entirely through
+ * The bar is intentionally contentless; styling is driven entirely through
  * the `--dv-floating-titlebar-*` theme variables.
  */
 export declare class FloatingTitleBar extends CompositeDisposable {
@@ -21,7 +21,7 @@ export declare class FloatingTitleBar extends CompositeDisposable {
     private readonly _onDragStart;
     readonly onDragStart: import("../../../events").Event<PointerEvent | DragEvent>;
     get element(): HTMLElement;
-    /** The window's current anchor group — the one this bar drags/activates. */
+    /** The window's current anchor group, the one this bar drags/activates. */
     get group(): DockviewGroupPanel;
     /**
      * Retarget the bar at a new anchor group. Called when the original anchor

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

@@ -7,7 +7,7 @@ export interface GroupDragSourceOptions {
     readonly accessor: DockviewComponent;
     /**
      * The group this handle drags. Pass a function when the handle outlives the
-     * group it represents and can be retargeted — e.g. a floating window's
+     * group it represents and can be retargeted, e.g. a floating window's
      * dedicated title bar, whose anchor group is reassigned when the original
      * anchor leaves a multi-group window. A fixed reference (the tab-bar void
      * container, which lives inside its own group's DOM) is also accepted.

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

@@ -8,7 +8,7 @@ import { DockviewApi } from '../../../api/component.api';
  * Visual chip for a tab group. Owns the DOM element, label, click /
  * context-menu interactions, and exposes a long-press gesture as a
  * second `onContextMenu` source. Drag-and-drop wiring lives in
- * `TabGroupManager` — the manager constructs the drag sources on this
+ * `TabGroupManager`, which constructs the drag sources on this
  * chip's element so it can include tabs-list context (custom group
  * drag image, tab-group transfer payload).
  */

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

@@ -3,6 +3,12 @@ import { DockviewHeaderDirection, DockviewHeaderPosition } from '../../options';
 import { Tab } from '../tab/tab';
 import { ITabGroup } from '../../tabGroup';
 import { TabGroupColorPalette } from '../../tabGroupAccent';
+/**
+ * Class for the small accent pip drawn at the leading edge of each wrapped
+ * row a tab group spans beyond its first. Echoes the group chip so a
+ * multi-row group reads as one group on every row it occupies.
+ */
+export declare const TAB_GROUP_CHIP_CONTINUATION_CLASS = "dv-tab-group-chip-continuation";
 export interface TabGroupIndicatorContext {
     readonly tabsList: HTMLElement;
     getTabGroups(): readonly ITabGroup[];
@@ -28,6 +34,12 @@ export interface ITabGroupIndicator {
 declare abstract class BaseTabGroupIndicator implements ITabGroupIndicator {
     protected readonly _ctx: TabGroupIndicatorContext;
     protected readonly _underlines: Map<string, HTMLElement>;
+    /**
+     * Per-group pool of continuation-marker pips (one per wrapped row the
+     * group spans beyond its first). Absolutely positioned so they sit
+     * outside the flex-wrap flow, exactly like the underline element.
+     */
+    private readonly _continuationMarkers;
     private _rafId;
     get underlines(): ReadonlyMap<string, HTMLElement>;
     constructor(_ctx: TabGroupIndicatorContext);
@@ -40,12 +52,71 @@ declare abstract class BaseTabGroupIndicator implements ITabGroupIndicator {
     syncUnderlineElements(activeGroupIds: Set<string>): void;
     getUnderline(groupId: string): HTMLElement | undefined;
     dispose(): void;
+    /**
+     * Grow/shrink a group's continuation-marker pool to `count` pips,
+     * creating/removing DOM nodes as needed, and return the pool.
+     */
+    private _syncContinuationMarkers;
+    /**
+     * Remove continuation markers for a single group, or (when `groupId`
+     * is omitted) for every group. Used when a group dissolves, stops
+     * wrapping, or the indicator is disposed.
+     */
+    private _clearContinuationMarkers;
     /**
      * Apply the visual shape to the underline element.
      * Called once per tab group per frame with the computed geometry.
      */
     protected abstract applyShape(underline: HTMLElement, tg: ITabGroup, startEdge: number, span: number, containerCrossSize: number, activePanelId: string | undefined, containerRect: DOMRect, isVertical: boolean): void;
     private _positionUnderlinesSync;
+    /**
+     * Position a group's underline across a multi-line (wrapped) tab strip. The
+     * single-bar model can't span lines, so the element is sized to cover the
+     * group's line span and an SVG draws one straight segment per line-run of
+     * the group's tabs: a horizontal segment per row (horizontal header) or a
+     * vertical segment per column (vertical header). Tabs are bucketed into
+     * runs by their cross-axis offset: `top` for rows, `left` for columns.
+     * (The active-tab wrap-around bump is omitted in wrap; the per-line lines
+     * still convey membership.)
+     */
+    private _positionWrappedUnderline;
+    /**
+     * Bucket a group's visible tabs into line-runs by their cross-axis offset
+     * (rows by `top`, columns by `left`), with a 2px sub-pixel tolerance.
+     * `firstRun` is the run holding the group's first tab (the chip's line),
+     * tracked by reference so it is correct regardless of axis or header side (a
+     * `vertical-rl` first column is right-most, not left-most).
+     */
+    private _computeWrappedRuns;
+    /**
+     * Build the SVG `path` data for a group's per-line underline segments: a
+     * horizontal segment along each row's edge (`svg-y` offset by `minTop`) or a
+     * vertical segment down each column's leading edge (`svg-x` offset by
+     * `minLeft`). `inverted` moves the line to the header-facing edge.
+     */
+    private _wrappedPathData;
+    /**
+     * Draw a small accent pip at the leading edge of every wrapped line-run a
+     * group spans beyond its first. The group's real chip already marks the
+     * first run; these lightweight markers echo it on the continuation runs so
+     * a group that wraps onto rows/columns 2–3 reads as one group on each line
+     * instead of losing its colour after the first.
+     *
+     * `runs` are the group's line-runs (container-relative geometry) as
+     * bucketed by {@link _positionWrappedUnderline}; `firstRun` is the run that
+     * holds the chip and is skipped. The pip sits at each continuation run's
+     * main-axis start (top of a column, left of a row), centred on the cross
+     * axis.
+     */
+    private _positionContinuationMarkers;
+    /**
+     * Ensure the underline element holds a single reusable `<svg><path/></svg>`
+     * (created once, reused across frames) and return them.
+     */
+    protected ensureSvgPath(underline: HTMLElement): {
+        svg: SVGSVGElement;
+        path: SVGPathElement;
+    };
 }
 /**
  * Chrome-style wrap-around indicator using SVG paths.
@@ -63,8 +134,8 @@ export declare class WrapTabGroupIndicator extends BaseTabGroupIndicator {
     protected applyShape(underline: HTMLElement, tg: ITabGroup, groupStart: number, groupSpan: number, containerCrossSize: number, activePanelId: string | undefined, containerRect: DOMRect, isVertical: boolean): void;
 }
 /**
- * Flat continuous bar indicator — no wrap-around, just a colored line
- * spanning the full tab group width.
+ * Flat continuous bar indicator: a plain colored line spanning the full tab
+ * group width, with no wrap-around.
  */
 export declare class NoneTabGroupIndicator extends BaseTabGroupIndicator {
     protected applyShape(underline: HTMLElement, tg: ITabGroup, _startEdge: number, span: number, _containerCrossSize: number, _activePanelId: string | undefined, _containerRect: DOMRect, isVertical: boolean): void;

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

@@ -75,7 +75,7 @@ export declare class TabGroupManager {
     /**
      * Synchronously dispose the chip drag sources for an in-flight chip
      * drag. Called from `_commitGroupMove` so the transfer payload +
-     * iframe shield are released BEFORE the cross-group move detaches
+     * iframe shield are released before the cross-group move detaches
      * the chip (chip dispose is scheduled on a microtask via
      * `_scheduleTabGroupUpdate`, which is too late for callers that read
      * `getPanelData()` synchronously after the move).