@theia/core 1.46.1 → 1.47.0

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

@@ -99,21 +99,41 @@ export interface TreeModel extends Tree, TreeSelectionService, TreeExpansionServ
      */
     navigateBackward(): Promise<void>;
 
+    /**
+     * Selects the previous tree node, regardless of its selection or visibility state.
+     */
+    selectPrev(): void;
+
     /**
      * Selects the previous node relatively to the currently selected one. This method takes the expansion state of the tree into consideration.
      */
     selectPrevNode(type?: TreeSelection.SelectionType): void;
 
+    /**
+     * Returns the previous tree node, regardless of its selection or visibility state.
+     */
+    getPrevNode(node?: TreeNode): TreeNode | undefined;
+
     /**
      * Returns the previous selectable tree node.
      */
     getPrevSelectableNode(node?: TreeNode): SelectableTreeNode | undefined;
 
+    /**
+     * Selects the next tree node, regardless of its selection or visibility state.
+     */
+    selectNext(): void;
+
     /**
      * Selects the next node relatively to the currently selected one. This method takes the expansion state of the tree into consideration.
      */
     selectNextNode(type?: TreeSelection.SelectionType): void;
 
+    /**
+     * Returns the next tree node, regardless of its selection or visibility state.
+     */
+    getNextNode(node?: TreeNode): TreeNode | undefined;
+
     /**
      * Returns the next selectable tree node.
      */
@@ -294,6 +314,11 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         }
     }
 
+    selectPrev(): void {
+        const node = this.getPrevNode();
+        this.selectNodeIfSelectable(node);
+    }
+
     selectPrevNode(type: TreeSelection.SelectionType = TreeSelection.SelectionType.DEFAULT): void {
         const node = this.getPrevSelectableNode();
         if (node) {
@@ -301,6 +326,11 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         }
     }
 
+    getPrevNode(node: TreeNode | undefined = this.getFocusedNode()): TreeNode | undefined {
+        const iterator = this.createBackwardTreeIterator(node);
+        return iterator && this.doGetNode(iterator);
+    }
+
     getPrevSelectableNode(node: TreeNode | undefined = this.getFocusedNode()): SelectableTreeNode | undefined {
         if (!node) {
             return this.getNextSelectableNode(this.root);
@@ -309,6 +339,11 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         return iterator && this.doGetNextNode(iterator, this.isVisibleSelectableNode.bind(this));
     }
 
+    selectNext(): void {
+        const node = this.getNextNode();
+        this.selectNodeIfSelectable(node);
+    }
+
     selectNextNode(type: TreeSelection.SelectionType = TreeSelection.SelectionType.DEFAULT): void {
         const node = this.getNextSelectableNode();
         if (node) {
@@ -316,11 +351,28 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         }
     }
 
+    getNextNode(node: TreeNode | undefined = this.getFocusedNode()): TreeNode | undefined {
+        const iterator = this.createTreeIterator(node);
+        return iterator && this.doGetNode(iterator);
+    }
+
     getNextSelectableNode(node: TreeNode | undefined = this.getFocusedNode() ?? this.root): SelectableTreeNode | undefined {
         const iterator = this.createIterator(node);
         return iterator && this.doGetNextNode(iterator, this.isVisibleSelectableNode.bind(this));
     }
 
+    protected selectNodeIfSelectable(node: TreeNode | undefined): void {
+        if (SelectableTreeNode.is(node)) {
+            this.addSelection(node);
+        }
+    }
+
+    protected doGetNode(iterator: TreeIterator): TreeNode | undefined {
+        iterator.next();
+        const result = iterator.next();
+        return result.done ? undefined : result.value;
+    }
+
     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();
@@ -338,6 +390,17 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         return SelectableTreeNode.isVisible(node);
     }
 
