dockview-core 1.6.0

package/dist/esm/dockview/components/titlebar/tabsContainer.d.ts

@@ -0,0 +1,63 @@
+import { IDisposable, CompositeDisposable } from '../../../lifecycle';
+import { Event } from '../../../events';
+import { ITab } from '../tab/tab';
+import { DockviewComponent } from '../../dockviewComponent';
+import { DockviewGroupPanel } from '../../dockviewGroupPanel';
+import { IDockviewPanel } from '../../dockviewPanel';
+export interface TabDropIndexEvent {
+    readonly event: DragEvent;
+    readonly index: number;
+}
+export interface ITabsContainer extends IDisposable {
+    readonly element: HTMLElement;
+    readonly panels: string[];
+    readonly size: number;
+    height: number | undefined;
+    delete: (id: string) => void;
+    indexOf: (id: string) => number;
+    onDrop: Event<TabDropIndexEvent>;
+    setActive: (isGroupActive: boolean) => void;
+    setActivePanel: (panel: IDockviewPanel) => void;
+    isActive: (tab: ITab) => boolean;
+    closePanel: (panel: IDockviewPanel) => void;
+    openPanel: (panel: IDockviewPanel, index?: number) => void;
+    setActionElement(element: HTMLElement | undefined): void;
+    hidden: boolean;
+    show(): void;
+    hide(): void;
+}
+export declare class TabsContainer extends CompositeDisposable implements ITabsContainer {
+    private readonly accessor;
+    private readonly group;
+    private readonly _element;
+    private readonly tabContainer;
+    private readonly actionContainer;
+    private readonly voidContainer;
+    private tabs;
+    private selectedIndex;
+    private actions;
+    private _height;
+    private _hidden;
+    private readonly _onDrop;
+    readonly onDrop: Event<TabDropIndexEvent>;
+    get panels(): string[];
+    get size(): number;
+    get height(): number | undefined;
+    set height(value: number | undefined);
+    get hidden(): boolean;
+    set hidden(value: boolean);
+    show(): void;
+    hide(): void;
+    setActionElement(element: HTMLElement | undefined): void;
+    get element(): HTMLElement;
+    isActive(tab: ITab): boolean;
+    indexOf(id: string): number;
+    constructor(accessor: DockviewComponent, group: DockviewGroupPanel);
+    setActive(_isGroupActive: boolean): void;
+    private addTab;
+    delete(id: string): void;
+    setActivePanel(panel: IDockviewPanel): void;
+    openPanel(panel: IDockviewPanel, index?: number): void;
+    closePanel(panel: IDockviewPanel): void;
+    dispose(): void;
+}

package/dist/esm/dockview/components/titlebar/tabsContainer.js

