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

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 };