@codingame/monaco-vscode-api 25.1.1 → 26.0.0

package/vscode/src/vs/workbench/api/common/extHostTreeViews.js

@@ -19,20 +19,29 @@ import { MarkdownString } from './extHostTypes/markdownString.js';
 
 function toTreeItemLabel(label, extension) {
     if (isString(label)) {
-        return { label };
+        return {
+            label
+        };
     }
-    if (label && typeof label === 'object' && label.label) {
+    if (label && typeof label === "object" && label.label) {
         let highlights = undefined;
         if (Array.isArray(label.highlights)) {
-            highlights = label.highlights.filter((highlight => highlight.length === 2 && typeof highlight[0] === 'number' && typeof highlight[1] === 'number'));
+            highlights = label.highlights.filter(
+                (highlight => highlight.length === 2 && typeof highlight[0] === "number" && typeof highlight[1] === "number")
+            );
             highlights = highlights.length ? highlights : undefined;
         }
         if (isString(label.label)) {
-            return { label: label.label, highlights };
-        }
-        else if (MarkdownString.isMarkdownString(label.label)) {
-            checkProposedApiEnabled(extension, 'treeItemMarkdownLabel');
-            return { label: MarkdownString$1.from(label.label), highlights };
+            return {
+                label: label.label,
+                highlights
+            };
+        } else if (MarkdownString.isMarkdownString(label.label)) {
+            checkProposedApiEnabled(extension, "treeItemMarkdownLabel");
+            return {
+                label: MarkdownString$1.from(label.label),
+                highlights
+            };
         }
     }
     return undefined;
@@ -52,8 +61,7 @@ class ExtHostTreeViews extends Disposable {
             processArgument: arg => {
                 if (isTreeViewConvertableItem(arg)) {
                     return this._convertArgument(arg);
-                }
-                else if (Array.isArray(arg) && (arg.length > 0)) {
+                } else if (Array.isArray(arg) && (arg.length > 0)) {
                     return ( arg.map(item => {
                         if (isTreeViewConvertableItem(item)) {
                             return this._convertArgument(item);
@@ -66,46 +74,74 @@ class ExtHostTreeViews extends Disposable {
         });
     }
     registerTreeDataProvider(id, treeDataProvider, extension) {
-        const treeView = this.createTreeView(id, { treeDataProvider }, extension);
-        return { dispose: () => treeView.dispose() };
+        const treeView = this.createTreeView(id, {
+            treeDataProvider
+        }, extension);
+        return {
+            dispose: () => treeView.dispose()
+        };
     }
     createTreeView(viewId, options, extension) {
         if (!options || !options.treeDataProvider) {
-            throw ( new Error('Options with treeDataProvider is mandatory'));
+            throw ( new Error("Options with treeDataProvider is mandatory"));
         }
         const dropMimeTypes = options.dragAndDropController?.dropMimeTypes ?? [];
         const dragMimeTypes = options.dragAndDropController?.dragMimeTypes ?? [];
         const hasHandleDrag = !!options.dragAndDropController?.handleDrag;
         const hasHandleDrop = !!options.dragAndDropController?.handleDrop;
         const treeView = this._createExtHostTreeView(viewId, options, extension);
-        const proxyOptions = { showCollapseAll: !!options.showCollapseAll, canSelectMany: !!options.canSelectMany, dropMimeTypes, dragMimeTypes, hasHandleDrag, hasHandleDrop, manuallyManageCheckboxes: !!options.manageCheckboxStateManually };
+        const proxyOptions = {
+            showCollapseAll: !!options.showCollapseAll,
+            canSelectMany: !!options.canSelectMany,
+            dropMimeTypes,
+            dragMimeTypes,
+            hasHandleDrag,
+            hasHandleDrop,
+            manuallyManageCheckboxes: !!options.manageCheckboxStateManually
+        };
         const registerPromise = this._proxy.$registerTreeViewDataProvider(viewId, proxyOptions);
         const view = {
-            get onDidCollapseElement() { return treeView.onDidCollapseElement; },
-            get onDidExpandElement() { return treeView.onDidExpandElement; },
-            get selection() { return treeView.selectedElements; },
-            get onDidChangeSelection() { return treeView.onDidChangeSelection; },
+            get onDidCollapseElement() {
+                return treeView.onDidCollapseElement;
+            },
+            get onDidExpandElement() {
+                return treeView.onDidExpandElement;
+            },
+            get selection() {
+                return treeView.selectedElements;
+            },
+            get onDidChangeSelection() {
+                return treeView.onDidChangeSelection;
+            },
             get activeItem() {
-                checkProposedApiEnabled(extension, 'treeViewActiveItem');
+                checkProposedApiEnabled(extension, "treeViewActiveItem");
                 return treeView.focusedElement;
             },
             get onDidChangeActiveItem() {
-                checkProposedApiEnabled(extension, 'treeViewActiveItem');
+                checkProposedApiEnabled(extension, "treeViewActiveItem");
                 return treeView.onDidChangeActiveItem;
             },
-            get visible() { return treeView.visible; },
-            get onDidChangeVisibility() { return treeView.onDidChangeVisibility; },
+            get visible() {
+                return treeView.visible;
+            },
+            get onDidChangeVisibility() {
+                return treeView.onDidChangeVisibility;
+            },
             get onDidChangeCheckboxState() {
                 return treeView.onDidChangeCheckboxState;
             },
-            get message() { return treeView.message; },
+            get message() {
+                return treeView.message;
+            },
             set message(message) {
                 if (isMarkdownString(message)) {
-                    checkProposedApiEnabled(extension, 'treeViewMarkdownMessage');
+                    checkProposedApiEnabled(extension, "treeViewMarkdownMessage");
                 }
                 treeView.message = message;
             },
-            get title() { return treeView.title; },
+            get title() {
+                return treeView.title;
+            },
             set title(title) {
                 treeView.title = title;
             },
@@ -124,8 +160,7 @@ class ExtHostTreeViews extends Disposable {
                         value: Math.floor(Math.abs(badge.value)),
                         tooltip: badge.tooltip
                     };
-                }
-                else if (badge === undefined) {
+                } else if (badge === undefined) {
                     treeView.badge = undefined;
                 }
             },
@@ -160,12 +195,21 @@ class ExtHostTreeViews extends Disposable {
         }
         return result;
     }
-    async $handleDrop(destinationViewId, requestId, treeDataTransferDTO, targetItemHandle, token, operationUuid, sourceViewId, sourceTreeItemHandles) {
+    async $handleDrop(
+        destinationViewId,
+        requestId,
+        treeDataTransferDTO,
+        targetItemHandle,
+        token,
+        operationUuid,
+        sourceViewId,
+        sourceTreeItemHandles
+    ) {
         const treeView = this._treeViews.get(destinationViewId);
         if (!treeView) {
             return Promise.reject(( new NoTreeViewError(destinationViewId)));
         }
-        const treeDataTransfer = DataTransfer.toDataTransfer(treeDataTransferDTO, async (dataItemIndex) => {
+        const treeDataTransfer = DataTransfer.toDataTransfer(treeDataTransferDTO, async dataItemIndex => {
             return (await this._proxy.$resolveDropFileData(destinationViewId, requestId, dataItemIndex)).buffer;
         });
         if ((sourceViewId === destinationViewId) && sourceTreeItemHandles) {
@@ -181,8 +225,7 @@ class ExtHostTreeViews extends Disposable {
                     treeDataTransfer.set(key, value);
                 }
             });
-        }
-        else if (operationUuid && treeView.handleDrag) {
+        } else if (operationUuid && treeView.handleDrag) {
             const willDropPromise = treeView.handleDrag(sourceTreeItemHandles, treeDataTransfer, token);
             this._treeDragAndDropService.addDragOperationTransfer(operationUuid, willDropPromise);
             await willDropPromise;
@@ -194,7 +237,13 @@ class ExtHostTreeViews extends Disposable {
         if (!treeView) {
             return Promise.reject(( new NoTreeViewError(sourceViewId)));
         }
-        const treeDataTransfer = await this._addAdditionalTransferItems(new DataTransfer$1(), treeView, sourceTreeItemHandles, token, operationUuid);
+        const treeDataTransfer = await this._addAdditionalTransferItems(
+            new DataTransfer$1(),
+            treeView,
+            sourceTreeItemHandles,
+            token,
+            operationUuid
+        );
         if (!treeDataTransfer || token.isCancellationRequested) {
             return;
         }
@@ -271,12 +320,24 @@ class ExtHostTreeViews extends Disposable {
     }
 }
 class ExtHostTreeView extends Disposable {
-    static { this.LABEL_HANDLE_PREFIX = '0'; }
-    static { this.ID_HANDLE_PREFIX = '1'; }
-    static { this.ROOT_FETCH_KEY = Symbol('extHostTreeViewRoot'); }
-    get visible() { return this._visible; }
-    get selectedElements() { return ( this._selectedHandles.map(handle => this.getExtensionElement(handle))).filter(element => !isUndefinedOrNull(element)); }
-    get focusedElement() { return (this._focusedHandle ? this.getExtensionElement(this._focusedHandle) : undefined); }
+    static {
+        this.LABEL_HANDLE_PREFIX = "0";
+    }
+    static {
+        this.ID_HANDLE_PREFIX = "1";
+    }
+    static {
+        this.ROOT_FETCH_KEY = Symbol("extHostTreeViewRoot");
+    }
+    get visible() {
+        return this._visible;
+    }
+    get selectedElements() {
+        return ( this._selectedHandles.map(handle => this.getExtensionElement(handle))).filter(element => !isUndefinedOrNull(element));
+    }
+    get focusedElement() {
+        return (this._focusedHandle ? this.getExtensionElement(this._focusedHandle) : undefined);
+    }
     constructor(_viewId, options, _proxy, _commands, _logService, _extension) {
         super();
         this._viewId = _viewId;
@@ -288,6 +349,7 @@ class ExtHostTreeView extends Disposable {
         this._elements = ( new Map());
         this._nodes = ( new Map());
         this._childrenFetchTokens = ( new Map());
+        this._globalFetchTokenCounter = 0;
         this._visible = false;
         this._selectedHandles = [];
         this._focusedHandle = undefined;
@@ -307,8 +369,8 @@ class ExtHostTreeView extends Disposable {
         this._refreshPromise = Promise.resolve();
         this._refreshQueue = Promise.resolve();
         this._nodesToClear = ( new Set());
-        this._message = '';
-        this._title = '';
+        this._message = "";
+        this._title = "";
         this._refreshCancellationSource = ( new CancellationTokenSource());
         if (_extension.contributes && _extension.contributes.views) {
             for (const location in _extension.contributes.views) {
@@ -326,14 +388,20 @@ class ExtHostTreeView extends Disposable {
                 if (Array.isArray(elementOrElements) && elementOrElements.length === 0) {
                     return;
                 }
-                this._onDidChangeData.fire({ message: false, element: elementOrElements });
+                this._onDidChangeData.fire({
+                    message: false,
+                    element: elementOrElements
+                });
             }));
         }
         let refreshingPromise;
         let promiseCallback;
         const onDidChangeData = Event.debounce(this._onDidChangeData.event, (result, current) => {
             if (!result) {
-                result = { message: false, elements: [] };
+                result = {
+                    message: false,
+                    elements: []
+                };
             }
             if (current.element !== false) {
                 if (!refreshingPromise) {
@@ -342,8 +410,7 @@ class ExtHostTreeView extends Disposable {
                 }
                 if (Array.isArray(current.element)) {
                     result.elements.push(...current.element);
-                }
-                else {
+                } else {
                     result.elements.push(current.element);
                 }
             }
@@ -352,7 +419,12 @@ class ExtHostTreeView extends Disposable {
             }
             return result;
         }, 200, true);
-        this._register(onDidChangeData(({ message, elements }) => {
+        this._register(onDidChangeData((
+            {
+                message,
+                elements
+            }
+        ) => {
             if (elements.length) {
                 elements = distinct(elements);
                 this._refreshQueue = this._refreshQueue.then(() => {
@@ -360,14 +432,14 @@ class ExtHostTreeView extends Disposable {
                     refreshingPromise = null;
                     const childrenToClear = Array.from(this._nodesToClear);
                     this._nodesToClear.clear();
-                    this._debugLogRefresh('start', elements, childrenToClear);
+                    this._debugLogRefresh("start", elements, childrenToClear);
                     return this._refresh(elements).then(() => {
-                        this._debugLogRefresh('done', elements, childrenToClear);
+                        this._debugLogRefresh("done", elements, childrenToClear);
                         this._clearNodes(childrenToClear);
                         return _promiseCallback();
                     }).catch(e => {
                         const message = e instanceof Error ? e.message : JSON.stringify(e);
-                        this._debugLogRefresh('error', elements, childrenToClear);
+                        this._debugLogRefresh("error", elements, childrenToClear);
                         this._clearNodes(childrenToClear);
                         this._logService.error(`Unable to refresh tree view ${this._viewId}: ${message}`);
                         return _promiseCallback();
@@ -375,7 +447,7 @@ class ExtHostTreeView extends Disposable {
                 });
             }
             if (message) {
-                this._proxy.$setMessage(this._viewId, MarkdownString$1.fromStrict(this._message) ?? '');
+                this._proxy.$setMessage(this._viewId, MarkdownString$1.fromStrict(this._message) ?? "");
             }
         }));
     }
@@ -383,7 +455,7 @@ class ExtHostTreeView extends Disposable {
         const changed = [];
         for (const el of elements) {
             if (!el) {
-                changed.push('<root>');
+                changed.push("<root>");
                 continue;
             }
             const node = this._nodes.get(el);
@@ -392,7 +464,10 @@ class ExtHostTreeView extends Disposable {
             }
         }
         const roots = this._roots?.map(r => r.item.handle) ?? [];
-        return { changed, roots };
+        return {
+            changed,
+            roots
+        };
     }
     _debugLogRefresh(phase, elements, childrenToClear) {
         if (!this._isDebugLogging()) {
@@ -403,9 +478,10 @@ class ExtHostTreeView extends Disposable {
             snapshot.clearing = ( childrenToClear.map(n => n.item.handle));
             const changedCount = snapshot.changed.length;
             const nodesToClearLen = childrenToClear.length;
-            this._logService.debug(`[TreeView:${this._viewId}] refresh ${phase} changed=${changedCount} nodesToClear=${nodesToClearLen} elements.size=${this._elements.size} nodes.size=${this._nodes.size} handles=${JSON.stringify(snapshot)}`);
-        }
-        catch {
+            this._logService.debug(
+                `[TreeView:${this._viewId}] refresh ${phase} changed=${changedCount} nodesToClear=${nodesToClearLen} elements.size=${this._elements.size} nodes.size=${this._nodes.size} handles=${JSON.stringify(snapshot)}`
+            );
+        } catch {
             this._logService.debug(`[TreeView:${this._viewId}] refresh ${phase} (snapshot failed)`);
         }
     }
@@ -413,8 +489,7 @@ class ExtHostTreeView extends Disposable {
         try {
             const level = this._logService.getLevel();
             return (level === LogLevel.Debug) || (level === LogLevel.Trace);
-        }
-        catch {
+        } catch {
             return false;
         }
     }
@@ -434,23 +509,36 @@ class ExtHostTreeView extends Disposable {
         return this._elements.get(treeItemHandle);
     }
     reveal(element, options) {
-        options = options ? options : { select: true, focus: false };
+        options = options ? options : {
+            select: true,
+            focus: false
+        };
         const select = isUndefinedOrNull(options.select) ? true : options.select;
         const focus = isUndefinedOrNull(options.focus) ? false : options.focus;
         const expand = isUndefinedOrNull(options.expand) ? false : options.expand;
-        if (typeof this._dataProvider.getParent !== 'function') {
+        if (typeof this._dataProvider.getParent !== "function") {
             return Promise.reject(( new Error(
                 `Required registered TreeDataProvider to implement 'getParent' method to access 'reveal' method`
             )));
         }
         if (element) {
-            return this._refreshPromise
-                .then(() => this._resolveUnknownParentChain(element))
-                .then(parentChain => this._resolveTreeNode(element, parentChain[parentChain.length - 1])
-                .then(treeNode => this._proxy.$reveal(this._viewId, { item: treeNode.item, parentChain: ( parentChain.map(p => p.item)) }, { select, focus, expand })), error => this._logService.error(error));
-        }
-        else {
-            return this._proxy.$reveal(this._viewId, undefined, { select, focus, expand });
+            return this._refreshPromise.then(() => this._resolveUnknownParentChain(element)).then(
+                parentChain => this._resolveTreeNode(element, parentChain[parentChain.length - 1]).then(treeNode => this._proxy.$reveal(this._viewId, {
+                    item: treeNode.item,
+                    parentChain: ( parentChain.map(p => p.item))
+                }, {
+                    select,
+                    focus,
+                    expand
+                })),
+                error => this._logService.error(error)
+            );
+        } else {
+            return this._proxy.$reveal(this._viewId, undefined, {
+                select,
+                focus,
+                expand
+            });
         }
     }
     get message() {
@@ -458,7 +546,10 @@ class ExtHostTreeView extends Disposable {
     }
     set message(message) {
         this._message = message;
-        this._onDidChangeData.fire({ message: true, element: false });
+        this._onDidChangeData.fire({
+            message: true,
+            element: false
+        });
     }
     get title() {
         return this._title;
@@ -478,8 +569,7 @@ class ExtHostTreeView extends Disposable {
         return this._badge;
     }
     set badge(badge) {
-        if (this._badge?.value === badge?.value &&
-            this._badge?.tooltip === badge?.tooltip) {
+        if (this._badge?.value === badge?.value && this._badge?.tooltip === badge?.tooltip) {
             return;
         }
         this._badge = ViewBadge$1.from(badge);
@@ -489,10 +579,13 @@ class ExtHostTreeView extends Disposable {
         const element = this.getExtensionElement(treeItemHandle);
         if (element) {
             if (expanded) {
-                this._onDidExpandElement.fire(( Object.freeze({ element })));
-            }
-            else {
-                this._onDidCollapseElement.fire(( Object.freeze({ element })));
+                this._onDidExpandElement.fire(( Object.freeze({
+                    element
+                })));
+            } else {
+                this._onDidCollapseElement.fire(( Object.freeze({
+                    element
+                })));
             }
         }
     }
@@ -502,20 +595,26 @@ class ExtHostTreeView extends Disposable {
         const changedFocus = this._focusedHandle !== focusedHandle;
         this._focusedHandle = focusedHandle;
         if (changedSelection) {
-            this._onDidChangeSelection.fire(( Object.freeze({ selection: this.selectedElements })));
+            this._onDidChangeSelection.fire(( Object.freeze({
+                selection: this.selectedElements
+            })));
         }
         if (changedFocus) {
-            this._onDidChangeActiveItem.fire(( Object.freeze({ activeItem: this.focusedElement })));
+            this._onDidChangeActiveItem.fire(( Object.freeze({
+                activeItem: this.focusedElement
+            })));
         }
     }
     setVisible(visible) {
         if (visible !== this._visible) {
             this._visible = visible;
-            this._onDidChangeVisibility.fire(( Object.freeze({ visible: this._visible })));
+            this._onDidChangeVisibility.fire(( Object.freeze({
+                visible: this._visible
+            })));
         }
     }
     async setCheckboxState(checkboxUpdates) {
-        const items = (await Promise.all(( checkboxUpdates.map(async (checkboxUpdate) => {
+        const items = (await Promise.all(( checkboxUpdates.map(async checkboxUpdate => {
             const extensionItem = this.getExtensionElement(checkboxUpdate.treeItemHandle);
             if (extensionItem) {
                 return {
@@ -525,11 +624,13 @@ class ExtHostTreeView extends Disposable {
                 };
             }
             return Promise.resolve(undefined);
-        })))).filter((item) => item !== undefined);
+        })))).filter(item => item !== undefined);
         items.forEach(item => {
             item.treeItem.checkboxState = item.newState ? TreeItemCheckboxState.Checked : TreeItemCheckboxState.Unchecked;
         });
-        this._onDidChangeCheckboxState.fire({ items: ( items.map(item => [item.extensionItem, item.newState])) });
+        this._onDidChangeCheckboxState.fire({
+            items: ( items.map(item => [item.extensionItem, item.newState]))
+        });
     }
     async handleDrag(sourceTreeItemHandles, treeDataTransfer, token) {
         const extensionTreeItems = [];
@@ -553,9 +654,9 @@ class ExtHostTreeView extends Disposable {
         if ((!target && targetHandleOrNode) || !this._dndController?.handleDrop) {
             return;
         }
-        return asPromise(() => this._dndController?.handleDrop
-            ? this._dndController.handleDrop(target, treeDataTransfer, token)
-            : undefined);
+        return asPromise(
+            () => this._dndController?.handleDrop ? this._dndController.handleDrop(target, treeDataTransfer, token) : undefined
+        );
     }
     get hasResolve() {
         return !!this._dataProvider.resolveTreeItem;
@@ -578,17 +679,16 @@ class ExtHostTreeView extends Disposable {
         return;
     }
     _resolveUnknownParentChain(element) {
-        return this._resolveParent(element)
-            .then((parent) => {
+        return this._resolveParent(element).then(parent => {
             if (!parent) {
                 return Promise.resolve([]);
             }
-            return this._resolveUnknownParentChain(parent)
-                .then(result => this._resolveTreeNode(parent, result[result.length - 1])
-                .then(parentNode => {
-                result.push(parentNode);
-                return result;
-            }));
+            return this._resolveUnknownParentChain(parent).then(
+                result => this._resolveTreeNode(parent, result[result.length - 1]).then(parentNode => {
+                    result.push(parentNode);
+                    return result;
+                })
+            );
         });
     }
     _resolveParent(element) {
@@ -598,35 +698,50 @@ class ExtHostTreeView extends Disposable {
         }
         return asPromise(() => this._dataProvider.getParent(element));
     }
-    _resolveTreeNode(element, parent) {
+    async _resolveTreeNode(element, parent) {
         const node = this._nodes.get(element);
         if (node) {
-            return Promise.resolve(node);
-        }
-        return asPromise(() => this._dataProvider.getTreeItem(element))
-            .then(extTreeItem => this._createHandle(element, extTreeItem, parent, true))
-            .then(handle => this.getChildren(parent ? parent.item.handle : undefined)
-            .then(() => {
+            return node;
+        }
+        const extTreeItem = await asPromise(() => this._dataProvider.getTreeItem(element));
+        const handle = this._createHandle(element, extTreeItem, parent, true);
+        const children = await this.getChildren(parent ? parent.item.handle : undefined);
+        if (children === undefined) {
+            this._logService.warn(
+                `[${this._viewId}] Concurrent refresh detected in _resolveTreeNode for element ${handle} from extension ${this._extension.identifier.value}, waiting for refresh to complete`
+            );
+            this._proxy.$logResolveTreeNodeRetry(this._extension.identifier.value, 1, false);
+            await this._refreshPromise;
             const cachedElement = this.getExtensionElement(handle);
             if (cachedElement) {
                 const node = this._nodes.get(cachedElement);
                 if (node) {
-                    return Promise.resolve(node);
+                    return node;
                 }
             }
+            this._proxy.$logResolveTreeNodeRetry(this._extension.identifier.value, 1, true);
             throw ( new Error(
                 `Cannot resolve tree item for element ${handle} from extension ${this._extension.identifier.value}`
             ));
-        }));
+        }
+        const cachedElement = this.getExtensionElement(handle);
+        if (cachedElement) {
+            const node = this._nodes.get(cachedElement);
+            if (node) {
+                return node;
+            }
+        }
+        throw ( new Error(
+            `Cannot resolve tree item for element ${handle} from extension ${this._extension.identifier.value}`
+        ));
     }
     _getChildrenNodes(parentNodeOrHandle) {
         if (parentNodeOrHandle) {
             let parentNode;
-            if (typeof parentNodeOrHandle === 'string') {
+            if (typeof parentNodeOrHandle === "string") {
                 const parentElement = this.getExtensionElement(parentNodeOrHandle);
                 parentNode = parentElement ? this._nodes.get(parentElement) : undefined;
-            }
-            else {
+            } else {
                 parentNode = parentNodeOrHandle;
             }
             return parentNode ? parentNode.children || undefined : undefined;
@@ -639,8 +754,7 @@ class ExtHostTreeView extends Disposable {
     async _fetchChildrenNodes(parentElement) {
         this._addChildrenToClear(parentElement);
         const fetchKey = this._getFetchKey(parentElement);
-        let requestId = this._childrenFetchTokens.get(fetchKey) ?? 0;
-        requestId++;
+        const requestId = ++this._globalFetchTokenCounter;
         this._childrenFetchTokens.set(fetchKey, requestId);
         const cts = ( new CancellationTokenSource(this._refreshCancellationSource.token));
         try {
@@ -669,8 +783,7 @@ class ExtHostTreeView extends Disposable {
                 return undefined;
             }
             return coalesce(items);
-        }
-        finally {
+        } finally {
             cts.dispose();
         }
     }
@@ -681,8 +794,7 @@ class ExtHostTreeView extends Disposable {
             this._refreshCancellationSource = ( new CancellationTokenSource());
             this._addChildrenToClear();
             return this._proxy.$refresh(this._viewId);
-        }
-        else {
+        } else {
             const handlesToRefresh = this._getHandlesToRefresh(elements);
             if (handlesToRefresh.length) {
                 return this._refreshHandles(handlesToRefresh);
@@ -696,7 +808,9 @@ class ExtHostTreeView extends Disposable {
         for (const elementNode of elementNodes) {
             if (elementNode && !( elementsToUpdate.has(elementNode.item.handle))) {
                 let currentNode = elementNode;
-                while (currentNode && currentNode.parent && elementNodes.findIndex(node => currentNode && currentNode.parent && node && node.item.handle === currentNode.parent.item.handle) === -1) {
+                while (currentNode && currentNode.parent && elementNodes.findIndex(
+                    node => currentNode && currentNode.parent && node && node.item.handle === currentNode.parent.item.handle
+                ) === -1) {
                     const parentElement = this._elements.get(currentNode.parent.item.handle);
                     currentNode = parentElement ? this._nodes.get(parentElement) : undefined;
                 }
@@ -706,7 +820,7 @@ class ExtHostTreeView extends Disposable {
             }
         }
         const handlesToUpdate = [];
-        elementsToUpdate.forEach((handle) => {
+        elementsToUpdate.forEach(handle => {
             const element = this._elements.get(handle);
             if (element) {
                 const node = this._nodes.get(element);
@@ -719,13 +833,11 @@ class ExtHostTreeView extends Disposable {
     }
     _refreshHandles(itemHandles) {
         const itemsToRefresh = {};
-        return Promise.all(( itemHandles.map(treeItemHandle => this._refreshNode(treeItemHandle)
-            .then(node => {
+        return Promise.all(( itemHandles.map(treeItemHandle => this._refreshNode(treeItemHandle).then(node => {
             if (node) {
                 itemsToRefresh[treeItemHandle] = node.item;
             }
-        }))))
-            .then(() => ( Object.keys(itemsToRefresh)).length ? this._proxy.$refresh(this._viewId, itemsToRefresh) : undefined);
+        })))).then(() => ( Object.keys(itemsToRefresh)).length ? this._proxy.$refresh(this._viewId, itemsToRefresh) : undefined);
     }
     _refreshNode(treeItemHandle) {
         const extElement = this.getExtensionElement(treeItemHandle);
@@ -733,8 +845,7 @@ class ExtHostTreeView extends Disposable {
             const existing = this._nodes.get(extElement);
             if (existing) {
                 this._addChildrenToClear(extElement);
-                return asPromise(() => this._dataProvider.getTreeItem(extElement))
-                    .then(extTreeItem => {
+                return asPromise(() => this._dataProvider.getTreeItem(extElement)).then(extTreeItem => {
                     if (extTreeItem) {
                         const newNode = this._createTreeNode(extElement, extTreeItem, existing.parent);
                         this._updateNodeCache(extElement, newNode, existing, existing.parent);
@@ -753,7 +864,7 @@ class ExtHostTreeView extends Disposable {
             const existingElement = this._elements.get(duplicateHandle);
             if (existingElement) {
                 if (existingElement !== element) {
-                    throw ( new Error(( localize(2704, 'Element with id {0} is already registered', extTreeItem.id))));
+                    throw ( new Error(( localize(2707, "Element with id {0} is already registered", extTreeItem.id))));
                 }
                 const existingNode = this._nodes.get(existingElement);
                 if (existingNode) {
@@ -776,7 +887,10 @@ class ExtHostTreeView extends Disposable {
         return tooltip;
     }
     _getCommand(disposable, command) {
-        return command ? { ...this._commands.toInternal(command, disposable), originalId: command.command } : undefined;
+        return command ? {
+            ...this._commands.toInternal(command, disposable),
+            originalId: command.command
+        } : undefined;
     }
     _getCheckbox(extensionTreeItem) {
         if (extensionTreeItem.checkboxState === undefined) {
@@ -785,15 +899,18 @@ class ExtHostTreeView extends Disposable {
         let checkboxState;
         let tooltip = undefined;
         let accessibilityInformation = undefined;
-        if (typeof extensionTreeItem.checkboxState === 'number') {
+        if (typeof extensionTreeItem.checkboxState === "number") {
             checkboxState = extensionTreeItem.checkboxState;
-        }
-        else {
+        } else {
             checkboxState = extensionTreeItem.checkboxState.state;
             tooltip = extensionTreeItem.checkboxState.tooltip;
             accessibilityInformation = extensionTreeItem.checkboxState.accessibilityInformation;
         }
-        return { isChecked: checkboxState === TreeItemCheckboxState.Checked, tooltip, accessibilityInformation };
+        return {
+            isChecked: checkboxState === TreeItemCheckboxState.Checked,
+            tooltip,
+            accessibilityInformation
+        };
     }
     _validateTreeItem(extensionTreeItem) {
         if (!TreeItem.isTreeItem(extensionTreeItem, this._extension)) {
@@ -821,7 +938,7 @@ class ExtHostTreeView extends Disposable {
             themeIcon: this._getThemeIcon(extensionTreeItem),
             collapsibleState: isUndefinedOrNull(extensionTreeItem.collapsibleState) ? TreeItemCollapsibleState.None : extensionTreeItem.collapsibleState,
             accessibilityInformation: extensionTreeItem.accessibilityInformation,
-            checkbox: this._getCheckbox(extensionTreeItem),
+            checkbox: this._getCheckbox(extensionTreeItem)
         };
         return {
             item,
@@ -829,29 +946,39 @@ class ExtHostTreeView extends Disposable {
             parent,
             children: undefined,
             disposableStore,
-            dispose() { disposableStore.dispose(); }
+            dispose() {
+                disposableStore.dispose();
+            }
         };
     }
     _getThemeIcon(extensionTreeItem) {
         return extensionTreeItem.iconPath instanceof ThemeIcon ? extensionTreeItem.iconPath : undefined;
     }
-    _createHandle(element, { id, label, resourceUri }, parent, returnFirst) {
+    _createHandle(
+        element,
+        {
+            id,
+            label,
+            resourceUri
+        },
+        parent,
+        returnFirst
+    ) {
         if (id) {
             return `${ExtHostTreeView.ID_HANDLE_PREFIX}/${id}`;
         }
         const treeItemLabel = toTreeItemLabel(label, this._extension);
         const prefix = parent ? parent.item.handle : ExtHostTreeView.LABEL_HANDLE_PREFIX;
-        let labelValue = '';
+        let labelValue = "";
         if (treeItemLabel) {
             if (isMarkdownString(treeItemLabel.label)) {
                 labelValue = treeItemLabel.label.value;
-            }
-            else {
+            } else {
                 labelValue = treeItemLabel.label;
             }
         }
-        let elementId = labelValue || (resourceUri ? basename(resourceUri) : '');
-        elementId = elementId.indexOf('/') !== -1 ? elementId.replace('/', '//') : elementId;
+        let elementId = labelValue || (resourceUri ? basename(resourceUri) : "");
+        elementId = elementId.indexOf("/") !== -1 ? elementId.replace("/", "//") : elementId;
         const existingHandle = ( this._nodes.has(element)) ? this._nodes.get(element).item.handle : undefined;
         const childrenNodes = (this._getChildrenNodes(parent) || []);
         let handle;
@@ -867,8 +994,7 @@ class ExtHostTreeView extends Disposable {
     }
     _getLightIconPath(extensionTreeItem) {
         if (extensionTreeItem.iconPath && !(extensionTreeItem.iconPath instanceof ThemeIcon)) {
-            if (typeof extensionTreeItem.iconPath === 'string'
-                || URI.isUri(extensionTreeItem.iconPath)) {
+            if (typeof extensionTreeItem.iconPath === "string" || URI.isUri(extensionTreeItem.iconPath)) {
                 return this._getIconPath(extensionTreeItem.iconPath);
             }
             return this._getIconPath(extensionTreeItem.iconPath.light);
@@ -910,8 +1036,7 @@ class ExtHostTreeView extends Disposable {
                 parentNode.children = [];
             }
             parentNode.children.push(node);
-        }
-        else {
+        } else {
             if (!this._roots) {
                 this._roots = [];
             }
@@ -935,8 +1060,7 @@ class ExtHostTreeView extends Disposable {
                 }
                 node.children = undefined;
             }
-        }
-        else {
+        } else {
             this._addAllToClear();
         }
     }