@@ -0,0 +1,179 @@
+import { CompositeDisposable, } from '../../../lifecycle';
+import { addDisposableListener, Emitter } from '../../../events';
+import { Tab } from '../tab/tab';
+import { VoidContainer } from './voidContainer';
+import { toggleClass } from '../../../dom';
+export class TabsContainer extends CompositeDisposable {
+    get panels() {
+        return this.tabs.map((_) => _.value.panelId);
+    }
+    get size() {
+        return this.tabs.length;
+    }
+    get height() {
+        return this._height;
+    }
+    set height(value) {
+        this._height = value;
+        if (typeof value !== 'number') {
+            this.element.style.removeProperty('--dv-tabs-and-actions-container-height');
+        }
+        else {
+            this.element.style.setProperty('--dv-tabs-and-actions-container-height', `${value}px`);
+        }
+    }
+    get hidden() {
+        return this._hidden;
+    }
+    set hidden(value) {
+        this._hidden = value;
+        this.element.style.display = value ? 'none' : '';
+    }
+    show() {
+        if (!this.hidden) {
+            this.element.style.display = '';
+        }
+    }
+    hide() {
+        this._element.style.display = 'none';
+    }
+    setActionElement(element) {
+        if (this.actions === element) {
+            return;
+        }
+        if (this.actions) {
+            this.actions.remove();
+            this.actions = undefined;
+        }
+        if (element) {
+            this.actionContainer.appendChild(element);
+            this.actions = element;
+        }
+    }
+    get element() {
+        return this._element;
+    }
+    isActive(tab) {
+        return (this.selectedIndex > -1 &&
+            this.tabs[this.selectedIndex].value === tab);
+    }
+    indexOf(id) {
+        return this.tabs.findIndex((tab) => tab.value.panelId === id);
+    }
+    constructor(accessor, group) {
+        super();
+        this.accessor = accessor;
+        this.group = group;
+        this.tabs = [];
+        this.selectedIndex = -1;
+        this._hidden = false;
+        this._onDrop = new Emitter();
+        this.onDrop = this._onDrop.event;
+        this.addDisposables(this._onDrop);
+        this._element = document.createElement('div');
+        this._element.className = 'tabs-and-actions-container';
+        this.height = accessor.options.tabHeight;
+        toggleClass(this._element, 'dv-full-width-single-tab', this.accessor.options.singleTabMode === 'fullwidth');
+        this.addDisposables(this.accessor.onDidAddPanel((e) => {
+            if (e.api.group === this.group) {
+                toggleClass(this._element, 'dv-single-tab', this.size === 1);
+            }
+        }), this.accessor.onDidRemovePanel((e) => {
+            if (e.api.group === this.group) {
+                toggleClass(this._element, 'dv-single-tab', this.size === 1);
+            }
+        }));
+        this.actionContainer = document.createElement('div');
+        this.actionContainer.className = 'action-container';
+        this.tabContainer = document.createElement('div');
+        this.tabContainer.className = 'tabs-container';
+        this.voidContainer = new VoidContainer(this.accessor, this.group);
+        this._element.appendChild(this.tabContainer);
+        this._element.appendChild(this.voidContainer.element);
+        this._element.appendChild(this.actionContainer);
+        this.addDisposables(this.voidContainer, this.voidContainer.onDrop((event) => {
+            this._onDrop.fire({
+                event: event.nativeEvent,
+                index: this.tabs.length,
+            });
+        }), addDisposableListener(this.tabContainer, 'mousedown', (event) => {
+            if (event.defaultPrevented) {
+                return;
+            }
+            const isLeftClick = event.button === 0;
+            if (isLeftClick) {
+                this.accessor.doSetGroupActive(this.group);
+            }
+        }));
+    }
+    setActive(_isGroupActive) {
+        // noop
+    }
+    addTab(tab, index = this.tabs.length) {
+        if (index < 0 || index > this.tabs.length) {
+            throw new Error('invalid location');
+        }
+        this.tabContainer.insertBefore(tab.value.element, this.tabContainer.children[index]);
+        this.tabs = [
+            ...this.tabs.slice(0, index),
+            tab,
+            ...this.tabs.slice(index),
+        ];
+        if (this.selectedIndex < 0) {
+            this.selectedIndex = index;
+        }
+    }
+    delete(id) {
+        const index = this.tabs.findIndex((tab) => tab.value.panelId === id);
+        const tabToRemove = this.tabs.splice(index, 1)[0];
+        const { value, disposable } = tabToRemove;
+        disposable.dispose();
+        value.element.remove();
+    }
+    setActivePanel(panel) {
+        this.tabs.forEach((tab) => {
+            const isActivePanel = panel.id === tab.value.panelId;
+            tab.value.setActive(isActivePanel);
+        });
+    }
+    openPanel(panel, index = this.tabs.length) {
+        var _a;
+        if (this.tabs.find((tab) => tab.value.panelId === panel.id)) {
+            return;
+        }
+        const tabToAdd = new Tab(panel.id, this.accessor, this.group);
+        if (!((_a = panel.view) === null || _a === void 0 ? void 0 : _a.tab)) {
+            throw new Error('invalid header component');
+        }
+        tabToAdd.setContent(panel.view.tab);
+        const disposable = CompositeDisposable.from(tabToAdd.onChanged((event) => {
+            var _a;
+            const alreadyFocused = panel.id === ((_a = this.group.model.activePanel) === null || _a === void 0 ? void 0 : _a.id) &&
+                this.group.model.isContentFocused;
+            const isLeftClick = event.button === 0;
+            if (!isLeftClick || event.defaultPrevented) {
+                return;
+            }
+            this.group.model.openPanel(panel, {
+                skipFocus: alreadyFocused,
+            });
+        }), tabToAdd.onDrop((event) => {
+            this._onDrop.fire({
+                event: event.nativeEvent,
+                index: this.tabs.findIndex((x) => x.value === tabToAdd),
+            });
+        }));
+        const value = { value: tabToAdd, disposable };
+        this.addTab(value, index);
+    }
+    closePanel(panel) {
+        this.delete(panel.id);
+    }
+    dispose() {
+        super.dispose();
+        this.tabs.forEach((tab) => {
+            tab.disposable.dispose();
+        });
+        this.tabs = [];
+    }
+}

