@theia/core 1.22.1 → 1.23.0-next.26

package/src/browser/tree/tree-compression/tree-compression-service.ts

@@ -0,0 +1,121 @@
+/********************************************************************************
+ * Copyright (c) 2021 SAP SE or an SAP affiliate company 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { injectable } from 'inversify';
+import { ArrayUtils } from '../../../common/types';
+import { TreeNode } from '../tree';
+import { ExpandableTreeNode } from '../tree-expansion';
+
+export interface CompressionParent extends ExpandableTreeNode {
+    children: [CompressionChild];
+}
+
+export interface CompressionChild extends ExpandableTreeNode {
+    parent: CompressionParent;
+}
+
+export type CompressionParticipant = CompressionChild | CompressionParent;
+
+export interface CompressionHead extends CompressionParent {
+    parent: ExpandableTreeNode;
+}
+
+export interface CompressionTail extends CompressionChild { }
+
+export const CompressionToggle = Symbol('CompressionToggle');
+export interface CompressionToggle {
+    compress: boolean;
+}
+
+@injectable()
+export class TreeCompressionService {
+    /**
+     * @returns `true` if the node has a single child that is a CompositeTreeNode
+     * In that case, the child can be shown in the same row as the parent.
+     */
+    isCompressionParent(node?: unknown): node is CompressionParent {
+        return ExpandableTreeNode.is(node) && node.children.length === 1 && ExpandableTreeNode.is(node.children[0]);
+    }
+
+    /**
+     * @returns `true` if the node is a CompositeTreeNode and is its parent's sole child
+     * In that case, the node can be shown in the same row as its parent.
+     */
+    isCompressionChild(node?: TreeNode): node is CompressionChild {
+        return this.isCompressionParent(node?.parent);
+    }
+
+    /**
+     * @returns `true` if the node is a CompositeTreeNode with a sole child, and the same is not true of its parent.
+     * In that case, the node will appear as the first member of a compressed row.
+     */
+    isCompressionHead(node?: unknown): node is CompressionHead {
+        return this.isCompressionParent(node) && !this.isCompressionParent(node.parent);
+    }
+
+    /**
+     * @returns `true` if the node's parent is a CompositeTreeNode with a sole child, and the same is not true of the node.
+     * In that case, the node will appear as the last member of a compressed row.
+     */
+    isCompressionTail(node?: TreeNode): node is CompressionTail {
+        return this.isCompressionChild(node) && !this.isCompressionParent(node);
+    }
+
+    /**
+     * @returns `true` if the node is part of a compression row, either a {@link CompressionChild} or {@link CompressionParent}
+     */
+    isCompressionParticipant(node?: TreeNode): node is CompressionParticipant {
+        return this.isCompressionParent(node) || this.isCompressionChild(node);
+    }
+
+    /**
+     * @returns a sequence of compressed items for the node if it is a {@link CompressionHead}.
+     */
+    getCompressedChildren(node?: CompressionHead): ArrayUtils.Tail<CompressionChild>;
+    getCompressedChildren(node: unknown): ArrayUtils.Tail<CompressionChild> | undefined {
+        if (this.isCompressionHead(node)) {
+            const items = [];
+            let next: TreeNode = node.children[0];
+            while (this.isCompressionChild(next)) {
+                items.push(next);
+                next = next.children[0];
+            }
+            return ArrayUtils.asTail(items);
+        }
+    }
+
+    /**
+     * @returns The {@link CompressionHead} of the node's compression chain, or undefined if the node is not a {@link CompressionParticipant}.
+     */
+    getCompressionHead(node?: TreeNode): CompressionHead | undefined {
+        while (this.isCompressionParticipant(node)) {
+            if (this.isCompressionHead(node)) {
+                return node;
+            }
+            node = node.parent;
+        }
+    }
+
+    /**
+     * @returns The compression chain of which the `node` is a part, or `undefined` if the `node` is not a {@link CompressionParticipant}
+     */
+    getCompressionChain(node?: TreeNode): ArrayUtils.HeadAndTail<CompressionParticipant> | undefined {
+        const head = this.getCompressionHead(node);
+        if (head) {
+            return ArrayUtils.asHeadAndTail([head as CompressionParticipant].concat(this.getCompressedChildren(head)));
+        }
+    }
+}

package/src/browser/tree/tree-compression/tree-compression.css

