@codingame/monaco-vscode-markers-service-override 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/contrib/markers/browser/markersFileDecorations.js

@@ -0,0 +1,128 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Extensions as Extensions$1 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { MarkerSeverity, IMarkerService } from 'vscode/vscode/vs/platform/markers/common/markers';
+import { IDecorationsService } from 'vscode/vscode/vs/workbench/services/decorations/common/decorations';
+import { dispose } from 'vscode/vscode/vs/base/common/lifecycle';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
+import { listErrorForeground, listWarningForeground } from 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+
+class MarkersDecorationsProvider {
+    constructor(_markerService) {
+        this._markerService = _markerService;
+        this.label = ( localizeWithPath(
+            'vs/workbench/contrib/markers/browser/markersFileDecorations',
+            'label',
+            "Problems"
+        ));
+        this.onDidChange = _markerService.onMarkerChanged;
+    }
+    provideDecorations(resource) {
+        const markers = this._markerService.read({
+            resource,
+            severities: MarkerSeverity.Error | MarkerSeverity.Warning
+        });
+        let first;
+        for (const marker of markers) {
+            if (!first || marker.severity > first.severity) {
+                first = marker;
+            }
+        }
+        if (!first) {
+            return undefined;
+        }
+        return {
+            weight: 100 * first.severity,
+            bubble: true,
+            tooltip: markers.length === 1 ? ( localizeWithPath(
+                'vs/workbench/contrib/markers/browser/markersFileDecorations',
+                'tooltip.1',
+                "1 problem in this file"
+            )) : ( localizeWithPath(
+                'vs/workbench/contrib/markers/browser/markersFileDecorations',
+                'tooltip.N',
+                "{0} problems in this file",
+                markers.length
+            )),
+            letter: markers.length < 10 ? ( markers.length.toString()) : '9+',
+            color: first.severity === MarkerSeverity.Error ? listErrorForeground : listWarningForeground,
+        };
+    }
+}
+let MarkersFileDecorations = class MarkersFileDecorations {
+    constructor(_markerService, _decorationsService, _configurationService) {
+        this._markerService = _markerService;
+        this._decorationsService = _decorationsService;
+        this._configurationService = _configurationService;
+        this._disposables = [
+            this._configurationService.onDidChangeConfiguration(e => {
+                if (e.affectsConfiguration('problems.visibility')) {
+                    this._updateEnablement();
+                }
+            }),
+        ];
+        this._updateEnablement();
+    }
+    dispose() {
+        dispose(this._provider);
+        dispose(this._disposables);
+    }
+    _updateEnablement() {
+        const problem = this._configurationService.getValue('problems.visibility');
+        if (problem === undefined) {
+            return;
+        }
+        const value = this._configurationService.getValue('problems');
+        const shouldEnable = (problem && value.decorations.enabled);
+        if (shouldEnable === this._enabled) {
+            if (!problem || !value.decorations.enabled) {
+                this._provider?.dispose();
+                this._provider = undefined;
+            }
+            return;
+        }
+        this._enabled = shouldEnable;
+        if (this._enabled) {
+            const provider = ( new MarkersDecorationsProvider(this._markerService));
+            this._provider = this._decorationsService.registerDecorationsProvider(provider);
+        }
+        else if (this._provider) {
+            this._provider.dispose();
+        }
+    }
+};
+MarkersFileDecorations = ( __decorate([
+    ( __param(0, IMarkerService)),
+    ( __param(1, IDecorationsService)),
+    ( __param(2, IConfigurationService))
+], MarkersFileDecorations));
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    'id': 'problems',
+    'order': 101,
+    'type': 'object',
+    'properties': {
+        'problems.decorations.enabled': {
+            'markdownDescription': ( localizeWithPath(
+                'vs/workbench/contrib/markers/browser/markersFileDecorations',
+                'markers.showOnFile',
+                "Show Errors & Warnings on files and folder. Overwritten by `#problems.visibility#` when it is off."
+            )),
+            'type': 'boolean',
+            'default': true
+        }
+    }
+});
+( Registry.as(Extensions$1.Workbench))
+    .registerWorkbenchContribution(MarkersFileDecorations, 3 );

package/vscode/src/vs/workbench/contrib/markers/browser/markersFilterOptions.js

