UNPKG

@theia/core

Version:

Theia is a cloud & desktop IDE framework implemented in TypeScript.

385 lines • 12.9 kB
// ***************************************************************************** // Copyright (C) 2017 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 { __decorate } from "tslib"; import { inject, injectable, postConstruct, named } from 'inversify'; import { Emitter } from '../../common/event.js'; import { DisposableCollection } from '../../common/disposable.js'; import { ILogger } from '../../common/logger.js'; import { Tree, CompositeTreeNode } from './tree.js'; import { TreeSelectionService, SelectableTreeNode, TreeSelection } from './tree-selection.js'; import { TreeExpansionService, ExpandableTreeNode } from './tree-expansion.js'; import { TreeNavigationService } from './tree-navigation.js'; import { BottomUpTreeIterator, TopDownTreeIterator, Iterators } from './tree-iterator.js'; import { TreeSearch } from './tree-search.js'; import { TreeFocusService } from './tree-focus-service.js'; /** * The tree model. */ export const TreeModel = Symbol('TreeModel'); let TreeModelImpl = class TreeModelImpl { constructor() { this.onChangedEmitter = new Emitter(); this.onOpenNodeEmitter = new Emitter(); this.toDispose = new DisposableCollection(); } init() { this.toDispose.push(this.tree); this.toDispose.push(this.tree.onChanged(() => this.fireChanged())); this.toDispose.push(this.selectionService); this.toDispose.push(this.expansionService); this.toDispose.push(this.expansionService.onExpansionChanged(node => { this.fireChanged(); this.handleExpansion(node); })); this.toDispose.push(this.onOpenNodeEmitter); this.toDispose.push(this.onChangedEmitter); this.toDispose.push(this.treeSearch); } dispose() { this.toDispose.dispose(); } handleExpansion(node) { this.selectIfAncestorOfSelected(node); } /** * Select the given node if it is the ancestor of a selected node. */ selectIfAncestorOfSelected(node) { if (!node.expanded && this.selectedNodes.some(selectedNode => CompositeTreeNode.isAncestor(node, selectedNode))) { if (SelectableTreeNode.isVisible(node)) { this.selectNode(node); } } } get root() { return this.tree.root; } set root(root) { this.tree.root = root; } get onChanged() { return this.onChangedEmitter.event; } get onOpenNode() { return this.onOpenNodeEmitter.event; } fireChanged() { this.onChangedEmitter.fire(undefined); } get onNodeRefreshed() { return this.tree.onNodeRefreshed; } getNode(id) { return this.tree.getNode(id); } getFocusedNode() { return this.focusService.focusedNode; } validateNode(node) { return this.tree.validateNode(node); } removeNode(node) { this.tree.removeNode(node); } async refresh(parent) { if (parent) { return this.tree.refresh(parent); } return this.tree.refresh(); } // eslint-disable-next-line @theia/explicit-return-type get selectedNodes() { return this.selectionService.selectedNodes; } // eslint-disable-next-line @theia/explicit-return-type get onSelectionChanged() { return this.selectionService.onSelectionChanged; } get onExpansionChanged() { return this.expansionService.onExpansionChanged; } async expandNode(raw) { for (const node of this.getExpansionCandidates(raw)) { if (ExpandableTreeNode.is(node)) { return this.expansionService.expandNode(node); } } return undefined; } *getExpansionCandidates(raw) { yield raw; yield this.getFocusedNode(); yield* this.selectedNodes; } async collapseNode(raw) { for (const node of this.getExpansionCandidates(raw)) { if (ExpandableTreeNode.is(node)) { return this.expansionService.collapseNode(node); } } return false; } async collapseAll(raw) { const node = raw || this.getFocusedNode(); if (SelectableTreeNode.is(node)) { this.selectNode(node); } if (CompositeTreeNode.is(node)) { return this.expansionService.collapseAll(node); } return false; } async toggleNodeExpansion(raw) { for (const node of raw ? [raw] : this.selectedNodes) { if (ExpandableTreeNode.is(node)) { await this.expansionService.toggleNodeExpansion(node); } } } selectPrev() { const node = this.getPrevNode(); this.selectNodeIfSelectable(node); } selectPrevNode(type = TreeSelection.SelectionType.DEFAULT) { const node = this.getPrevSelectableNode(); if (node) { this.addSelection({ node, type }); } } getPrevNode(node = this.getFocusedNode()) { const iterator = this.createBackwardTreeIterator(node); return iterator && this.doGetNode(iterator); } getPrevSelectableNode(node = this.getFocusedNode()) { if (!node) { return this.getNextSelectableNode(this.root); } const iterator = this.createBackwardIterator(node); return iterator && this.doGetNextNode(iterator, this.isVisibleSelectableNode.bind(this)); } selectNext() { const node = this.getNextNode(); this.selectNodeIfSelectable(node); } selectNextNode(type = TreeSelection.SelectionType.DEFAULT) { const node = this.getNextSelectableNode(); if (node) { this.addSelection({ node, type }); } } getNextNode(node = this.getFocusedNode()) { const iterator = this.createTreeIterator(node); return iterator && this.doGetNode(iterator); } getNextSelectableNode(node = this.getFocusedNode() ?? this.root) { const iterator = this.createIterator(node); return iterator && this.doGetNextNode(iterator, this.isVisibleSelectableNode.bind(this)); } selectNodeIfSelectable(node) { if (SelectableTreeNode.is(node)) { this.addSelection(node); } } doGetNode(iterator) { iterator.next(); const result = iterator.next(); return result.done ? undefined : result.value; } doGetNextNode(iterator, criterion) { // Skip the first item. // TODO: clean this up, and skip the first item in a different way without loading everything. iterator.next(); let result = iterator.next(); while (!result.done) { if (criterion(result.value)) { return result.value; } result = iterator.next(); } return undefined; } isVisibleSelectableNode(node) { return SelectableTreeNode.isVisible(node); } createBackwardTreeIterator(node) { const { filteredNodes } = this.treeSearch; if (filteredNodes.length === 0) { return node ? new BottomUpTreeIterator(node, { pruneCollapsed: false }) : undefined; } if (node && filteredNodes.indexOf(node) === -1) { return undefined; } return Iterators.cycle(filteredNodes.slice().reverse(), node); } createBackwardIterator(node) { const { filteredNodes } = this.treeSearch; if (filteredNodes.length === 0) { return node ? new BottomUpTreeIterator(node, { pruneCollapsed: true }) : undefined; } if (node && filteredNodes.indexOf(node) === -1) { return undefined; } return Iterators.cycle(filteredNodes.slice().reverse(), node); } createTreeIterator(node) { const { filteredNodes } = this.treeSearch; if (filteredNodes.length === 0) { return node && new TopDownTreeIterator(node, { pruneCollapsed: false }); } if (node && filteredNodes.indexOf(node) === -1) { return undefined; } return Iterators.cycle(filteredNodes, node); } createIterator(node) { const { filteredNodes } = this.treeSearch; if (filteredNodes.length === 0) { return node && this.createForwardIteratorForNode(node); } if (node && filteredNodes.indexOf(node) === -1) { return undefined; } return Iterators.cycle(filteredNodes, node); } createForwardIteratorForNode(node) { return new TopDownTreeIterator(node, { pruneCollapsed: true }); } openNode(raw) { const node = raw ?? this.focusService.focusedNode; if (node) { this.doOpenNode(node); this.onOpenNodeEmitter.fire(node); } } doOpenNode(node) { if (ExpandableTreeNode.is(node)) { this.toggleNodeExpansion(node); } } selectParent() { const node = this.getFocusedNode(); if (node) { const parent = SelectableTreeNode.getVisibleParent(node); if (parent) { this.selectNode(parent); } } } async navigateTo(nodeOrId) { if (nodeOrId) { const node = typeof nodeOrId === 'string' ? this.getNode(nodeOrId) : nodeOrId; if (node) { this.navigationService.push(node); await this.doNavigate(node); return node; } } return undefined; } canNavigateForward() { return !!this.navigationService.next; } canNavigateBackward() { return !!this.navigationService.prev; } async navigateForward() { const node = this.navigationService.advance(); if (node) { await this.doNavigate(node); } } async navigateBackward() { const node = this.navigationService.retreat(); if (node) { await this.doNavigate(node); } } async doNavigate(node) { this.tree.root = node; if (ExpandableTreeNode.is(node)) { await this.expandNode(node); } if (SelectableTreeNode.is(node)) { this.selectNode(node); } } addSelection(selectionOrTreeNode) { this.selectionService.addSelection(selectionOrTreeNode); } clearSelection() { this.selectionService.clearSelection(); } selectNode(node) { this.addSelection(node); } toggleNode(node) { this.addSelection({ node, type: TreeSelection.SelectionType.TOGGLE }); } selectRange(node) { this.addSelection({ node, type: TreeSelection.SelectionType.RANGE }); } storeState() { return { selection: this.selectionService.storeState() }; } restoreState(state) { if (state.selection) { this.selectionService.restoreState(state.selection); } } get onDidChangeBusy() { return this.tree.onDidChangeBusy; } markAsBusy(node, ms, token) { return this.tree.markAsBusy(node, ms, token); } get onDidUpdate() { return this.tree.onDidUpdate; } markAsChecked(node, checked) { this.tree.markAsChecked(node, checked); } }; __decorate([ inject(ILogger), named('core:TreeModelImpl') ], TreeModelImpl.prototype, "logger", void 0); __decorate([ inject(Tree) ], TreeModelImpl.prototype, "tree", void 0); __decorate([ inject(TreeSelectionService) ], TreeModelImpl.prototype, "selectionService", void 0); __decorate([ inject(TreeExpansionService) ], TreeModelImpl.prototype, "expansionService", void 0); __decorate([ inject(TreeNavigationService) ], TreeModelImpl.prototype, "navigationService", void 0); __decorate([ inject(TreeFocusService) ], TreeModelImpl.prototype, "focusService", void 0); __decorate([ inject(TreeSearch) ], TreeModelImpl.prototype, "treeSearch", void 0); __decorate([ postConstruct() ], TreeModelImpl.prototype, "init", null); TreeModelImpl = __decorate([ injectable() ], TreeModelImpl); export { TreeModelImpl }; //# sourceMappingURL=tree-model.js.map