@@ -0,0 +1,28 @@
+/********************************************************************************
+ * Copyright (C) 2022 Ericsson 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+.theia-tree-compressed-selected {
+    text-decoration: underline;
+}
+
+.theia-tree-compressed-label-separator {
+    padding: 0 2px;
+    opacity: 0.5;
+}
+
+.theia-tree-compressed-label-part:hover {
+    text-decoration: underline;
+}

package/src/browser/tree/tree-container.ts

@@ -25,45 +25,123 @@ import { TreeNavigationService } from './tree-navigation';
 import { TreeDecoratorService, NoopTreeDecoratorService } from './tree-decorator';
 import { TreeSearch } from './tree-search';
 import { FuzzySearch } from './fuzzy-search';
-import { SearchBox, SearchBoxFactory, SearchBoxProps } from './search-box';
+import { SearchBox, SearchBoxFactory } from './search-box';
 import { SearchBoxDebounce } from './search-box-debounce';
-import { TreeViewWelcomeWidget } from './tree-view-welcome-widget';
 
-export function createTreeContainer(parent: interfaces.Container, props?: Partial<TreeProps>): Container {
+function isTreeServices(candidate?: Partial<TreeProps> | Partial<TreeContainerProps>): candidate is TreeContainerProps {
+    if (candidate) {
+        const maybeServices = candidate as TreeContainerProps;
+        for (const key of Object.keys(maybeServices)) {
+            if (key in defaultImplementations) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+export function createTreeContainer(parent: interfaces.Container, props?: Partial<TreeContainerProps>): Container;
+/**
+ * @deprecated Please use TreeContainerProps instead of TreeProps
+ * @since 1.23.0
+ */
+export function createTreeContainer(parent: interfaces.Container, props?: Partial<TreeProps>): Container;
+export function createTreeContainer(parent: interfaces.Container, props?: Partial<TreeProps> | Partial<TreeContainerProps>): Container {
     const child = new Container({ defaultScope: 'Singleton' });
     child.parent = parent;
+    const overrideServices: Partial<TreeServiceProviders> = isTreeServices(props) ? props : {};
+    for (const key of Object.keys(serviceIdentifiers) as (keyof TreeIdentifiers)[]) {
+        if (key === 'props') {
+            const { service, identifier } = getServiceAndIdentifier(key, overrideServices);
+            child.bind(identifier).toConstantValue({
+                ...defaultImplementations.props,
+                ...service
+            });
+        } else if (key === 'searchBoxFactory') {
+            const { service, identifier } = getServiceAndIdentifier(key, overrideServices);
+            child.bind(identifier).toFactory(context => service(context));
+        } else {
+            const { service, identifier } = getServiceAndIdentifier(key, overrideServices);
+            child.bind(service).toSelf().inSingletonScope();
+            if (identifier !== service) {
+                child.bind(identifier as interfaces.ServiceIdentifier<typeof service>).toService(service);
+            }
+        }
+    }
+    return child;
+}
 
-    child.bind(TreeImpl).toSelf();
-    child.bind(Tree).toService(TreeImpl);
-
-    child.bind(TreeSelectionServiceImpl).toSelf();
-    child.bind(TreeSelectionService).toService(TreeSelectionServiceImpl);
+function getServiceAndIdentifier<Key extends keyof TreeIdentifiers>(
+    key: Key, overrides: Partial<TreeContainerProps>
+): { service: TreeContainerProps[Key], identifier: TreeIdentifiers[Key] } {
+    const override = overrides[key] as TreeContainerProps[Key] | undefined;
+    const service = override ?? defaultImplementations[key];
+    return {
+        service,
+        identifier: serviceIdentifiers[key]
+    };
+}
 
-    child.bind(TreeExpansionServiceImpl).toSelf();
-    child.bind(TreeExpansionService).toService(TreeExpansionServiceImpl);
+export interface SearchBoxFactoryFactory {
+    (context: interfaces.Context): SearchBoxFactory;
+}
 
-    child.bind(TreeNavigationService).toSelf();
+const defaultSearchBoxFactoryFactory: SearchBoxFactoryFactory = () => options => {
+    const debounce = new SearchBoxDebounce(options);
+    return new SearchBox(options, debounce);
+};
 