@@ -0,0 +1,77 @@
+import { matchesFuzzy2, matchesFuzzy } from 'vscode/vscode/vs/base/common/filters';
+import { getEmptyExpression, splitGlobAware, parse } from 'vscode/vscode/vs/base/common/glob';
+import { rtrim, ltrim } from 'vscode/vscode/vs/base/common/strings';
+import { relativePath } from 'vscode/vscode/vs/base/common/resources';
+import { TernarySearchTree } from 'vscode/vscode/vs/base/common/ternarySearchTree';
+
+class ResourceGlobMatcher {
+    constructor(globalExpression, rootExpressions, uriIdentityService) {
+        this.globalExpression = parse(globalExpression);
+        this.expressionsByRoot = TernarySearchTree.forUris(uri => uriIdentityService.extUri.ignorePathCasing(uri));
+        for (const expression of rootExpressions) {
+            this.expressionsByRoot.set(expression.root, { root: expression.root, expression: parse(expression.expression) });
+        }
+    }
+    matches(resource) {
+        const rootExpression = this.expressionsByRoot.findSubstr(resource);
+        if (rootExpression) {
+            const path = relativePath(rootExpression.root, resource);
+            if (path && !!rootExpression.expression(path)) {
+                return true;
+            }
+        }
+        return !!this.globalExpression(resource.path);
+    }
+}
+class FilterOptions {
+    static { this._filter = matchesFuzzy2; }
+    static { this._messageFilter = matchesFuzzy; }
+    static EMPTY(uriIdentityService) { return ( new FilterOptions('', [], false, false, false, uriIdentityService)); }
+    constructor(filter, filesExclude, showWarnings, showErrors, showInfos, uriIdentityService) {
+        this.filter = filter;
+        this.showWarnings = false;
+        this.showErrors = false;
+        this.showInfos = false;
+        filter = filter.trim();
+        this.showWarnings = showWarnings;
+        this.showErrors = showErrors;
+        this.showInfos = showInfos;
+        const filesExcludeByRoot = Array.isArray(filesExclude) ? filesExclude : [];
+        const excludesExpression = Array.isArray(filesExclude) ? getEmptyExpression() : filesExclude;
+        for (const { expression } of filesExcludeByRoot) {
+            for (const pattern of ( Object.keys(expression))) {
+                if (!pattern.endsWith('/**')) {
+                    expression[`${rtrim(pattern, '/')}/**`] = expression[pattern];
+                }
+            }
+        }
+        const negate = filter.startsWith('!');
+        this.textFilter = { text: (negate ? ltrim(filter, '!') : filter).trim(), negate };
+        const includeExpression = getEmptyExpression();
+        if (filter) {
+            const filters = ( splitGlobAware(filter, ',').map(s => s.trim())).filter(s => !!s.length);
+            for (const f of filters) {
+                if (f.startsWith('!')) {
+                    const filterText = ltrim(f, '!');
+                    if (filterText) {
+                        this.setPattern(excludesExpression, filterText);
+                    }
+                }
+                else {
+                    this.setPattern(includeExpression, f);
+                }
+            }
+        }
+        this.excludesMatcher = ( new ResourceGlobMatcher(excludesExpression, filesExcludeByRoot, uriIdentityService));
+        this.includesMatcher = ( new ResourceGlobMatcher(includeExpression, [], uriIdentityService));
+    }
+    setPattern(expression, pattern) {
+        if (pattern[0] === '.') {
+            pattern = '*' + pattern;
+        }
+        expression[`**/${pattern}/**`] = true;
+        expression[`**/${pattern}`] = true;
+    }
+}
+
+export { FilterOptions, ResourceGlobMatcher };

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

@@ -0,0 +1,202 @@
+import { basename, extUri } from 'vscode/vscode/vs/base/common/resources';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { MarkerSeverity, IMarkerData } from 'vscode/vscode/vs/platform/markers/common/markers';
+import { flatten, isNonEmptyArray } from 'vscode/vscode/vs/base/common/arrays';
+import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Hasher } from 'vscode/vscode/vs/base/common/hash';
+import { splitLines } from 'vscode/vscode/vs/base/common/strings';
+import { unsupportedSchemas } from 'vscode/vscode/vs/platform/markers/common/markerService';
+
+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 this.resourcesByUri.get(extUri.getComparisonKey(resource, true)) ?? null;
+    }
+    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 };