dockview-core 7.0.4 → 8.1.0

package/dist/esm/gridview/branchNode.js

@@ -1,257 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- * Accreditation: This file is largly based upon the MIT licenced VSCode sourcecode found at:
- * https://github.com/microsoft/vscode/tree/main/src/vs/base/browser/ui/grid
- *--------------------------------------------------------------------------------------------*/
-import { Splitview, Orientation, LayoutPriority, } from '../splitview/splitview';
-import { Emitter, Event } from '../events';
-import { LeafNode } from './leafNode';
-import { CompositeDisposable, Disposable } from '../lifecycle';
-export class BranchNode extends CompositeDisposable {
-    get width() {
-        return this.orientation === Orientation.HORIZONTAL
-            ? this.size
-            : this.orthogonalSize;
-    }
-    get height() {
-        return this.orientation === Orientation.HORIZONTAL
-            ? this.orthogonalSize
-            : this.size;
-    }
-    get minimumSize() {
-        return this.children.length === 0
-            ? 0
-            : Math.max(...this.children.map((c, index) => this.splitview.isViewVisible(index)
-                ? c.minimumOrthogonalSize
-                : 0));
-    }
-    get maximumSize() {
-        return Math.min(...this.children.map((c, index) => this.splitview.isViewVisible(index)
-            ? c.maximumOrthogonalSize
-            : Number.POSITIVE_INFINITY));
-    }
-    get minimumOrthogonalSize() {
-        return this.splitview.minimumSize;
-    }
-    get maximumOrthogonalSize() {
-        return this.splitview.maximumSize;
-    }
-    get orthogonalSize() {
-        return this._orthogonalSize;
-    }
-    get size() {
-        return this._size;
-    }
-    get minimumWidth() {
-        return this.orientation === Orientation.HORIZONTAL
-            ? this.minimumOrthogonalSize
-            : this.minimumSize;
-    }
-    get minimumHeight() {
-        return this.orientation === Orientation.HORIZONTAL
-            ? this.minimumSize
-            : this.minimumOrthogonalSize;
-    }
-    get maximumWidth() {
-        return this.orientation === Orientation.HORIZONTAL
-            ? this.maximumOrthogonalSize
-            : this.maximumSize;
-    }
-    get maximumHeight() {
-        return this.orientation === Orientation.HORIZONTAL
-            ? this.maximumSize
-            : this.maximumOrthogonalSize;
-    }
-    get priority() {
-        if (this.children.length === 0) {
-            return LayoutPriority.Normal;
-        }
-        const priorities = new Set(this.children.map((c) => { var _a; return (_a = c.priority) !== null && _a !== void 0 ? _a : LayoutPriority.Normal; }));
-        if (priorities.has(LayoutPriority.High)) {
-            return LayoutPriority.High;
-        }
-        else if (priorities.has(LayoutPriority.Low)) {
-            return LayoutPriority.Low;
-        }
-        return LayoutPriority.Normal;
-    }
-    get disabled() {
-        return this.splitview.disabled;
-    }
-    set disabled(value) {
-        this.splitview.disabled = value;
-    }
-    get margin() {
-        return this.splitview.margin;
-    }
-    set margin(value) {
-        this.splitview.margin = value;
-        this.children.forEach((child) => {
-            if (child instanceof BranchNode) {
-                child.margin = value;
-            }
-        });
-    }
-    constructor(orientation, proportionalLayout, styles, size, orthogonalSize, disabled, margin, childDescriptors) {
-        super();
-        this.orientation = orientation;
-        this.proportionalLayout = proportionalLayout;
-        this.styles = styles;
-        this._childrenDisposable = Disposable.NONE;
-        this.children = [];
-        this._onDidChange = new Emitter();
-        this.onDidChange = this._onDidChange.event;
-        this._onDidVisibilityChange = new Emitter();
-        this.onDidVisibilityChange = this._onDidVisibilityChange.event;
-        this._orthogonalSize = orthogonalSize;
-        this._size = size;
-        this.element = document.createElement('div');
-        this.element.className = 'dv-branch-node';
-        if (childDescriptors) {
-            const descriptor = {
-                views: childDescriptors.map((childDescriptor) => {
-                    return {
-                        view: childDescriptor.node,
-                        size: childDescriptor.node.size,
-                        visible: childDescriptor.node instanceof LeafNode &&
-                            childDescriptor.visible !== undefined
-                            ? childDescriptor.visible
-                            : true,
-                    };
-                }),
-                size: this.orthogonalSize,
-            };
-            this.children = childDescriptors.map((c) => c.node);
-            this.splitview = new Splitview(this.element, {
-                orientation: this.orientation,
-                descriptor,
-                proportionalLayout,
-                styles,
-                margin,
-            });
-        }
-        else {
-            this.splitview = new Splitview(this.element, {
-                orientation: this.orientation,
-                proportionalLayout,
-                styles,
-                margin,
-            });
-            this.splitview.layout(this.size, this.orthogonalSize);
-        }
-        this.disabled = disabled;
-        this.addDisposables(this._onDidChange, this._onDidVisibilityChange, this.splitview.onDidSashEnd(() => {
-            this._onDidChange.fire({});
-        }));
-        this.setupChildrenEvents();
-    }
-    setVisible(_visible) {
-        // noop
-    }
-    isChildVisible(index) {
-        if (index < 0 || index >= this.children.length) {
-            throw new Error('Invalid index');
-        }
-        return this.splitview.isViewVisible(index);
-    }
-    setChildVisible(index, visible) {
-        if (index < 0 || index >= this.children.length) {
-            throw new Error('Invalid index');
-        }
-        if (this.splitview.isViewVisible(index) === visible) {
-            return;
-        }
-        const wereAllChildrenHidden = this.splitview.contentSize === 0;
-        this.splitview.setViewVisible(index, visible);
-        // }
-        const areAllChildrenHidden = this.splitview.contentSize === 0;
-        // If all children are hidden then the parent should hide the entire splitview
-        // If the entire splitview is hidden then the parent should show the splitview when a child is shown
-        if ((visible && wereAllChildrenHidden) ||
-            (!visible && areAllChildrenHidden)) {
-            this._onDidVisibilityChange.fire({ visible });
-        }
-    }
-    moveChild(from, to) {
-        if (from === to) {
-            return;
-        }
-        if (from < 0 || from >= this.children.length) {
-            throw new Error('Invalid from index');
-        }
-        if (from < to) {
-            to--;
-        }
-        this.splitview.moveView(from, to);
-        const child = this._removeChild(from);
-        this._addChild(child, to);
-    }
-    getChildSize(index) {
-        if (index < 0 || index >= this.children.length) {
-            throw new Error('Invalid index');
-        }
-        return this.splitview.getViewSize(index);
-    }
-    resizeChild(index, size) {
-        if (index < 0 || index >= this.children.length) {
-            throw new Error('Invalid index');
-        }
-        this.splitview.resizeView(index, size);
-    }
-    layout(size, orthogonalSize) {
-        this._size = orthogonalSize;
-        this._orthogonalSize = size;
-        this.splitview.layout(orthogonalSize, size);
-    }
-    addChild(node, size, index, skipLayout) {
-        if (index < 0 || index > this.children.length) {
-            throw new Error('Invalid index');
-        }
-        this.splitview.addView(node, size, index, skipLayout);
-        this._addChild(node, index);
-    }
-    getChildCachedVisibleSize(index) {
-        if (index < 0 || index >= this.children.length) {
-            throw new Error('Invalid index');
-        }
-        return this.splitview.getViewCachedVisibleSize(index);
-    }
-    removeChild(index, sizing) {
-        if (index < 0 || index >= this.children.length) {
-            throw new Error('Invalid index');
-        }
-        this.splitview.removeView(index, sizing);
-        return this._removeChild(index);
-    }
-    _addChild(node, index) {
-        this.children.splice(index, 0, node);
-        this.setupChildrenEvents();
-    }
-    _removeChild(index) {
-        const [child] = this.children.splice(index, 1);
-        this.setupChildrenEvents();
-        return child;
-    }
-    setupChildrenEvents() {
-        this._childrenDisposable.dispose();
-        this._childrenDisposable = new CompositeDisposable(Event.any(...this.children.map((c) => c.onDidChange))((e) => {
-            /**
-             * indicate a change has occured to allows any re-rendering but don't bubble
-             * event because that was specific to this branch
-             */
-            this._onDidChange.fire({ size: e.orthogonalSize });
-        }), ...this.children.map((c, i) => {
-            if (c instanceof BranchNode) {
-                return c.onDidVisibilityChange(({ visible }) => {
-                    this.setChildVisible(i, visible);
-                });
-            }
-            return Disposable.NONE;
-        }));
-    }
-    dispose() {
-        this._childrenDisposable.dispose();
-        this.splitview.dispose();
-        this.children.forEach((child) => child.dispose());
-        super.dispose();
-    }
-}

