@codingame/monaco-vscode-testing-service-override 1.83.16

package/external/rollup-plugin-styles/dist/runtime/inject-css.js

@@ -0,0 +1,3 @@
+var e=[],t=[];function n(n,r){if(n&&"undefined"!=typeof document){var a,s=!0===r.prepend?"prepend":"append",d=!0===r.singleTag,i="string"==typeof r.container?document.querySelector(r.container):document.getElementsByTagName("head")[0];if(d){var u=e.indexOf(i);-1===u&&(u=e.push(i)-1,t[u]={}),a=t[u]&&t[u][s]?t[u][s]:t[u][s]=c();}else a=c();65279===n.charCodeAt(0)&&(n=n.substring(1)),a.styleSheet?a.styleSheet.cssText+=n:a.appendChild(document.createTextNode(n));}function c(){var e=document.createElement("style");if(e.setAttribute("type","text/css"),r.attributes)for(var t=( Object.keys(r.attributes)),n=0;n<t.length;n++)e.setAttribute(t[n],r.attributes[t[n]]);var a="prepend"===s?"afterbegin":"beforeend";return i.insertAdjacentElement(a,e),e}}
+
+export { n as default };

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export { __decorate, __param };

package/index.d.ts

@@ -0,0 +1 @@
+export { default } from './testing.js';

package/index.js

@@ -0,0 +1 @@
+export { default } from './testing.js';

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@codingame/monaco-vscode-testing-service-override",
+  "version": "1.83.16",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - testing service-override",
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "dependencies": {
+    "vscode": "npm:@codingame/monaco-vscode-api@1.83.16",
+    "monaco-editor": "0.44.0",
+    "xterm-addon-canvas": "0.6.0-beta.27",
+    "xterm-addon-image": "0.6.0-beta.21",
+    "xterm-addon-search": "0.14.0-beta.27",
+    "xterm-addon-serialize": "0.12.0-beta.26",
+    "xterm-addon-unicode11": "0.7.0-beta.26",
+    "xterm-addon-webgl": "0.17.0-beta.26"
+  }
+}

package/testing.d.ts

@@ -0,0 +1,5 @@
+import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/testing.js

