@codingame/monaco-vscode-api 9.0.3 → 10.0.1

package/vscode/src/vs/base/browser/ui/tree/asyncDataTree.js

@@ -1,16 +1,18 @@
 import { ElementsDragAndDropData } from '../list/listView.js';
-import { ComposedTreeDelegate } from './abstractTree.js';
+import { AbstractFindController, ComposedTreeDelegate } from './abstractTree.js';
 import { isFilterResult, getVisibleState } from './indexTreeModel.js';
 import { ObjectTree, CompressibleObjectTree } from './objectTree.js';
-import { WeakMapper, ObjectTreeElementCollapseState, TreeError, TreeVisibility } from './tree.js';
-import { Promises, timeout, createCancelablePromise } from '../../../common/async.js';
+import { WeakMapper, ObjectTreeElementCollapseState, TreeError } from './tree.js';
+import { Promises, timeout, createCancelablePromise, TimeoutTimer } from '../../../common/async.js';
 import { Codicon } from '../../../common/codicons.js';
 import { ThemeIcon } from '../../../common/themables.js';
 import { isCancellationError, onUnexpectedError } from '../../../common/errors.js';
 import { Event, Emitter } from '../../../common/event.js';
 import { Iterable } from '../../../common/iterator.js';
 import { DisposableStore, dispose } from '../../../common/lifecycle.js';
