@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/markers/browser/markersModel.js

@@ -0,0 +1,201 @@
+import { basename, extUri } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { MarkerSeverity, IMarkerData } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import { flatten, isNonEmptyArray } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Hasher } from 'monaco-editor/esm/vs/base/common/hash.js';
+import { withUndefinedAsNull } from 'monaco-editor/esm/vs/base/common/types.js';
+import { splitLines } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { unsupportedSchemas } from 'monaco-editor/esm/vs/platform/markers/common/markerService.js';
+function compareMarkersByUri(a, b) {
+    return extUri.compare(a.resource, b.resource);
+}
+function compareResourceMarkers(a, b) {
+    const [firstMarkerOfA] = a.markers;
+    const [firstMarkerOfB] = b.markers;
+    let res = 0;
+    if (firstMarkerOfA && firstMarkerOfB) {
+        res = MarkerSeverity.compare(firstMarkerOfA.marker.severity, firstMarkerOfB.marker.severity);
+    }
+    if (res === 0) {
+        res = a.path.localeCompare(b.path) || a.name.localeCompare(b.name);
+    }
+    return res;
+}
+class ResourceMarkers {
+    constructor(id, resource) {
+        this.id = id;
+        this.resource = resource;
+        this._markersMap = ( new ResourceMap());
+        this._total = 0;
+        this.path = this.resource.fsPath;
+        this.name = basename(this.resource);
+    }
+    get markers() {
+        if (!this._cachedMarkers) {
+            this._cachedMarkers = flatten([...( this._markersMap.values())]).sort(ResourceMarkers._compareMarkers);
+        }
+        return this._cachedMarkers;
+    }
+    has(uri) {
+        return ( this._markersMap.has(uri));
+    }
+    set(uri, marker) {
+        this.delete(uri);
+        if (isNonEmptyArray(marker)) {
+            this._markersMap.set(uri, marker);
+            this._total += marker.length;
+            this._cachedMarkers = undefined;
+        }
+    }
+    delete(uri) {
+        const array = this._markersMap.get(uri);
+        if (array) {
+            this._total -= array.length;
+            this._cachedMarkers = undefined;
+            this._markersMap.delete(uri);
+        }
+    }
+    get total() {
+        return this._total;
+    }
+    static _compareMarkers(a, b) {
+        return MarkerSeverity.compare(a.marker.severity, b.marker.severity)
+            || extUri.compare(a.resource, b.resource)
+            || Range.compareRangesUsingStarts(a.marker, b.marker);
+    }
+}
+class Marker {
+    get resource() { return this.marker.resource; }
+    get range() { return this.marker; }
+    get lines() {
+        if (!this._lines) {
+            this._lines = splitLines(this.marker.message);
+        }
+        return this._lines;
+    }
+    constructor(id, marker, relatedInformation = []) {
+        this.id = id;
+        this.marker = marker;
+        this.relatedInformation = relatedInformation;
+    }
+    toString() {
+        return JSON.stringify({
+            ...this.marker,
+            resource: this.marker.resource.path,
+            relatedInformation: this.relatedInformation.length ? ( this.relatedInformation.map(r => ({ ...r.raw, resource: r.raw.resource.path }))) : undefined
+        }, null, '\t');
+    }
+}
+class MarkerTableItem extends Marker {
+    constructor(marker, sourceMatches, codeMatches, messageMatches, fileMatches, ownerMatches) {
+        super(marker.id, marker.marker, marker.relatedInformation);
+        this.sourceMatches = sourceMatches;
+        this.codeMatches = codeMatches;
+        this.messageMatches = messageMatches;
+        this.fileMatches = fileMatches;
+        this.ownerMatches = ownerMatches;
+    }
+}
+class RelatedInformation {
+    constructor(id, marker, raw) {
+        this.id = id;
+        this.marker = marker;
+        this.raw = raw;
+    }
+}
+class MarkersModel {
+    get resourceMarkers() {
+        if (!this.cachedSortedResources) {
+            this.cachedSortedResources = [...( this.resourcesByUri.values())].sort(compareResourceMarkers);
+        }
+        return this.cachedSortedResources;
+    }
+    constructor() {
+        this.cachedSortedResources = undefined;
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._total = 0;
+        this.resourcesByUri = ( new Map());
+    }
+    reset() {
+        const removed = ( new Set());
+        for (const resourceMarker of ( this.resourcesByUri.values())) {
+            removed.add(resourceMarker);
+        }
+        this.resourcesByUri.clear();
+        this._total = 0;
+        this._onDidChange.fire({ removed, added: ( new Set()), updated: ( new Set()) });
+    }
+    get total() {
+        return this._total;
+    }
+    getResourceMarkers(resource) {
+        return withUndefinedAsNull(this.resourcesByUri.get(extUri.getComparisonKey(resource, true)));
+    }
+    setResourceMarkers(resourcesMarkers) {
+        const change = { added: ( new Set()), removed: ( new Set()), updated: ( new Set()) };
+        for (const [resource, rawMarkers] of resourcesMarkers) {
+            if (( unsupportedSchemas.has(resource.scheme))) {
+                continue;
+            }
+            const key = extUri.getComparisonKey(resource, true);
+            let resourceMarkers = this.resourcesByUri.get(key);
+            if (isNonEmptyArray(rawMarkers)) {
+                if (!resourceMarkers) {
+                    const resourceMarkersId = this.id(( resource.toString()));
+                    resourceMarkers = ( new ResourceMarkers(resourceMarkersId, resource.with({ fragment: null })));
+                    this.resourcesByUri.set(key, resourceMarkers);
+                    change.added.add(resourceMarkers);
+                }
+                else {
+                    change.updated.add(resourceMarkers);
+                }
+                const markersCountByKey = ( new Map());
+                const markers = ( rawMarkers.map((rawMarker) => {
+                    const key = IMarkerData.makeKey(rawMarker);
+                    const index = markersCountByKey.get(key) || 0;
+                    markersCountByKey.set(key, index + 1);
+                    const markerId = this.id(resourceMarkers.id, key, index, ( rawMarker.resource.toString()));
+                    let relatedInformation = undefined;
+                    if (rawMarker.relatedInformation) {
+                        relatedInformation = ( rawMarker.relatedInformation.map((r, index) => ( new RelatedInformation(this.id(markerId, ( r.resource.toString()), r.startLineNumber, r.startColumn, r.endLineNumber, r.endColumn, index), rawMarker, r))));
+                    }
+                    return ( new Marker(markerId, rawMarker, relatedInformation));
+                }));
+                this._total -= resourceMarkers.total;
+                resourceMarkers.set(resource, markers);
+                this._total += resourceMarkers.total;
+            }
+            else if (resourceMarkers) {
+                this._total -= resourceMarkers.total;
+                resourceMarkers.delete(resource);
+                this._total += resourceMarkers.total;
+                if (resourceMarkers.total === 0) {
+                    this.resourcesByUri.delete(key);
+                    change.removed.add(resourceMarkers);
+                }
+                else {
+                    change.updated.add(resourceMarkers);
+                }
+            }
+        }
+        this.cachedSortedResources = undefined;
+        if (change.added.size || change.removed.size || change.updated.size) {
+            this._onDidChange.fire(change);
+        }
+    }
+    id(...values) {
+        const hasher = ( new Hasher());
+        for (const value of values) {
+            hasher.hash(value);
+        }
+        return `${hasher.value}`;
+    }
+    dispose() {
+        this._onDidChange.dispose();
+        this.resourcesByUri.clear();
+    }
+}
+export { Marker, MarkerTableItem, MarkersModel, RelatedInformation, ResourceMarkers, compareMarkersByUri };

