dockview-core 8.0.0 → 8.1.0

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

@@ -692,11 +692,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.

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/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;