-    child.bind(TreeModelImpl).toSelf();
-    child.bind(TreeModel).toService(TreeModelImpl);
+interface TreeConstants {
+    searchBoxFactory: SearchBoxFactory,
+    props: TreeProps,
+}
 
-    child.bind(TreeWidget).toSelf();
-    child.bind(TreeProps).toConstantValue({
-        ...defaultTreeProps,
-        ...props
-    });
+interface TreeServices {
+    tree: Tree,
+    selectionService: TreeSelectionService,
+    expansionService: TreeExpansionService,
+    navigationService: TreeNavigationService,
+    model: TreeModel,
+    widget: TreeWidget,
+    search: TreeSearch,
+    fuzzy: FuzzySearch,
+    decoratorService: TreeDecoratorService,
+}
 
-    child.bind(TreeViewWelcomeWidget).toSelf();
+interface TreeTypes extends TreeServices, TreeConstants { }
 
-    child.bind(TreeSearch).toSelf().inSingletonScope();
-    child.bind(FuzzySearch).toSelf().inSingletonScope();
-    child.bind(SearchBoxFactory).toFactory(context =>
-        (options: SearchBoxProps) => {
-            const debounce = new SearchBoxDebounce(options);
-            return new SearchBox(options, debounce);
-        }
-    );
+export type TreeIdentifiers = { [K in keyof TreeTypes]: interfaces.ServiceIdentifier<TreeTypes[K]>; };
+type TreeServiceProviders = { [K in keyof TreeServices]: interfaces.Newable<TreeServices[K]> };
 
-    child.bind(TreeDecoratorService).to(NoopTreeDecoratorService).inSingletonScope();
-    return child;
+export interface TreeContainerProps extends TreeServiceProviders {
+    props: Partial<TreeProps>,
+    searchBoxFactory: SearchBoxFactoryFactory;
 }
+
+const defaultImplementations: TreeContainerProps & { props: TreeProps } = {
+    tree: TreeImpl,
+    selectionService: TreeSelectionServiceImpl,
+    expansionService: TreeExpansionServiceImpl,
+    navigationService: TreeNavigationService,
+    model: TreeModelImpl,
+    widget: TreeWidget,
+    search: TreeSearch,
+    fuzzy: FuzzySearch,
+    decoratorService: NoopTreeDecoratorService,
+    props: defaultTreeProps,
+    searchBoxFactory: defaultSearchBoxFactoryFactory,
+};
+
+const serviceIdentifiers: TreeIdentifiers = {
+    tree: Tree,
+    selectionService: TreeSelectionService,
+    expansionService: TreeExpansionService,
+    navigationService: TreeNavigationService,
+    model: TreeModel,
+    widget: TreeWidget,
+    props: TreeProps,
+    search: TreeSearch,
+    fuzzy: FuzzySearch,
+    searchBoxFactory: SearchBoxFactory,
+    decoratorService: TreeDecoratorService,
+};

package/src/browser/tree/tree-expansion.ts