package/dist/vscode/vs/workbench/contrib/markers/browser/markersTable.js

@@ -0,0 +1,451 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { WorkbenchTable } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { HighlightedLabel } from 'monaco-editor/esm/vs/base/browser/ui/highlightedlabel/highlightedLabel.js';
+import { compareMarkersByUri, Marker, MarkerTableItem } from './markersModel.js';
+import { MarkerSeverity } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import { SeverityIcon } from 'monaco-editor/esm/vs/platform/severityIcon/browser/severityIcon.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { FilterOptions } from './markersFilterOptions.js';
+import { Link } from 'monaco-editor/esm/vs/platform/opener/browser/link.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { QuickFixAction, QuickFixActionViewItem } from './markersViewActions.js';
+import { DomEmitter } from 'monaco-editor/esm/vs/base/browser/event.js';
+import Messages$1 from './messages.js';
+import { isUndefinedOrNull } from 'monaco-editor/esm/vs/base/common/types.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { unsupportedSchemas } from 'monaco-editor/esm/vs/platform/markers/common/markerService.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+const $ = dom.$;
+let MarkerSeverityColumnRenderer = class MarkerSeverityColumnRenderer {
+    constructor(markersViewModel, instantiationService) {
+        this.markersViewModel = markersViewModel;
+        this.instantiationService = instantiationService;
+        this.templateId = MarkerSeverityColumnRenderer.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        const severityColumn = dom.append(container, $('.severity'));
+        const icon = dom.append(severityColumn, $(''));
+        const actionBarColumn = dom.append(container, $('.actions'));
+        const actionBar = ( (new ActionBar(actionBarColumn, {
+            actionViewItemProvider: (action) => action.id === QuickFixAction.ID ? this.instantiationService.createInstance(QuickFixActionViewItem, action) : undefined,
+            animated: false
+        })));
+        return { actionBar, icon };
+    }
+    renderElement(element, index, templateData, height) {
+        const toggleQuickFix = (enabled) => {
+            if (!isUndefinedOrNull(enabled)) {
+                const container = dom.findParentWithClass(templateData.icon, 'monaco-table-td');
+                container.classList.toggle('quickFix', enabled);
+            }
+        };
+        templateData.icon.title = ( (MarkerSeverity.toString(element.marker.severity)));
+        templateData.icon.className = `marker-icon ${( ( Severity.toString(MarkerSeverity.toSeverity(element.marker.severity))))} codicon ${SeverityIcon.className(MarkerSeverity.toSeverity(element.marker.severity))}`;
+        templateData.actionBar.clear();
+        const viewModel = this.markersViewModel.getViewModel(element);
+        if (viewModel) {
+            const quickFixAction = viewModel.quickFixAction;
+            templateData.actionBar.push([quickFixAction], { icon: true, label: false });
+            toggleQuickFix(viewModel.quickFixAction.enabled);
+            quickFixAction.onDidChange(({ enabled }) => toggleQuickFix(enabled));
+            quickFixAction.onShowQuickFixes(() => {
+                const quickFixActionViewItem = templateData.actionBar.viewItems[0];
+                if (quickFixActionViewItem) {
+                    quickFixActionViewItem.showQuickFixes();
+                }
+            });
+        }
+    }
+    disposeTemplate(templateData) { }
+};
+MarkerSeverityColumnRenderer.TEMPLATE_ID = 'severity';
+MarkerSeverityColumnRenderer = ( (__decorate([
+    ( (__param(1, IInstantiationService)))
+], MarkerSeverityColumnRenderer)));
+let MarkerCodeColumnRenderer = class MarkerCodeColumnRenderer {
+    constructor(openerService) {
+        this.openerService = openerService;
+        this.templateId = MarkerCodeColumnRenderer.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        const codeColumn = dom.append(container, $('.code'));
+        const sourceLabel = ( (new HighlightedLabel(codeColumn)));
+        sourceLabel.element.classList.add('source-label');
+        const codeLabel = ( (new HighlightedLabel(codeColumn)));
+        codeLabel.element.classList.add('code-label');
+        const codeLink = ( (new Link(codeColumn, { href: '', label: '' }, {}, this.openerService)));
+        return { codeColumn, sourceLabel, codeLabel, codeLink };
+    }
+    renderElement(element, index, templateData, height) {
+        templateData.codeColumn.classList.remove('code-label');
+        templateData.codeColumn.classList.remove('code-link');
+        if (element.marker.source && element.marker.code) {
+            if (typeof element.marker.code === 'string') {
+                templateData.codeColumn.classList.add('code-label');
+                templateData.codeColumn.title = `${element.marker.source} (${element.marker.code})`;
+                templateData.sourceLabel.set(element.marker.source, element.sourceMatches);
+                templateData.codeLabel.set(element.marker.code, element.codeMatches);
+            }
+            else {
+                templateData.codeColumn.classList.add('code-link');
+                templateData.codeColumn.title = `${element.marker.source} (${element.marker.code.value})`;
+                templateData.sourceLabel.set(element.marker.source, element.sourceMatches);
+                const codeLinkLabel = ( (new HighlightedLabel($('.code-link-label'))));
+                codeLinkLabel.set(element.marker.code.value, element.codeMatches);
+                templateData.codeLink.link = {
+                    href: ( (element.marker.code.target.toString())),
+                    title: ( (element.marker.code.target.toString())),
+                    label: codeLinkLabel.element,
+                };
+            }
+        }
+        else {
+            templateData.codeColumn.title = '';
+            templateData.sourceLabel.set('-');
+        }
+    }
+    disposeTemplate(templateData) { }
+};
+MarkerCodeColumnRenderer.TEMPLATE_ID = 'code';
+MarkerCodeColumnRenderer = ( (__decorate([
+    ( (__param(0, IOpenerService)))
+], MarkerCodeColumnRenderer)));
+class MarkerMessageColumnRenderer {
+    constructor() {
+        this.templateId = MarkerMessageColumnRenderer.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        const columnElement = dom.append(container, $('.message'));
+        const highlightedLabel = ( (new HighlightedLabel(columnElement)));
+        return { columnElement, highlightedLabel };
+    }
+    renderElement(element, index, templateData, height) {
+        templateData.columnElement.title = element.marker.message;
+        templateData.highlightedLabel.set(element.marker.message, element.messageMatches);
+    }
+    disposeTemplate(templateData) { }
+}
+MarkerMessageColumnRenderer.TEMPLATE_ID = 'message';
+let MarkerFileColumnRenderer = class MarkerFileColumnRenderer {
+    constructor(labelService) {
+        this.labelService = labelService;
+        this.templateId = MarkerFileColumnRenderer.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        const columnElement = dom.append(container, $('.file'));
+        const fileLabel = ( (new HighlightedLabel(columnElement)));
+        fileLabel.element.classList.add('file-label');
+        const positionLabel = ( (new HighlightedLabel(columnElement)));
+        positionLabel.element.classList.add('file-position');
+        return { columnElement, fileLabel, positionLabel };
+    }
+    renderElement(element, index, templateData, height) {
+        const positionLabel = Messages$1.MARKERS_PANEL_AT_LINE_COL_NUMBER(element.marker.startLineNumber, element.marker.startColumn);
+        templateData.columnElement.title = `${this.labelService.getUriLabel(element.marker.resource, { relative: false })} ${positionLabel}`;
+        templateData.fileLabel.set(this.labelService.getUriLabel(element.marker.resource, { relative: true }), element.fileMatches);
+        templateData.positionLabel.set(positionLabel, undefined);
+    }
+    disposeTemplate(templateData) { }
+};
+MarkerFileColumnRenderer.TEMPLATE_ID = 'file';
+MarkerFileColumnRenderer = ( (__decorate([
+    ( (__param(0, ILabelService)))
+], MarkerFileColumnRenderer)));
+class MarkerOwnerColumnRenderer {
+    constructor() {
+        this.templateId = MarkerOwnerColumnRenderer.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        const columnElement = dom.append(container, $('.owner'));
+        const highlightedLabel = ( (new HighlightedLabel(columnElement)));
+        return { columnElement, highlightedLabel };
+    }
+    renderElement(element, index, templateData, height) {
+        templateData.columnElement.title = element.marker.owner;
+        templateData.highlightedLabel.set(element.marker.owner, element.ownerMatches);
+    }
+    disposeTemplate(templateData) { }
+}
+MarkerOwnerColumnRenderer.TEMPLATE_ID = 'owner';
+class MarkersTableVirtualDelegate {
+    constructor() {
+        this.headerRowHeight = MarkersTableVirtualDelegate.HEADER_ROW_HEIGHT;
+    }
+    getHeight(item) {
+        return MarkersTableVirtualDelegate.ROW_HEIGHT;
+    }
+}
+MarkersTableVirtualDelegate.HEADER_ROW_HEIGHT = 24;
+MarkersTableVirtualDelegate.ROW_HEIGHT = 24;
+let MarkersTable = class MarkersTable extends Disposable {
+    constructor(container, markersViewModel, resourceMarkers, filterOptions, options, instantiationService, labelService) {
+        super();
+        this.container = container;
+        this.markersViewModel = markersViewModel;
+        this.resourceMarkers = resourceMarkers;
+        this.filterOptions = filterOptions;
+        this.instantiationService = instantiationService;
+        this.labelService = labelService;
+        this._itemCount = 0;
+        this.table = this.instantiationService.createInstance(WorkbenchTable, 'Markers', this.container, ( (new MarkersTableVirtualDelegate())), [
+            {
+                label: '',
+                tooltip: '',
+                weight: 0,
+                minimumWidth: 36,
+                maximumWidth: 36,
+                templateId: MarkerSeverityColumnRenderer.TEMPLATE_ID,
+                project(row) { return row; }
+            },
+            {
+                label: ( (localize('codeColumnLabel', "Code"))),
+                tooltip: '',
+                weight: 1,
+                minimumWidth: 100,
+                maximumWidth: 300,
+                templateId: MarkerCodeColumnRenderer.TEMPLATE_ID,
+                project(row) { return row; }
+            },
+            {
+                label: ( (localize('messageColumnLabel', "Message"))),
+                tooltip: '',
+                weight: 4,
+                templateId: MarkerMessageColumnRenderer.TEMPLATE_ID,
+                project(row) { return row; }
+            },
+            {
+                label: ( (localize('fileColumnLabel', "File"))),
+                tooltip: '',
+                weight: 2,
+                templateId: MarkerFileColumnRenderer.TEMPLATE_ID,
+                project(row) { return row; }
+            },
+            {
+                label: ( (localize('sourceColumnLabel', "Source"))),
+                tooltip: '',
+                weight: 1,
+                minimumWidth: 100,
+                maximumWidth: 300,
+                templateId: MarkerOwnerColumnRenderer.TEMPLATE_ID,
+                project(row) { return row; }
+            }
+        ], [
+            this.instantiationService.createInstance(MarkerSeverityColumnRenderer, this.markersViewModel),
+            this.instantiationService.createInstance(MarkerCodeColumnRenderer),
+            this.instantiationService.createInstance(MarkerMessageColumnRenderer),
+            this.instantiationService.createInstance(MarkerFileColumnRenderer),
+            this.instantiationService.createInstance(MarkerOwnerColumnRenderer),
+        ], options);
+        const list = this.table.domNode.querySelector('.monaco-list-rows');
+        const onRowHover = ( (( (Event.chain(this._register(( (new DomEmitter(list, 'mouseover')))).event)
+            .map(
+            e => dom.findParentWithClass(e.target, 'monaco-list-row', 'monaco-list-rows')
+        )))
+            .filter(((e) => !!e))
+            .map(e => parseInt(e.getAttribute('data-index')))))
+            .event;
+        const onListLeave = ( (Event.map(
+            this._register(( (new DomEmitter(list, 'mouseleave')))).event,
+            () => -1
+        )));
+        const onRowHoverOrLeave = Event.latch(Event.any(onRowHover, onListLeave));
+        const onRowPermanentHover = Event.debounce(onRowHoverOrLeave, (_, e) => e, 500);
+        this._register(onRowPermanentHover(e => {
+            if (e !== -1 && this.table.row(e)) {
+                this.markersViewModel.onMarkerMouseHover(this.table.row(e));
+            }
+        }));
+    }
+    get contextKeyService() {
+        return this.table.contextKeyService;
+    }
+    get onContextMenu() {
+        return this.table.onContextMenu;
+    }
+    get onDidOpen() {
+        return this.table.onDidOpen;
+    }
+    get onDidChangeFocus() {
+        return this.table.onDidChangeFocus;
+    }
+    get onDidChangeSelection() {
+        return this.table.onDidChangeSelection;
+    }
+    collapseMarkers() { }
+    domFocus() {
+        this.table.domFocus();
+    }
+    filterMarkers(resourceMarkers, filterOptions) {
+        this.filterOptions = filterOptions;
+        this.reset(resourceMarkers);
+    }
+    getFocus() {
+        const focus = this.table.getFocus();
+        return focus.length > 0 ? [...( (focus.map(f => this.table.row(f))))] : [];
+    }
+    getHTMLElement() {
+        return this.table.getHTMLElement();
+    }
+    getRelativeTop(marker) {
+        return marker ? this.table.getRelativeTop(this.table.indexOf(marker)) : null;
+    }
+    getSelection() {
+        const selection = this.table.getSelection();
+        return selection.length > 0 ? [...( (selection.map(i => this.table.row(i))))] : [];
+    }
+    getVisibleItemCount() {
+        return this._itemCount;
+    }
+    isVisible() {
+        return !this.container.classList.contains('hidden');
+    }
+    layout(height, width) {
+        this.container.style.height = `${height}px`;
+        this.table.layout(height, width);
+    }
+    reset(resourceMarkers) {
+        this.resourceMarkers = resourceMarkers;
+        const items = [];
+        for (const resourceMarker of this.resourceMarkers) {
+            for (const marker of resourceMarker.markers) {
+                if (( (unsupportedSchemas.has(marker.resource.scheme)))) {
+                    continue;
+                }
+                if (this.filterOptions.excludesMatcher.matches(marker.resource)) {
+                    continue;
+                }
+                if (this.filterOptions.includesMatcher.matches(marker.resource)) {
+                    items.push(( (new MarkerTableItem(marker))));
+                    continue;
+                }
+                const matchesSeverity = this.filterOptions.showErrors && MarkerSeverity.Error === marker.marker.severity ||
+                    this.filterOptions.showWarnings && MarkerSeverity.Warning === marker.marker.severity ||
+                    this.filterOptions.showInfos && MarkerSeverity.Info === marker.marker.severity;
+                if (!matchesSeverity) {
+                    continue;
+                }
+                if (this.filterOptions.textFilter.text) {
+                    const sourceMatches = marker.marker.source ? FilterOptions._filter(this.filterOptions.textFilter.text, marker.marker.source) ?? undefined : undefined;
+                    const codeMatches = marker.marker.code ? FilterOptions._filter(this.filterOptions.textFilter.text, typeof marker.marker.code === 'string' ? marker.marker.code : marker.marker.code.value) ?? undefined : undefined;
+                    const messageMatches = FilterOptions._messageFilter(this.filterOptions.textFilter.text, marker.marker.message) ?? undefined;
+                    const fileMatches = FilterOptions._messageFilter(this.filterOptions.textFilter.text, this.labelService.getUriLabel(marker.resource, { relative: true })) ?? undefined;
+                    const ownerMatches = FilterOptions._messageFilter(this.filterOptions.textFilter.text, marker.marker.owner) ?? undefined;
+                    const matched = sourceMatches || codeMatches || messageMatches || fileMatches || ownerMatches;
+                    if ((matched && !this.filterOptions.textFilter.negate) || (!matched && this.filterOptions.textFilter.negate)) {
+                        items.push(( (new MarkerTableItem(
+                            marker,
+                            sourceMatches,
+                            codeMatches,
+                            messageMatches,
+                            fileMatches,
+                            ownerMatches
+                        ))));
+                    }
+                    continue;
+                }
+                items.push(( (new MarkerTableItem(marker))));
+            }
+        }
+        this._itemCount = items.length;
+        this.table.splice(0, Number.POSITIVE_INFINITY, items.sort((a, b) => {
+            let result = MarkerSeverity.compare(a.marker.severity, b.marker.severity);
+            if (result === 0) {
+                result = compareMarkersByUri(a.marker, b.marker);
+            }
+            if (result === 0) {
+                result = Range.compareRangesUsingStarts(a.marker, b.marker);
+            }
+            return result;
+        }));
+    }
+    revealMarkers(activeResource, focus, lastSelectedRelativeTop) {
+        if (activeResource) {
+            const activeResourceIndex = this.resourceMarkers.indexOf(activeResource);
+            if (activeResourceIndex !== -1) {
+                if (this.hasSelectedMarkerFor(activeResource)) {
+                    const tableSelection = this.table.getSelection();
+                    this.table.reveal(tableSelection[0], lastSelectedRelativeTop);
+                    if (focus) {
+                        this.table.setFocus(tableSelection);
+                    }
+                }
+                else {
+                    this.table.reveal(activeResourceIndex, 0);
+                    if (focus) {
+                        this.table.setFocus([activeResourceIndex]);
+                        this.table.setSelection([activeResourceIndex]);
+                    }
+                }
+            }
+        }
+        else if (focus) {
+            this.table.setSelection([]);
+            this.table.focusFirst();
+        }
+    }
+    setAriaLabel(label) {
+        this.table.domNode.ariaLabel = label;
+    }
+    setMarkerSelection(selection, focus) {
+        if (this.isVisible()) {
+            if (selection && selection.length > 0) {
+                this.table.setSelection(( (selection.map(m => this.findMarkerIndex(m)))));
+                if (focus && focus.length > 0) {
+                    this.table.setFocus(( (focus.map(f => this.findMarkerIndex(f)))));
+                }
+                else {
+                    this.table.setFocus([this.findMarkerIndex(selection[0])]);
+                }
+                this.table.reveal(this.findMarkerIndex(selection[0]));
+            }
+            else if (this.getSelection().length === 0 && this.getVisibleItemCount() > 0) {
+                this.table.setSelection([0]);
+                this.table.setFocus([0]);
+                this.table.reveal(0);
+            }
+        }
+    }
+    toggleVisibility(hide) {
+        this.container.classList.toggle('hidden', hide);
+    }
+    update(resourceMarkers) {
+        for (const resourceMarker of resourceMarkers) {
+            const index = this.resourceMarkers.indexOf(resourceMarker);
+            this.resourceMarkers.splice(index, 1, resourceMarker);
+        }
+        this.reset(this.resourceMarkers);
+    }
+    updateMarker(marker) {
+        this.table.rerender();
+    }
+    findMarkerIndex(marker) {
+        for (let index = 0; index < this.table.length; index++) {
+            if (this.table.row(index).marker === marker.marker) {
+                return index;
+            }
+        }
+        return -1;
+    }
+    hasSelectedMarkerFor(resource) {
+        const selectedElement = this.getSelection();
+        if (selectedElement && selectedElement.length > 0) {
+            if (selectedElement[0] instanceof Marker) {
+                if (( (resource.has(selectedElement[0].marker.resource)))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+};
+MarkersTable = ( (__decorate([
+    ( (__param(5, IInstantiationService))),
+    ( (__param(6, ILabelService)))
+], MarkersTable)));
+export { MarkersTable };