-import { isIterable } from '../../../common/types.js';
+import { isNumber, isIterable } from '../../../common/types.js';
+import { CancellationTokenSource } from '../../../common/cancellation.js';
+import { FuzzyScore, fuzzyScore } from '../../../common/filters.js';
 function createAsyncDataTreeNode(props) {
     return {
         ...props,
@@ -152,6 +154,286 @@ class AsyncDataTreeNodeListDragAndDrop {
         this.dnd.dispose();
     }
 }
+class AsyncFindTreeNode {
+    get children() {
+        return ( this._children.values());
+    }
+    constructor(element, id, sorter) {
+        this.element = element;
+        this.id = id;
+        this.sorter = sorter;
+        this._children = [];
+    }
+    addChild(child) {
+        if (!this.sorter) {
+            this._children.push(child);
+            return;
+        }
+        const index = this._children.findIndex(existingChild => this.sorter.compare(child.element, existingChild.element) < 0);
+        if (index !== -1) {
+            this._children.splice(index, 0, child);
+        }
+        else {
+            this._children.push(child);
+        }
+    }
+}
+class AsyncFindTree {
+    get rootNodes() {
+        return [...this.root.children];
+    }
+    get totalLeafs() {
+        return this._totalLeafs;
+    }
+    get totalNodes() {
+        return this.cachedNodes.size;
+    }
+    constructor(dataSource, identityProvider, sorter) {
+        this.dataSource = dataSource;
+        this.identityProvider = identityProvider;
+        this.sorter = sorter;
+        this.cachedNodes = ( new Map());
+        this.root = ( new AsyncFindTreeNode(undefined, '_AsyncFindTreeRoot_', this.sorter));
+        this._totalLeafs = 0;
+        if (!dataSource.getParent) {
+            throw ( new Error('Data source must implement `getParent`'));
+        }
+    }
+    add(element) {
+        const elementId = ( this.identityProvider.getId(element).toString());
+        if (( this.cachedNodes.has(elementId))) {
+            return;
+        }
+        this._totalLeafs++;
+        const node = ( new AsyncFindTreeNode(element, elementId, this.sorter));
+        this.cachedNodes.set(elementId, node);
+        let currentNode = node;
+        while (true) {
+            let currentParentElement = this.dataSource.getParent(currentNode.element);
+            if (currentParentElement === currentNode.element) {
+                this.root.addChild(currentNode);
+                break;
+            }
+            currentParentElement = currentParentElement;
+            const parentId = ( this.identityProvider.getId(currentParentElement).toString());
+            const parentNode = this.cachedNodes.get(parentId);
+            if (parentNode) {
+                parentNode.addChild(currentNode);
+                break;
+            }
+            const newParent = ( new AsyncFindTreeNode(currentParentElement, parentId, this.sorter));
+            this.cachedNodes.set(parentId, newParent);
+            newParent.addChild(currentNode);
+            currentNode = newParent;
+        }
+    }
+}
+class AsyncFindFilter {
+    get pattern() {
+        return this._pattern;
+    }
+    set pattern(pattern) {
+        this._pattern = pattern;
+        this._lowercasePattern = pattern.toLowerCase();
+    }
+    constructor(keyboardNavigationLabelProvider, _filter) {
+        this.keyboardNavigationLabelProvider = keyboardNavigationLabelProvider;
+        this._filter = _filter;
+        this._pattern = '';
+        this._lowercasePattern = '';
+        this.disposables = ( new DisposableStore());
+    }
+    filter(element, parentVisibility) {
+        let visibility = 1 ;
+        if (this._filter) {
+            const result = this._filter.filter(element, parentVisibility);
+            if (typeof result === 'boolean') {
+                visibility = result ? 1  : 0 ;
+            }
+            else if (isFilterResult(result)) {
+                visibility = getVisibleState(result.visibility);
+            }
+            else {
+                visibility = result;
+            }
+            if (visibility === 0 ) {
+                return false;
+            }
+        }
+        if (!this._pattern) {
+            return { data: FuzzyScore.Default, visibility };
+        }
+        const label = this.keyboardNavigationLabelProvider.getKeyboardNavigationLabel(element.element);
+        const labels = Array.isArray(label) ? label : [label];
+        for (const l of labels) {
+            const labelStr = l && ( l.toString());
+            if (typeof labelStr === 'undefined') {
+                return { data: FuzzyScore.Default, visibility };
+            }
+            const score = fuzzyScore(this._pattern, this._lowercasePattern, 0, labelStr, labelStr.toLowerCase(), 0, { firstMatchCanBeWeak: true, boostFullMatch: true });
+            if (score) {
+                return labels.length === 1 ?
+                    { data: score, visibility } :
+                    { data: { label: labelStr, score: score }, visibility };
+            }
+        }
+        return { data: FuzzyScore.Default, visibility };
+    }
+    dispose() {
+        dispose(this.disposables);
+    }
+}
+class AsyncFindController extends AbstractFindController {
+    constructor(user, tree, findProvider, filter, sorter, dataSource, identityProvider, contextViewProvider, options, asTreeElement) {
+        super(tree, filter, contextViewProvider, { ...options, placeholder: findProvider.placeholder, toggles: findProvider.toggles });
+        this.user = user;
+        this.tree = tree;
+        this.findProvider = findProvider;
+        this.sorter = sorter;
+        this.dataSource = dataSource;
+        this.identityProvider = identityProvider;
+        this.asTreeElement = asTreeElement;
+        this.nodes = ( new Map());
+        this.previousFocus = [];
+        this.previousSelection = [];
+        this.sessionId = 0;
+        this.active = false;
+        this.store = ( new DisposableStore());
+        this.model = tree.getModel();
+        this.scheduler = this.store.add(( new TimeoutTimer()));
+    }
+    setFindModeActive(active) {
+        if (this.active === active) {
+            return;
+        }
+        if (active) {
+            this.activateFindMode();
+        }
+        else {
+            this.deactivateFindMode();
+        }
+        this.active = active;
+    }
+    activateFindMode() {
+        this.sessionId++;
+        this.previousScrollTop = this.tree.scrollTop;
+        this.previousFocus = this.tree.getFocus();
+        this.previousSelection = this.tree.getSelection();
+        this.tree.scrollTop = 0;
+        const findModel = this.tree.createNewModel({ filter: this.filter });
+        this.tree.setModel(findModel);
+    }
+    deactivateFindMode() {
+        const focus = this.tree.getFocus()[0];
+        this.tree.setModel(this.model);
+        if (focus && focus.element && this.findProvider.revealResultInTree) {
+            this.findProvider.revealResultInTree(focus.element);
+        }
+        else {
+            this.tree.scrollTop = this.previousScrollTop ?? 0;
+            this.tree.setFocus(this.previousFocus);
+            this.tree.setSelection(this.previousSelection);
+        }
+        this.activeTokenSource = undefined;
+        this.nodes.clear();
+    }
+    applyPattern(pattern) {
+        this.renderMessage(false);
+        this.scheduler.cancel();
+        this.activeTokenSource?.cancel();
+        if (!pattern) {
+            this.setFindModeActive(false);
+            return;
+        }
+        this.activeTokenSource = ( new CancellationTokenSource());
+        const results = this.findProvider.getFindResults(pattern, this.sessionId, this.activeTokenSource.token, this.toggles.states());
+        this.pocessFindResults(results, this.activeTokenSource.token);
+    }
+    async pocessFindResults(results, token) {
+        if (!this.dataSource.getParent || !this.identityProvider) {
+            return;
+        }
+        this.clearFindResults();
+        const findTree = ( new AsyncFindTree(this.dataSource, this.identityProvider, this.sorter));
+        for await (const result of results) {
+            if (token.isCancellationRequested) {
+                return;
+            }
+            findTree.add(result);
+        }
+        if (token.isCancellationRequested) {
+            return;
+        }
+        this.setFindResults(findTree);
+        this.activeTokenSource?.dispose();
+        this.activeTokenSource = undefined;
+    }
+    clearFindResults() {
+        this.schedule(() => {
+            if (!this.active) {
+                this.setFindModeActive(true);
+                return;
+            }
+            else {
+                this.tree.setChildren(null, []);
+            }
+        }, 600);
+    }
+    setFindResults(findTree) {
+        const rootChildren = [];
+        for (const rootNodes of findTree.rootNodes) {
+            rootChildren.push(this.asTreeElement(this.findNodeToAsyncNode(rootNodes, null)));
+        }
+        this.schedule(() => {
+            this.setFindModeActive(true);
+            this.tree.setChildren(null, rootChildren);
+            this.renderMessage(rootChildren.length === 0);
+            this.alertResults(findTree.totalLeafs);
+        }, 0);
+    }
+    findNodeToAsyncNode(node, parent) {
+        const children = [];
+        if (node.element === undefined) {
+            throw ( new TreeError(this.user, 'Found node without an element'));
+        }
+        const asyncNode = {
+            element: node.element,
+            parent,
+            children,
+            hasChildren: false,
+            defaultCollapseState: ObjectTreeElementCollapseState.PreserveOrExpanded,
+            stale: false,
+            refreshPromise: undefined,
+            slow: false,
+            forceExpanded: false
+        };
+        for (const child of node.children) {
+            children.push(this.findNodeToAsyncNode(child, asyncNode));
+        }
+        asyncNode.hasChildren = !!children.length;
+        this.nodes.set(node.element, asyncNode);
+        return asyncNode;
+    }
+    schedule(fn, delay) {
+        if (delay === 0) {
+            this.scheduler.cancel();
+            fn();
+            return;
+        }
+        this.scheduler.cancelAndSet(fn, delay);
+    }
+    onDidToggleChange(e) {
+        super.onDidToggleChange(e);
+        this.applyPattern(this.pattern);
+    }
+    getDataNode(element) {
+        return this.nodes.get(element);
+    }
+    dispose() {
+        super.dispose();
+        this.store.dispose();
+    }
+}
 function asObjectTreeOptions(options) {
     return options && {
         ...options,
@@ -209,13 +491,13 @@ function asObjectTreeOptions(options) {
         expandOnlyOnTwistieClick: typeof options.expandOnlyOnTwistieClick === 'undefined' ? undefined : (typeof options.expandOnlyOnTwistieClick !== 'function' ? options.expandOnlyOnTwistieClick : (e => options.expandOnlyOnTwistieClick(e.element))),
         defaultFindVisibility: e => {
             if (e.hasChildren && e.stale) {
-                return TreeVisibility.Visible;
+                return 1 ;
             }
             else if (typeof options.defaultFindVisibility === 'number') {
                 return options.defaultFindVisibility;
             }
             else if (typeof options.defaultFindVisibility === 'undefined') {
-                return TreeVisibility.Recurse;
+                return 2 ;
             }
             else {
                 return options.defaultFindVisibility(e.element);
@@ -242,7 +524,6 @@ class AsyncDataTree {
     get onDidChangeModel() { return this.tree.onDidChangeModel; }
     get onDidChangeCollapseState() { return this.tree.onDidChangeCollapseState; }
     get onDidUpdateOptions() { return this.tree.onDidUpdateOptions; }
-    get onDidChangeFindOpenState() { return this.tree.onDidChangeFindOpenState; }
     get onDidChangeStickyScrollFocused() { return this.tree.onDidChangeStickyScrollFocused; }
     get findMode() { return this.tree.findMode; }
     set findMode(mode) { this.tree.findMode = mode; }
@@ -270,9 +551,15 @@ class AsyncDataTree {
         this.autoExpandSingleChildren = typeof options.autoExpandSingleChildren === 'undefined' ? false : options.autoExpandSingleChildren;
         this.sorter = options.sorter;
         this.getDefaultCollapseState = e => options.collapseByDefault ? (options.collapseByDefault(e) ? ObjectTreeElementCollapseState.PreserveOrCollapsed : ObjectTreeElementCollapseState.PreserveOrExpanded) : undefined;
-        this.tree = this.createTree(user, container, delegate, renderers, options);
-        this.onDidChangeFindMode = this.tree.onDidChangeFindMode;
-        this.onDidChangeFindMatchType = this.tree.onDidChangeFindMatchType;
+        let asyncFindEnabled = false;
+        if (options.findResultsProvider && (options.findWidgetEnabled ?? true) && options.keyboardNavigationLabelProvider && options.contextViewProvider) {
+            if (!this.dataSource.getParent || !this.identityProvider) {
+                throw ( new TreeError(this.user, 'Find Provider requires `getParent` and `identityProvider`'));
+            }
+            asyncFindEnabled = true;
+        }
+        this.tree = this.createTree(user, container, delegate, renderers, { ...options, findWidgetEnabled: !asyncFindEnabled });
+        this.model = this.tree.getModel();
         this.root = createAsyncDataTreeNode({
             element: undefined,
             parent: null,
@@ -287,6 +574,30 @@ class AsyncDataTree {
         }
         this.nodes.set(null, this.root);
         this.tree.onDidChangeCollapseState(this._onDidChangeCollapseState, this, this.disposables);
+        if (asyncFindEnabled) {
+            const findFilter = this.disposables.add(( new AsyncFindFilter(options.keyboardNavigationLabelProvider, this.tree.options.filter)));
+            const findOptions = { styles: options.findWidgetStyles, showNotFoundMessage: options.showNotFoundMessage };
+            this.findController = this.disposables.add(( new AsyncFindController(
+                user,
+                this.tree,
+                options.findResultsProvider,
+                findFilter,
+                this.sorter,
+                this.dataSource,
+                this.identityProvider,
+                options.contextViewProvider,
+                findOptions,
+                node => this.asTreeElement(node)
+            )));
+            this.onDidChangeFindOpenState = this.findController.onDidChangeOpenState;
+            this.onDidChangeFindMode = Event.None;
+            this.onDidChangeFindMatchType = Event.None;
+        }
+        else {
+            this.onDidChangeFindOpenState = this.tree.onDidChangeFindOpenState;
+            this.onDidChangeFindMode = this.tree.onDidChangeFindMode;
+            this.onDidChangeFindMatchType = this.tree.onDidChangeFindMatchType;
+        }
     }
     createTree(user, container, delegate, renderers, options) {
         const objectTreeDelegate = ( new ComposedTreeDelegate(delegate));
@@ -351,8 +662,21 @@ class AsyncDataTree {
     domFocus() {
         this.tree.domFocus();
     }
+    isDOMFocused() {
+        return this.tree.isDOMFocused();
+    }
+    navigate(start) {
+        let startNode;
+        if (start) {
+            startNode = this.getDataNode(start);
+        }
+        return ( new AsyncDataTreeNavigator(this.tree.navigate(startNode)));
+    }
     layout(height, width) {
         this.tree.layout(height, width);
+        if (isNumber(width)) {
+            this.findController?.layout(width);
+        }
     }
     style(styles) {
         this.tree.style(styles);
@@ -396,7 +720,7 @@ class AsyncDataTree {
         }
     }
     resort(element = this.root.element, recursive = true) {
-        this.tree.resort(this.getDataNode(element), recursive);
+        this.model.resort(this.getDataNode(element), recursive);
     }
     hasNode(element) {
         return element === this.root.element || ( this.nodes.has(element));
@@ -487,10 +811,20 @@ class AsyncDataTree {
         this.tree.triggerTypeNavigation();
     }
     openFind() {
-        this.tree.openFind();
+        if (this.findController) {
+            this.findController.open();
+        }
+        else {
+            this.tree.openFind();
+        }
     }
     closeFind() {
-        this.tree.closeFind();
+        if (this.findController) {
+            this.findController.close();
+        }
+        else {
+            this.tree.closeFind();
+        }
     }
     refilter() {
         this.tree.refilter();
@@ -559,6 +893,10 @@ class AsyncDataTree {
         return (node && node.element);
     }
     getDataNode(element) {
+        const asyncFindNode = this.findController?.getDataNode(element);
+        if (asyncFindNode) {
+            return asyncFindNode;
+        }
         const node = this.nodes.get((element === this.root.element ? null : element));
         if (!node) {
             throw ( new TreeError(this.user, `Data tree node not found: ${element}`));
@@ -635,8 +973,8 @@ class AsyncDataTree {
             return this.setChildren(node, children, recursive, viewStateContext);
         }
         catch (err) {
-            if (node !== this.root && this.tree.hasElement(node)) {
-                this.tree.collapse(node);
+            if (node !== this.root && ( this.model.has(node))) {
+                this.model.setCollapsed(node);
             }
             if (isCancellationError(err)) {
                 return [];
@@ -689,7 +1027,7 @@ class AsyncDataTree {
         for (const child of node.children) {
             nodesToForget.set(child.element, child);
             if (this.identityProvider) {
-                childrenTreeNodesById.set(child.id, { node: child, collapsed: this.tree.hasElement(child) && this.tree.isCollapsed(child) });
+                childrenTreeNodesById.set(child.id, { node: child, collapsed: ( this.model.has(child)) && this.model.isCollapsed(child) });
             }
         }
         const childrenToRefresh = [];
@@ -764,9 +1102,9 @@ class AsyncDataTree {
                 }
             }
         };
-        this.tree.setChildren(node === this.root ? null : node, children, objectTreeOptions);
+        this.model.setChildren(node === this.root ? null : node, children, objectTreeOptions);
         if (node !== this.root) {
-            this.tree.setCollapsible(node, node.hasChildren);
+            this.model.setCollapsible(node, node.hasChildren);
         }
         this._onDidRender.fire();
     }
@@ -908,6 +1246,10 @@ class CompressibleAsyncDataTree extends AsyncDataTree {
         this.compressibleNodeMapper = ( new WeakMapper(node => ( new CompressibleAsyncDataTreeNodeWrapper(node))));
         this.filter = options.filter;
     }
+    getCompressedTreeNode(e) {
+        const node = this.getDataNode(e);
+        return this.tree.getCompressedTreeNode(node).element;
+    }
     createTree(user, container, delegate, renderers, options) {
         const objectTreeDelegate = ( new ComposedTreeDelegate(delegate));
         const objectTreeRenderers = ( renderers.map(r => ( new CompressibleAsyncDataTreeRenderer(
@@ -1009,20 +1351,23 @@ class CompressibleAsyncDataTree extends AsyncDataTree {
     processChildren(children) {
         if (this.filter) {
             children = Iterable.filter(children, e => {
-                const result = this.filter.filter(e, TreeVisibility.Visible);
+                const result = this.filter.filter(e, 1 );
                 const visibility = getVisibility(result);
-                if (visibility === TreeVisibility.Recurse) {
+                if (visibility === 2 ) {
                     throw ( new Error('Recursive tree visibility not supported in async data compressed trees'));
                 }
-                return visibility === TreeVisibility.Visible;
+                return visibility === 1 ;
             });
         }
         return super.processChildren(children);
     }
+    navigate(start) {
+        return super.navigate(start);
+    }
 }
 function getVisibility(filterResult) {
     if (typeof filterResult === 'boolean') {
-        return filterResult ? TreeVisibility.Visible : TreeVisibility.Hidden;
+        return filterResult ? 1  : 0 ;
     }
     else if (isFilterResult(filterResult)) {
         return getVisibleState(filterResult.visibility);
@@ -1031,4 +1376,32 @@ function getVisibility(filterResult) {
         return getVisibleState(filterResult);
     }
 }
+class AsyncDataTreeNavigator {
+    constructor(navigator) {
+        this.navigator = navigator;
+    }
+    current() {
+        const current = this.navigator.current();
+        if (current === null) {
+            return null;
+        }
+        return current.element;
+    }
+    previous() {
+        this.navigator.previous();
+        return this.current();
+    }
+    first() {
+        this.navigator.first();
+        return this.current();
+    }
+    last() {
+        this.navigator.last();
+        return this.current();
+    }
+    next() {
+        this.navigator.next();
+        return this.current();
+    }
+}
 export { AsyncDataTree, CompressibleAsyncDataTree };

package/vscode/src/vs/base/browser/ui/tree/compressedObjectTreeModel.js

@@ -1,3 +1,4 @@
+import { getVisibleState, isFilterResult } from './indexTreeModel.js';
 import { ObjectTreeModel } from './objectTreeModel.js';
 import { WeakMapper, TreeError } from './tree.js';
 import { equals } from '../../../common/arrays.js';
@@ -75,15 +76,16 @@ const wrapIdentityProvider = (base) => ({
     }
 });
 class CompressedObjectTreeModel {
-    get onDidSplice() { return this.model.onDidSplice; }
+    get onDidSpliceRenderedNodes() { return this.model.onDidSpliceRenderedNodes; }
+    get onDidSpliceModel() { return this.model.onDidSpliceModel; }
     get onDidChangeCollapseState() { return this.model.onDidChangeCollapseState; }
     get onDidChangeRenderNodeCount() { return this.model.onDidChangeRenderNodeCount; }
     get size() { return this.nodes.size; }
-    constructor(user, list, options = {}) {
+    constructor(user, options = {}) {
         this.user = user;
         this.rootRef = null;
         this.nodes = ( new Map());
-        this.model = ( new ObjectTreeModel(user, list, options));
+        this.model = ( new ObjectTreeModel(user, options));
         this.enabled = typeof options.compressionEnabled === 'undefined' ? true : options.compressionEnabled;
         this.identityProvider = options.identityProvider;
     }
@@ -217,13 +219,6 @@ class CompressedObjectTreeModel {
         const compressedNode = this.getCompressedNode(location);
         this.model.rerender(compressedNode);
     }
-    updateElementHeight(element, height) {
-        const compressedNode = this.getCompressedNode(element);
-        if (!compressedNode) {
-            return;
-        }
-        this.model.updateElementHeight(compressedNode, height);
-    }
     refilter() {
         this.model.refilter();
     }
@@ -258,16 +253,6 @@ class CompressedTreeNodeWrapper {
         this.node = node;
     }
 }
-function mapList(nodeMapper, list) {
-    return {
-        splice(start, deleteCount, toInsert) {
-            list.splice(start, deleteCount, ( toInsert.map(node => ( nodeMapper.map(node)))));
-        },
-        updateElementHeight(index, height) {
-            list.updateElementHeight(index, height);
-        }
-    };
-}
 function mapOptions(compressedNodeUnwrapper, options) {
     return {
         ...options,
@@ -283,18 +268,33 @@ function mapOptions(compressedNodeUnwrapper, options) {
         },
         filter: options.filter && {
             filter(node, parentVisibility) {
-                return options.filter.filter(compressedNodeUnwrapper(node), parentVisibility);
+                const elements = node.elements;
+                for (let i = 0; i < elements.length - 1; i++) {
+                    const result = options.filter.filter(elements[i], parentVisibility);
+                    parentVisibility = getVisibleState(isFilterResult(result) ? result.visibility : result);
+                }
+                return options.filter.filter(elements[elements.length - 1], parentVisibility);
             }
         }
     };
 }
 class CompressibleObjectTreeModel {
-    get onDidSplice() {
-        return ( Event.map(this.model.onDidSplice, ({ insertedNodes, deletedNodes }) => ({
+    get onDidSpliceModel() {
+        return ( Event.map(this.model.onDidSpliceModel, ({ insertedNodes, deletedNodes }) => ({
             insertedNodes: ( insertedNodes.map(node => ( this.nodeMapper.map(node)))),
             deletedNodes: ( deletedNodes.map(node => ( this.nodeMapper.map(node)))),
         })));
     }
+    get onDidSpliceRenderedNodes() {
+        return ( Event.map(
+            this.model.onDidSpliceRenderedNodes,
+            ({ start, deleteCount, elements }) => ({
+                start,
+                deleteCount,
+                elements: ( elements.map(node => ( this.nodeMapper.map(node))))
+            })
+        ));
+    }
     get onDidChangeCollapseState() {
         return ( Event.map(this.model.onDidChangeCollapseState, ({ node, deep }) => ({
             node: ( this.nodeMapper.map(node)),
@@ -304,16 +304,12 @@ class CompressibleObjectTreeModel {
     get onDidChangeRenderNodeCount() {
         return ( Event.map(this.model.onDidChangeRenderNodeCount, node => ( this.nodeMapper.map(node))));
     }
-    constructor(user, list, options = {}) {
+    constructor(user, options = {}) {
         this.rootRef = null;
         this.elementMapper = options.elementMapper || DefaultElementMapper;
         const compressedNodeUnwrapper = node => this.elementMapper(node.elements);
         this.nodeMapper = ( new WeakMapper(node => ( new CompressedTreeNodeWrapper(compressedNodeUnwrapper, node))));
-        this.model = ( new CompressedObjectTreeModel(
-            user,
-            mapList(this.nodeMapper, list),
-            mapOptions(compressedNodeUnwrapper, options)
-        ));
+        this.model = ( new CompressedObjectTreeModel(user, mapOptions(compressedNodeUnwrapper, options)));
     }
     setChildren(element, children = Iterable.empty(), options = {}) {
         this.model.setChildren(element, children, options);
@@ -374,9 +370,6 @@ class CompressibleObjectTreeModel {
     rerender(location) {
         return this.model.rerender(location);
     }
-    updateElementHeight(element, height) {
-        this.model.updateElementHeight(element, height);
-    }
     refilter() {
         return this.model.refilter();
     }

package/vscode/src/vs/base/browser/ui/tree/dataTree.js

@@ -106,8 +106,8 @@ class DataTree extends AbstractTree {
         }));
         return { elements, size: children.length };
     }
-    createModel(user, view, options) {
-        return ( new ObjectTreeModel(user, view, options));
+    createModel(user, options) {
+        return ( new ObjectTreeModel(user, options));
     }
 }
 export { DataTree };