package/dist/esm/dockview/components/titlebar/voidContainer.d.ts

@@ -0,0 +1,15 @@
+import { DroptargetEvent } from '../../../dnd/droptarget';
+import { DockviewComponent } from '../../dockviewComponent';
+import { Event } from '../../../events';
+import { CompositeDisposable } from '../../../lifecycle';
+import { DockviewGroupPanel } from '../../dockviewGroupPanel';
+export declare class VoidContainer extends CompositeDisposable {
+    private readonly accessor;
+    private readonly group;
+    private readonly _element;
+    private readonly voidDropTarget;
+    private readonly _onDrop;
+    readonly onDrop: Event<DroptargetEvent>;
+    get element(): HTMLElement;
+    constructor(accessor: DockviewComponent, group: DockviewGroupPanel);
+}

package/dist/esm/dockview/components/titlebar/voidContainer.js

@@ -0,0 +1,47 @@
+import { last } from '../../../array';
+import { getPanelData } from '../../../dnd/dataTransfer';
+import { Droptarget } from '../../../dnd/droptarget';
+import { GroupDragHandler } from '../../../dnd/groupDragHandler';
+import { addDisposableListener, Emitter } from '../../../events';
+import { CompositeDisposable } from '../../../lifecycle';
+import { DockviewDropTargets } from '../../types';
+export class VoidContainer extends CompositeDisposable {
+    get element() {
+        return this._element;
+    }
+    constructor(accessor, group) {
+        super();
+        this.accessor = accessor;
+        this.group = group;
+        this._onDrop = new Emitter();
+        this.onDrop = this._onDrop.event;
+        this._element = document.createElement('div');
+        this._element.className = 'void-container';
+        this._element.tabIndex = 0;
+        this._element.draggable = true;
+        this.addDisposables(this._onDrop, addDisposableListener(this._element, 'click', () => {
+            this.accessor.doSetGroupActive(this.group);
+        }));
+        const handler = new GroupDragHandler(this._element, accessor.id, group);
+        this.voidDropTarget = new Droptarget(this._element, {
+            acceptedTargetZones: ['center'],
+            canDisplayOverlay: (event, position) => {
+                var _a;
+                const data = getPanelData();
+                if (data && this.accessor.id === data.viewId) {
+                    if (data.panelId === null &&
+                        data.groupId === this.group.id) {
+                        // don't allow group move to drop on self
+                        return false;
+                    }
+                    // don't show the overlay if the tab being dragged is the last panel of this group
+                    return ((_a = last(this.group.panels)) === null || _a === void 0 ? void 0 : _a.id) !== data.panelId;
+                }
+                return group.model.canDisplayOverlay(event, position, DockviewDropTargets.Panel);
+            },
+        });
+        this.addDisposables(handler, this.voidDropTarget.onDrop((event) => {
+            this._onDrop.fire(event);
+        }), this.voidDropTarget);
+    }
+}

package/dist/esm/dockview/components/watermark/watermark.d.ts