@@ -0,0 +1,28 @@
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { ITestProfileService, TestProfileService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testProfileService';
+import { ITestResultService, TestResultService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResultService';
+import { ITestResultStorage, TestResultStorage } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResultStorage';
+import { ITestService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testService';
+import { TestService } from './vscode/src/vs/workbench/contrib/testing/common/testServiceImpl.js';
+import { ITestingDecorationsService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testingDecorations';
+import { TestingDecorationService } from './vscode/src/vs/workbench/contrib/testing/browser/testingDecorations.js';
+import { ITestingPeekOpener } from 'vscode/vscode/vs/workbench/contrib/testing/common/testingPeekOpener';
+import { ITestingContinuousRunService, TestingContinuousRunService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testingContinuousRunService';
+import { ITestExplorerFilterState, TestExplorerFilterState } from 'vscode/vscode/vs/workbench/contrib/testing/common/testExplorerFilterState';
+import { TestingPeekOpener } from './vscode/src/vs/workbench/contrib/testing/browser/testingOutputPeek.js';
+import './vscode/src/vs/workbench/contrib/testing/browser/testing.contribution.js';
+
+function getServiceOverride() {
+    return {
+        [( ITestService.toString())]: new SyncDescriptor(TestService, [], true),
+        [( ITestResultStorage.toString())]: new SyncDescriptor(TestResultStorage, [], true),
+        [( ITestProfileService.toString())]: new SyncDescriptor(TestProfileService, [], true),
+        [( ITestingContinuousRunService.toString())]: new SyncDescriptor(TestingContinuousRunService, [], true),
+        [( ITestResultService.toString())]: new SyncDescriptor(TestResultService, [], true),
+        [( ITestExplorerFilterState.toString())]: new SyncDescriptor(TestExplorerFilterState, [], true),
+        [( ITestingPeekOpener.toString())]: new SyncDescriptor(TestingPeekOpener, [], true),
+        [( ITestingDecorationsService.toString())]: new SyncDescriptor(TestingDecorationService, [], true)
+    };
+}
+
+export { getServiceOverride as default };

package/vscode/src/vs/workbench/contrib/testing/browser/explorerProjections/display.js

@@ -0,0 +1,3 @@
+const flatTestItemDelimiter = ' \u203A ';
+
+export { flatTestItemDelimiter };

package/vscode/src/vs/workbench/contrib/testing/browser/explorerProjections/index.js

@@ -0,0 +1,76 @@
+import { ObjectTreeElementCollapseState } from 'monaco-editor/esm/vs/base/browser/ui/tree/tree.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { isCollapsedInSerializedTestTree } from './testingViewState.js';
+import { InternalTestItem } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
+
+let idCounter = 0;
+const getId = () => String(idCounter++);
+class TestItemTreeElement {
+    constructor(test,
+    parent = null) {
+        this.test = test;
+        this.parent = parent;
+        this.changeEmitter = ( new Emitter());
+        this.onChange = this.changeEmitter.event;
+        this.children = ( new Set());
+        this.treeId = getId();
+        this.depth = this.parent ? this.parent.depth + 1 : 0;
+        this.retired = false;
+        this.state = 0 ;
+    }
+    toJSON() {
+        if (this.depth === 0) {
+            return { controllerId: this.test.controllerId };
+        }
+        const context = {
+            $mid: 16 ,
+            tests: [InternalTestItem.serialize(this.test)],
+        };
+        for (let p = this.parent; p && p.depth > 0; p = p.parent) {
+            context.tests.unshift(InternalTestItem.serialize(p.test));
+        }
+        return context;
+    }
+}
+class TestTreeErrorMessage {
+    get description() {
+        return typeof this.message === 'string' ? this.message : this.message.value;
+    }
+    constructor(message, parent) {
+        this.message = message;
+        this.parent = parent;
+        this.treeId = getId();
+        this.children = ( new Set());
+    }
+}
+const testIdentityProvider = {
+    getId(element) {
+        return element.treeId + '\0' + (element instanceof TestTreeErrorMessage ? 'error' : element.test.expand);
+    }
+};
+const getChildrenForParent = (serialized, rootsWithChildren, node) => {
+    let it;
+    if (node === null) {
+        const rootsWithChildrenArr = [...rootsWithChildren];
+        if (rootsWithChildrenArr.length === 1) {
+            return getChildrenForParent(serialized, rootsWithChildrenArr, rootsWithChildrenArr[0]);
+        }
+        it = rootsWithChildrenArr;
+    }
+    else {
+        it = node.children;
+    }
+    return ( Iterable.map(it, element => (element instanceof TestTreeErrorMessage
+        ? { element }
+        : {
+            element,
+            collapsible: element.test.expand !== 0 ,
+            collapsed: isCollapsedInSerializedTestTree(serialized, element.test.item.extId) ?? element.depth > 0
+                ? ObjectTreeElementCollapseState.PreserveOrCollapsed
+                : ObjectTreeElementCollapseState.PreserveOrExpanded,
+            children: getChildrenForParent(serialized, rootsWithChildren, element),
+        })));
+};
+
+export { TestItemTreeElement, TestTreeErrorMessage, getChildrenForParent, testIdentityProvider };

package/vscode/src/vs/workbench/contrib/testing/browser/explorerProjections/listProjection.js

@@ -0,0 +1,186 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { flatTestItemDelimiter } from './display.js';
+import { getChildrenForParent, testIdentityProvider, TestItemTreeElement, TestTreeErrorMessage } from './index.js';
+import { isCollapsedInSerializedTestTree } from './testingViewState.js';
+import { TestId } from 'vscode/vscode/vs/workbench/contrib/testing/common/testId';
+import { ITestResultService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResultService';
+import { ITestService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testService';
+import { applyTestItemUpdate } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
+
+class ListTestItemElement extends TestItemTreeElement {
+    get description() {
+        return ( this.chain.map(c => c.item.label)).join(flatTestItemDelimiter);
+    }
+    constructor(test, parent, chain) {
+        super({ ...test, item: { ...test.item } }, parent);
+        this.chain = chain;
+        this.descriptionParts = [];
+        this.updateErrorVisibility();
+    }
+    update(patch) {
+        applyTestItemUpdate(this.test, patch);
+        this.updateErrorVisibility(patch);
+        this.fireChange();
+    }
+    fireChange() {
+        this.changeEmitter.fire();
+    }
+    updateErrorVisibility(patch) {
+        if (this.errorChild && (!this.test.item.error || patch?.item?.error)) {
+            this.children.delete(this.errorChild);
+            this.errorChild = undefined;
+        }
+        if (this.test.item.error && !this.errorChild) {
+            this.errorChild = ( new TestTreeErrorMessage(this.test.item.error, this));
+            this.children.add(this.errorChild);
+        }
+    }
+}
+let ListProjection = class ListProjection extends Disposable {
+    get rootsWithChildren() {
+        const rootsIt = ( Iterable.map(this.testService.collection.rootItems, r => this.items.get(r.item.extId)));
+        return Iterable.filter(rootsIt, (r) => !!r?.children.size);
+    }
+    constructor(lastState, testService, results) {
+        super();
+        this.lastState = lastState;
+        this.testService = testService;
+        this.results = results;
+        this.updateEmitter = ( new Emitter());
+        this.items = ( new Map());
+        this.onUpdate = this.updateEmitter.event;
+        this._register(testService.onDidProcessDiff((diff) => this.applyDiff(diff)));
+        this._register(results.onResultsChanged((evt) => {
+            if (!('removed' in evt)) {
+                return;
+            }
+            for (const inTree of ( this.items.values())) {
+                const lookup = this.results.getStateById(inTree.test.item.extId)?.[1];
+                inTree.duration = lookup?.ownDuration;
+                inTree.state = lookup?.ownComputedState || 0 ;
+                inTree.fireChange();
+            }
+        }));
+        this._register(results.onTestChanged(ev => {
+            if (ev.reason === 2 ) {
+                return;
+            }
+            let result = ev.item;
+            if (result.ownComputedState === 0  || ev.result !== results.results[0]) {
+                const fallback = results.getStateById(result.item.extId);
+                if (fallback) {
+                    result = fallback[1];
+                }
+            }
+            const item = this.items.get(result.item.extId);
+            if (!item) {
+                return;
+            }
+            item.retired = !!result.retired;
+            item.state = result.computedState;
+            item.duration = result.ownDuration;
+            item.fireChange();
+        }));
+        for (const test of testService.collection.all) {
+            this.storeItem(test);
+        }
+    }
+    getElementByTestId(testId) {
+        return this.items.get(testId);
+    }
+    applyDiff(diff) {
+        for (const op of diff) {
+            switch (op.op) {
+                case 0 : {
+                    this.storeItem(op.item);
+                    break;
+                }
+                case 1 : {
+                    this.items.get(op.item.extId)?.update(op.item);
+                    break;
+                }
+                case 3 : {
+                    for (const [id, item] of this.items) {
+                        if (id === op.itemId || TestId.isChild(op.itemId, id)) {
+                            this.unstoreItem(item);
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        if (diff.length !== 0) {
+            this.updateEmitter.fire();
+        }
+    }
+    applyTo(tree) {
+        tree.setChildren(null, getChildrenForParent(this.lastState, this.rootsWithChildren, null), {
+            diffIdentityProvider: testIdentityProvider,
+            diffDepth: Infinity
+        });
+    }
+    expandElement(element, depth) {
+        if (!(element instanceof ListTestItemElement)) {
+            return;
+        }
+        if (element.test.expand === 0 ) {
+            return;
+        }
+        this.testService.collection.expand(element.test.item.extId, depth);
+    }
+    unstoreItem(treeElement) {
+        this.items.delete(treeElement.test.item.extId);
+        treeElement.parent?.children.delete(treeElement);
+        const parentId = TestId.fromString(treeElement.test.item.extId).parentId;
+        if (!parentId) {
+            return;
+        }
+        for (const id of parentId.idsToRoot()) {
+            const parentTest = this.testService.collection.getNodeById(( id.toString()));
+            if (parentTest) {
+                if (parentTest.children.size === 0 && !( this.items.has(( id.toString())))) {
+                    this._storeItem(parentId, parentTest);
+                }
+                break;
+            }
+        }
+    }
+    _storeItem(testId, item) {
+        const displayedParent = testId.isRoot ? null : this.items.get(item.controllerId);
+        const chain = ( [...testId.idsFromRoot()].slice(1, -1).map(id => this.testService.collection.getNodeById(( id.toString()))));
+        const treeElement = ( new ListTestItemElement(item, displayedParent, chain));
+        displayedParent?.children.add(treeElement);
+        this.items.set(treeElement.test.item.extId, treeElement);
+        if (treeElement.depth === 0 || isCollapsedInSerializedTestTree(this.lastState, treeElement.test.item.extId) === false) {
+            this.expandElement(treeElement, Infinity);
+        }
+        const prevState = this.results.getStateById(treeElement.test.item.extId)?.[1];
+        if (prevState) {
+            treeElement.retired = !!prevState.retired;
+            treeElement.state = prevState.computedState;
+            treeElement.duration = prevState.ownDuration;
+        }
+    }
+    storeItem(item) {
+        const testId = TestId.fromString(item.item.extId);
+        for (const parentId of testId.idsToRoot()) {
+            if (!parentId.isRoot) {
+                const prevParent = this.items.get(( parentId.toString()));
+                if (prevParent) {
+                    this.unstoreItem(prevParent);
+                    break;
+                }
+            }
+        }
+        this._storeItem(testId, item);
+    }
+};
+ListProjection = ( __decorate([
+    ( __param(1, ITestService)),
+    ( __param(2, ITestResultService))
+], ListProjection));
+
+export { ListProjection };

package/vscode/src/vs/workbench/contrib/testing/browser/explorerProjections/testItemContextOverlay.js

@@ -0,0 +1,18 @@
+import { capabilityContextKeys } from 'vscode/vscode/vs/workbench/contrib/testing/common/testProfileService';
+import { TestId } from 'vscode/vscode/vs/workbench/contrib/testing/common/testId';
+import { TestingContextKeys } from 'vscode/vscode/vs/workbench/contrib/testing/common/testingContextKeys';
+
+const getTestItemContextOverlay = (test, capabilities) => {
+    if (!test) {
+        return [];
+    }
+    const testId = TestId.fromString(test.item.extId);
+    return [
+        [TestingContextKeys.testItemExtId.key, testId.localId],
+        [TestingContextKeys.controllerId.key, test.controllerId],
+        [TestingContextKeys.testItemHasUri.key, !!test.item.uri],
+        ...capabilityContextKeys(capabilities),
+    ];
+};
+
+export { getTestItemContextOverlay };

package/vscode/src/vs/workbench/contrib/testing/browser/explorerProjections/testingObjectTree.js

@@ -0,0 +1,46 @@
+import { WorkbenchObjectTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { TestItemTreeElement } from './index.js';
+import { TestId } from 'vscode/vscode/vs/workbench/contrib/testing/common/testId';
+
+class TestingObjectTree extends WorkbenchObjectTree {
+    getOptimizedViewState(updatePreviousState) {
+        const root = updatePreviousState || {};
+        const build = (node, parent) => {
+            if (!(node.element instanceof TestItemTreeElement)) {
+                return false;
+            }
+            const localId = TestId.localId(node.element.test.item.extId);
+            const inTree = parent.children?.[localId] || {};
+            inTree.collapsed = node.depth === 0 || !node.collapsed ? node.collapsed : undefined;
+            let hasAnyNonDefaultValue = inTree.collapsed !== undefined;
+            if (node.children.length) {
+                for (const child of node.children) {
+                    hasAnyNonDefaultValue = build(child, inTree) || hasAnyNonDefaultValue;
+                }
+            }
+            if (hasAnyNonDefaultValue) {
+                parent.children ??= {};
+                parent.children[localId] = inTree;
+            }
+            else if (parent.children?.hasOwnProperty(localId)) {
+                delete parent.children[localId];
+            }
+            return hasAnyNonDefaultValue;
+        };
+        root.children ??= {};
+        for (const node of this.getNode().children) {
+            if (node.element instanceof TestItemTreeElement) {
+                if (node.element.test.controllerId === node.element.test.item.extId) {
+                    build(node, root);
+                }
+                else {
+                    const ctrlNode = root.children[node.element.test.controllerId] ??= { children: {} };
+                    build(node, ctrlNode);
+                }
+            }
+        }
+        return root;
+    }
+}
+
+export { TestingObjectTree };

package/vscode/src/vs/workbench/contrib/testing/browser/explorerProjections/testingViewState.js

@@ -0,0 +1,17 @@
+import { TestId } from 'vscode/vscode/vs/workbench/contrib/testing/common/testId';
+
+function isCollapsedInSerializedTestTree(serialized, id) {
+    if (!(id instanceof TestId)) {
+        id = TestId.fromString(id);
+    }
+    let node = serialized;
+    for (const part of id.path) {
+        if (!node.children?.hasOwnProperty(part)) {
+            return undefined;
+        }
+        node = node.children[part];
+    }
+    return node.collapsed;
+}
+
+export { isCollapsedInSerializedTestTree };

package/vscode/src/vs/workbench/contrib/testing/browser/explorerProjections/treeProjection.js

@@ -0,0 +1,220 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { getChildrenForParent, testIdentityProvider, TestItemTreeElement, TestTreeErrorMessage } from './index.js';
+import { isCollapsedInSerializedTestTree } from './testingViewState.js';
+import { refreshComputedState } from 'vscode/vscode/vs/workbench/contrib/testing/common/getComputedState';
+import { TestId } from 'vscode/vscode/vs/workbench/contrib/testing/common/testId';
+import { ITestResultService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResultService';
+import { ITestService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testService';
+import { applyTestItemUpdate } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
+
+const computedStateAccessor = {
+    getOwnState: i => i instanceof TestItemTreeElement ? i.ownState : 0 ,
+    getCurrentComputedState: i => i.state,
+    setComputedState: (i, s) => i.state = s,
+    getCurrentComputedDuration: i => i.duration,
+    getOwnDuration: i => i instanceof TestItemTreeElement ? i.ownDuration : undefined,
+    setComputedDuration: (i, d) => i.duration = d,
+    getChildren: i => Iterable.filter(( i.children.values()), (t) => t instanceof TreeTestItemElement),
+    *getParents(i) {
+        for (let parent = i.parent; parent; parent = parent.parent) {
+            yield parent;
+        }
+    },
+};
+class TreeTestItemElement extends TestItemTreeElement {
+    get description() {
+        return this.test.item.description;
+    }
+    constructor(test, parent, addedOrRemoved) {
+        super({ ...test, item: { ...test.item } }, parent);
+        this.addedOrRemoved = addedOrRemoved;
+        this.ownState = 0 ;
+        this.updateErrorVisibility();
+    }
+    update(patch) {
+        applyTestItemUpdate(this.test, patch);
+        this.updateErrorVisibility(patch);
+        this.fireChange();
+    }
+    fireChange() {
+        this.changeEmitter.fire();
+    }
+    updateErrorVisibility(patch) {
+        if (this.errorChild && (!this.test.item.error || patch?.item?.error)) {
+            this.addedOrRemoved(this);
+            this.children.delete(this.errorChild);
+            this.errorChild = undefined;
+        }
+        if (this.test.item.error && !this.errorChild) {
+            this.errorChild = ( new TestTreeErrorMessage(this.test.item.error, this));
+            this.children.add(this.errorChild);
+            this.addedOrRemoved(this);
+        }
+    }
+}
+let TreeProjection = class TreeProjection extends Disposable {
+    get rootsWithChildren() {
+        const rootsIt = ( Iterable.map(this.testService.collection.rootItems, r => this.items.get(r.item.extId)));
+        return Iterable.filter(rootsIt, (r) => !!r?.children.size);
+    }
+    constructor(lastState, testService, results) {
+        super();
+        this.lastState = lastState;
+        this.testService = testService;
+        this.results = results;
+        this.updateEmitter = ( new Emitter());
+        this.changedParents = ( new Set());
+        this.resortedParents = ( new Set());
+        this.items = ( new Map());
+        this.onUpdate = this.updateEmitter.event;
+        this._register(testService.onDidProcessDiff((diff) => this.applyDiff(diff)));
+        this._register(results.onResultsChanged((evt) => {
+            if (!('removed' in evt)) {
+                return;
+            }
+            for (const inTree of [...( this.items.values())].sort((a, b) => b.depth - a.depth)) {
+                const lookup = this.results.getStateById(inTree.test.item.extId)?.[1];
+                inTree.ownDuration = lookup?.ownDuration;
+                refreshComputedState(computedStateAccessor, inTree, lookup?.ownComputedState ?? 0 ).forEach(i => i.fireChange());
+            }
+        }));
+        this._register(results.onTestChanged(ev => {
+            if (ev.reason === 2 ) {
+                return;
+            }
+            let result = ev.item;
+            if (result.ownComputedState === 0  || ev.result !== results.results[0]) {
+                const fallback = results.getStateById(result.item.extId);
+                if (fallback) {
+                    result = fallback[1];
+                }
+            }
+            const item = this.items.get(result.item.extId);
+            if (!item) {
+                return;
+            }
+            const refreshDuration = ev.reason === 1  && ev.previousOwnDuration !== result.ownDuration;
+            const explicitComputed = item.children.size ? undefined : result.computedState;
+            item.retired = !!result.retired;
+            item.ownState = result.ownComputedState;
+            item.ownDuration = result.ownDuration;
+            item.fireChange();
+            refreshComputedState(computedStateAccessor, item, explicitComputed, refreshDuration).forEach(i => i.fireChange());
+        }));
+        for (const test of testService.collection.all) {
+            this.storeItem(this.createItem(test));
+        }
+    }
+    getElementByTestId(testId) {
+        return this.items.get(testId);
+    }
+    applyDiff(diff) {
+        for (const op of diff) {
+            switch (op.op) {
+                case 0 : {
+                    const item = this.createItem(op.item);
+                    this.storeItem(item);
+                    break;
+                }
+                case 1 : {
+                    const patch = op.item;
+                    const existing = this.items.get(patch.extId);
+                    if (!existing) {
+                        break;
+                    }
+                    const needsParentUpdate = existing.test.expand === 0  && patch.expand;
+                    existing.update(patch);
+                    if (needsParentUpdate) {
+                        this.changedParents.add(existing.parent);
+                    }
+                    else {
+                        this.resortedParents.add(existing.parent);
+                    }
+                    break;
+                }
+                case 3 : {
+                    const toRemove = this.items.get(op.itemId);
+                    if (!toRemove) {
+                        break;
+                    }
+                    const affectsRootElement = toRemove.depth === 1 && toRemove.parent?.children.size === 1;
+                    this.changedParents.add(affectsRootElement ? null : toRemove.parent);
+                    const queue = [[toRemove]];
+                    while (queue.length) {
+                        for (const item of queue.pop()) {
+                            if (item instanceof TreeTestItemElement) {
+                                queue.push(this.unstoreItem(item));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (diff.length !== 0) {
+            this.updateEmitter.fire();
+        }
+    }
+    applyTo(tree) {
+        for (const s of [this.changedParents, this.resortedParents]) {
+            for (const element of s) {
+                if (element && !tree.hasElement(element)) {
+                    s.delete(element);
+                }
+            }
+        }
+        for (const parent of this.changedParents) {
+            tree.setChildren(parent, getChildrenForParent(this.lastState, this.rootsWithChildren, parent), { diffIdentityProvider: testIdentityProvider });
+        }
+        for (const parent of this.resortedParents) {
+            tree.resort(parent, false);
+        }
+    }
+    expandElement(element, depth) {
+        if (!(element instanceof TreeTestItemElement)) {
+            return;
+        }
+        if (element.test.expand === 0 ) {
+            return;
+        }
+        this.testService.collection.expand(element.test.item.extId, depth);
+    }
+    createItem(item) {
+        const parentId = TestId.parentId(item.item.extId);
+        const parent = parentId ? this.items.get(parentId) : null;
+        return ( new TreeTestItemElement(item, parent, n => this.changedParents.add(n)));
+    }
+    unstoreItem(treeElement) {
+        const parent = treeElement.parent;
+        parent?.children.delete(treeElement);
+        this.items.delete(treeElement.test.item.extId);
+        if (parent instanceof TreeTestItemElement) {
+            refreshComputedState(computedStateAccessor, parent, undefined, !!treeElement.duration).forEach(i => i.fireChange());
+        }
+        return treeElement.children;
+    }
+    storeItem(treeElement) {
+        treeElement.parent?.children.add(treeElement);
+        this.items.set(treeElement.test.item.extId, treeElement);
+        const affectsRootElement = treeElement.depth === 1 && treeElement.parent?.children.size === 1;
+        this.changedParents.add(affectsRootElement ? null : treeElement.parent);
+        if (treeElement.depth === 0 || isCollapsedInSerializedTestTree(this.lastState, treeElement.test.item.extId) === false) {
+            this.expandElement(treeElement, 0);
+        }
+        const prevState = this.results.getStateById(treeElement.test.item.extId)?.[1];
+        if (prevState) {
+            treeElement.retired = !!prevState.retired;
+            treeElement.ownState = prevState.computedState;
+            treeElement.ownDuration = prevState.ownDuration;
+            refreshComputedState(computedStateAccessor, treeElement, undefined, !!treeElement.ownDuration).forEach(i => i.fireChange());
+        }
+    }
+};
+TreeProjection = ( __decorate([
+    ( __param(1, ITestService)),
+    ( __param(2, ITestResultService))
+], TreeProjection));
+
+export { TreeProjection };