dockview-core 7.0.4 → 8.0.0

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

@@ -18,6 +18,8 @@ export interface IDockviewPanel extends IDisposable, IPanel {
     readonly minimumHeight?: number;
     readonly maximumWidth?: number;
     readonly maximumHeight?: number;
+    readonly isPinned: boolean;
+    setPinned(pinned: boolean): void;
     updateParentGroup(group: DockviewGroupPanel, options?: {
         skipSetActive?: boolean;
     }): void;
@@ -38,12 +40,14 @@ export declare class DockviewPanel extends CompositeDisposable implements IDockv
     private _params?;
     private _title;
     private _renderer;
+    private _pinned;
     private _minimumWidth;
     private _minimumHeight;
     private _maximumWidth;
     private _maximumHeight;
     get params(): Parameters | undefined;
     get title(): string | undefined;
+    get isPinned(): boolean;
     get group(): DockviewGroupPanel;
     get renderer(): DockviewPanelRenderer;
     get minimumWidth(): number | undefined;
@@ -57,6 +61,14 @@ export declare class DockviewPanel extends CompositeDisposable implements IDockv
     focus(): void;
     toJSON(): GroupviewPanelState;
     setTitle(title: string): void;
+    /**
+     * Low-level pinned-state mutation. Sets the flag and fires the panel-api
+     * event. The public, module-gated entry point is
+     * `panel.api.setPinned` → `DockviewComponent.setPanelPinned`, which decides
+     * whether pinning is active before reaching here; this method itself does
+     * not gate, so the ordering module and serialization can drive it directly.
+     */
+    setPinned(pinned: boolean): void;
     setRenderer(renderer: DockviewPanelRenderer): void;
     update(event: PanelUpdateEvent): void;
     updateFromStateModel(state: GroupviewPanelState): void;

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

@@ -10,31 +10,45 @@ export interface EdgeGroupOptions {
     collapsedSize?: number;
     collapsed?: boolean;
 }
+/**
+ * Options accepted by `api.addEdgeGroup`. Extends the shell's geometry options
+ * with per-group presentation flags the component (not the shell) owns.
+ */
+export interface AddEdgeGroupOptions extends EdgeGroupOptions {
+    /**
+     * Opt this edge group in/out of auto-hide (pinnable tool-window) behaviour,
+     * overriding the global `autoHideEdgeGroups` option. Requires the
+     * auto-hide module to have any effect. Leave unset to inherit the global.
+     */
+    autoHide?: boolean;
+    /**
+     * When true, this edge group tears itself down to zero footprint once
+     * emptied (instead of collapsing to a strip). This is the behaviour used
+     * by drag-revealed edges.
+     */
+    autoReveal?: boolean;
+}
+export interface SerializedEdgeGroup {
+    size: number;
+    visible: boolean;
+    collapsed?: boolean;
+    group?: unknown;
+    /** Per-group auto-hide override (drag-revealed / co-existence). Absent =
+     *  inherit the global `autoHideEdgeGroups` option. */
+    autoHide?: boolean;
+    /** Per-group "tear down to zero footprint when emptied" flag. */
+    autoReveal?: boolean;
+    /** User-configured geometry constraints (as passed to `addEdgeGroup`), so
+     *  they survive the auto-create fromJSON path. Absent = use the defaults. */
+    minimumSize?: number;
+    maximumSize?: number;
+    collapsedSize?: number;
+}
 export interface SerializedEdgeGroups {
-    top?: {
-        size: number;
-        visible: boolean;
-        collapsed?: boolean;
-        group?: unknown;
-    };
-    bottom?: {
-        size: number;
-        visible: boolean;
-        collapsed?: boolean;
-        group?: unknown;
-    };
-    left?: {
-        size: number;
-        visible: boolean;
-        collapsed?: boolean;
-        group?: unknown;
-    };
-    right?: {
-        size: number;
-        visible: boolean;
-        collapsed?: boolean;
-        group?: unknown;
-    };
+    top?: SerializedEdgeGroup;
+    bottom?: SerializedEdgeGroup;
+    left?: SerializedEdgeGroup;
+    right?: SerializedEdgeGroup;
 }
 /**
  * Minimal interface for a edge group host.
@@ -73,6 +87,13 @@ export declare class EdgeGroupView implements IView {
     get isCollapsed(): boolean;
     get lastExpandedSize(): number;
     get collapsedSize(): number;
+    /** The user-configured (pre-gap) geometry constraints, for serialization.
+     *  These are the raw values passed to `addEdgeGroup`, unlike the effective
+     *  `minimumSize`/`maximumSize`/`collapsedSize` getters, which fold in the
+     *  theme gap and collapse-locking. */
+    get configuredMinimumSize(): number | undefined;
+    get configuredMaximumSize(): number;
+    get configuredCollapsedSize(): number;
     constructor(options: EdgeGroupOptions, group: IEdgeGroupHost, orientation: 'horizontal' | 'vertical', gapAdd?: number);
     /**
      * Watch the group's tab strip so the collapsed size follows the live tab
@@ -143,6 +164,9 @@ export declare class ShellManager implements IDisposable {
     isEdgeGroupVisible(position: EdgeGroupPosition): boolean;
     setEdgeGroupCollapsed(position: EdgeGroupPosition, collapsed: boolean): void;
     isEdgeGroupCollapsed(position: EdgeGroupPosition): boolean;
+    /** The size an edge group expands to (its pre-collapse size), used to size
+     *  the auto-hide peek overlay. */
+    getEdgeGroupExpandedSize(position: EdgeGroupPosition): number;
     private _getView;
     toJSON(): SerializedEdgeGroups;
     fromJSON(data: SerializedEdgeGroups): void;

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

@@ -19,11 +19,27 @@ export interface IEdgeGroupService extends IDisposable {
     entries(): IterableIterator<[EdgeGroupPosition, DockviewGroupPanel]>;
     includes(group: DockviewGroupPanel): boolean;
     findPositionOf(group: DockviewGroupPanel): EdgeGroupPosition | undefined;
+    /**
+     * Per-group auto-hide opt-in. `undefined` means "unset", so callers should
+     * fall back to the global `autoHideEdgeGroups` option. This lets a static
+     * edge group and an auto-hiding one co-exist in the same layout.
+     */
+    setAutoHide(group: DockviewGroupPanel, value: boolean | undefined): void;
+    isAutoHide(group: DockviewGroupPanel): boolean | undefined;
+    /**
+     * Per-group "auto-reveal" flag. When set, an edge group tears itself down
+     * to zero footprint when emptied (instead of collapsing to a strip). This
+     * is the state used by drag-revealed edges.
+     */
+    setAutoReveal(group: DockviewGroupPanel, value: boolean): void;
+    isAutoReveal(group: DockviewGroupPanel): boolean;
     disposeAll(): void;
 }
 export declare class EdgeGroupService implements IEdgeGroupService {
     private readonly _edgeGroups;
     private readonly _edgeGroupDisposables;
+    private readonly _autoHide;
+    private readonly _autoReveal;
     add(position: EdgeGroupPosition, group: DockviewGroupPanel, autoCollapseDisposable: IDisposable): void;
     remove(position: EdgeGroupPosition): void;
     get(position: EdgeGroupPosition): DockviewGroupPanel | undefined;
@@ -32,6 +48,10 @@ export declare class EdgeGroupService implements IEdgeGroupService {
     entries(): IterableIterator<[EdgeGroupPosition, DockviewGroupPanel]>;
     includes(group: DockviewGroupPanel): boolean;
     findPositionOf(group: DockviewGroupPanel): EdgeGroupPosition | undefined;
+    setAutoHide(group: DockviewGroupPanel, value: boolean | undefined): void;
+    isAutoHide(group: DockviewGroupPanel): boolean | undefined;
+    setAutoReveal(group: DockviewGroupPanel, value: boolean): void;
+    isAutoReveal(group: DockviewGroupPanel): boolean;
     disposeAll(): void;
     dispose(): void;
 }

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

@@ -28,6 +28,12 @@ export declare class DockviewWillShowOverlayLocationEvent implements IDockviewEv
     /** Narrow with `instanceof DragEvent` before reading `dataTransfer`. */
     get nativeEvent(): DragEvent | PointerEvent;
     get position(): Position;
+    /** The resolved cell was marked `edge` (an outer "dock to the whole layout"
+     *  cell). See {@link DroptargetEvent.edge}. */
+    get edge(): boolean;
+    /** The resolved cell docks as a dedicated edge group (display hint). See
+     *  {@link PositionResolverResult.edgeGroup}. */
+    get edgeGroup(): boolean;
     get defaultPrevented(): boolean;
     get panel(): IDockviewPanel | undefined;
     get api(): DockviewApi;

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

@@ -6,7 +6,7 @@ import { DockviewLayoutMutationEvent, DockviewMaximizedGroupChangeEvent } from '
 import { DockviewComponentOptions } from './options';
 /**
  * The narrow surface the {@link LiveRegionService} needs from the host
- * (the `DockviewComponent`) — somewhere to mount the region and the layout
+ * (the `DockviewComponent`): somewhere to mount the region and the layout
  * events to narrate. `onWill/onDidMutateLayout` are used to suppress the
  * bulk-load / clear burst (one transaction, not N panel announcements).
  */
@@ -20,11 +20,15 @@ export interface ILiveRegionHost {
     readonly onDidMaximizedGroupChange: Event<DockviewMaximizedGroupChangeEvent>;
     readonly onDidAddGroup: Event<DockviewGroupPanel>;
     readonly onDidRemoveGroup: Event<DockviewGroupPanel>;
+    /** Live popout windows + a signal when that set changes, so the service can
+     *  mount a live region inside each popout document and route to it. */
+    getPopoutWindows(): Window[];
+    readonly onDidChangePopouts: Event<void>;
 }
 export interface ILiveRegionService extends IDisposable {
     /**
-     * Announce a message to assistive technology via the live region. The
-     * shared sink — the accessibility module writes keyboard-docking
+     * Announce a message to assistive technology via the live region. This
+     * is the shared sink: the accessibility module writes keyboard-docking
      * narration here too, so all announcements use one region.
      */
     announce(message: string, politeness?: 'polite' | 'assertive'): void;
@@ -40,11 +44,20 @@ export interface ILiveRegionService extends IDisposable {
  */
 export declare class LiveRegionService extends CompositeDisposable implements ILiveRegionService {
     private readonly _host;
-    private readonly _polite;
-    private readonly _assertive;
+    private readonly _mainWindow;
+    /** One live-region pair per window (main + each popout document). */
+    private readonly _regions;
     private _suppressDepth;
     private readonly _locationSubs;
     constructor(host: ILiveRegionHost);
+    /** Create a live region in every popout document that lacks one, and remove
+     *  regions for popouts that have closed. The main window's pair is permanent. */
+    private _syncPopoutRegions;
+    private _disposeRegions;
+    /** Route announcements to the live region of the window that currently has
+     *  focus, so a screen-reader user in a popout hears them, falling back to
+     *  the main window. */
+    private _focusedRegions;
     private _trackLocation;
     announce(message: string, politeness?: 'polite' | 'assertive'): void;
     private _announce;