@@ -0,0 +1,18 @@
+import { IWatermarkRenderer, WatermarkRendererInitParameters } from '../../types';
+import { CompositeDisposable } from '../../../lifecycle';
+import { DockviewGroupPanel } from '../../dockviewGroupPanel';
+import { PanelUpdateEvent } from '../../../panel/types';
+export declare class Watermark extends CompositeDisposable implements IWatermarkRenderer {
+    private _element;
+    private group;
+    private params;
+    get element(): HTMLElement;
+    constructor();
+    update(_event: PanelUpdateEvent): void;
+    focus(): void;
+    layout(_width: number, _height: number): void;
+    init(_params: WatermarkRendererInitParameters): void;
+    updateParentGroup(group: DockviewGroupPanel, _visible: boolean): void;
+    dispose(): void;
+    private render;
+}

package/dist/esm/dockview/components/watermark/watermark.js

@@ -0,0 +1,60 @@
+import { addDisposableListener } from '../../../events';
+import { toggleClass } from '../../../dom';
+import { CompositeDisposable } from '../../../lifecycle';
+import { createCloseButton } from '../../../svg';
+export class Watermark extends CompositeDisposable {
+    get element() {
+        return this._element;
+    }
+    constructor() {
+        super();
+        this._element = document.createElement('div');
+        this._element.className = 'watermark';
+        const title = document.createElement('div');
+        title.className = 'watermark-title';
+        const emptySpace = document.createElement('span');
+        emptySpace.style.flexGrow = '1';
+        const content = document.createElement('div');
+        content.className = 'watermark-content';
+        this._element.appendChild(title);
+        this._element.appendChild(content);
+        const actionsContainer = document.createElement('div');
+        actionsContainer.className = 'actions-container';
+        const closeAnchor = document.createElement('div');
+        closeAnchor.className = 'close-action';
+        closeAnchor.appendChild(createCloseButton());
+        actionsContainer.appendChild(closeAnchor);
+        title.appendChild(emptySpace);
+        title.appendChild(actionsContainer);
+        this.addDisposables(addDisposableListener(closeAnchor, 'click', (ev) => {
+            var _a;
+            ev.preventDefault();
+            if (this.group) {
+                (_a = this.params) === null || _a === void 0 ? void 0 : _a.containerApi.removeGroup(this.group);
+            }
+        }));
+    }
+    update(_event) {
+        // noop
+    }
+    focus() {
+        // noop
+    }
+    layout(_width, _height) {
+        // noop
+    }
+    init(_params) {
+        this.render();
+    }
+    updateParentGroup(group, _visible) {
+        this.group = group;
+        this.render();
+    }
+    dispose() {
+        super.dispose();
+    }
+    render() {
+        const isOneGroup = !!(this.params && this.params.containerApi.size <= 1);
+        toggleClass(this.element, 'has-actions', isOneGroup);
+    }
+}

package/dist/esm/dockview/deserializer.d.ts

@@ -0,0 +1,12 @@
+import { GroupviewPanelState } from './types';
+import { DockviewGroupPanel } from './dockviewGroupPanel';
+import { IDockviewPanel } from './dockviewPanel';
+import { IDockviewComponent } from './dockviewComponent';
+export interface IPanelDeserializer {
+    fromJSON(panelData: GroupviewPanelState, group: DockviewGroupPanel): IDockviewPanel;
+}
+export declare class DefaultDockviewDeserialzier implements IPanelDeserializer {
+    private readonly layout;
+    constructor(layout: IDockviewComponent);
+    fromJSON(panelData: GroupviewPanelState, group: DockviewGroupPanel): IDockviewPanel;
+}

package/dist/esm/dockview/deserializer.js