+    protected createBackwardTreeIterator(node: TreeNode | undefined): TreeIterator | undefined {
+        const { filteredNodes } = this.treeSearch;
+        if (filteredNodes.length === 0) {
+            return node ? new BottomUpTreeIterator(node!, { pruneCollapsed: false }) : undefined;
+        }
+        if (node && filteredNodes.indexOf(node) === -1) {
+            return undefined;
+        }
+        return Iterators.cycle(filteredNodes.slice().reverse(), node);
+    }
+
     protected createBackwardIterator(node: TreeNode | undefined): TreeIterator | undefined {
         const { filteredNodes } = this.treeSearch;
         if (filteredNodes.length === 0) {
@@ -349,6 +412,17 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         return Iterators.cycle(filteredNodes.slice().reverse(), node);
     }
 
+    protected createTreeIterator(node: TreeNode | undefined): TreeIterator | undefined {
+        const { filteredNodes } = this.treeSearch;
+        if (filteredNodes.length === 0) {
+            return node && new TopDownTreeIterator(node, { pruneCollapsed: false });
+        }
+        if (node && filteredNodes.indexOf(node) === -1) {
+            return undefined;
+        }
+        return Iterators.cycle(filteredNodes, node);
+    }
+
     protected createIterator(node: TreeNode | undefined): TreeIterator | undefined {
         const { filteredNodes } = this.treeSearch;
         if (filteredNodes.length === 0) {

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

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

package/src/browser/widgets/widget.ts

@@ -381,12 +381,20 @@ export function pin(title: Title<Widget>): void {
     }
 }
 
+export function isLocked(title: Title<Widget>): boolean {
+    return title.className.includes(LOCKED_CLASS);
+}
+
 export function lock(title: Title<Widget>): void {
     if (!title.className.includes(LOCKED_CLASS)) {
         title.className += ` ${LOCKED_CLASS}`;
     }
 }
 
+export function unlock(title: Title<Widget>): void {
+    title.className = title.className.replace(LOCKED_CLASS, '').trim();
+}
+
 export function togglePinned(title?: Title<Widget>): void {
     if (title) {
         if (isPinned(title)) {

package/src/common/disposable.spec.ts

@@ -14,8 +14,11 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { expect } from 'chai';
+import { expect, spy, use } from 'chai';
 import { DisposableCollection, Disposable } from './disposable';
+import * as spies from 'chai-spies';
+
+use(spies);
 
 describe('Disposables', () => {
     it('Is safe to use Disposable.NULL', () => {
@@ -26,4 +29,66 @@ describe('Disposables', () => {
         expect(collectionA.disposed, 'A should be disposed after being disposed.').to.be.true;
         expect(collectionB.disposed, 'B should not be disposed because A was disposed.').to.be.false;
     });
+
+    it('Collection is auto-pruned when an element is disposed', () => {
+        const onDispose = spy(() => { });
+        const elementDispose = () => { };
+
+        const collection = new DisposableCollection();
+        collection.onDispose(onDispose);
+
+        const disposable1 = Disposable.create(elementDispose);
+        collection.push(disposable1);
+        expect(collection['disposables']).to.have.lengthOf(1);
+
+        const disposable2 = Disposable.create(elementDispose);
+        collection.push(disposable2);
+        expect(collection['disposables']).to.have.lengthOf(2);
+
+        disposable1.dispose();
+        expect(collection['disposables']).to.have.lengthOf(1);
+        expect(onDispose).to.have.not.been.called();
+        expect(collection.disposed).is.false;
+
+        // Test that calling dispose on an already disposed element doesn't
+        // alter the collection state
+        disposable1.dispose();
+        expect(collection['disposables']).to.have.lengthOf(1);
+        expect(onDispose).to.have.not.been.called();
+        expect(collection.disposed).is.false;
+
+        disposable2.dispose();
+        expect(collection['disposables']).to.be.empty;
+        expect(collection.disposed).is.true;
+        expect(onDispose).to.have.been.called.once;
+    });
+
+    it('onDispose is only called once on actual disposal of elements', () => {
+        const onDispose = spy(() => { });
+        const elementDispose = spy(() => { });
+
+        const collection = new DisposableCollection();
+        collection.onDispose(onDispose);
+
+        // if the collection is empty 'onDispose' is not called
+        collection.dispose();
+        expect(onDispose).to.not.have.been.called();
+
+        // 'onDispose' is called because we actually dispose an element
+        collection.push(Disposable.create(elementDispose));
+        collection.dispose();
+        expect(elementDispose).to.have.been.called.once;
+        expect(onDispose).to.have.been.called.once;
+
+        // if the collection is empty 'onDispose' is not called and no further element is disposed
+        collection.dispose();
+        expect(elementDispose).to.have.been.called.once;
+        expect(onDispose).to.have.been.called.once;
+
+        // 'onDispose' is not called again even if we actually dispose an element
+        collection.push(Disposable.create(elementDispose));
+        collection.dispose();
+        expect(elementDispose).to.have.been.called.twice;
+        expect(onDispose).to.have.been.called.once;
+    });
 });

package/src/common/disposable.ts

@@ -47,6 +47,34 @@ Object.defineProperty(Disposable, 'NULL', {
     }
 });
 
+/**
+ * Utility for tracking a collection of Disposable objects.
+ *
+ * This utility provides a number of benefits over just using an array of
+ * Disposables:
+ *
+ * - the collection is auto-pruned when an element it contains is disposed by
+ * any code that has a reference to it
+ * - you can register to be notified when all elements in the collection have
+ * been disposed [1]
+ * - you can conveniently dispose all elements by calling dispose()
+ * on the collection
+ *
+ * Unlike an array, however, this utility does not give you direct access to
+ * its elements.
+ *
+ * Being notified when all elements are disposed is simple:
+ * ```
+ * const dc = new DisposableCollection(myDisposables);
+ * dc.onDispose(() => {
+ *    console.log('All elements in the collection have been disposed');
+ * });
+ * ```
+ *
+ * [1] The collection will notify only once. It will continue to function in so
+ * far as accepting new Disposables and pruning them when they are disposed, but
+ * such activity will never result in another notification.
+ */
 export class DisposableCollection implements Disposable {
 
     protected readonly disposables: Disposable[] = [];

package/src/common/index.ts

@@ -46,5 +46,6 @@ export * from './strings';
 export * from './telemetry';
 export * from './types';
 export { default as URI } from './uri';
+export * from './uuid';
 export * from './view-column';
 export * from './version';

package/src/common/markdown-rendering/markdown-string.ts

@@ -19,9 +19,13 @@ import { UriComponents } from '../uri';
 import { escapeIcons } from './icon-utilities';
 import { isObject, isString } from '../types';
 
+export interface MarkdownStringTrustedOptions {
+    readonly enabledCommands: readonly string[];
+}
+
 export interface MarkdownString {
     readonly value: string;
-    readonly isTrusted?: boolean;
+    readonly isTrusted?: boolean | MarkdownStringTrustedOptions;
     readonly supportThemeIcons?: boolean;
     readonly supportHtml?: boolean;
     readonly baseUri?: UriComponents;
@@ -45,9 +49,8 @@ export namespace MarkdownString {
 // Copied from https://github.com/microsoft/vscode/blob/7d9b1c37f8e5ae3772782ba3b09d827eb3fdd833/src/vs/base/common/htmlContent.ts
 
 export class MarkdownStringImpl implements MarkdownString {
-
     public value: string;
-    public isTrusted?: boolean;
+    public isTrusted?: boolean | MarkdownStringTrustedOptions;
     public supportThemeIcons?: boolean;
     public supportHtml?: boolean;
     public baseUri?: UriComponents;

package/src/common/menu/composite-menu-node.spec.ts

@@ -0,0 +1,67 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+import { expect } from 'chai';
+import { CompositeMenuNode } from './composite-menu-node';
+import { CompoundMenuNodeRole } from './menu-types';
+
+describe('composite-menu-node', () => {
+    describe('updateOptions', () => {
+        it('should update undefined node properties', () => {
+            const node = new CompositeMenuNode('test-id');
+            node.updateOptions({ label: 'node-label', icon: 'icon', order: 'a', role: CompoundMenuNodeRole.Flat, when: 'node-condition' });
+            expect(node.label).to.equal('node-label');
+            expect(node.icon).to.equal('icon');
+            expect(node.order).to.equal('a');
+            expect(node.role).to.equal(CompoundMenuNodeRole.Flat);
+            expect(node.when).to.equal('node-condition');
+        });
+        it('should update existing node properties', () => {
+            const node = new CompositeMenuNode('test-id', 'test-label', { icon: 'test-icon', order: 'a1', role: CompoundMenuNodeRole.Submenu, when: 'test-condition' });
+            node.updateOptions({ label: 'NEW-label', icon: 'NEW-icon', order: 'a2', role: CompoundMenuNodeRole.Flat, when: 'NEW-condition' });
+            expect(node.label).to.equal('NEW-label');
+            expect(node.icon).to.equal('NEW-icon');
+            expect(node.order).to.equal('a2');
+            expect(node.role).to.equal(CompoundMenuNodeRole.Flat);
+            expect(node.when).to.equal('NEW-condition');
+        });
+        it('should update only the icon without affecting other properties', () => {
+            const node = new CompositeMenuNode('test-id', 'test-label', { icon: 'test-icon', order: 'a' });
+            node.updateOptions({ icon: 'NEW-icon' });
+            expect(node.label).to.equal('test-label');
+            expect(node.icon).to.equal('NEW-icon');
+            expect(node.order).to.equal('a');
+        });
+        it('should not allow to unset properties', () => {
+            const node = new CompositeMenuNode('test-id', 'test-label', { icon: 'test-icon', order: 'a' });
+            node.updateOptions({ icon: undefined });
+            expect(node.label).to.equal('test-label');
+            expect(node.icon).to.equal('test-icon');
+            expect(node.order).to.equal('a');
+        });
+        it('should allow to set empty strings in properties', () => {
+            const node = new CompositeMenuNode('test-id', 'test-label');
+            node.updateOptions({ label: '' });
+            expect(node.label).to.equal('');
+        });
+        it('should not cause side effects when updating a property to its existing value', () => {
+            const node = new CompositeMenuNode('test-id', 'test-label', { icon: 'test-icon', order: 'a' });
+            node.updateOptions({ icon: 'test-icon' });
+            expect(node.label).to.equal('test-label');
+            expect(node.icon).to.equal('test-icon');
+            expect(node.order).to.equal('a');
+        });
+    });
+});

package/src/common/menu/composite-menu-node.ts

@@ -63,11 +63,11 @@ export class CompositeMenuNode implements MutableCompoundMenuNode {
 
     updateOptions(options?: SubMenuOptions): void {
         if (options) {
-            this.iconClass ??= options.icon ?? options.iconClass;
-            this.label ??= options.label;
-            this.order ??= options.order;
-            this._role ??= options.role;
-            this._when ??= options.when;
+            this.iconClass = options.icon ?? options.iconClass ?? this.iconClass;
+            this.label = options.label ?? this.label;
+            this.order = options.order ?? this.order;
+            this._role = options.role ?? this._role;
+            this._when = options.when ?? this._when;
         }
     }
 

package/src/common/promise-util.spec.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import * as assert from 'assert/strict';
-import { firstTrue, waitForEvent } from './promise-util';
+import { Deferred, firstTrue, waitForEvent } from './promise-util';
 import { Emitter } from './event';
 import { CancellationError } from './cancellation';
 
@@ -35,7 +35,30 @@ describe('promise-util', () => {
         });
     });
 
+    type ExecutionHandler<T> = (resolve: (value: T) => void, reject: (error: unknown) => void) => void;
+
     describe('firstTrue', () => {
+        function createSequentialPromises<T>(...executionHandlers: ExecutionHandler<T>[]): Promise<T>[] {
+            const deferreds: Deferred<T>[] = [];
+            let i = 0;
+            for (let k = 0; k < executionHandlers.length; k++) {
+                deferreds.push(new Deferred<T>());
+            }
+
+            const resolveNext = () => {
+                if (i < executionHandlers.length) {
+                    executionHandlers[i](value => deferreds[i].resolve(value), error => deferreds[i].reject(error));
+                    i++;
+                }
+                if (i < executionHandlers.length) {
+                    setTimeout(resolveNext, 1);
+                }
+            };
+
+            setTimeout(resolveNext, 1);
+            return deferreds.map(deferred => deferred.promise);
+        }
+
         it('should resolve to false when the promises arg is empty', async () => {
             const actual = await firstTrue();
             assert.strictEqual(actual, false);
@@ -43,29 +66,36 @@ describe('promise-util', () => {
 
         it('should resolve to true when the first promise resolves to true', async () => {
             const signals: string[] = [];
-            const createPromise = (signal: string, timeout: number, result: boolean) =>
-                new Promise<boolean>(resolve => setTimeout(() => {
+
+            function createHandler(signal: string, result?: boolean): ExecutionHandler<boolean> {
+                return (resolve: (value: boolean) => void, reject: (error: unknown) => void) => {
                     signals.push(signal);
-                    resolve(result);
-                }, timeout));
-            const actual = await firstTrue(
-                createPromise('a', 10, false),
-                createPromise('b', 20, false),
-                createPromise('c', 30, true),
-                createPromise('d', 40, false),
-                createPromise('e', 50, true)
-            );
+                    if (typeof result !== 'undefined') {
+                        resolve(result);
+                    } else {
+                        reject(undefined);
+                    }
+                };
+            }
+
+            const actual = await firstTrue(...createSequentialPromises(
+                createHandler('a', false),
+                createHandler('b', false),
+                createHandler('c', true),
+                createHandler('d', false),
+                createHandler('e', true)
+            ));
             assert.strictEqual(actual, true);
             assert.deepStrictEqual(signals, ['a', 'b', 'c']);
         });
 
         it('should reject when one of the promises rejects', async () => {
-            await assert.rejects(firstTrue(
-                new Promise<boolean>(resolve => setTimeout(() => resolve(false), 10)),
-                new Promise<boolean>(resolve => setTimeout(() => resolve(false), 20)),
-                new Promise<boolean>((_, reject) => setTimeout(() => reject(new Error('my test error')), 30)),
-                new Promise<boolean>(resolve => setTimeout(() => resolve(true), 40)),
-            ), /Error: my test error/);
+            await assert.rejects(firstTrue(...createSequentialPromises<boolean>(
+                (resolve, _) => resolve(false),
+                resolve => resolve(false),
+                (_, reject) => reject(new Error('my test error')),
+                resolve => resolve(true),
+            )), /Error: my test error/);
         });
     });