@codingame/monaco-vscode-testing-service-override 3.2.3 → 4.1.0

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

@@ -1,545 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { append, $ } from 'vscode/vscode/vs/base/browser/dom';
-import { assertNever } from 'vscode/vscode/vs/base/common/assert';
-import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
-import { memoize } from 'vscode/vscode/vs/base/common/decorators';
-import { createMatches } from 'vscode/vscode/vs/base/common/filters';
-import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
-import { DisposableStore, MutableDisposable, Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { basenameOrAuthority } from 'vscode/vscode/vs/base/common/resources';
-import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
-import { Position } from 'vscode/vscode/vs/editor/common/core/position';
-import { Range } from 'vscode/vscode/vs/editor/common/core/range';
-import { localize2WithPath, localizeWithPath } from 'vscode/vscode/vs/nls';
-import { registerAction2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
-import { EditorOpenSource } from 'vscode/vscode/vs/platform/editor/common/editor';
-import { FileKind } from 'vscode/vscode/vs/platform/files/common/files';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
-import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
-import { WorkbenchCompressibleObjectTree } from 'vscode/vscode/vs/platform/list/browser/listService';
-import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
-import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { ResourceLabels } from 'vscode/vscode/vs/workbench/browser/labels';
-import { ViewAction, ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
-import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
-import { testingWasCovered, testingStatesToIcons } from './icons.js';
-import { ManagedTestCoverageBars } from './testCoverageBars.js';
-import { FileCoverage, getTotalCoveragePercent } from 'vscode/vscode/vs/workbench/contrib/testing/common/testCoverage';
-import { ITestCoverageService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testCoverageService';
-import { SIDE_GROUP, ACTIVE_GROUP, IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { observableValue } from 'vscode/vscode/vs/base/common/observableInternal/base';
-import { autorun } from 'vscode/vscode/vs/base/common/observableInternal/autorun';
-
-var FileCoverageRenderer_1, DeclarationCoverageRenderer_1;
-let TestCoverageView = class TestCoverageView extends ViewPane {
-    constructor(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, coverageService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
-        this.coverageService = coverageService;
-        this.tree = ( new MutableDisposable());
-        this.sortOrder = observableValue('sortOrder', 1 );
-    }
-    renderBody(container) {
-        super.renderBody(container);
-        const labels = this._register(this.instantiationService.createInstance(ResourceLabels, { onDidChangeVisibility: this.onDidChangeBodyVisibility }));
-        this._register(autorun(reader => {
-            const coverage = this.coverageService.selected.read(reader);
-            if (coverage) {
-                const t = (this.tree.value ??= this.instantiationService.createInstance(TestCoverageTree, container, labels, this.sortOrder));
-                t.setInput(coverage);
-            }
-            else {
-                this.tree.clear();
-            }
-        }));
-    }
-    layoutBody(height, width) {
-        super.layoutBody(height, width);
-        this.tree.value?.layout(height, width);
-    }
-};
-TestCoverageView = ( __decorate([
-    ( __param(1, IKeybindingService)),
-    ( __param(2, IContextMenuService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IContextKeyService)),
-    ( __param(5, IViewDescriptorService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, IOpenerService)),
-    ( __param(8, IThemeService)),
-    ( __param(9, ITelemetryService)),
-    ( __param(10, ITestCoverageService))
-], TestCoverageView));
-let fnNodeId = 0;
-class DeclarationCoverageNode {
-    get hits() {
-        return this.data.count;
-    }
-    get label() {
-        return this.data.name;
-    }
-    get location() {
-        return this.data.location;
-    }
-    get tpc() {
-        const attr = this.attributableCoverage();
-        return attr && getTotalCoveragePercent(attr.statement, attr.branch, undefined);
-    }
-    constructor(uri, data, details) {
-        this.uri = uri;
-        this.data = data;
-        this.id = String(fnNodeId++);
-        this.containedDetails = ( new Set());
-        this.children = [];
-        if (data.location instanceof Range) {
-            for (const detail of details) {
-                if (this.contains(detail.location)) {
-                    this.containedDetails.add(detail);
-                }
-            }
-        }
-    }
-    contains(location) {
-        const own = this.data.location;
-        return own instanceof Range && (location instanceof Range ? own.containsRange(location) : own.containsPosition(location));
-    }
-    attributableCoverage() {
-        const { location, count } = this.data;
-        if (!(location instanceof Range) || !count) {
-            return;
-        }
-        const statement = { covered: 0, total: 0 };
-        const branch = { covered: 0, total: 0 };
-        for (const detail of this.containedDetails) {
-            if (detail.type !== 1 ) {
-                continue;
-            }
-            statement.covered += detail.count ? 1 : 0;
-            statement.total++;
-            if (detail.branches) {
-                for (const { count } of detail.branches) {
-                    branch.covered += count ? 1 : 0;
-                    branch.total++;
-                }
-            }
-        }
-        return { statement, branch };
-    }
-}
-DeclarationCoverageNode.__decorator = ( __decorate([
-    memoize
-], DeclarationCoverageNode.prototype, "attributableCoverage", null));
-class RevealUncoveredDeclarations {
-    get label() {
-        return ( localizeWithPath(
-            'vs/workbench/contrib/testing/browser/testCoverageView',
-            'functionsWithoutCoverage',
-            "{0} declarations without coverage...",
-            this.n
-        ));
-    }
-    constructor(n) {
-        this.n = n;
-        this.id = String(fnNodeId++);
-    }
-}
-class LoadingDetails {
-    constructor() {
-        this.id = String(fnNodeId++);
-        this.label = ( localizeWithPath(
-            'vs/workbench/contrib/testing/browser/testCoverageView',
-            'loadingCoverageDetails',
-            "Loading Coverage Details..."
-        ));
-    }
-}
-const isFileCoverage = (c) => typeof c === 'object' && 'value' in c;
-const isDeclarationCoverage = (c) => c instanceof DeclarationCoverageNode;
-const shouldShowDeclDetailsOnExpand = (c) => isFileCoverage(c) && c.value instanceof FileCoverage && !!c.value.declaration?.total;
-let TestCoverageTree = class TestCoverageTree extends Disposable {
-    constructor(container, labels, sortOrder, instantiationService, editorService) {
-        super();
-        this.tree = instantiationService.createInstance(WorkbenchCompressibleObjectTree, 'TestCoverageView', container, ( new TestCoverageTreeListDelegate()), [
-            instantiationService.createInstance(FileCoverageRenderer, labels),
-            instantiationService.createInstance(DeclarationCoverageRenderer),
-            instantiationService.createInstance(BasicRenderer),
-        ], {
-            expandOnlyOnTwistieClick: true,
-            sorter: ( new Sorter(sortOrder)),
-            keyboardNavigationLabelProvider: {
-                getCompressedNodeKeyboardNavigationLabel(elements) {
-                    return ( elements.map(e => this.getKeyboardNavigationLabel(e))).join('/');
-                },
-                getKeyboardNavigationLabel(e) {
-                    return isFileCoverage(e)
-                        ? basenameOrAuthority(e.value.uri)
-                        : e.label;
-                },
-            },
-            accessibilityProvider: {
-                getAriaLabel(element) {
-                    if (isFileCoverage(element)) {
-                        const name = basenameOrAuthority(element.value.uri);
-                        return ( localizeWithPath(
-                            'vs/workbench/contrib/testing/browser/testCoverageView',
-                            'testCoverageItemLabel',
-                            "{0} coverage: {0}%",
-                            name,
-                            (element.value.tpc * 100).toFixed(2)
-                        ));
-                    }
-                    else {
-                        return element.label;
-                    }
-                },
-                getWidgetAriaLabel() {
-                    return ( localizeWithPath(
-                        'vs/workbench/contrib/testing/browser/testCoverageView',
-                        'testCoverageTreeLabel',
-                        "Test Coverage Explorer"
-                    ));
-                }
-            },
-            identityProvider: ( new TestCoverageIdentityProvider()),
-        });
-        this._register(autorun(reader => {
-            sortOrder.read(reader);
-            this.tree.resort(null, true);
-        }));
-        this._register(this.tree);
-        this._register(this.tree.onDidChangeCollapseState(e => {
-            const el = e.node.element;
-            if (!e.node.collapsed && !e.node.children.length && el && shouldShowDeclDetailsOnExpand(el)) {
-                if (el.value.hasSynchronousDetails) {
-                    this.tree.setChildren(el, [{ element: ( new LoadingDetails()), incompressible: true }]);
-                }
-                el.value.details().then(details => this.updateWithDetails(el, details));
-            }
-        }));
-        this._register(this.tree.onDidOpen(e => {
-            let resource;
-            let selection;
-            if (e.element) {
-                if (isFileCoverage(e.element) && !e.element.children?.size) {
-                    resource = e.element.value.uri;
-                }
-                else if (isDeclarationCoverage(e.element)) {
-                    resource = e.element.uri;
-                    selection = e.element.location;
-                }
-            }
-            if (!resource) {
-                return;
-            }
-            editorService.openEditor({
-                resource,
-                options: {
-                    selection: selection instanceof Position ? Range.fromPositions(selection, selection) : selection,
-                    revealIfOpened: true,
-                    selectionRevealType: 3 ,
-                    preserveFocus: e.editorOptions.preserveFocus,
-                    pinned: e.editorOptions.pinned,
-                    source: EditorOpenSource.USER,
-                },
-            }, e.sideBySide ? SIDE_GROUP : ACTIVE_GROUP);
-        }));
-    }
-    setInput(coverage) {
-        const files = [];
-        for (let node of coverage.tree.nodes) {
-            while (!(node.value instanceof FileCoverage) && node.children?.size === 1) {
-                node = Iterable.first(( node.children.values()));
-            }
-            files.push(node);
-        }
-        const toChild = (file) => {
-            const isFile = !file.children?.size;
-            return {
-                element: file,
-                incompressible: isFile,
-                collapsed: isFile,
-                collapsible: !isFile || !!file.value?.declaration?.total,
-                children: file.children && ( Iterable.map(file.children?.values(), toChild))
-            };
-        };
-        this.tree.setChildren(null, ( Iterable.map(files, toChild)));
-    }
-    layout(height, width) {
-        this.tree.layout(height, width);
-    }
-    updateWithDetails(el, details) {
-        if (!this.tree.hasElement(el)) {
-            return;
-        }
-        const decl = [];
-        for (const fn of details) {
-            if (fn.type !== 0 ) {
-                continue;
-            }
-            let arr = decl;
-            while (true) {
-                const parent = arr.find(p => ( p.containedDetails.has(fn)));
-                if (parent) {
-                    arr = parent.children;
-                }
-                else {
-                    break;
-                }
-            }
-            arr.push(( new DeclarationCoverageNode(el.value.uri, fn, details)));
-        }
-        const makeChild = (fn) => ({
-            element: fn,
-            incompressible: true,
-            collapsed: true,
-            collapsible: fn.children.length > 0,
-            children: ( fn.children.map(makeChild))
-        });
-        this.tree.setChildren(el, ( decl.map(makeChild)));
-    }
-};
-TestCoverageTree = ( __decorate([
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IEditorService))
-], TestCoverageTree));
-class TestCoverageTreeListDelegate {
-    getHeight(element) {
-        return 22;
-    }
-    getTemplateId(element) {
-        if (isFileCoverage(element)) {
-            return FileCoverageRenderer.ID;
-        }
-        if (isDeclarationCoverage(element)) {
-            return DeclarationCoverageRenderer.ID;
-        }
-        if (element instanceof LoadingDetails || element instanceof RevealUncoveredDeclarations) {
-            return BasicRenderer.ID;
-        }
-        assertNever();
-    }
-}
-class Sorter {
-    constructor(order) {
-        this.order = order;
-    }
-    compare(a, b) {
-        const order = this.order.get();
-        if (isFileCoverage(a) && isFileCoverage(b)) {
-            switch (order) {
-                case 1 :
-                case 2 :
-                    return ( a.value.uri.toString()).localeCompare(( b.value.uri.toString()));
-                case 0 :
-                    return b.value.tpc - a.value.tpc;
-            }
-        }
-        else if (isDeclarationCoverage(a) && isDeclarationCoverage(b)) {
-            switch (order) {
-                case 1 :
-                    return Position.compare(a.location instanceof Range ? a.location.getStartPosition() : a.location, b.location instanceof Range ? b.location.getStartPosition() : b.location);
-                case 2 :
-                    return a.label.localeCompare(b.label);
-                case 0 : {
-                    const attrA = a.tpc;
-                    const attrB = b.tpc;
-                    return (attrA !== undefined && attrB !== undefined && attrB - attrA)
-                        || (+b.hits - +a.hits)
-                        || a.label.localeCompare(b.label);
-                }
-            }
-        }
-        else {
-            return 0;
-        }
-    }
-}
-let FileCoverageRenderer = class FileCoverageRenderer {
-    static { FileCoverageRenderer_1 = this; }
-    static { this.ID = 'F'; }
-    constructor(labels, labelService, instantiationService) {
-        this.labels = labels;
-        this.labelService = labelService;
-        this.instantiationService = instantiationService;
-        this.templateId = FileCoverageRenderer_1.ID;
-    }
-    renderTemplate(container) {
-        const templateDisposables = ( new DisposableStore());
-        container.classList.add('test-coverage-list-item');
-        return {
-            container,
-            bars: templateDisposables.add(this.instantiationService.createInstance(ManagedTestCoverageBars, { compact: false, container })),
-            label: templateDisposables.add(this.labels.create(container, {
-                supportHighlights: true,
-            })),
-            templateDisposables,
-        };
-    }
-    renderElement(node, _index, templateData) {
-        this.doRender(node.element, templateData, node.filterData);
-    }
-    renderCompressedElements(node, _index, templateData) {
-        this.doRender(node.element.elements, templateData, node.filterData);
-    }
-    disposeTemplate(templateData) {
-        templateData.templateDisposables.dispose();
-    }
-    doRender(element, templateData, filterData) {
-        const stat = (element instanceof Array ? element[element.length - 1] : element);
-        const file = stat.value;
-        const name = element instanceof Array ? ( element.map(e => basenameOrAuthority(e.value.uri))) : basenameOrAuthority(file.uri);
-        templateData.bars.setCoverageInfo(file);
-        templateData.label.setResource({ resource: file.uri, name }, {
-            fileKind: stat.children?.size ? FileKind.FOLDER : FileKind.FILE,
-            matches: createMatches(filterData),
-            separator: this.labelService.getSeparator(file.uri.scheme, file.uri.authority),
-            extraClasses: ['test-coverage-list-item-label'],
-        });
-    }
-};
-FileCoverageRenderer = FileCoverageRenderer_1 = ( __decorate([
-    ( __param(1, ILabelService)),
-    ( __param(2, IInstantiationService))
-], FileCoverageRenderer));
-let DeclarationCoverageRenderer = class DeclarationCoverageRenderer {
-    static { DeclarationCoverageRenderer_1 = this; }
-    static { this.ID = 'N'; }
-    constructor(instantiationService) {
-        this.instantiationService = instantiationService;
-        this.templateId = DeclarationCoverageRenderer_1.ID;
-    }
-    renderTemplate(container) {
-        const templateDisposables = ( new DisposableStore());
-        container.classList.add('test-coverage-list-item');
-        const icon = append(container, $('.state'));
-        const label = append(container, $('.name'));
-        return {
-            container,
-            bars: templateDisposables.add(this.instantiationService.createInstance(ManagedTestCoverageBars, { compact: false, container })),
-            templateDisposables,
-            icon,
-            label,
-        };
-    }
-    renderElement(node, _index, templateData) {
-        this.doRender(node.element, templateData, node.filterData);
-    }
-    renderCompressedElements(node, _index, templateData) {
-        this.doRender(node.element.elements[node.element.elements.length - 1], templateData, node.filterData);
-    }
-    disposeTemplate(templateData) {
-        templateData.templateDisposables.dispose();
-    }
-    doRender(element, templateData, _filterData) {
-        const covered = !!element.hits;
-        const icon = covered ? testingWasCovered : testingStatesToIcons.get(0 );
-        templateData.container.classList.toggle('not-covered', !covered);
-        templateData.icon.className = `computed-state ${ThemeIcon.asClassName(icon)}`;
-        templateData.label.innerText = element.label;
-        templateData.bars.setCoverageInfo(element.attributableCoverage());
-    }
-};
-DeclarationCoverageRenderer = DeclarationCoverageRenderer_1 = ( __decorate([
-    ( __param(0, IInstantiationService))
-], DeclarationCoverageRenderer));
-class BasicRenderer {
-    constructor() {
-        this.templateId = BasicRenderer.ID;
-    }
-    static { this.ID = 'B'; }
-    renderCompressedElements(node, _index, container) {
-        this.renderInner(node.element.elements[node.element.elements.length - 1], container);
-    }
-    renderTemplate(container) {
-        return container;
-    }
-    renderElement(node, index, container) {
-        this.renderInner(node.element, container);
-    }
-    disposeTemplate() {
-    }
-    renderInner(element, container) {
-        container.innerText = element.label;
-    }
-}
-class TestCoverageIdentityProvider {
-    getId(element) {
-        return isFileCoverage(element)
-            ? ( element.value.uri.toString())
-            : element.id;
-    }
-}
-registerAction2(class TestCoverageChangeSortingAction extends ViewAction {
-    constructor() {
-        super({
-            id: "testing.coverageViewChangeSorting" ,
-            viewId: "workbench.view.testCoverage" ,
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/testing/browser/testCoverageView',
-                'testing.changeCoverageSort',
-                'Change Sort Order'
-            )),
-            icon: Codicon.sortPrecedence,
-            menu: {
-                id: MenuId.ViewTitle,
-                when: ( ContextKeyExpr.equals('view', "workbench.view.testCoverage" )),
-                group: 'navigation',
-            }
-        });
-    }
-    runInView(accessor, view) {
-        const disposables = ( new DisposableStore());
-        const quickInput = disposables.add(accessor.get(IQuickInputService).createQuickPick());
-        const items = [
-            { label: ( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testCoverageView',
-                'testing.coverageSortByLocation',
-                'Sort by Location'
-            )), value: 1 , description: ( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testCoverageView',
-                'testing.coverageSortByLocationDescription',
-                'Files are sorted alphabetically, declarations are sorted by position'
-            )) },
-            { label: ( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testCoverageView',
-                'testing.coverageSortByCoverage',
-                'Sort by Coverage'
-            )), value: 0 , description: ( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testCoverageView',
-                'testing.coverageSortByCoverageDescription',
-                'Files and declarations are sorted by total coverage'
-            )) },
-            { label: ( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testCoverageView',
-                'testing.coverageSortByName',
-                'Sort by Name'
-            )), value: 2 , description: ( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testCoverageView',
-                'testing.coverageSortByNameDescription',
-                'Files and declarations are sorted alphabetically'
-            )) },
-        ];
-        quickInput.placeholder = ( localizeWithPath(
-            'vs/workbench/contrib/testing/browser/testCoverageView',
-            'testing.coverageSortPlaceholder',
-            'Sort the Test Coverage view...'
-        ));
-        quickInput.items = items;
-        quickInput.show();
-        quickInput.onDidHide(() => quickInput.dispose());
-        quickInput.onDidAccept(() => {
-            const picked = quickInput.selectedItems[0]?.value;
-            if (picked !== undefined) {
-                view.sortOrder.set(picked, undefined);
-                quickInput.dispose();
-            }
-        });
-    }
-});
-
-export { TestCoverageView };