@@ -0,0 +1,40 @@
+import { DockviewPanel } from './dockviewPanel';
+import { createComponent } from '../panel/componentFactory';
+import { DefaultTab } from './components/tab/defaultTab';
+import { DockviewPanelModel } from './dockviewPanelModel';
+import { DockviewApi } from '../api/component.api';
+export class DefaultDockviewDeserialzier {
+    constructor(layout) {
+        this.layout = layout;
+    }
+    fromJSON(panelData, group) {
+        var _a, _b, _c;
+        const panelId = panelData.id;
+        const params = panelData.params;
+        const title = panelData.title;
+        const viewData = panelData.view;
+        const contentComponent = viewData
+            ? viewData.content.id
+            : panelData.contentComponent || 'unknown';
+        const tabComponent = viewData
+            ? (_a = viewData.tab) === null || _a === void 0 ? void 0 : _a.id
+            : panelData.tabComponent;
+        let tab;
+        if (tabComponent) {
+            tab = createComponent(panelId, tabComponent, this.layout.options.tabComponents, this.layout.options.frameworkTabComponents, (_b = this.layout.options.frameworkComponentFactory) === null || _b === void 0 ? void 0 : _b.tab, () => new DefaultTab());
+        }
+        else if (this.layout.options.defaultTabComponent) {
+            tab = createComponent(panelId, this.layout.options.defaultTabComponent, this.layout.options.tabComponents, this.layout.options.frameworkTabComponents, (_c = this.layout.options.frameworkComponentFactory) === null || _c === void 0 ? void 0 : _c.tab, () => new DefaultTab());
+        }
+        else {
+            tab = new DefaultTab();
+        }
+        const view = new DockviewPanelModel(this.layout, panelId, contentComponent, tabComponent);
+        const panel = new DockviewPanel(panelId, this.layout, new DockviewApi(this.layout), group, view);
+        panel.init({
+            title: title || panelId,
+            params: params || {},
+        });
+        return panel;
+    }
+}

package/dist/esm/dockview/dockviewComponent.d.ts

