@theia/core 1.53.0-next.55 → 1.53.0-next.64

package/src/browser/tree/tree-selectable.spec.ts

@@ -1,152 +1,152 @@
-// *****************************************************************************
-// Copyright (C) 2018 TypeFox and others.
-//
-// This program and the accompanying materials are made available under the
-// terms of the Eclipse Public License v. 2.0 which is available at
-// http://www.eclipse.org/legal/epl-2.0.
-//
-// This Source Code may also be made available under the following Secondary
-// Licenses when the conditions for such availability set forth in the Eclipse
-// Public License v. 2.0 are satisfied: GNU General Public License, version 2
-// with the GNU Classpath Exception which is available at
-// https://www.gnu.org/software/classpath/license.html.
-//
-// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
-// *****************************************************************************
-
-import { TreeNode } from './tree';
-import { TreeModel } from './tree-model';
-import { notEmpty } from '../../common/objects';
-import { expect } from 'chai';
-import { createTreeTestContainer } from './test/tree-test-container';
-import { SelectableTreeNode } from './tree-selection';
-import { MockSelectableTreeModel } from './test/mock-selectable-tree-model';
-import { ExpandableTreeNode } from './tree-expansion';
-
-describe('Selectable Tree', () => {
-    let model: TreeModel;
-    function assertNodeRetrieval(method: () => TreeNode | undefined, sequence: string[]): void {
-        for (const expectedNodeId of sequence) {
-            const actualNode = method();
-            const expectedNode = retrieveNode<SelectableTreeNode>(expectedNodeId);
-            expect(actualNode?.id).to.be.equal(expectedNode.id);
-            model.addSelection(expectedNode);
-        }
-    }
-    function assertNodeSelection(method: () => void, sequence: string[]): void {
-        for (const expectedNodeId of sequence) {
-            method();
-            const node = retrieveNode<SelectableTreeNode>(expectedNodeId);
-            expect(node.selected).to.be.true;
-        }
-    }
-    describe('Get and Set Next Nodes Methods', () => {
-        const uncollapsedSelectionOrder = ['1.1', '1.1.1', '1.1.2', '1.2', '1.2.1', '1.2.1.1', '1.2.1.2', '1.2.2', '1.2.3', '1.3'];
-        const collapsedSelectionOrder = ['1.1', '1.2', '1.2.1', '1.2.2', '1.2.3', '1.3'];
-        beforeEach(() => {
-            model = createTreeModel();
-            model.root = MockSelectableTreeModel.HIERARCHICAL_MOCK_ROOT();
-            model.addSelection(retrieveNode<SelectableTreeNode>('1'));
-
-        });
-        it('`getNextNode()` should select each node in sequence (uncollapsed)', done => {
-            assertNodeRetrieval(model.getNextNode.bind(model), uncollapsedSelectionOrder);
-            done();
-        });
-        it('`getNextNode()` should select each node in sequence (collapsed)', done => {
-            collapseNode('1.1', '1.2.1');
-            assertNodeRetrieval(model.getNextNode.bind(model), uncollapsedSelectionOrder);
-            done();
-        });
-        it('`getNextSelectableNode()` should select each node in sequence (uncollapsed)', done => {
-            assertNodeRetrieval(model.getNextSelectableNode.bind(model), uncollapsedSelectionOrder);
-            done();
-        });
-        it('`getNextSelectableNode()` should select each node in sequence (collapsed)', done => {
-            collapseNode('1.1', '1.2.1');
-            assertNodeRetrieval(model.getNextSelectableNode.bind(model), collapsedSelectionOrder);
-            done();
-        });
-        it('`selectNext()` should select each node in sequence (uncollapsed)', done => {
-            assertNodeSelection(model.selectNext.bind(model), uncollapsedSelectionOrder);
-            done();
-        });
-        it('`selectNext()` should select each node in sequence (collapsed)', done => {
-            collapseNode('1.1', '1.2.1');
-            assertNodeSelection(model.selectNext.bind(model), uncollapsedSelectionOrder);
-            done();
-        });
-        it('`selectNextNode()` should select each node in sequence (uncollapsed)', done => {
-            assertNodeSelection(model.selectNextNode.bind(model), uncollapsedSelectionOrder);
-            done();
-        });
-        it('`selectNextNode()` should select each node in sequence (collapsed)', done => {
-            collapseNode('1.1', '1.2.1');
-            assertNodeSelection(model.selectNextNode.bind(model), collapsedSelectionOrder);
-            done();
-        });
-    });
-
-    describe('Get and Set Previous Nodes Methods', () => {
-        const uncollapsedSelectionOrder = ['1.2.3', '1.2.2', '1.2.1.2', '1.2.1.1', '1.2.1', '1.2', '1.1.2', '1.1.1', '1.1'];
-        const collapsedSelectionOrder = ['1.2.3', '1.2.2', '1.2.1', '1.2', '1.1'];
-        beforeEach(() => {
-            model = createTreeModel();
-            model.root = MockSelectableTreeModel.HIERARCHICAL_MOCK_ROOT();
-            model.addSelection(retrieveNode<SelectableTreeNode>('1.3'));
-        });
-        it('`getPrevNode()` should select each node in reverse sequence (uncollapsed)', done => {
-            assertNodeRetrieval(model.getPrevNode.bind(model), uncollapsedSelectionOrder);
-            done();
-        });
-        it('`getPrevNode()` should select each node in reverse sequence (collapsed)', done => {
-            collapseNode('1.1', '1.2.1');
-            assertNodeRetrieval(model.getPrevNode.bind(model), uncollapsedSelectionOrder);
-            done();
-        });
-        it('`getPrevSelectableNode()` should select each node in reverse sequence (uncollapsed)', done => {
-            assertNodeRetrieval(model.getPrevSelectableNode.bind(model), uncollapsedSelectionOrder);
-            done();
-        });
-        it('`getPrevSelectableNode()` should select each node in reverse sequence (collapsed)', done => {
-            collapseNode('1.1', '1.2.1');
-            assertNodeRetrieval(model.getPrevSelectableNode.bind(model), collapsedSelectionOrder);
-            done();
-        });
-        it('`selectPrev()` should select each node in reverse sequence (uncollapsed)', done => {
-            assertNodeSelection(model.selectPrev.bind(model), uncollapsedSelectionOrder);
-            done();
-        });
-        it('`selectPrev()` should select each node in reverse sequence (collapsed)', done => {
-            collapseNode('1.1', '1.2.1');
-            assertNodeSelection(model.selectPrev.bind(model), uncollapsedSelectionOrder);
-            done();
-        });
-        it('`selectPrevNode()` should select each node in reverse sequence (uncollapsed)', done => {
-            assertNodeSelection(model.selectPrevNode.bind(model), uncollapsedSelectionOrder);
-            done();
-        });
-        it('`selectPrevNode()` should select each node in reverse sequence (collapsed)', done => {
-            collapseNode('1.1', '1.2.1');
-            assertNodeSelection(model.selectPrevNode.bind(model), collapsedSelectionOrder);
-            done();
-        });
-    });
-
-    const findNode = (id: string) => model.getNode(id);
-    function createTreeModel(): TreeModel {
-        const container = createTreeTestContainer();
-        return container.get(TreeModel);
-    }
-    function retrieveNode<T extends TreeNode>(id: string): Readonly<T> {
-        const readonlyNode: Readonly<T> = model.getNode(id) as T;
-        return readonlyNode;
-    }
-    function collapseNode(...ids: string[]): void {
-        ids.map(findNode).filter(notEmpty).filter(ExpandableTreeNode.is).forEach(node => {
-            model.collapseNode(node);
-            expect(node).to.have.property('expanded', false);
-        });
-    }
-
-});
+// *****************************************************************************
+// Copyright (C) 2018 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { TreeNode } from './tree';
+import { TreeModel } from './tree-model';
+import { notEmpty } from '../../common/objects';
+import { expect } from 'chai';
+import { createTreeTestContainer } from './test/tree-test-container';
+import { SelectableTreeNode } from './tree-selection';
+import { MockSelectableTreeModel } from './test/mock-selectable-tree-model';
+import { ExpandableTreeNode } from './tree-expansion';
+
+describe('Selectable Tree', () => {
+    let model: TreeModel;
+    function assertNodeRetrieval(method: () => TreeNode | undefined, sequence: string[]): void {
+        for (const expectedNodeId of sequence) {
+            const actualNode = method();
+            const expectedNode = retrieveNode<SelectableTreeNode>(expectedNodeId);
+            expect(actualNode?.id).to.be.equal(expectedNode.id);
+            model.addSelection(expectedNode);
+        }
+    }
+    function assertNodeSelection(method: () => void, sequence: string[]): void {
+        for (const expectedNodeId of sequence) {
+            method();
+            const node = retrieveNode<SelectableTreeNode>(expectedNodeId);
+            expect(node.selected).to.be.true;
+        }
+    }
+    describe('Get and Set Next Nodes Methods', () => {
+        const uncollapsedSelectionOrder = ['1.1', '1.1.1', '1.1.2', '1.2', '1.2.1', '1.2.1.1', '1.2.1.2', '1.2.2', '1.2.3', '1.3'];
+        const collapsedSelectionOrder = ['1.1', '1.2', '1.2.1', '1.2.2', '1.2.3', '1.3'];
+        beforeEach(() => {
+            model = createTreeModel();
+            model.root = MockSelectableTreeModel.HIERARCHICAL_MOCK_ROOT();
+            model.addSelection(retrieveNode<SelectableTreeNode>('1'));
+
+        });
+        it('`getNextNode()` should select each node in sequence (uncollapsed)', done => {
+            assertNodeRetrieval(model.getNextNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getNextNode()` should select each node in sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeRetrieval(model.getNextNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getNextSelectableNode()` should select each node in sequence (uncollapsed)', done => {
+            assertNodeRetrieval(model.getNextSelectableNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getNextSelectableNode()` should select each node in sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeRetrieval(model.getNextSelectableNode.bind(model), collapsedSelectionOrder);
+            done();
+        });
+        it('`selectNext()` should select each node in sequence (uncollapsed)', done => {
+            assertNodeSelection(model.selectNext.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectNext()` should select each node in sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeSelection(model.selectNext.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectNextNode()` should select each node in sequence (uncollapsed)', done => {
+            assertNodeSelection(model.selectNextNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectNextNode()` should select each node in sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeSelection(model.selectNextNode.bind(model), collapsedSelectionOrder);
+            done();
+        });
+    });
+
+    describe('Get and Set Previous Nodes Methods', () => {
+        const uncollapsedSelectionOrder = ['1.2.3', '1.2.2', '1.2.1.2', '1.2.1.1', '1.2.1', '1.2', '1.1.2', '1.1.1', '1.1'];
+        const collapsedSelectionOrder = ['1.2.3', '1.2.2', '1.2.1', '1.2', '1.1'];
+        beforeEach(() => {
+            model = createTreeModel();
+            model.root = MockSelectableTreeModel.HIERARCHICAL_MOCK_ROOT();
+            model.addSelection(retrieveNode<SelectableTreeNode>('1.3'));
+        });
+        it('`getPrevNode()` should select each node in reverse sequence (uncollapsed)', done => {
+            assertNodeRetrieval(model.getPrevNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getPrevNode()` should select each node in reverse sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeRetrieval(model.getPrevNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getPrevSelectableNode()` should select each node in reverse sequence (uncollapsed)', done => {
+            assertNodeRetrieval(model.getPrevSelectableNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getPrevSelectableNode()` should select each node in reverse sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeRetrieval(model.getPrevSelectableNode.bind(model), collapsedSelectionOrder);
+            done();
+        });
+        it('`selectPrev()` should select each node in reverse sequence (uncollapsed)', done => {
+            assertNodeSelection(model.selectPrev.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectPrev()` should select each node in reverse sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeSelection(model.selectPrev.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectPrevNode()` should select each node in reverse sequence (uncollapsed)', done => {
+            assertNodeSelection(model.selectPrevNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectPrevNode()` should select each node in reverse sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeSelection(model.selectPrevNode.bind(model), collapsedSelectionOrder);
+            done();
+        });
+    });
+
+    const findNode = (id: string) => model.getNode(id);
+    function createTreeModel(): TreeModel {
+        const container = createTreeTestContainer();
+        return container.get(TreeModel);
+    }
+    function retrieveNode<T extends TreeNode>(id: string): Readonly<T> {
+        const readonlyNode: Readonly<T> = model.getNode(id) as T;
+        return readonlyNode;
+    }
+    function collapseNode(...ids: string[]): void {
+        ids.map(findNode).filter(notEmpty).filter(ExpandableTreeNode.is).forEach(node => {
+            model.collapseNode(node);
+            expect(node).to.have.property('expanded', false);
+        });
+    }
+
+});

package/src/browser/tree/tree-selection-impl.ts

@@ -1,176 +1,176 @@
-// *****************************************************************************
-// Copyright (C) 2018 TypeFox and others.
-//
-// This program and the accompanying materials are made available under the
-// terms of the Eclipse Public License v. 2.0 which is available at
-// http://www.eclipse.org/legal/epl-2.0.
-//
-// This Source Code may also be made available under the following Secondary
-// Licenses when the conditions for such availability set forth in the Eclipse
-// Public License v. 2.0 are satisfied: GNU General Public License, version 2
-// with the GNU Classpath Exception which is available at
-// https://www.gnu.org/software/classpath/license.html.
-//
-// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
-// *****************************************************************************
-
-import { injectable, inject, postConstruct } from 'inversify';
-import { Tree, TreeNode } from './tree';
-import { Event, Emitter } from '../../common';
-import { TreeSelectionState, FocusableTreeSelection } from './tree-selection-state';
-import { TreeSelectionService, SelectableTreeNode, TreeSelection } from './tree-selection';
-import { TreeFocusService } from './tree-focus-service';
-
-@injectable()
-export class TreeSelectionServiceImpl implements TreeSelectionService {
-
-    @inject(Tree) protected readonly tree: Tree;
-    @inject(TreeFocusService) protected readonly focusService: TreeFocusService;
-
-    protected readonly onSelectionChangedEmitter = new Emitter<ReadonlyArray<Readonly<SelectableTreeNode>>>();
-
-    protected state: TreeSelectionState;
-
-    @postConstruct()
-    protected init(): void {
-        this.state = new TreeSelectionState(this.tree);
-    }
-
-    dispose(): void {
-        this.onSelectionChangedEmitter.dispose();
-    }
-
-    get selectedNodes(): ReadonlyArray<Readonly<SelectableTreeNode>> {
-        return this.state.selection();
-    }
-
-    get onSelectionChanged(): Event<ReadonlyArray<Readonly<SelectableTreeNode>>> {
-        return this.onSelectionChangedEmitter.event;
-    }
-
-    protected fireSelectionChanged(): void {
-        this.onSelectionChangedEmitter.fire(this.state.selection());
-    }
-
-    addSelection(selectionOrTreeNode: TreeSelection | Readonly<SelectableTreeNode>): void {
-        const selection = ((arg: TreeSelection | Readonly<SelectableTreeNode>): TreeSelection => {
-            const type = TreeSelection.SelectionType.DEFAULT;
-            if (TreeSelection.is(arg)) {
-                return {
-                    type,
-                    ...arg
-                };
-            }
-            return {
-                type,
-                node: arg
-            };
-        })(selectionOrTreeNode);
-
-        const node = this.validateNode(selection.node);
-        if (node === undefined) {
-            return;
-        }
-        Object.assign(selection, { node });
-
-        const newState = this.state.nextState(selection);
-        this.transiteTo(newState);
-    }
-
-    clearSelection(): void {
-        this.transiteTo(new TreeSelectionState(this.tree), false);
-    }
-
-    protected transiteTo(newState: TreeSelectionState, setFocus = true): void {
-        const oldNodes = this.state.selection();
-        const newNodes = newState.selection();
-
-        const toUnselect = this.difference(oldNodes, newNodes);
-        const toSelect = this.difference(newNodes, oldNodes);
-
-        this.unselect(toUnselect);
-        this.select(toSelect);
-        this.removeFocus(oldNodes, newNodes);
-        if (setFocus) {
-            this.addFocus(newState.node);
-        }
-
-        this.state = newState;
-        this.fireSelectionChanged();
-    }
-
-    protected unselect(nodes: ReadonlyArray<SelectableTreeNode>): void {
-        nodes.forEach(node => node.selected = false);
-    }
-
-    protected select(nodes: ReadonlyArray<SelectableTreeNode>): void {
-        nodes.forEach(node => node.selected = true);
-    }
-
-    protected removeFocus(...nodes: ReadonlyArray<SelectableTreeNode>[]): void {
-        nodes.forEach(node => node.forEach(n => n.focus = false));
-    }
-
-    protected addFocus(node: SelectableTreeNode | undefined): void {
-        if (node) {
-            node.focus = true;
-        }
-        this.focusService.setFocus(node);
-    }
-
-    /**
-     * Returns an array of the difference of two arrays. The returned array contains all elements that are contained by
-     * `left` and not contained by `right`. `right` may also contain elements not present in `left`: these are simply ignored.
-     */
-    protected difference<T>(left: ReadonlyArray<T>, right: ReadonlyArray<T>): ReadonlyArray<T> {
-        return left.filter(item => right.indexOf(item) === -1);
-    }
-
-    /**
-     * Returns a reference to the argument if the node exists in the tree. Otherwise, `undefined`.
-     */
-    protected validateNode(node: Readonly<TreeNode>): Readonly<TreeNode> | undefined {
-        const result = this.tree.validateNode(node);
-        return SelectableTreeNode.is(result) ? result : undefined;
-    }
-
-    storeState(): TreeSelectionServiceImpl.State {
-        return {
-            selectionStack: this.state.selectionStack.map(s => ({
-                focus: s.focus && s.focus.id || undefined,
-                node: s.node && s.node.id || undefined,
-                type: s.type
-            }))
-        };
-    }
-
-    restoreState(state: TreeSelectionServiceImpl.State): void {
-        const selectionStack: FocusableTreeSelection[] = [];
-        for (const selection of state.selectionStack) {
-            const node = selection.node && this.tree.getNode(selection.node) || undefined;
-            if (!SelectableTreeNode.is(node)) {
-                break;
-            }
-            const focus = selection.focus && this.tree.getNode(selection.focus) || undefined;
-            selectionStack.push({
-                node,
-                focus: SelectableTreeNode.is(focus) && focus || undefined,
-                type: selection.type
-            });
-        }
-        if (selectionStack.length) {
-            this.transiteTo(new TreeSelectionState(this.tree, selectionStack));
-        }
-    }
-
-}
-export namespace TreeSelectionServiceImpl {
-    export interface State {
-        selectionStack: ReadonlyArray<FocusableTreeSelectionState>
-    }
-    export interface FocusableTreeSelectionState {
-        focus?: string
-        node?: string
-        type?: TreeSelection.SelectionType
-    }
-}
+// *****************************************************************************
+// Copyright (C) 2018 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable, inject, postConstruct } from 'inversify';
+import { Tree, TreeNode } from './tree';
+import { Event, Emitter } from '../../common';
+import { TreeSelectionState, FocusableTreeSelection } from './tree-selection-state';
+import { TreeSelectionService, SelectableTreeNode, TreeSelection } from './tree-selection';
+import { TreeFocusService } from './tree-focus-service';
+
+@injectable()
+export class TreeSelectionServiceImpl implements TreeSelectionService {
+
+    @inject(Tree) protected readonly tree: Tree;
+    @inject(TreeFocusService) protected readonly focusService: TreeFocusService;
+
+    protected readonly onSelectionChangedEmitter = new Emitter<ReadonlyArray<Readonly<SelectableTreeNode>>>();
+
+    protected state: TreeSelectionState;
+
+    @postConstruct()
+    protected init(): void {
+        this.state = new TreeSelectionState(this.tree);
+    }
+
+    dispose(): void {
+        this.onSelectionChangedEmitter.dispose();
+    }
+
+    get selectedNodes(): ReadonlyArray<Readonly<SelectableTreeNode>> {
+        return this.state.selection();
+    }
+
+    get onSelectionChanged(): Event<ReadonlyArray<Readonly<SelectableTreeNode>>> {
+        return this.onSelectionChangedEmitter.event;
+    }
+
+    protected fireSelectionChanged(): void {
+        this.onSelectionChangedEmitter.fire(this.state.selection());
+    }
+
+    addSelection(selectionOrTreeNode: TreeSelection | Readonly<SelectableTreeNode>): void {
+        const selection = ((arg: TreeSelection | Readonly<SelectableTreeNode>): TreeSelection => {
+            const type = TreeSelection.SelectionType.DEFAULT;
+            if (TreeSelection.is(arg)) {
+                return {
+                    type,
+                    ...arg
+                };
+            }
+            return {
+                type,
+                node: arg
+            };
+        })(selectionOrTreeNode);
+
+        const node = this.validateNode(selection.node);
+        if (node === undefined) {
+            return;
+        }
+        Object.assign(selection, { node });
+
+        const newState = this.state.nextState(selection);
+        this.transiteTo(newState);
+    }
+
+    clearSelection(): void {
+        this.transiteTo(new TreeSelectionState(this.tree), false);
+    }
+
+    protected transiteTo(newState: TreeSelectionState, setFocus = true): void {
+        const oldNodes = this.state.selection();
+        const newNodes = newState.selection();
+
+        const toUnselect = this.difference(oldNodes, newNodes);
+        const toSelect = this.difference(newNodes, oldNodes);
+
+        this.unselect(toUnselect);
+        this.select(toSelect);
+        this.removeFocus(oldNodes, newNodes);
+        if (setFocus) {
+            this.addFocus(newState.node);
+        }
+
+        this.state = newState;
+        this.fireSelectionChanged();
+    }
+
+    protected unselect(nodes: ReadonlyArray<SelectableTreeNode>): void {
+        nodes.forEach(node => node.selected = false);
+    }
+
+    protected select(nodes: ReadonlyArray<SelectableTreeNode>): void {
+        nodes.forEach(node => node.selected = true);
+    }
+
+    protected removeFocus(...nodes: ReadonlyArray<SelectableTreeNode>[]): void {
+        nodes.forEach(node => node.forEach(n => n.focus = false));
+    }
+
+    protected addFocus(node: SelectableTreeNode | undefined): void {
+        if (node) {
+            node.focus = true;
+        }
+        this.focusService.setFocus(node);
+    }
+
+    /**
+     * Returns an array of the difference of two arrays. The returned array contains all elements that are contained by
+     * `left` and not contained by `right`. `right` may also contain elements not present in `left`: these are simply ignored.
+     */
+    protected difference<T>(left: ReadonlyArray<T>, right: ReadonlyArray<T>): ReadonlyArray<T> {
+        return left.filter(item => right.indexOf(item) === -1);
+    }
+
+    /**
+     * Returns a reference to the argument if the node exists in the tree. Otherwise, `undefined`.
+     */
+    protected validateNode(node: Readonly<TreeNode>): Readonly<TreeNode> | undefined {
+        const result = this.tree.validateNode(node);
+        return SelectableTreeNode.is(result) ? result : undefined;
+    }
+
+    storeState(): TreeSelectionServiceImpl.State {
+        return {
+            selectionStack: this.state.selectionStack.map(s => ({
+                focus: s.focus && s.focus.id || undefined,
+                node: s.node && s.node.id || undefined,
+                type: s.type
+            }))
+        };
+    }
+
+    restoreState(state: TreeSelectionServiceImpl.State): void {
+        const selectionStack: FocusableTreeSelection[] = [];
+        for (const selection of state.selectionStack) {
+            const node = selection.node && this.tree.getNode(selection.node) || undefined;
+            if (!SelectableTreeNode.is(node)) {
+                break;
+            }
+            const focus = selection.focus && this.tree.getNode(selection.focus) || undefined;
+            selectionStack.push({
+                node,
+                focus: SelectableTreeNode.is(focus) && focus || undefined,
+                type: selection.type
+            });
+        }
+        if (selectionStack.length) {
+            this.transiteTo(new TreeSelectionState(this.tree, selectionStack));
+        }
+    }
+
+}
+export namespace TreeSelectionServiceImpl {
+    export interface State {
+        selectionStack: ReadonlyArray<FocusableTreeSelectionState>
+    }
+    export interface FocusableTreeSelectionState {
+        focus?: string
+        node?: string
+        type?: TreeSelection.SelectionType
+    }
+}