dockview-core 8.0.0 → 8.2.0

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/dataTransfer.d.ts

@@ -1,4 +1,5 @@
 declare class TransferObject {
+    protected constructor();
 }
 export declare class PanelTransfer extends TransferObject {
     readonly viewId: string;

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

@@ -6,26 +6,11 @@ import { DockviewWillDropEvent } from './dockviewGroupPanelModel';
 import { DockviewGroupPanel } from './dockviewGroupPanel';
 import { DockviewGroupDropLocation, DockviewWillShowOverlayLocationEvent } from './events';
 import { IAdvancedDnDHost, IAdvancedDnDService } from './moduleContracts';
-/**
- * The narrow surface the {@link AdvancedDnDService} needs from the host
- * (the `DockviewComponent`).
- *
- * The `onWill*` emitters stay on the component so the public event shape is
- * unchanged whether or not this module is registered; the service is only the
- * dispatch point those fires are routed through. Engine policy (e.g. the
- * `disableDnd` guard) stays on the component, ahead of the dispatch.
- */
 /**
  * Owns the dispatch of the advanced drag-and-drop hooks: `onWillDragPanel`,
- * `onWillDragGroup`, `onWillDrop` and `onWillShowOverlay`.
- *
- * At this stage the service is a thin dispatcher that forwards to the host's
- * emitters; the customisation surface it gates (custom drop overlays, custom
- * group drag ghosts, hook veto/transform behaviour) is currently inlined in
- * core and is extracted into this service in later phases. Routing the
- * dispatch through a module slot is what lets that customisation layer move
- * into a separately-distributed package in a future major version without
- * changing the public event surface.
+ * `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

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;
@@ -692,11 +698,15 @@ export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> impl
     /**
      * Reveal (create-or-fill) the edge group at `position` and move the dragged
      * item described by `data` into it. A newly created edge group is created
-     * collapsed and flagged `autoReveal` so it tears down to zero footprint when
-     * later emptied. If an edge group already exists there it is reused: the
-     * panel is added to its tabs and its collapsed/toggled state is left as-is
-     * (never re-created; `addEdgeGroup` throws on a duplicate position). No-op if
-     * the EdgeGroup module is absent.
+     * collapsed, flagged `autoReveal` so it tears down to zero footprint when
+     * later emptied, and takes its auto-hide state from `options.autoHide`. If an
+     * edge group already exists there it is reused: the panel is added to its
+     * tabs and its collapsed/toggled *and auto-hide* state are left as-is (never
+     * re-created; `addEdgeGroup` throws on a duplicate position). This keeps a
+     * drag-reveal from silently converting a static edge group into an
+     * auto-hiding one; to change an existing group's auto-hide, call
+     * `api.getEdgeGroup(position)?.setAutoHide(...)` directly. No-op if the
+     * EdgeGroup module is absent.
      *
      * This is the primitive behind the dock-to-edge groups: the two-band
      * drag-reveal affordance routes its outer-band drops here.
@@ -852,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
@@ -873,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;

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

@@ -187,6 +187,22 @@ export declare class DockviewGroupPanelModel extends CompositeDisposable impleme
     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;
@@ -384,6 +400,14 @@ export declare class DockviewGroupPanelModel extends CompositeDisposable impleme
      * 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;

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

@@ -474,6 +474,11 @@ export interface IPinnedTabsHost {
     readonly options: DockviewComponentOptions;
     readonly onDidAddGroup: Event<DockviewGroupPanel>;
     readonly onDidRemoveGroup: Event<DockviewGroupPanel>;
+    /** Fires after `updateOptions`; the service re-applies the pinned-tabs
+     *  presentation (mode / sticky) to every existing group so a runtime
+     *  `pinnedTabs` change takes effect. New groups pick it up in
+     *  `onDidAddGroup`; this retrofits the ones that already exist. */
+    readonly onDidOptionsChange: Event<void>;
     /** Fires after a panel's pinned flag is mutated via the gated
      *  `setPanelPinned`; the service's sole trigger to re-order the strip. */
     readonly onDidPanelPinnedChange: Event<DockviewPanelPinnedChangeEvent>;

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

@@ -589,7 +589,6 @@ export interface PinnedTabsOptions {
     /**
      * `'inline'` (default) keeps pinned tabs first within the existing strip;
      * `'separate-row'` renders them on their own VS-Code-style row.
-     * (Phase 1 implements `'inline'` only.)
      */
     mode?: 'inline' | 'separate-row';
     /**

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

@@ -7,6 +7,9 @@ import { CompositeDisposable } from '../lifecycle';
  * a raw color literal (`'#abc123'`, `'rgb(0,0,0)'`), or `undefined` to inherit
  * the default. Resolution to a concrete CSS value is handled by the
  * dockview's `TabGroupColorPalette` (see `tabGroupAccent.ts`).
+ *
+ * This is a deliberate semantic alias for a public API type; inlining it to
+ * `string` would be a breaking API change and lose the documented meaning.
  */
 export type DockviewTabGroupColor = string;
 export interface SerializedTabGroup {

package/dist/cjs/events.d.ts

@@ -45,7 +45,7 @@ export declare class Emitter<T> implements IDisposable {
     private _last?;
     private _listeners;
     private _disposed;
-    private readonly _pauseTokens;
+    private _pauseTokens?;
     static ENABLE_TRACKING: boolean;
     static readonly MEMORY_LEAK_WATCHER: LeakageMonitor;
     static setLeakageMonitorEnabled(isEnabled: boolean): void;

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

@@ -13,6 +13,20 @@ export declare class BranchNode extends CompositeDisposable implements IView {
     private _size;
     private _childrenDisposable;
     readonly children: Node[];
+    /**
+     * `minimumSize`/`maximumSize`/`priority` are aggregates over all children,
+     * read repeatedly per frame inside `Splitview.resize` / `layoutViews`.
+     * Because a grid is splitviews-of-splitviews, recomputing them on every
+     * getter access (with array allocations) would make a sash drag O(children²)
+     * with per-read allocation. These values only change on a structural
+     * mutation, a visibility toggle, or a child's own constraints changing (which
+     * surfaces as the child's `onDidChange`) — none of which fire during a plain
+     * sash drag — so we cache them and invalidate on exactly those signals.
+     * `undefined` means "dirty; recompute on read".
+     */
+    private _cachedMinimumSize;
+    private _cachedMaximumSize;
+    private _cachedPriority;
     private readonly _onDidChange;
     readonly onDidChange: Event<{
         size?: number;
@@ -35,6 +49,8 @@ export declare class BranchNode extends CompositeDisposable implements IView {
     get maximumWidth(): number;
     get maximumHeight(): number;
     get priority(): LayoutPriority;
+    private computePriority;
+    private invalidateCachedSizes;
     get disabled(): boolean;
     set disabled(value: boolean);
     get margin(): number;

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;

package/dist/cjs/scrollbar.d.ts

@@ -5,11 +5,21 @@ export declare class Scrollbar extends CompositeDisposable {
     private readonly _scrollbar;
     private _scrollOffset;
     private _animationTimer;
+    private _pendingStyleFrame;
     private _orientation;
     static readonly MouseWheelSpeed = 1;
     get element(): HTMLElement;
     get orientation(): 'horizontal' | 'vertical';
     set orientation(value: 'horizontal' | 'vertical');
     constructor(scrollableElement: HTMLElement);
+    /**
+     * Coalesce the scrollbar restyle to one pass per animation frame. The
+     * wheel / scroll / pointermove handlers can each fire many times per frame,
+     * and `calculateScrollbarStyles` both reads layout (`clientWidth`/
+     * `scrollWidth`) and writes styles + `scrollLeft`/`scrollTop`; running it
+     * synchronously per event caused repeated read→write→read reflow. Batching
+     * to a frame keeps a burst of events to a single measure+write.
+     */
+    private scheduleStyleUpdate;
     private calculateScrollbarStyles;
 }

package/dist/cjs/splitview/viewItem.d.ts

@@ -6,7 +6,17 @@ export declare class ViewItem {
     private readonly disposable;
     private _size;
     private _cachedVisibleSize;
+    /**
+     * The geometry styles last written to `container` by `layoutViews`. Sizes
+     * are re-applied on every layout/resize frame, but for the many views that
+     * didn't move on a given frame the value is identical to last time; writing
+     * an unchanged inline style still dirties the element for style recalc, so
+     * we diff against these and skip the no-op writes. `layoutViews` is the only
+     * writer of these four properties (verified), so the cache cannot drift.
+     */
+    private readonly _appliedStyles;
     set size(size: number);
+    setContainerGeometry(prop: 'width' | 'height' | 'top' | 'left', value: string): void;
     get size(): number;
     get cachedVisibleSize(): number | undefined;
     get visible(): boolean;