@@ -0,0 +1,126 @@
+import { SerializedGridObject } from '../gridview/gridview';
+import { Position } from '../dnd/droptarget';
+import { IDockviewPanel } from './dockviewPanel';
+import { Event } from '../events';
+import { IWatermarkRenderer, GroupviewPanelState } from './types';
+import { AddGroupOptions, AddPanelOptions, DockviewComponentOptions, MovementOptions } from './options';
+import { BaseGrid, IBaseGrid } from '../gridview/baseComponentGridview';
+import { DockviewApi } from '../api/component.api';
+import { Orientation } from '../splitview/splitview';
+import { GroupOptions, GroupPanelViewState, GroupviewDropEvent } from './dockviewGroupPanelModel';
+import { DockviewGroupPanel, IDockviewGroupPanel } from './dockviewGroupPanel';
+export interface PanelReference {
+    update: (event: {
+        params: {
+            [key: string]: any;
+        };
+    }) => void;
+    remove: () => void;
+}
+export interface SerializedDockview {
+    grid: {
+        root: SerializedGridObject<GroupPanelViewState>;
+        height: number;
+        width: number;
+        orientation: Orientation;
+    };
+    panels: {
+        [key: string]: GroupviewPanelState;
+    };
+    activeGroup?: string;
+    options?: {
+        tabHeight?: number;
+    };
+}
+export type DockviewComponentUpdateOptions = Pick<DockviewComponentOptions, 'orientation' | 'components' | 'frameworkComponents' | 'tabComponents' | 'frameworkTabComponents' | 'showDndOverlay' | 'watermarkFrameworkComponent' | 'defaultTabComponent' | 'createGroupControlElement'>;
+export interface DockviewDropEvent extends GroupviewDropEvent {
+    api: DockviewApi;
+    group: DockviewGroupPanel | null;
+}
+export interface IDockviewComponent extends IBaseGrid<DockviewGroupPanel> {
+    readonly activePanel: IDockviewPanel | undefined;
+    readonly totalPanels: number;
+    readonly panels: IDockviewPanel[];
+    readonly onDidDrop: Event<DockviewDropEvent>;
+    readonly orientation: Orientation;
+    tabHeight: number | undefined;
+    updateOptions(options: DockviewComponentUpdateOptions): void;
+    moveGroupOrPanel(referenceGroup: DockviewGroupPanel, groupId: string, itemId: string, target: Position, index?: number): void;
+    doSetGroupActive: (group: DockviewGroupPanel, skipFocus?: boolean) => void;
+    removeGroup: (group: DockviewGroupPanel) => void;
+    options: DockviewComponentOptions;
+    addPanel(options: AddPanelOptions): IDockviewPanel;
+    removePanel(panel: IDockviewPanel): void;
+    getGroupPanel: (id: string) => IDockviewPanel | undefined;
+    createWatermarkComponent(): IWatermarkRenderer;
+    addGroup(options?: AddGroupOptions): IDockviewGroupPanel;
+    closeAllGroups(): void;
+    moveToNext(options?: MovementOptions): void;
+    moveToPrevious(options?: MovementOptions): void;
+    setActivePanel(panel: IDockviewPanel): void;
+    focus(): void;
+    toJSON(): SerializedDockview;
+    fromJSON(data: SerializedDockview): void;
+    readonly onDidRemovePanel: Event<IDockviewPanel>;
+    readonly onDidAddPanel: Event<IDockviewPanel>;
+    readonly onDidLayoutFromJSON: Event<void>;
+    readonly onDidActivePanelChange: Event<IDockviewPanel | undefined>;
+}
+export declare class DockviewComponent extends BaseGrid<DockviewGroupPanel> implements IDockviewComponent {
+    private readonly nextGroupId;
+    private readonly _deserializer;
+    private readonly _api;
+    private _options;
+    private watermark;
+    private readonly _onDidDrop;
+    readonly onDidDrop: Event<DockviewDropEvent>;
+    private readonly _onDidRemovePanel;
+    readonly onDidRemovePanel: Event<IDockviewPanel>;
+    private readonly _onDidAddPanel;
+    readonly onDidAddPanel: Event<IDockviewPanel>;
+    private readonly _onDidLayoutFromJSON;
+    readonly onDidLayoutFromJSON: Event<void>;
+    private readonly _onDidActivePanelChange;
+    readonly onDidActivePanelChange: Event<IDockviewPanel | undefined>;
+    get orientation(): Orientation;
+    get totalPanels(): number;
+    get panels(): IDockviewPanel[];
+    get options(): DockviewComponentOptions;
+    get activePanel(): IDockviewPanel | undefined;
+    set tabHeight(height: number | undefined);
+    get tabHeight(): number | undefined;
+    constructor(element: HTMLElement, options: DockviewComponentOptions);
+    private orthogonalize;
+    updateOptions(options: DockviewComponentUpdateOptions): void;
+    focus(): void;
+    getGroupPanel(id: string): IDockviewPanel | undefined;
+    setActivePanel(panel: IDockviewPanel): void;
+    moveToNext(options?: MovementOptions): void;
+    moveToPrevious(options?: MovementOptions): void;
+    /**
+     * Serialize the current state of the layout
+     *
+     * @returns A JSON respresentation of the layout
+     */
+    toJSON(): SerializedDockview;
+    fromJSON(data: SerializedDockview): void;
+    clear(): void;
+    closeAllGroups(): void;
+    addPanel(options: AddPanelOptions): IDockviewPanel;
+    removePanel(panel: IDockviewPanel, options?: {
+        removeEmptyGroup: boolean;
+        skipDispose: boolean;
+    }): void;
+    createWatermarkComponent(): IWatermarkRenderer;
+    private updateWatermark;
+    addGroup(options?: AddGroupOptions): DockviewGroupPanel;
+    removeGroup(group: DockviewGroupPanel, skipActive?: boolean): void;
+    moveGroupOrPanel(referenceGroup: DockviewGroupPanel, groupId: string, itemId: string | undefined, target: Position, index?: number): void;
+    private moveGroup;
+    doSetGroupActive(group: DockviewGroupPanel | undefined, skipFocus?: boolean): void;
+    createGroup(options?: GroupOptions): DockviewGroupPanel;
+    private createPanel;
+    private createGroupAtLocation;
+    private findGroup;
+    dispose(): void;
+}