@codingame/monaco-vscode-api 4.1.0 → 4.1.1

package/vscode/src/vs/workbench/contrib/testing/browser/codeCoverageDecorations.js

@@ -1,589 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { $, append, clearNode } from '../../../../base/browser/dom.js';
-import { HoverWidget } from '../../../../base/browser/ui/hover/hoverWidget.js';
-import { mapFindFirst } from '../../../../base/common/arraysFind.js';
-import { assertNever } from '../../../../base/common/assert.js';
-import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
-import { MarkdownString } from '../../../../base/common/htmlContent.js';
-import { KeyChord } from '../../../../base/common/keyCodes.js';
-import { Lazy } from '../../../../base/common/lazy.js';
-import { Disposable, DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
-import { observableValue } from '../../../../base/common/observableInternal/base.js';
-import { derived } from '../../../../base/common/observableInternal/derived.js';
-import { autorun } from '../../../../base/common/observableInternal/autorun.js';
-import { observableFromEvent } from '../../../../base/common/observableInternal/utils.js';
-import { ThemeIcon } from '../../../../base/common/themables.js';
-import { MarkdownRenderer } from '../../../../editor/browser/widget/markdownRenderer/browser/markdownRenderer.js';
-import { Position } from '../../../../editor/common/core/position.js';
-import { Range } from '../../../../editor/common/core/range.js';
-import { InjectedTextCursorStops } from '../../../../editor/common/model.js';
-import { HoverOperation } from '../../../../editor/contrib/hover/browser/hoverOperation.js';
-import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
-import { Categories } from '../../../../platform/action/common/actionCommonCategories.js';
-import { registerAction2, Action2 } from '../../../../platform/actions/common/actions.js';
-import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
-import { ILogService } from '../../../../platform/log/common/log.js';
-import { testingCoverageMissingBranch } from './icons.js';
-import { ITestCoverageService } from '../common/testCoverageService.js';
-import { TestingContextKeys } from '../common/testingContextKeys.js';
-var CodeCoverageDecorations_1, LineHoverWidget_1;
-const MAX_HOVERED_LINES = 30;
-const CLASS_HIT = 'coverage-deco-hit';
-const CLASS_MISS = 'coverage-deco-miss';
-const TOGGLE_INLINE_COMMAND_TEXT = ( localizeWithPath(
-    'vs/workbench/contrib/testing/browser/codeCoverageDecorations',
-    'testing.toggleInlineCoverage',
-    'Toggle Inline Coverage'
-));
-const TOGGLE_INLINE_COMMAND_ID = 'testing.toggleInlineCoverage';
-const BRANCH_MISS_INDICATOR_CHARS = 4;
-let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
-    static { CodeCoverageDecorations_1 = this; }
-    static { this.showInline = observableValue('inlineCoverage', false); }
-    static { this.fileCoverageDecorations = ( new WeakMap()); }
-    constructor(editor, instantiationService, coverage, log) {
-        super();
-        this.editor = editor;
-        this.log = log;
-        this.displayedStore = this._register(( new DisposableStore()));
-        this.hoveredStore = this._register(( new DisposableStore()));
-        this.decorationIds = ( new Map());
-        this.lineHoverWidget = ( new Lazy(
-            () => this._register(instantiationService.createInstance(LineHoverWidget, this.editor))
-        ));
-        const modelObs = observableFromEvent(editor.onDidChangeModel, () => editor.getModel());
-        const configObs = observableFromEvent(editor.onDidChangeConfiguration, i => i);
-        const fileCoverage = derived(reader => {
-            const report = coverage.selected.read(reader);
-            if (!report) {
-                return;
-            }
-            const model = modelObs.read(reader);
-            if (!model) {
-                return;
-            }
-            const file = report.getUri(model.uri);
-            if (file) {
-                return file;
-            }
-            report.didAddCoverage.read(reader);
-            return undefined;
-        });
-        this._register(autorun(reader => {
-            const c = fileCoverage.read(reader);
-            if (c) {
-                this.apply(editor.getModel(), c, CodeCoverageDecorations_1.showInline.read(reader));
-            }
-            else {
-                this.clear();
-            }
-        }));
-        this._register(autorun(reader => {
-            const c = fileCoverage.read(reader);
-            if (c) {
-                const evt = configObs.read(reader);
-                if (evt?.hasChanged(67 ) !== false) {
-                    this.updateEditorStyles();
-                }
-            }
-        }));
-        this._register(editor.onMouseMove(e => {
-            const model = editor.getModel();
-            if (e.target.type === 3  && model) {
-                this.hoverLineNumber(editor.getModel(), e.target.position.lineNumber);
-            }
-            else if (this.lineHoverWidget.hasValue && this.lineHoverWidget.value.getDomNode().contains(e.target.element)) ;
-            else if (CodeCoverageDecorations_1.showInline.get() && e.target.type === 6  && model) {
-                this.hoverInlineDecoration(model, e.target.position);
-            }
-            else {
-                this.hoveredStore.clear();
-            }
-        }));
-        this._register(editor.onWillChangeModel(() => {
-            const model = editor.getModel();
-            if (!this.details || !model) {
-                return;
-            }
-            for (const decoration of model.getAllDecorations()) {
-                const own = this.decorationIds.get(decoration.id);
-                if (own) {
-                    own.detail.range = decoration.range;
-                }
-            }
-        }));
-    }
-    updateEditorStyles() {
-        const lineHeight = this.editor.getOption(67 );
-        const { style } = this.editor.getContainerDomNode();
-        style.setProperty('--vscode-testing-coverage-lineHeight', `${lineHeight}px`);
-    }
-    hoverInlineDecoration(model, position) {
-        const allDecorations = model.getDecorationsInRange(Range.fromPositions(position));
-        const decoration = mapFindFirst(allDecorations, ({ id }) => ( this.decorationIds.has(id)) ? { id, deco: this.decorationIds.get(id) } : undefined);
-        if (decoration === this.hoveredSubject) {
-            return;
-        }
-        this.hoveredStore.clear();
-        this.hoveredSubject = decoration;
-        if (!decoration) {
-            return;
-        }
-        model.changeDecorations(e => {
-            e.changeDecorationOptions(decoration.id, {
-                ...decoration.deco.options,
-                className: `${decoration.deco.options.className} coverage-deco-hovered`,
-            });
-        });
-        this.hoveredStore.add(toDisposable(() => {
-            this.hoveredSubject = undefined;
-            model.changeDecorations(e => {
-                e.changeDecorationOptions(decoration.id, decoration.deco.options);
-            });
-        }));
-    }
-    hoverLineNumber(model, lineNumber) {
-        if (lineNumber === this.hoveredSubject || !this.details) {
-            return;
-        }
-        this.hoveredStore.clear();
-        this.hoveredSubject = lineNumber;
-        const todo = [{ line: lineNumber, dir: 0 }];
-        const toEnable = ( new Set());
-        const inlineEnabled = CodeCoverageDecorations_1.showInline.get();
-        if (!CodeCoverageDecorations_1.showInline.get()) {
-            for (let i = 0; i < todo.length && i < MAX_HOVERED_LINES; i++) {
-                const { line, dir } = todo[i];
-                let found = false;
-                for (const decoration of model.getLineDecorations(line)) {
-                    if (( this.decorationIds.has(decoration.id))) {
-                        toEnable.add(decoration.id);
-                        found = true;
-                    }
-                }
-                if (found) {
-                    if (dir <= 0) {
-                        todo.push({ line: line - 1, dir: -1 });
-                    }
-                    if (dir >= 0) {
-                        todo.push({ line: line + 1, dir: 1 });
-                    }
-                }
-            }
-            model.changeDecorations(e => {
-                for (const id of toEnable) {
-                    const { applyHoverOptions, options } = this.decorationIds.get(id);
-                    const dup = { ...options };
-                    applyHoverOptions(dup);
-                    e.changeDecorationOptions(id, dup);
-                }
-            });
-        }
-        if (toEnable.size || inlineEnabled) {
-            this.lineHoverWidget.value.startShowingAt(lineNumber);
-        }
-        this.hoveredStore.add(this.editor.onMouseLeave(() => {
-            this.hoveredStore.clear();
-        }));
-        this.hoveredStore.add(toDisposable(() => {
-            this.lineHoverWidget.value.hide();
-            this.hoveredSubject = undefined;
-            model.changeDecorations(e => {
-                for (const id of toEnable) {
-                    const deco = this.decorationIds.get(id);
-                    if (deco) {
-                        e.changeDecorationOptions(id, deco.options);
-                    }
-                }
-            });
-        }));
-    }
-    async apply(model, coverage, showInlineByDefault) {
-        const details = this.details = await this.loadDetails(coverage, model);
-        if (!details) {
-            return this.clear();
-        }
-        this.displayedStore.clear();
-        model.changeDecorations(e => {
-            for (const detailRange of details.ranges) {
-                const { metadata: { detail, description }, range, primary } = detailRange;
-                if (detail.type === 2 ) {
-                    const hits = detail.detail.branches[detail.branch].count;
-                    const cls = hits ? CLASS_HIT : CLASS_MISS;
-                    const showMissIndicator = !hits && range.isEmpty() && ( detail.detail.branches.some(b => b.count));
-                    const options = {
-                        showIfCollapsed: showMissIndicator,
-                        description: 'coverage-gutter',
-                        lineNumberClassName: `coverage-deco-gutter ${cls}`,
-                    };
-                    const applyHoverOptions = (target) => {
-                        target.hoverMessage = description;
-                        if (showMissIndicator) {
-                            target.after = {
-                                content: '\xa0'.repeat(BRANCH_MISS_INDICATOR_CHARS),
-                                inlineClassName: `coverage-deco-branch-miss-indicator ${ThemeIcon.asClassName(testingCoverageMissingBranch)}`,
-                                inlineClassNameAffectsLetterSpacing: true,
-                                cursorStops: InjectedTextCursorStops.None,
-                            };
-                        }
-                        else {
-                            target.className = `coverage-deco-inline ${cls}`;
-                            if (primary && typeof hits === 'number') {
-                                target.before = countBadge(hits);
-                            }
-                        }
-                    };
-                    if (showInlineByDefault) {
-                        applyHoverOptions(options);
-                    }
-                    this.decorationIds.set(e.addDecoration(range, options), { options, applyHoverOptions, detail: detailRange });
-                }
-                else if (detail.type === 1 ) {
-                    const cls = detail.count ? CLASS_HIT : CLASS_MISS;
-                    const options = {
-                        showIfCollapsed: false,
-                        description: 'coverage-inline',
-                        lineNumberClassName: `coverage-deco-gutter ${cls}`,
-                    };
-                    const applyHoverOptions = (target) => {
-                        target.className = `coverage-deco-inline ${cls}`;
-                        target.hoverMessage = description;
-                        if (primary && typeof detail.count === 'number') {
-                            target.before = countBadge(detail.count);
-                        }
-                    };
-                    if (showInlineByDefault) {
-                        applyHoverOptions(options);
-                    }
-                    this.decorationIds.set(e.addDecoration(range, options), { options, applyHoverOptions, detail: detailRange });
-                }
-            }
-        });
-        this.displayedStore.add(toDisposable(() => {
-            model.changeDecorations(e => {
-                for (const decoration of ( this.decorationIds.keys())) {
-                    e.removeDecoration(decoration);
-                }
-                this.decorationIds.clear();
-            });
-        }));
-    }
-    clear() {
-        this.loadingCancellation?.cancel();
-        this.loadingCancellation = undefined;
-        this.displayedStore.clear();
-        this.hoveredStore.clear();
-    }
-    async loadDetails(coverage, textModel) {
-        const existing = CodeCoverageDecorations_1.fileCoverageDecorations.get(coverage);
-        if (existing) {
-            return existing;
-        }
-        const cts = this.loadingCancellation = ( new CancellationTokenSource());
-        this.displayedStore.add(this.loadingCancellation);
-        try {
-            const details = await coverage.details(this.loadingCancellation.token);
-            if (cts.token.isCancellationRequested) {
-                return;
-            }
-            const model = CodeCoverageDecorations_1.fileCoverageDecorations.get(coverage)
-                || ( new CoverageDetailsModel(details, textModel));
-            CodeCoverageDecorations_1.fileCoverageDecorations.set(coverage, model);
-            return model;
-        }
-        catch (e) {
-            this.log.error('Error loading coverage details', e);
-        }
-        return undefined;
-    }
-};
-CodeCoverageDecorations = CodeCoverageDecorations_1 = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, ITestCoverageService)),
-    ( __param(3, ILogService))
-], CodeCoverageDecorations));
-const countBadge = (count) => {
-    if (count === 0) {
-        return undefined;
-    }
-    return {
-        content: `${count > 99 ? '99+' : count}x`,
-        cursorStops: InjectedTextCursorStops.None,
-        inlineClassName: `coverage-deco-inline-count`,
-        inlineClassNameAffectsLetterSpacing: true,
-    };
-};
-class CoverageDetailsModel {
-    constructor(details, textModel) {
-        this.details = details;
-        this.ranges = [];
-        const detailRanges = ( details.map(detail => ({
-            range: tidyLocation(detail.location),
-            primary: true,
-            metadata: { detail, description: this.describe(detail, textModel) }
-        })));
-        for (const { range, metadata: { detail } } of detailRanges) {
-            if (detail.type === 1  && detail.branches) {
-                for (let i = 0; i < detail.branches.length; i++) {
-                    const branch = { type: 2 , branch: i, detail };
-                    detailRanges.push({
-                        range: tidyLocation(detail.branches[i].location || Range.fromPositions(range.getEndPosition())),
-                        primary: true,
-                        metadata: {
-                            detail: branch,
-                            description: this.describe(branch, textModel),
-                        },
-                    });
-                }
-            }
-        }
-        detailRanges.sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range) || a.metadata.detail.type - b.metadata.detail.type);
-        const stack = [];
-        const result = this.ranges = [];
-        const pop = () => {
-            const next = stack.pop();
-            const prev = stack[stack.length - 1];
-            if (prev) {
-                prev.range = prev.range.setStartPosition(next.range.endLineNumber, next.range.endColumn);
-            }
-            result.push(next);
-        };
-        for (const item of detailRanges) {
-            const start = item.range.getStartPosition();
-            while (stack[stack.length - 1]?.range.containsPosition(start) === false) {
-                pop();
-            }
-            if (item.range.isEmpty()) {
-                result.push(item);
-                continue;
-            }
-            const prev = stack[stack.length - 1];
-            if (prev) {
-                const primary = prev.primary;
-                const si = prev.range.setEndPosition(start.lineNumber, start.column);
-                prev.range = prev.range.setStartPosition(item.range.endLineNumber, item.range.endColumn);
-                prev.primary = false;
-                if (prev.range.isEmpty()) {
-                    stack.pop();
-                }
-                result.push({ range: si, primary, metadata: prev.metadata });
-            }
-            stack.push(item);
-        }
-        while (stack.length) {
-            pop();
-        }
-    }
-    describe(detail, model) {
-        if (detail.type === 0 ) {
-            return namedDetailLabel(detail.name, detail);
-        }
-        else if (detail.type === 1 ) {
-            const text = wrapName(model.getValueInRange(tidyLocation(detail.location)).trim() || `<empty statement>`);
-            if (detail.branches?.length) {
-                const covered = detail.branches.filter(b => !!b.count).length;
-                return ( new MarkdownString()).appendMarkdown(( localizeWithPath(
-                    'vs/workbench/contrib/testing/browser/codeCoverageDecorations',
-                    'coverage.branches',
-                    '{0} of {1} of branches in {2} were covered.',
-                    covered,
-                    detail.branches.length,
-                    text
-                )));
-            }
-            else {
-                return namedDetailLabel(text, detail);
-            }
-        }
-        else if (detail.type === 2 ) {
-            const text = wrapName(model.getValueInRange(tidyLocation(detail.detail.location)).trim() || `<empty statement>`);
-            const { count, label } = detail.detail.branches[detail.branch];
-            const label2 = label ? wrapInBackticks(label) : `#${detail.branch + 1}`;
-            if (!count) {
-                return ( new MarkdownString()).appendMarkdown(( localizeWithPath(
-                    'vs/workbench/contrib/testing/browser/codeCoverageDecorations',
-                    'coverage.branchNotCovered',
-                    'Branch {0} in {1} was not covered.',
-                    label2,
-                    text
-                )));
-            }
-            else if (count === true) {
-                return ( new MarkdownString()).appendMarkdown(( localizeWithPath(
-                    'vs/workbench/contrib/testing/browser/codeCoverageDecorations',
-                    'coverage.branchCoveredYes',
-                    'Branch {0} in {1} was executed.',
-                    label2,
-                    text
-                )));
-            }
-            else {
-                return ( new MarkdownString()).appendMarkdown(( localizeWithPath(
-                    'vs/workbench/contrib/testing/browser/codeCoverageDecorations',
-                    'coverage.branchCovered',
-                    'Branch {0} in {1} was executed {2} time(s).',
-                    label2,
-                    text,
-                    count
-                )));
-            }
-        }
-        assertNever();
-    }
-}
-function namedDetailLabel(name, detail) {
-    return ( new MarkdownString()).appendMarkdown(!detail.count
-        ? ( localizeWithPath(
-        'vs/workbench/contrib/testing/browser/codeCoverageDecorations',
-        'coverage.declExecutedNo',
-        '`{0}` was not executed.',
-        name
-    ))
-        : typeof detail.count === 'number'
-            ? ( localizeWithPath(
-        'vs/workbench/contrib/testing/browser/codeCoverageDecorations',
-        'coverage.declExecutedCount',
-        '`{0}` was executed {1} time(s).',
-        name,
-        detail.count
-    ))
-            : ( localizeWithPath(
-        'vs/workbench/contrib/testing/browser/codeCoverageDecorations',
-        'coverage.declExecutedYes',
-        '`{0}` was executed.',
-        name
-    )));
-}
-function tidyLocation(location) {
-    if (location instanceof Position) {
-        return Range.fromPositions(location, ( new Position(location.lineNumber, 0x7FFFFFFF)));
-    }
-    return location;
-}
-let LineHoverComputer = class LineHoverComputer {
-    constructor(keybindingService) {
-        this.keybindingService = keybindingService;
-        this.line = -1;
-    }
-    computeSync() {
-        const strs = [];
-        const s = ( new MarkdownString()).appendMarkdown(`[${TOGGLE_INLINE_COMMAND_TEXT}](command:${TOGGLE_INLINE_COMMAND_ID})`);
-        s.isTrusted = true;
-        const binding = this.keybindingService.lookupKeybinding(TOGGLE_INLINE_COMMAND_ID);
-        if (binding) {
-            s.appendText(` (${binding.getLabel()})`);
-        }
-        strs.push(s);
-        return strs;
-    }
-};
-LineHoverComputer = ( __decorate([
-    ( __param(0, IKeybindingService))
-], LineHoverComputer));
-function wrapInBackticks(str) {
-    return '`' + str.replace(/[\n\r`]/g, '') + '`';
-}
-function wrapName(functionNameOrCode) {
-    if (functionNameOrCode.length > 50) {
-        functionNameOrCode = functionNameOrCode.slice(0, 40) + '...';
-    }
-    return wrapInBackticks(functionNameOrCode);
-}
-let LineHoverWidget = class LineHoverWidget extends Disposable {
-    static { LineHoverWidget_1 = this; }
-    static { this.ID = 'editor.contrib.testingCoverageLineHoverWidget'; }
-    constructor(editor, instantiationService) {
-        super();
-        this.editor = editor;
-        this.hover = this._register(( new HoverWidget()));
-        this.renderDisposables = this._register(( new DisposableStore()));
-        this.computer = instantiationService.createInstance(LineHoverComputer);
-        this.markdownRenderer = this._register(instantiationService.createInstance(MarkdownRenderer, { editor: this.editor }));
-        this.hoverOperation = this._register(( new HoverOperation(this.editor, this.computer)));
-        this.hover.containerDomNode.classList.add('hidden');
-        this.hoverOperation.onResult(result => {
-            if (result.value.length) {
-                this.render(result.value);
-            }
-            else {
-                this.hide();
-            }
-        });
-        this.editor.addOverlayWidget(this);
-    }
-    getId() {
-        return LineHoverWidget_1.ID;
-    }
-    getDomNode() {
-        return this.hover.containerDomNode;
-    }
-    getPosition() {
-        return null;
-    }
-    dispose() {
-        this.editor.removeOverlayWidget(this);
-        super.dispose();
-    }
-    startShowingAt(lineNumber) {
-        this.hide();
-        const textModel = this.editor.getModel();
-        if (!textModel) {
-            return;
-        }
-        this.computer.line = lineNumber;
-        this.hoverOperation.start(0 );
-    }
-    hide() {
-        this.hoverOperation.cancel();
-        this.hover.containerDomNode.classList.add('hidden');
-    }
-    render(elements) {
-        const { hover: h, editor: editor } = this;
-        const fragment = document.createDocumentFragment();
-        for (const msg of elements) {
-            const markdownHoverElement = $('div.hover-row.markdown-hover');
-            const hoverContentsElement = append(markdownHoverElement, $('div.hover-contents'));
-            const renderedContents = this.renderDisposables.add(this.markdownRenderer.render(msg));
-            hoverContentsElement.appendChild(renderedContents.element);
-            fragment.appendChild(markdownHoverElement);
-        }
-        clearNode(h.contentsDomNode);
-        h.contentsDomNode.appendChild(fragment);
-        h.containerDomNode.classList.remove('hidden');
-        const editorLayout = editor.getLayoutInfo();
-        const topForLineNumber = editor.getTopForLineNumber(this.computer.line);
-        const editorScrollTop = editor.getScrollTop();
-        const lineHeight = editor.getOption(67 );
-        const nodeHeight = h.containerDomNode.clientHeight;
-        const top = topForLineNumber - editorScrollTop - ((nodeHeight - lineHeight) / 2);
-        const left = editorLayout.lineNumbersLeft + editorLayout.lineNumbersWidth;
-        h.containerDomNode.style.left = `${left}px`;
-        h.containerDomNode.style.top = `${Math.max(Math.round(top), 0)}px`;
-    }
-};
-LineHoverWidget = LineHoverWidget_1 = ( __decorate([
-    ( __param(1, IInstantiationService))
-], LineHoverWidget));
-registerAction2(class ToggleInlineCoverage extends Action2 {
-    constructor() {
-        super({
-            id: TOGGLE_INLINE_COMMAND_ID,
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/testing/browser/codeCoverageDecorations',
-                'coverage.toggleInline',
-                "Toggle Inline Coverage"
-            )),
-            category: Categories.Test,
-            keybinding: {
-                weight: 200 ,
-                primary: KeyChord(2048  | 85 , 2048  | 1024  | 39 ),
-            },
-            precondition: TestingContextKeys.isTestCoverageOpen,
-        });
-    }
-    run() {
-        CodeCoverageDecorations.showInline.set(!CodeCoverageDecorations.showInline.get(), undefined);
-    }
-});
-export { CodeCoverageDecorations, CoverageDetailsModel };

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

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

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

@@ -1,81 +0,0 @@
-import { ObjectTreeElementCollapseState } from '../../../../../base/browser/ui/tree/tree.js';
-import { Emitter } from '../../../../../base/common/event.js';
-import { Iterable } from '../../../../../base/common/iterator.js';
-import { isCollapsedInSerializedTestTree } from './testingViewState.js';
-import { InternalTestItem } from '../../common/testTypes.js';
-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) {
-        const expandComponent = element instanceof TestTreeErrorMessage
-            ? 'error'
-            : element.test.expand === 0
-                ? !!element.children.size
-                : element.test.expand;
-        return element.treeId + '\0' + expandComponent;
-    }
-};
-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: element.test.item.error
-                ? ObjectTreeElementCollapseState.PreserveOrExpanded
-                : (isCollapsedInSerializedTestTree(serialized, element.test.item.extId) ?? element.depth > 0
-                    ? ObjectTreeElementCollapseState.PreserveOrCollapsed
-                    : ObjectTreeElementCollapseState.PreserveOrExpanded),
-            children: getChildrenForParent(serialized, rootsWithChildren, element),
-        })));
-};
-export { TestItemTreeElement, TestTreeErrorMessage, getChildrenForParent, testIdentityProvider };