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

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

@@ -1,128 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,202 +0,0 @@
-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 };