@@ -65,7 +65,7 @@ export interface ExpandableTreeNode extends CompositeTreeNode {
 }
 
 export namespace ExpandableTreeNode {
-    export function is(node: Object | undefined): node is ExpandableTreeNode {
+    export function is(node: unknown): node is ExpandableTreeNode {
         return !!node && CompositeTreeNode.is(node) && 'expanded' in node;
     }
 

package/src/browser/tree/tree-model.ts

@@ -180,7 +180,7 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
      * Select the given node if it is the ancestor of a selected node.
      */
     protected selectIfAncestorOfSelected(node: Readonly<ExpandableTreeNode>): void {
-        if (!node.expanded && [...this.selectedNodes].some(selectedNode => CompositeTreeNode.isAncestor(node, selectedNode))) {
+        if (!node.expanded && this.selectedNodes.some(selectedNode => CompositeTreeNode.isAncestor(node, selectedNode))) {
             if (SelectableTreeNode.isVisible(node)) {
                 this.selectNode(node);
             }
@@ -273,7 +273,6 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         for (const node of raw ? [raw] : this.selectedNodes) {
             if (ExpandableTreeNode.is(node)) {
                 await this.expansionService.toggleNodeExpansion(node);
-                return;
             }
         }
     }
@@ -287,7 +286,7 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
 
     getPrevSelectableNode(node: TreeNode = this.selectedNodes[0]): SelectableTreeNode | undefined {
         const iterator = this.createBackwardIterator(node);
-        return iterator && this.doGetNextNode(iterator);
+        return iterator && this.doGetNextNode(iterator, this.isVisibleSelectableNode.bind(this));
     }
 
     selectNextNode(type: TreeSelection.SelectionType = TreeSelection.SelectionType.DEFAULT): void {
@@ -299,20 +298,19 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
 
     getNextSelectableNode(node: TreeNode = this.selectedNodes[0]): SelectableTreeNode | undefined {
         const iterator = this.createIterator(node);
-        return iterator && this.doGetNextNode(iterator);
+        return iterator && this.doGetNextNode(iterator, this.isVisibleSelectableNode.bind(this));
     }
 
-    protected doGetNextNode(iterator: TreeIterator): SelectableTreeNode | undefined {
+    protected doGetNextNode<T extends TreeNode>(iterator: TreeIterator, criterion: (node: TreeNode) => node is T): T | undefined {
         // 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 && !this.isVisibleSelectableNode(result.value)) {
+        while (!result.done) {
+            if (criterion(result.value)) {
+                return result.value;
+            }
             result = iterator.next();
         }
-        const node = result.value;
-        if (SelectableTreeNode.isVisible(node)) {
-            return node;
-        }
         return undefined;
     }
 
@@ -334,7 +332,7 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
     protected createIterator(node: TreeNode | undefined): TreeIterator | undefined {
         const { filteredNodes } = this.treeSearch;
         if (filteredNodes.length === 0) {
-            return node ? new TopDownTreeIterator(node!, { pruneCollapsed: true }) : undefined;
+            return node && this.createForwardIteratorForNode(node);
         }
         if (node && filteredNodes.indexOf(node) === -1) {
             return undefined;
@@ -342,6 +340,10 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         return Iterators.cycle(filteredNodes, node);
     }
 
+    protected createForwardIteratorForNode(node: TreeNode): TreeIterator {
+        return new TopDownTreeIterator(node, { pruneCollapsed: true });
+    }
+
     openNode(raw?: TreeNode | undefined): void {
         const node = raw || this.selectedNodes[0];
         if (node) {

package/src/browser/tree/tree-widget.tsx

@@ -303,16 +303,11 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
                 pruneSiblings: true
             })) {
                 if (this.shouldDisplayNode(node)) {
-                    const parentDepth = depths.get(node.parent);
-                    const depth = parentDepth === undefined ? 0 : TreeNode.isVisible(node.parent) ? parentDepth + 1 : parentDepth;
+                    const depth = this.getDepthForNode(node, depths);
                     if (CompositeTreeNode.is(node)) {
                         depths.set(node, depth);
                     }
-                    rowsToUpdate.push([node.id, {
-                        index: index++,
-                        node,
-                        depth
-                    }]);
+                    rowsToUpdate.push([node.id, this.toNodeRow(node, index++, depth)]);
                 }
             }
         }
@@ -320,6 +315,15 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
         this.updateScrollToRow();
     }
 
+    protected getDepthForNode(node: TreeNode, depths: Map<CompositeTreeNode | undefined, number>): number {
+        const parentDepth = depths.get(node.parent);
+        return parentDepth === undefined ? 0 : TreeNode.isVisible(node.parent) ? parentDepth + 1 : parentDepth;
+    }
+
+    protected toNodeRow(node: TreeNode, index: number, depth: number): TreeWidget.NodeRow {
+        return { node, index, depth };
+    }
+
     protected shouldDisplayNode(node: TreeNode): boolean {
         return TreeNode.isVisible(node) && (!this.searchBox?.isFiltering || this.treeSearch.passesFilters(node));
     }
@@ -585,6 +589,12 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
      * @param props the node properties.
      */
     protected renderCaption(node: TreeNode, props: NodeProps): React.ReactNode {
+        const attrs = this.getCaptionAttributes(node, props);
+        const children = this.getCaptionChildren(node, props);
+        return React.createElement('div', attrs, children);
+    }
+
+    protected getCaptionAttributes(node: TreeNode, props: NodeProps): React.Attributes & React.HTMLAttributes<HTMLElement> {
         const tooltip = this.getDecorationData(node, 'tooltip').filter(notEmpty).join(' • ');
         const classes = [TREE_NODE_SEGMENT_CLASS];
         if (!this.hasTrailingSuffixes(node)) {
@@ -600,7 +610,11 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
                 title: tooltip
             };
         }
-        const children: React.ReactNode[] = [];
+        return attrs;
+    }
+
+    protected getCaptionChildren(node: TreeNode, props: NodeProps): React.ReactNode {
+        const children = [];
         const caption = this.toNodeName(node);
         const highlight = this.getDecorationData(node, 'highlight')[0];
         if (highlight) {
@@ -612,7 +626,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
         } else if (!highlight) {
             children.push(caption);
         }
-        return React.createElement('div', attrs, ...children);
+        return children;
     }
 
     /**
@@ -925,7 +939,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
         if (this.isExpandable(node)) {
             classNames.push(EXPANDABLE_TREE_NODE_CLASS);
         }
-        if (SelectableTreeNode.isSelected(node)) {
+        if (this.rowIsSelected(node, props)) {
             classNames.push(SELECTED_CLASS);
         }
         if (SelectableTreeNode.hasFocus(node)) {
@@ -934,6 +948,10 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
         return classNames;
     }
 
+    protected rowIsSelected(node: TreeNode, props: NodeProps): boolean {
+        return SelectableTreeNode.isSelected(node);
+    }
+
     /**
      * Get the default node style.
      * @param node the tree node.
@@ -1096,7 +1114,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
         if (!!this.props.multiSelect && (this.hasCtrlCmdMask(event) || this.hasShiftMask(event))) {
             return;
         }
-        if (! await this.model.collapseNode()) {
+        if (!await this.model.collapseNode()) {
             this.model.selectParent();
         }
     }
@@ -1109,7 +1127,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
         if (!!this.props.multiSelect && (this.hasCtrlCmdMask(event) || this.hasShiftMask(event))) {
             return;
         }
-        if (! await this.model.expandNode()) {
+        if (!await this.model.expandNode()) {
             this.model.selectNextNode();
         }
     }

package/src/browser/tree/tree.ts

@@ -147,8 +147,8 @@ export interface CompositeTreeNode extends TreeNode {
 }
 
 export namespace CompositeTreeNode {
-    export function is(node: Object | undefined): node is CompositeTreeNode {
-        return !!node && 'children' in node;
+    export function is(node: unknown): node is CompositeTreeNode {
+        return typeof node === 'object' && !!node && 'children' in node;
     }
 
     export function getFirstChild(parent: CompositeTreeNode): TreeNode | undefined {

package/src/browser/view-container.ts

@@ -580,6 +580,9 @@ export class ViewContainer extends BaseWidget implements StatefulWidget, Applica
         if (this.titleOptions) {
             this.menuRegistry.registerMenuAction([...SIDE_PANEL_TOOLBAR_CONTEXT_MENU, 'navigation'], action);
         }
+
+        ViewContainer.updateSashState(SashType.TopSash, part.node.previousElementSibling, part.collapsed);
+        ViewContainer.updateSashState(SashType.BottomSash, part.node.nextElementSibling, part.collapsed);
     }
 
     protected unregisterPart(part: ViewContainerPart): void {
@@ -885,6 +888,27 @@ export namespace ViewContainer {
         }
         return 'vertical';
     }
+
+    export function updateSashState(sashType: SashType, sashElement: Element | null, activeContainerCollapsed: boolean): void {
+        if (sashElement && sashElement.className.includes('p-SplitPanel-handle')) {
+            // Hide the sash when the active `horizontal` container in the left panel is collapsed
+            sashElement.classList.toggle('sash-hidden', activeContainerCollapsed);
+
+            let adjacentContainer: Element | null;
+            if (sashType === SashType.TopSash) {
+                adjacentContainer = sashElement.previousElementSibling;
+            } else {
+                adjacentContainer = sashElement.nextElementSibling;
+            }
+
+            // Sash should only appear when the following two conditions are met:
+            //    1.  the active `horizontal` container is expanded
+            //    2.  the container that is above/below the active `horizontal` container is also expanded
+            if (!activeContainerCollapsed && adjacentContainer) {
+                sashElement.classList.toggle('sash-hidden', adjacentContainer.className.includes('collapsed'));
+            }
+        }
+    }
 }
 
 /**
@@ -1001,8 +1025,8 @@ export class ViewContainerPart extends BaseWidget {
         this.node.classList.toggle('collapsed', collapsed);
 
         // Update the sashes for the active `horizontal` container when the container is collapsed/expanded
-        this.updateSashState(SashType.TopSash, this.node.previousElementSibling, collapsed);
-        this.updateSashState(SashType.BottomSash, this.node.nextElementSibling, collapsed);
+        ViewContainer.updateSashState(SashType.TopSash, this.node.previousElementSibling, collapsed);
+        ViewContainer.updateSashState(SashType.BottomSash, this.node.nextElementSibling, collapsed);
 
         if (collapsed && this.wrapped.node.contains(document.activeElement)) {
             this.header.focus();
@@ -1239,27 +1263,6 @@ export class ViewContainerPart extends BaseWidget {
             this.wrapped.activate();
         }
     }
-
-    protected updateSashState(sashType: SashType, sashElement: Element | null, activeContainerCollapsed: boolean): void {
-        if (sashElement && sashElement.className.includes('p-SplitPanel-handle')) {
-            // Hide the sash when the active `horizontal` container in the left panel is collapsed
-            sashElement.classList.toggle('sash-hidden', activeContainerCollapsed);
-
-            let adjacentContainer: Element | null;
-            if (sashType === SashType.TopSash) {
-                adjacentContainer = sashElement.previousElementSibling;
-            } else {
-                adjacentContainer = sashElement.nextElementSibling;
-            }
-
-            // Sash should only appear when the following two conditions are met:
-            //    1.  the active `horizontal` container is expanded
-            //    2.  the container that is above/below the active `horizontal` container is also expanded
-            if (!activeContainerCollapsed && adjacentContainer) {
-                sashElement.classList.toggle('sash-hidden', adjacentContainer.className.includes('collapsed'));
-            }
-        }
-    }
 }
 
 export namespace ViewContainerPart {
@@ -1307,6 +1310,7 @@ export class ViewContainerLayout extends SplitLayout {
         return map(this.items, item => item.widget);
     }
 
+    // @ts-expect-error TS2611 `SplitLayout.widgets` is declared as `readonly widgets` but is implemented as a getter.
     get widgets(): ViewContainerPart[] {
         return toArray(this.iter());
     }

package/src/browser/widget-open-handler.ts

@@ -160,8 +160,6 @@ export abstract class WidgetOpenHandler<W extends BaseWidget> implements OpenHan
      * @returns a promise of all closed widgets that resolves after they have been closed.
      */
     async closeAll(options?: ApplicationShell.CloseOptions): Promise<W[]> {
-        const closed = await Promise.all(this.all.map(widget => this.shell.closeWidget(widget.id, options)));
-        return closed.filter(widget => !!widget) as W[];
+        return this.shell.closeMany(this.all, options) as Promise<W[]>;
     }
-
 }

package/src/common/event.ts

@@ -330,7 +330,7 @@ export namespace WaitUntilEvent {
             // Asynchronous calls to `waitUntil` should fail.
             Object.freeze(waitables);
         } finally {
-            delete asyncEvent['waitUntil'];
+            delete (asyncEvent as any)['waitUntil'];
         }
         if (!waitables.length) {
             return;
@@ -390,7 +390,7 @@ export class AsyncEmitter<T extends WaitUntilEvent> extends Emitter<T> {
             } catch (e) {
                 console.error(e);
             } finally {
-                delete asyncEvent['waitUntil'];
+                delete (asyncEvent as any)['waitUntil'];
             }
             if (!waitables.length) {
                 return;

package/src/common/index.ts

@@ -40,6 +40,7 @@ export * from './lsp-types';
 export * from './contribution-filter';
 export * from './nls';
 export * from './numbers';
+export * from './performance';
 
 import { environment } from '@theia/application-package/lib/environment';
 export { environment };

package/src/common/messaging/proxy-factory.ts

@@ -236,7 +236,7 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
             const method = p.toString();
             const capturedError = new Error(`Request '${method}' failed`);
             return this.connectionPromise.then(connection =>
-                new Promise((resolve, reject) => {
+                new Promise<void>((resolve, reject) => {
                     try {
                         if (isNotify) {
                             connection.sendNotification(method, ...args);

package/src/common/performance/index.ts

@@ -0,0 +1,19 @@
+/********************************************************************************
+ * Copyright (C) 2021 STMicroelectronics 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+export * from './measurement';
+export * from './stopwatch';
+export * from './measurement-protocol';