Method removeView

packages/dockview-core/src/gridview/gridview.ts:991–1109

(location: number[], sizing?: Sizing)

    }

    removeView(location: number[], sizing?: Sizing): IGridView {
        if (this.hasMaximizedView()) {
            this.exitMaximizedView();
        }

        const [rest, index] = tail(location);
        const [pathToParent, parent] = this.getNode(rest);

        if (!(parent instanceof BranchNode)) {
            throw new Error('Invalid location');
        }

        const nodeToRemove = parent.children[index];

        if (!(nodeToRemove instanceof LeafNode)) {
            throw new Error('Invalid location');
        }

        parent.removeChild(index, sizing);
        nodeToRemove.dispose();

        if (parent.children.length !== 1) {
            return nodeToRemove.view;
        }

        // if the parent has only one child and we know the parent is a BranchNode we can make the tree
        // more efficiently spaced by replacing the parent BranchNode with the child.
        // if that child is a LeafNode then we simply replace the BranchNode with the child otherwise if the child
        // is a BranchNode too we should spread it's children into the grandparent.

        // refer to the remaining child as the sibling
        const sibling = parent.children[0];

        if (pathToParent.length === 0) {
            // if the parent is root

            if (sibling instanceof LeafNode) {
                // if the sibling is a leaf node no action is required
                return nodeToRemove.view;
            }

            // otherwise the sibling is a branch node. since the parent is the root and the root has only one child
            // which is a branch node we can just set this branch node to be the new root node

            // for good housekeeping we'll removing the sibling from it's existing tree
            parent.removeChild(0, sizing);

            // and set that sibling node to be root
            this.root = sibling;

            return nodeToRemove.view;
        }

        // otherwise the parent is apart of a large sub-tree

        const [grandParent, ..._] = [...pathToParent].reverse();
        const [parentIndex, ...__] = [...rest].reverse();