package/dist/esm/gridview/gridview.d.ts

@@ -1,158 +0,0 @@
-import { ISplitviewStyles, LayoutPriority, Orientation, Sizing } from '../splitview/splitview';
-import { LeafNode } from './leafNode';
-import { Node } from './types';
-import { Event } from '../events';
-import { IDisposable } from '../lifecycle';
-import { Position } from '../dnd/droptarget';
-export declare function indexInParent(element: HTMLElement): number;
-/**
- * Find the grid location of a specific DOM element by traversing the parent
- * chain and finding each child index on the way.
- *
- * This will break as soon as DOM structures of the Splitview or Gridview change.
- */
-export declare function getGridLocation(element: HTMLElement): number[];
-export declare function getRelativeLocation(rootOrientation: Orientation, location: number[], direction: Position): number[];
-export declare function getDirectionOrientation(direction: Position): Orientation;
-export declare function getLocationOrientation(rootOrientation: Orientation, location: number[]): Orientation;
-export interface IViewSize {
-    width?: number;
-    height?: number;
-}
-export interface IGridView {
-    readonly onDidChange: Event<IViewSize | undefined>;
-    readonly element: HTMLElement;
-    readonly minimumWidth: number;
-    readonly maximumWidth: number;
-    readonly minimumHeight: number;
-    readonly maximumHeight: number;
-    readonly isVisible: boolean;
-    priority?: LayoutPriority;
-    layout(width: number, height: number): void;
-    toJSON(): object;
-    fromJSON?(json: object): void;
-    snap?: boolean;
-    setVisible?(visible: boolean): void;
-}
-export declare const orthogonal: (orientation: Orientation) => Orientation;
-export interface GridLeafNode<T extends IGridView> {
-    readonly view: T;
-    readonly cachedVisibleSize: number | undefined;
-    readonly box: {
-        width: number;
-        height: number;
-    };
-}
-export interface GridBranchNode<T extends IGridView> {
-    readonly children: GridNode<T>[];
-    readonly box: {
-        width: number;
-        height: number;
-    };
-}
-export type GridNode<T extends IGridView> = GridLeafNode<T> | GridBranchNode<T>;
-export declare function isGridBranchNode<T extends IGridView>(node: GridNode<T>): node is GridBranchNode<T>;
-export interface SerializedGridObject<T> {
-    type: 'leaf' | 'branch';
-    data: T | SerializedGridObject<T>[];
-    size?: number;
-    visible?: boolean;
-}
-export interface ISerializedLeafNode<T = any> {
-    type: 'leaf';
-    data: T;
-    size: number;
-    visible?: boolean;
-}
-export interface ISerializedBranchNode {
-    type: 'branch';
-    data: ISerializedNode[];
-    size: number;
-}
-export type ISerializedNode = ISerializedLeafNode | ISerializedBranchNode;
-export interface INodeDescriptor {
-    node: Node;
-    visible?: boolean;
-}
-export interface IViewDeserializer {
-    fromJSON: (data: ISerializedLeafNode) => IGridView;
-}
-export interface SerializedNodeDescriptor {
-    location: number[];
-}
-export interface SerializedGridview<T> {
-    root: SerializedGridObject<T>;
-    width: number;
-    height: number;
-    orientation: Orientation;
-    maximizedNode?: SerializedNodeDescriptor;
-}
-export interface MaximizedViewChanged {
-    view: IGridView;
-    isMaximized: boolean;
-}
-export declare class Gridview implements IDisposable {
-    readonly proportionalLayout: boolean;
-    readonly styles: ISplitviewStyles | undefined;
-    readonly element: HTMLElement;
-    private _root;
-    private _locked;
-    private _margin;
-    private _maximizedNode;
-    private readonly disposable;
-    private readonly _onDidChange;
-    readonly onDidChange: Event<{
-        size?: number;
-        orthogonalSize?: number;
-    }>;
-    private readonly _onDidViewVisibilityChange;
-    readonly onDidViewVisibilityChange: Event<void>;
-    private readonly _onDidMaximizedNodeChange;
-    readonly onDidMaximizedNodeChange: Event<MaximizedViewChanged>;
-    get length(): number;
-    get orientation(): Orientation;
-    set orientation(orientation: Orientation);
-    get width(): number;
-    get height(): number;
-    get minimumWidth(): number;
-    get minimumHeight(): number;
-    get maximumWidth(): number;
-    get maximumHeight(): number;
-    get locked(): boolean;
-    set locked(value: boolean);
-    get margin(): number;
-    set margin(value: number);
-    maximizedView(): IGridView | undefined;
-    hasMaximizedView(): boolean;
-    maximizeView(view: IGridView): void;
-    exitMaximizedView(): void;
-    serialize(): SerializedGridview<any>;
-    dispose(): void;
-    clear(): void;
-    deserialize<T>(json: SerializedGridview<T>, deserializer: IViewDeserializer): void;
-    private _deserialize;
-    private _deserializeNode;
-    private get root();
-    private set root(value);
-    normalize(): void;
-    /**
-     * If the root is orientated as a VERTICAL node then nest the existing root within a new HORIZIONTAL root node
-     * If the root is orientated as a HORIZONTAL node then nest the existing root within a new VERITCAL root node
-     */
-    insertOrthogonalSplitviewAtRoot(): void;
-    next(location: number[]): LeafNode;
-    previous(location: number[]): LeafNode;
-    getView(): GridBranchNode<IGridView>;
-    getView(location?: number[]): GridNode<IGridView>;
-    private _getViews;
-    private progmaticSelect;
-    constructor(proportionalLayout: boolean, styles: ISplitviewStyles | undefined, orientation: Orientation, locked?: boolean, margin?: number);
-    isViewVisible(location: number[]): boolean;
-    setViewVisible(location: number[], visible: boolean): void;
-    moveView(parentLocation: number[], from: number, to: number): void;
-    addView(view: IGridView, size: number | Sizing, location: number[]): void;
-    remove(view: IGridView, sizing?: Sizing): IGridView;
-    removeView(location: number[], sizing?: Sizing): IGridView;
-    layout(width: number, height: number): void;
-    private getNode;
-}