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

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;