refactor: rename panel api objects

packages/splitview/src/__tests__/api/api.spec.ts

@@ -1,10 +1,10 @@
-import { BaseViewApi, StateObject } from '../../api/api';
+import { PanelApi, StateObject } from '../../api/panelApi';
 
 describe('api', () => {
-    let api: BaseViewApi;
+    let api: PanelApi;
 
     beforeEach(() => {
-        api = new BaseViewApi('dummy_id');
+        api = new PanelApi('dummy_id');
     });
 
     it('sets api state', () => {

packages/splitview/src/__tests__/groupview/groupview.spec.ts

@@ -1,4 +1,3 @@
-import { IGroupPanelApi } from '../../api/groupPanelApi';
 import { IDockviewComponent } from '../../dockview/dockviewComponent';
 import { Emitter } from '../../events';
 import {
@@ -22,6 +21,7 @@ import {
     IGroupPanelView,
 } from '../../react/dockview/v2/defaultGroupPanelView';
 import { GroupOptions, GroupDropEvent } from '../../groupview/v2/component';
+import { IDockviewPanelApi } from '../../api/groupPanelApi';
 
 class Watermark implements WatermarkPart {
     public readonly element = document.createElement('div');
@@ -129,7 +129,7 @@ class TestPanel implements IGroupPanel {
         return this._view;
     }
 
-    constructor(public readonly id: string, public api: IGroupPanelApi) {
+    constructor(public readonly id: string, public api: IDockviewPanelApi) {
         this.init({
             view: new DefaultGroupPanelView({
                 tab: new TestHeaderPart(id),

packages/splitview/src/__tests__/paneview/paneviewComponent.spec.ts

@@ -1,4 +1,4 @@
-import { PanelDimensionChangeEvent } from '../../api/api';
+import { PanelDimensionChangeEvent } from '../../api/panelApi';
 import { CompositeDisposable } from '../../lifecycle';
 import { PanelUpdateEvent } from '../../panel/types';
 import { PaneviewComponent } from '../../paneview/paneviewComponent';

packages/splitview/src/__tests__/splitview/splitviewComponent.spec.ts

@@ -1,4 +1,4 @@
-import { PanelDimensionChangeEvent } from '../../api/api';
+import { PanelDimensionChangeEvent } from '../../api/panelApi';
 import { CompositeDisposable } from '../../lifecycle';
 import { Orientation } from '../../splitview/core/splitview';
 import { SplitviewComponent } from '../../splitview/splitviewComponent';

packages/splitview/src/api/api.ts

@@ -1,207 +0,0 @@
-import { Emitter, Event } from '../events';
-import { CompositeDisposable } from '../lifecycle';
-
-/**
- * A valid JSON type
- */
-export type StateObject =
-    | number
-    | string
-    | boolean
-    | null
-    | object
-    | StateObject[]
-    | { [key: string]: StateObject };
-
-/**
- * A JSON-serializable object
- */
-export interface State {
-    [key: string]: StateObject;
-}
-
-export interface FocusEvent {
-    isFocused: boolean;
-}
-export interface PanelDimensionChangeEvent {
-    width: number;
-    height: number;
-}
-
-export interface VisibilityEvent {
-    isVisible: boolean;
-}
-
-export interface ActiveEvent {
-    isActive: boolean;
-}
-
-export interface IBaseViewApi {
-    // events
-    onDidDimensionsChange: Event<PanelDimensionChangeEvent>;
-    onDidStateChange: Event<void>;
-    onDidFocusChange: Event<FocusEvent>;
-    onDidVisibilityChange: Event<VisibilityEvent>;
-    onDidActiveChange: Event<ActiveEvent>;
-    onFocusEvent: Event<void>;
-    //
-    setVisible(isVisible: boolean): void;
-    setActive(): void;
-    // state
-    setState(key: string, value: StateObject): void;
-    setState(state: State): void;
-    getState: () => State;
-    getStateKey: <T extends StateObject>(key: string) => T;
-    /**
-     * The id of the panel that would have been assigned when the panel was created
-     */
-    readonly id: string;
-    /**
-     * Whether the panel holds the current focus
-     */
-    readonly isFocused: boolean;
-    /**
-     * Whether the panel is the actively selected panel
-     */
-    readonly isActive: boolean;
-    /**
-     * Whether the panel is visible
-     */
-    readonly isVisible: boolean;
-    /**
-     * The panel width in pixels
-     */
-    readonly width: number;
-    /**
-     * The panel height in pixels
-     */
-    readonly height: number;
-}
-
-/**
- * A core api implementation that should be used across all panel-like objects
- */
-export class BaseViewApi extends CompositeDisposable implements IBaseViewApi {
-    private _state: State = {};
-    private _isFocused = false;
-    private _isActive = false;
-    private _isVisible = true;
-    private _width = 0;
-    private _height = 0;
-
-    readonly _onDidStateChange = new Emitter<void>();
-    readonly onDidStateChange: Event<void> = this._onDidStateChange.event;
-    //
-    readonly _onDidPanelDimensionChange = new Emitter<PanelDimensionChangeEvent>(
-        {
-            replay: true,
-        }
-    );
-    readonly onDidDimensionsChange = this._onDidPanelDimensionChange.event;
-    //
-    readonly _onDidChangeFocus = new Emitter<FocusEvent>({
-        replay: true,
-    });
-    readonly onDidFocusChange: Event<FocusEvent> = this._onDidChangeFocus.event;
-    //
-    readonly _onFocusEvent = new Emitter<void>();
-    readonly onFocusEvent: Event<void> = this._onFocusEvent.event;
-    //
-    readonly _onDidVisibilityChange = new Emitter<VisibilityEvent>({
-        replay: true,
-    });
-    readonly onDidVisibilityChange: Event<VisibilityEvent> = this
-        ._onDidVisibilityChange.event;
-    //
-
-    readonly _onVisibilityChange = new Emitter<VisibilityEvent>();
-    readonly onVisibilityChange: Event<VisibilityEvent> = this
-        ._onVisibilityChange.event;
-    //
-    readonly _onDidActiveChange = new Emitter<ActiveEvent>({
-        replay: true,
-    });
-    readonly onDidActiveChange: Event<ActiveEvent> = this._onDidActiveChange
-        .event;
-    //
-    readonly _onActiveChange = new Emitter<void>();
-    readonly onActiveChange: Event<void> = this._onActiveChange.event;
-    //
-
-    get isFocused() {
-        return this._isFocused;
-    }
-
-    get isActive() {
-        return this._isActive;
-    }
-    get isVisible() {
-        return this._isVisible;
-    }
-
-    get width() {
-        return this._width;
-    }
-
-    get height() {
-        return this._height;
-    }
-
-    constructor(readonly id: string) {
-        super();
-
-        this.addDisposables(
-            this._onDidStateChange,
-            this._onDidPanelDimensionChange,
-            this._onDidChangeFocus,
-            this._onDidVisibilityChange,
-            this._onDidActiveChange,
-            this._onFocusEvent,
-            this.onDidFocusChange((event) => {
-                this._isFocused = event.isFocused;
-            }),
-            this.onDidActiveChange((event) => {
-                this._isActive = event.isActive;
-            }),
-            this.onDidVisibilityChange((event) => {
-                this._isVisible = event.isVisible;
-            }),
-            this.onDidDimensionsChange((event) => {
-                this._width = event.width;
-                this._height = event.height;
-            })
-        );
-    }
-
-    setVisible(isVisible: boolean) {
-        this._onVisibilityChange.fire({ isVisible });
-    }
-
-    setActive(): void {
-        this._onActiveChange.fire();
-    }
-
-    setState(
-        key: string | { [key: string]: StateObject },
-        value?: StateObject
-    ): void {
-        if (typeof key === 'object') {
-            this._state = key;
-        } else if (typeof value !== undefined) {
-            this._state[key] = value!;
-        }
-        this._onDidStateChange.fire(undefined);
-    }
-
-    getState(): State {
-        return this._state;
-    }
-
-    getStateKey<T extends StateObject>(key: string): T {
-        return this._state[key] as T;
-    }
-
-    dispose() {
-        super.dispose();
-    }
-}

packages/splitview/src/api/gridviewPanelApi.ts

@@ -1,6 +1,6 @@
 import { Emitter, Event } from '../events';
 import { FunctionOrValue } from '../types';
-import { BaseViewApi, IBaseViewApi } from './api';
+import { PanelApi, IPanelApi } from './panelApi';
 
 export interface GridConstraintChangeEvent {
     minimumWidth?: number;
@@ -21,19 +21,16 @@ export interface SizeEvent {
     height?: number;
 }
 
-export interface IGridPanelApi extends IBaseViewApi {
+export interface IGridviewPanelApi extends IPanelApi {
     onDidConstraintsChange: Event<GridConstraintChangeEvent>;
     setConstraints(value: GridConstraintChangeEvent2): void;
     setSize(event: SizeEvent): void;
 }
 
-export class GridPanelApi extends BaseViewApi implements IGridPanelApi {
+export class GridviewPanelApi extends PanelApi implements IGridviewPanelApi {
-    readonly _onDidConstraintsChangeInternal = new Emitter<
+    readonly _onDidConstraintsChangeInternal = new Emitter<GridConstraintChangeEvent2>();
-        GridConstraintChangeEvent2
+    readonly onDidConstraintsChangeInternal: Event<GridConstraintChangeEvent2> = this
-    >();
+        ._onDidConstraintsChangeInternal.event;
-    readonly onDidConstraintsChangeInternal: Event<
-        GridConstraintChangeEvent2
-    > = this._onDidConstraintsChangeInternal.event;
     //
 
     readonly _onDidConstraintsChange = new Emitter<GridConstraintChangeEvent>({

packages/splitview/src/api/groupPanelApi.ts

@@ -1,5 +1,5 @@
 import { Emitter, Event } from '../events';
-import { GridPanelApi, IGridPanelApi } from './gridPanelApi';
+import { GridviewPanelApi, IGridviewPanelApi } from './gridviewPanelApi';
 import { IGroupPanel } from '../groupview/groupPanel';
 import { GroupviewPanel } from '../groupview/v2/groupviewPanel';
 
@@ -11,8 +11,8 @@ export interface TitleEvent {
  * omit visibility modifiers since the visibility of a single group doesn't make sense
  * because it belongs to a groupview
  */
-export interface IGroupPanelApi
+export interface IDockviewPanelApi
-    extends Omit<IGridPanelApi, 'setVisible' | 'visible'> {
+    extends Omit<IGridviewPanelApi, 'setVisible' | 'visible'> {
     readonly group: GroupviewPanel | undefined;
     readonly isGroupActive: boolean;
     onDidDirtyChange: Event<boolean>;
@@ -22,7 +22,9 @@ export interface IGroupPanelApi
     setTitle(title: string): void;
 }
 
-export class GroupPanelApi extends GridPanelApi implements IGroupPanelApi {
+export class DockviewPanelApi
+    extends GridviewPanelApi
+    implements IDockviewPanelApi {
     private _group: GroupviewPanel | undefined;
     private _interceptor: undefined | (() => Promise<boolean>);
 

packages/splitview/src/api/panelApi.ts

@@ -1,64 +1,207 @@
 import { Emitter, Event } from '../events';
-import { IDisposable } from '../lifecycle';
+import { CompositeDisposable } from '../lifecycle';
-import { FunctionOrValue } from '../types';
-import { BaseViewApi, IBaseViewApi } from './api';
 
-interface PanelConstraintChangeEvent2 {
+/**
-    minimumSize?: FunctionOrValue<number>;
+ * A valid JSON type
-    maximumSize?: FunctionOrValue<number>;
+ */
+export type StateObject =
+    | number
+    | string
+    | boolean
+    | null
+    | object
+    | StateObject[]
+    | { [key: string]: StateObject };
+
+/**
+ * A JSON-serializable object
+ */
+export interface State {
+    [key: string]: StateObject;
 }
 
-export interface PanelConstraintChangeEvent {
+export interface FocusEvent {
-    minimumSize?: number;
+    isFocused: boolean;
-    maximumSize?: number;
+}
+export interface PanelDimensionChangeEvent {
+    width: number;
+    height: number;
 }
 
-export interface PanelSizeEvent {
+export interface VisibilityEvent {
-    size: number;
+    isVisible: boolean;
 }
 
-export interface IPanelApi extends IBaseViewApi {
+export interface ActiveEvent {
-    onDidConstraintsChange: Event<PanelConstraintChangeEvent>;
+    isActive: boolean;
-    setConstraints(value: PanelConstraintChangeEvent2): void;
-    setSize(event: PanelSizeEvent): void;
 }
 
-export class PanelApi extends BaseViewApi implements IPanelApi, IDisposable {
+export interface IPanelApi {
-    readonly _onDidConstraintsChangeInternal = new Emitter<
+    // events
-        PanelConstraintChangeEvent2
+    onDidDimensionsChange: Event<PanelDimensionChangeEvent>;
-    >();
+    onDidStateChange: Event<void>;
-    readonly onDidConstraintsChangeInternal: Event<
+    onDidFocusChange: Event<FocusEvent>;
-        PanelConstraintChangeEvent2
+    onDidVisibilityChange: Event<VisibilityEvent>;
-    > = this._onDidConstraintsChangeInternal.event;
+    onDidActiveChange: Event<ActiveEvent>;
+    onFocusEvent: Event<void>;
     //
+    setVisible(isVisible: boolean): void;
+    setActive(): void;
+    // state
+    setState(key: string, value: StateObject): void;
+    setState(state: State): void;
+    getState: () => State;
+    getStateKey: <T extends StateObject>(key: string) => T;
+    /**
+     * The id of the panel that would have been assigned when the panel was created
+     */
+    readonly id: string;
+    /**
+     * Whether the panel holds the current focus
+     */
+    readonly isFocused: boolean;
+    /**
+     * Whether the panel is the actively selected panel
+     */
+    readonly isActive: boolean;
+    /**
+     * Whether the panel is visible
+     */
+    readonly isVisible: boolean;
+    /**
+     * The panel width in pixels
+     */
+    readonly width: number;
+    /**
+     * The panel height in pixels
+     */
+    readonly height: number;
+}
 
-    readonly _onDidConstraintsChange = new Emitter<PanelConstraintChangeEvent>({
+/**
+ * A core api implementation that should be used across all panel-like objects
+ */
+export class PanelApi extends CompositeDisposable implements IPanelApi {
+    private _state: State = {};
+    private _isFocused = false;
+    private _isActive = false;
+    private _isVisible = true;
+    private _width = 0;
+    private _height = 0;
+
+    readonly _onDidStateChange = new Emitter<void>();
+    readonly onDidStateChange: Event<void> = this._onDidStateChange.event;
+    //
+    readonly _onDidPanelDimensionChange = new Emitter<PanelDimensionChangeEvent>(
+        {
+            replay: true,
+        }
+    );
+    readonly onDidDimensionsChange = this._onDidPanelDimensionChange.event;
+    //
+    readonly _onDidChangeFocus = new Emitter<FocusEvent>({
         replay: true,
     });
-    readonly onDidConstraintsChange: Event<PanelConstraintChangeEvent> = this
+    readonly onDidFocusChange: Event<FocusEvent> = this._onDidChangeFocus.event;
-        ._onDidConstraintsChange.event;
+    //
+    readonly _onFocusEvent = new Emitter<void>();
+    readonly onFocusEvent: Event<void> = this._onFocusEvent.event;
+    //
+    readonly _onDidVisibilityChange = new Emitter<VisibilityEvent>({
+        replay: true,
+    });
+    readonly onDidVisibilityChange: Event<VisibilityEvent> = this
+        ._onDidVisibilityChange.event;
     //
 
-    readonly _onDidSizeChange = new Emitter<PanelSizeEvent>();
+    readonly _onVisibilityChange = new Emitter<VisibilityEvent>();
-    readonly onDidSizeChange: Event<PanelSizeEvent> = this._onDidSizeChange
+    readonly onVisibilityChange: Event<VisibilityEvent> = this
+        ._onVisibilityChange.event;
+    //
+    readonly _onDidActiveChange = new Emitter<ActiveEvent>({
+        replay: true,
+    });
+    readonly onDidActiveChange: Event<ActiveEvent> = this._onDidActiveChange
         .event;
     //
+    readonly _onActiveChange = new Emitter<void>();
+    readonly onActiveChange: Event<void> = this._onActiveChange.event;
+    //
 
-    constructor(id: string) {
+    get isFocused() {
-        super(id);
+        return this._isFocused;
     }
 
-    setConstraints(value: PanelConstraintChangeEvent2) {
+    get isActive() {
-        this._onDidConstraintsChangeInternal.fire(value);
+        return this._isActive;
+    }
+    get isVisible() {
+        return this._isVisible;
     }
 
-    setSize(event: PanelSizeEvent) {
+    get width() {
-        this._onDidSizeChange.fire(event);
+        return this._width;
+    }
+
+    get height() {
+        return this._height;
+    }
+
+    constructor(readonly id: string) {
+        super();
+
+        this.addDisposables(
+            this._onDidStateChange,
+            this._onDidPanelDimensionChange,
+            this._onDidChangeFocus,
+            this._onDidVisibilityChange,
+            this._onDidActiveChange,
+            this._onFocusEvent,
+            this.onDidFocusChange((event) => {
+                this._isFocused = event.isFocused;
+            }),
+            this.onDidActiveChange((event) => {
+                this._isActive = event.isActive;
+            }),
+            this.onDidVisibilityChange((event) => {
+                this._isVisible = event.isVisible;
+            }),
+            this.onDidDimensionsChange((event) => {
+                this._width = event.width;
+                this._height = event.height;
+            })
+        );
+    }
+
+    setVisible(isVisible: boolean) {
+        this._onVisibilityChange.fire({ isVisible });
+    }
+
+    setActive(): void {
+        this._onActiveChange.fire();
+    }
+
+    setState(
+        key: string | { [key: string]: StateObject },
+        value?: StateObject
+    ): void {
+        if (typeof key === 'object') {
+            this._state = key;
+        } else if (typeof value !== undefined) {
+            this._state[key] = value!;
+        }
+        this._onDidStateChange.fire(undefined);
+    }
+
+    getState(): State {
+        return this._state;
+    }
+
+    getStateKey<T extends StateObject>(key: string): T {
+        return this._state[key] as T;
     }
 
     dispose() {
         super.dispose();
-        this._onDidConstraintsChange.dispose();
-        this._onDidSizeChange.dispose();
     }
 }

packages/splitview/src/api/paneviewPanelApi.ts

@@ -1,12 +1,12 @@
 import { Emitter, Event } from '../events';
 import { PaneviewPanel } from '../paneview/paneviewPanel';
-import { IPanelApi, PanelApi } from './panelApi';
+import { ISplitviewPanelApi, SplitviewPanelApi } from './splitviewPanelApi';
 
 export interface ExpansionEvent {
     isExpanded: boolean;
 }
 
-export interface IPanePanelApi extends IPanelApi {
+export interface IPaneviewPanelApi extends ISplitviewPanelApi {
     onDidExpansionChange: Event<ExpansionEvent>;
     readonly onMouseEnter: Event<MouseEvent>;
     readonly onMouseLeave: Event<MouseEvent>;
@@ -14,7 +14,9 @@ export interface IPanePanelApi extends IPanelApi {
     readonly isExpanded: boolean;
 }
 
-export class PanePanelApi extends PanelApi implements IPanePanelApi {
+export class PaneviewPanelApi
+    extends SplitviewPanelApi
+    implements IPaneviewPanelApi {
     readonly _onDidExpansionChange = new Emitter<ExpansionEvent>({
         replay: true,
     });

packages/splitview/src/api/splitviewPanelApi.ts

@@ -0,0 +1,63 @@
+import { Emitter, Event } from '../events';
+import { IDisposable } from '../lifecycle';
+import { FunctionOrValue } from '../types';
+import { PanelApi, IPanelApi } from './panelApi';
+
+interface PanelConstraintChangeEvent2 {
+    minimumSize?: FunctionOrValue<number>;
+    maximumSize?: FunctionOrValue<number>;
+}
+
+export interface PanelConstraintChangeEvent {
+    minimumSize?: number;
+    maximumSize?: number;
+}
+
+export interface PanelSizeEvent {
+    size: number;
+}
+
+export interface ISplitviewPanelApi extends IPanelApi {
+    onDidConstraintsChange: Event<PanelConstraintChangeEvent>;
+    setConstraints(value: PanelConstraintChangeEvent2): void;
+    setSize(event: PanelSizeEvent): void;
+}
+
+export class SplitviewPanelApi
+    extends PanelApi
+    implements ISplitviewPanelApi, IDisposable {
+    readonly _onDidConstraintsChangeInternal = new Emitter<PanelConstraintChangeEvent2>();
+    readonly onDidConstraintsChangeInternal: Event<PanelConstraintChangeEvent2> = this
+        ._onDidConstraintsChangeInternal.event;
+    //
+
+    readonly _onDidConstraintsChange = new Emitter<PanelConstraintChangeEvent>({
+        replay: true,
+    });
+    readonly onDidConstraintsChange: Event<PanelConstraintChangeEvent> = this
+        ._onDidConstraintsChange.event;
+    //
+
+    readonly _onDidSizeChange = new Emitter<PanelSizeEvent>();
+    readonly onDidSizeChange: Event<PanelSizeEvent> = this._onDidSizeChange
+        .event;
+    //
+
+    constructor(id: string) {
+        super(id);
+    }
+
+    setConstraints(value: PanelConstraintChangeEvent2) {
+        this._onDidConstraintsChangeInternal.fire(value);
+    }
+
+    setSize(event: PanelSizeEvent) {
+        this._onDidSizeChange.fire(event);
+    }
+
+    dispose() {
+        super.dispose();
+        this._onDidConstraintsChange.dispose();
+        this._onDidSizeChange.dispose();
+    }
+}

packages/splitview/src/dockview/dockviewComponent.ts

@@ -47,7 +47,7 @@ import {
     toTarget,
 } from '../gridview/baseComponentGridview';
 import { DockviewApi } from '../api/component.api';
-import { State } from '../api/api';
+import { State } from '../api/panelApi';
 import { LayoutMouseEvent, MouseEventKind } from '../groupview/tab';
 import { Orientation } from '../splitview/core/splitview';
 import { DefaultTab } from './components/tab/defaultTab';

packages/splitview/src/gridview/basePanelView.ts

@@ -6,7 +6,7 @@ import {
     PanelInitParameters,
     IPanel,
 } from '../panel/types';
-import { BaseViewApi } from '../api/api';
+import { PanelApi } from '../api/panelApi';
 
 export interface BasePanelViewState {
     id: string;
@@ -15,7 +15,7 @@ export interface BasePanelViewState {
     state?: { [key: string]: any };
 }
 
-export interface BasePanelViewExported<T extends BaseViewApi> {
+export interface BasePanelViewExported<T extends PanelApi> {
     readonly id: string;
     readonly api: T;
     readonly width: number;
@@ -25,7 +25,7 @@ export interface BasePanelViewExported<T extends BaseViewApi> {
     update(params: PanelUpdateEvent): void;
 }
 
-export abstract class BasePanelView<T extends BaseViewApi>
+export abstract class BasePanelView<T extends PanelApi>
     extends CompositeDisposable
     implements IPanel, BasePanelViewExported<T> {
     private _height = 0;

packages/splitview/src/gridview/gridviewComponent.ts

@@ -19,14 +19,14 @@ import {
     IGridviewPanel,
 } from './gridviewPanel';
 import { BaseComponentOptions } from '../panel/types';
-import { GridPanelApi } from '../api/gridPanelApi';
+import { GridviewPanelApi } from '../api/gridviewPanelApi';
 import { GridviewApi } from '../api/component.api';
 import { Orientation, Sizing } from '../splitview/core/splitview';
 import { createComponent } from '../panel/componentFactory';
 import { GroupChangeKind } from '../groupview/v2/component';
 
 interface PanelReference {
-    api: GridPanelApi;
+    api: GridviewPanelApi;
 }
 
 export interface SerializedGridview {

packages/splitview/src/gridview/gridviewPanel.ts

@@ -6,7 +6,7 @@ import {
     BasePanelViewExported,
     BasePanelViewState,
 } from './basePanelView';
-import { GridPanelApi } from '../api/gridPanelApi';
+import { GridviewPanelApi } from '../api/gridviewPanelApi';
 import { LayoutPriority } from '../splitview/core/splitview';
 import { Emitter, Event } from '../events';
 import { IViewSize } from './gridview';
@@ -23,7 +23,8 @@ export interface GridviewInitParameters extends PanelInitParameters {
     isVisible?: boolean;
 }
 
-export interface IGridviewPanel extends BasePanelViewExported<GridPanelApi> {
+export interface IGridviewPanel
+    extends BasePanelViewExported<GridviewPanelApi> {
     readonly minimumWidth: number;
     readonly maximumWidth: number;
     readonly minimumHeight: number;
@@ -33,7 +34,7 @@ export interface IGridviewPanel extends BasePanelViewExported<GridPanelApi> {
 }
 
 export abstract class GridviewPanel
-    extends BasePanelView<GridPanelApi>
+    extends BasePanelView<GridviewPanelApi>
     implements IGridPanelComponentView, IGridviewPanel {
     private _evaluatedMinimumWidth = 0;
     private _evaluatedMaximumWidth = Number.MAX_SAFE_INTEGER;
@@ -119,7 +120,7 @@ export abstract class GridviewPanel
         return this.api.isActive;
     }
 
-    constructor(id: string, component: string, api = new GridPanelApi(id)) {
+    constructor(id: string, component: string, api = new GridviewPanelApi(id)) {
         super(id, component, api);
 
         this.addDisposables(

packages/splitview/src/groupview/groupPanel.ts

@@ -1,4 +1,4 @@
-import { GroupPanelApi, IGroupPanelApi } from '../api/groupPanelApi';
+import { DockviewPanelApi, IDockviewPanelApi } from '../api/groupPanelApi';
 import { Event } from '../events';
 import {
     MutableDisposable,
@@ -31,7 +31,7 @@ export interface IGroupPanel extends IDisposable, IPanel {
     // readonly content?: IContentRenderer;
     readonly view?: IGroupPanelView;
     readonly group?: GroupviewPanel;
-    readonly api: IGroupPanelApi;
+    readonly api: IDockviewPanelApi;
     updateParentGroup(group: GroupviewPanel, isGroupActive: boolean): void;
     setDirty(isDirty: boolean): void;
     close?(): Promise<boolean>;
@@ -52,7 +52,7 @@ export interface GroupviewPanelState {
 export class GroupPanel extends CompositeDisposable implements IGroupPanel {
     private readonly mutableDisposable = new MutableDisposable();
 
-    readonly api: GroupPanelApi;
+    readonly api: DockviewPanelApi;
     private _group: GroupviewPanel | undefined;
     private params?: IGroupPanelInitParameters;
 
@@ -84,7 +84,7 @@ export class GroupPanel extends CompositeDisposable implements IGroupPanel {
     ) {
         super();
 
-        this.api = new GroupPanelApi(this, this._group);
+        this.api = new DockviewPanelApi(this, this._group);
         this.onDidStateChange = this.api.onDidStateChange;
 
         this.addDisposables(

packages/splitview/src/groupview/panel/content.ts

@@ -6,7 +6,7 @@ import {
 import { Emitter, Event } from '../../events';
 import { trackFocus } from '../../dom';
 import { HostedContainer } from '../../hostedContainer';
-import { IGroupPanelApi } from '../../api/groupPanelApi';
+import { IDockviewPanelApi } from '../../api/groupPanelApi';
 import { IGroupPanel } from '../groupPanel';
 
 export interface IRenderable {

packages/splitview/src/groupview/types.ts

@@ -1,6 +1,6 @@
 import { IDisposable } from '../lifecycle';
 import { IDockviewComponent } from '../dockview/dockviewComponent';
-import { IGroupPanelApi } from '../api/groupPanelApi';
+import { IDockviewPanelApi } from '../api/groupPanelApi';
 import { PanelInitParameters, IPanel } from '../panel/types';
 import { DockviewApi } from '../api/component.api';
 import { GroupviewPanel } from './v2/groupviewPanel';
@@ -14,7 +14,7 @@ export interface HeaderPartInitParameters {
 export interface GroupPanelPartInitParameters
     extends PanelInitParameters,
         HeaderPartInitParameters {
-    api: IGroupPanelApi;
+    api: IDockviewPanelApi;
     containerApi: DockviewApi;
 }
 

packages/splitview/src/groupview/v2/groupviewPanel.ts

@@ -1,15 +1,18 @@
 import { IFrameworkPart } from '../../panel/types';
 import { IDockviewComponent } from '../../dockview/dockviewComponent';
-import { GridPanelApi, IGridPanelApi } from '../../api/gridPanelApi';
+import {
+    GridviewPanelApi,
+    IGridviewPanelApi,
+} from '../../api/gridviewPanelApi';
 import { GroupComponent, GroupOptions, GroupPanelViewState } from './component';
 import {
     GridPanelViewState,
     GridviewPanel,
 } from '../../gridview/gridviewPanel';
 
-interface IGroupApi extends IGridPanelApi {}
+interface IGroupApi extends IGridviewPanelApi {}
 
-class GroupApi extends GridPanelApi implements IGroupApi {
+class GroupApi extends GridviewPanelApi implements IGroupApi {
     private _value?: GroupComponent;
 
     set group(value: GroupComponent) {

packages/splitview/src/index.ts

@@ -27,16 +27,16 @@ export {
     PanelDimensionChangeEvent,
     VisibilityEvent,
     ActiveEvent,
-} from './api/api';
+} from './api/panelApi';
 export {
     SizeEvent,
-    IGridPanelApi,
+    IGridviewPanelApi,
     GridConstraintChangeEvent,
-} from './api/gridPanelApi';
+} from './api/gridviewPanelApi';
-export { TitleEvent, IGroupPanelApi } from './api/groupPanelApi';
+export { TitleEvent, IDockviewPanelApi } from './api/groupPanelApi';
 export {
     PanelSizeEvent,
     PanelConstraintChangeEvent,
-    IPanelApi,
+    ISplitviewPanelApi,
-} from './api/panelApi';
+} from './api/splitviewPanelApi';
-export { ExpansionEvent, IPanePanelApi } from './api/panePanelApi';
+export { ExpansionEvent, IPaneviewPanelApi } from './api/paneviewPanelApi';

packages/splitview/src/panel/types.ts

@@ -1,4 +1,4 @@
-import { State } from '../api/api';
+import { State } from '../api/panelApi';
 import { IDisposable } from '../lifecycle';
 import { LayoutPriority } from '../splitview/core/splitview';
 

packages/splitview/src/paneview/paneviewComponent.ts

@@ -1,5 +1,5 @@
 import { PaneviewApi } from '../api/component.api';
-import { PanePanelApi } from '../api/panePanelApi';
+import { PaneviewPanelApi } from '../api/paneviewPanelApi';
 import { createComponent } from '../panel/componentFactory';
 import { addDisposableListener, Emitter, Event } from '../events';
 import {
@@ -47,7 +47,7 @@ export interface SerializedPaneview {
 
 class DefaultHeader extends CompositeDisposable implements IPaneHeaderPart {
     private _element: HTMLElement;
-    private apiRef: { api: PanePanelApi | null } = { api: null };
+    private apiRef: { api: PaneviewPanelApi | null } = { api: null };
 
     get element() {
         return this._element;
@@ -64,7 +64,7 @@ class DefaultHeader extends CompositeDisposable implements IPaneHeaderPart {
         );
     }
 
-    init(params: PanePanelInitParameter & { api: PanePanelApi }) {
+    init(params: PanePanelInitParameter & { api: PaneviewPanelApi }) {
         this.apiRef.api = params.api;
         this._element.textContent = params.title;
     }

packages/splitview/src/paneview/paneviewPanel.ts

@@ -1,5 +1,5 @@
 import { PaneviewApi } from '../api/component.api';
-import { PanePanelApi } from '../api/panePanelApi';
+import { PaneviewPanelApi } from '../api/paneviewPanelApi';
 import { addDisposableListener, Emitter, Event } from '../events';
 import {
     BasePanelView,
@@ -30,7 +30,7 @@ export interface PanePanelInitParameter extends PanelInitParameters {
 
 export interface PanePanelComponentInitParameter
     extends PanePanelInitParameter {
-    api: PanePanelApi;
+    api: PaneviewPanelApi;
 }
 
 export interface IPaneBodyPart extends IDisposable {
@@ -49,7 +49,8 @@ export interface IPaneview extends IView {
     onDidChangeExpansionState: Event<boolean>;
 }
 
-export interface IPaneviewPanel extends BasePanelViewExported<PanePanelApi> {
+export interface IPaneviewPanel
+    extends BasePanelViewExported<PaneviewPanelApi> {
     readonly minimumSize: number;
     readonly maximumSize: number;
     readonly minimumBodySize: number;
@@ -59,7 +60,7 @@ export interface IPaneviewPanel extends BasePanelViewExported<PanePanelApi> {
 }
 
 export abstract class PaneviewPanel
-    extends BasePanelView<PanePanelApi>
+    extends BasePanelView<PaneviewPanelApi>
     implements IPaneview, IPaneviewPanel {
     private _onDidChangeExpansionState: Emitter<boolean> = new Emitter<boolean>(
         { replay: true }
@@ -138,7 +139,7 @@ export abstract class PaneviewPanel
         orientation: Orientation,
         isExpanded: boolean
     ) {
-        super(id, component, new PanePanelApi(id));
+        super(id, component, new PaneviewPanelApi(id));
         this.api.pane = this; // TODO cannot use 'this' before 'super'
         this._isExpanded = isExpanded;
 

packages/splitview/src/react/dockview/dockview.tsx

@@ -12,7 +12,7 @@ import {
     GroupPanelFrameworkComponentFactory,
     TabContextMenuEvent,
 } from '../../dockview/options';
-import { IGroupPanelApi } from '../../api/groupPanelApi';
+import { IDockviewPanelApi } from '../../api/groupPanelApi';
 import { usePortalsLifecycle } from '../react';
 import { DockviewApi } from '../../api/component.api';
 import { ReactWatermarkPart } from './reactWatermarkPart';
@@ -27,7 +27,7 @@ export interface ActionsbarReference<P> extends IDisposable {
 }
 
 export interface IGroupPanelBaseProps {
-    api: IGroupPanelApi;
+    api: IDockviewPanelApi;
     containerApi: DockviewApi;
     [key: string]: any;
 }

packages/splitview/src/react/dockview/reactContentPart.ts

@@ -6,14 +6,14 @@ import {
 import { ReactPart, ReactPortalStore } from '../react';
 import { ActionsbarReference, IDockviewPanelProps } from '../dockview/dockview';
 import { PanelUpdateEvent } from '../../panel/types';
-import { IGroupPanelApi } from '../../api/groupPanelApi';
+import { IDockviewPanelApi } from '../../api/groupPanelApi';
 import { DockviewApi } from '../../api/component.api';
 import { HostedContainer } from '../../hostedContainer';
 import { GroupviewPanel } from '../../groupview/v2/groupviewPanel';
 import { Emitter, Event } from '../../events';
 
 export interface IGroupPanelActionbarProps {
-    api: IGroupPanelApi;
+    api: IDockviewPanelApi;
     containerApi: DockviewApi;
 }
 

packages/splitview/src/react/gridview/gridview.tsx

@@ -3,7 +3,7 @@ import {
     GridviewComponent,
     IGridviewComponent,
 } from '../../gridview/gridviewComponent';
-import { IGridPanelApi } from '../../api/gridPanelApi';
+import { IGridviewPanelApi } from '../../api/gridviewPanelApi';
 import { Orientation } from '../../splitview/core/splitview';
 import { ReactGridPanelView } from './view';
 import { usePortalsLifecycle } from '../react';
@@ -16,7 +16,7 @@ export interface GridviewReadyEvent {
 }
 
 export interface IGridviewPanelProps {
-    api: IGridPanelApi;
+    api: IGridviewPanelApi;
     containerApi: GridviewApi;
     [key: string]: any;
 }

packages/splitview/src/react/paneview/paneview.tsx

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { IPanePanelApi } from '../../api/panePanelApi';
+import { IPaneviewPanelApi } from '../../api/paneviewPanelApi';
 import {
     PaneviewComponent,
     IPaneviewComponent,
@@ -15,7 +15,7 @@ export interface PaneviewReadyEvent {
 }
 
 export interface IPaneviewPanelProps {
-    api: IPanePanelApi;
+    api: IPaneviewPanelApi;
     containerApi: PaneviewApi;
     title: string;
     [key: string]: any;

packages/splitview/src/react/splitview/splitview.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { SplitviewApi } from '../../api/component.api';
-import { IPanelApi } from '../../api/panelApi';
+import { ISplitviewPanelApi } from '../../api/splitviewPanelApi';
 import {
     ISplitviewComponent,
     SplitviewComponent,
@@ -16,7 +16,7 @@ export interface SplitviewReadyEvent {
 }
 
 export interface ISplitviewPanelProps {
-    api: IPanelApi;
+    api: ISplitviewPanelApi;
     containerApi: SplitviewApi;
     [key: string]: any;
 }

packages/splitview/src/splitview/splitviewPanel.ts

@@ -3,12 +3,13 @@ import {
     BasePanelView,
     BasePanelViewExported,
 } from '../gridview/basePanelView';
-import { PanelApi } from '../api/panelApi';
+import { SplitviewPanelApi } from '../api/splitviewPanelApi';
 import { LayoutPriority, Orientation } from './core/splitview';
 import { FunctionOrValue } from '../types';
 import { Emitter, Event } from '../events';
 
-export interface ISplitviewPanel extends BasePanelViewExported<PanelApi> {
+export interface ISplitviewPanel
+    extends BasePanelViewExported<SplitviewPanelApi> {
     readonly priority: LayoutPriority | undefined;
     readonly minimumSize: number;
     readonly maximumSize: number;
@@ -17,7 +18,7 @@ export interface ISplitviewPanel extends BasePanelViewExported<PanelApi> {
 }
 
 export abstract class SplitviewPanel
-    extends BasePanelView<PanelApi>
+    extends BasePanelView<SplitviewPanelApi>
     implements ISerializableView, ISplitviewPanel {
     private _evaluatedMinimumSize = 0;
     private _evaluatedMaximumSize = Number.POSITIVE_INFINITY;
@@ -77,7 +78,7 @@ export abstract class SplitviewPanel
     }
 
     constructor(id: string, componentName: string) {
-        super(id, componentName, new PanelApi(id));
+        super(id, componentName, new SplitviewPanelApi(id));
 
         this.addDisposables(
             this.api.onVisibilityChange((event) => {