@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.1

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

@@ -0,0 +1,586 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Marker, ResourceMarkers, RelatedInformation } from './markersModel.js';
+import { MarkersView } from './markersView.js';
+import { registerAction2, MenuId, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Markers, MarkersContextKeys } from '../common/markers.js';
+import Messages$1 from './messages.js';
+import { Extensions as Extensions$2 } from '../../../common/contributions.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { Disposable, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IStatusbarService } from '../../../services/statusbar/browser/statusbar.js';
+import { IMarkerService } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import { IViewsService, Extensions as Extensions$1 } from '../../../common/views.js';
+import { FocusedViewContext, getVisbileViewContextKey } from '../../../common/contextkeys.js';
+import { ViewPaneContainer } from '../../../browser/parts/views/viewPaneContainer.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { ViewAction } from '../../../browser/parts/views/viewPane.js';
+import { NumberBadge, IActivityService } from '../../../services/activity/common/activity.js';
+import { viewFilterSubmenu } from '../../../browser/parts/views/viewFilter.js';
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: Markers.MARKER_OPEN_ACTION_ID,
+    weight: 200 ,
+    when: ( ContextKeyExpr.and(MarkersContextKeys.MarkerFocusContextKey)),
+    primary: 3 ,
+    mac: {
+        primary: 3 ,
+        secondary: [2048  | 18 ]
+    },
+    handler: (accessor, args) => {
+        const markersView = accessor.get(IViewsService).getActiveViewWithId(Markers.MARKERS_VIEW_ID);
+        markersView.openFileAtElement(markersView.getFocusElement(), false, false, true);
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: Markers.MARKER_OPEN_SIDE_ACTION_ID,
+    weight: 200 ,
+    when: ( ContextKeyExpr.and(MarkersContextKeys.MarkerFocusContextKey)),
+    primary: 2048  | 3 ,
+    mac: {
+        primary: 256  | 3
+    },
+    handler: (accessor, args) => {
+        const markersView = accessor.get(IViewsService).getActiveViewWithId(Markers.MARKERS_VIEW_ID);
+        markersView.openFileAtElement(markersView.getFocusElement(), false, true, true);
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: Markers.MARKER_SHOW_PANEL_ID,
+    weight: 200 ,
+    when: undefined,
+    primary: undefined,
+    handler: async (accessor, args) => {
+        await accessor.get(IViewsService).openView(Markers.MARKERS_VIEW_ID);
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: Markers.MARKER_SHOW_QUICK_FIX,
+    weight: 200 ,
+    when: MarkersContextKeys.MarkerFocusContextKey,
+    primary: 2048  | 89 ,
+    handler: (accessor, args) => {
+        const markersView = accessor.get(IViewsService).getActiveViewWithId(Markers.MARKERS_VIEW_ID);
+        const focusedElement = markersView.getFocusElement();
+        if (focusedElement instanceof Marker) {
+            markersView.showQuickFixes(focusedElement);
+        }
+    }
+});
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    'id': 'problems',
+    'order': 101,
+    'title': Messages$1.PROBLEMS_PANEL_CONFIGURATION_TITLE,
+    'type': 'object',
+    'properties': {
+        'problems.autoReveal': {
+            'description': Messages$1.PROBLEMS_PANEL_CONFIGURATION_AUTO_REVEAL,
+            'type': 'boolean',
+            'default': true
+        },
+        'problems.defaultViewMode': {
+            'description': Messages$1.PROBLEMS_PANEL_CONFIGURATION_VIEW_MODE,
+            'type': 'string',
+            'default': 'tree',
+            'enum': ['table', 'tree'],
+        },
+        'problems.showCurrentInStatus': {
+            'description': Messages$1.PROBLEMS_PANEL_CONFIGURATION_SHOW_CURRENT_STATUS,
+            'type': 'boolean',
+            'default': false
+        },
+        'problems.sortOrder': {
+            'description': Messages$1.PROBLEMS_PANEL_CONFIGURATION_COMPARE_ORDER,
+            'type': 'string',
+            'default': 'severity',
+            'enum': ['severity', 'position'],
+            'enumDescriptions': [
+                Messages$1.PROBLEMS_PANEL_CONFIGURATION_COMPARE_ORDER_SEVERITY,
+                Messages$1.PROBLEMS_PANEL_CONFIGURATION_COMPARE_ORDER_POSITION,
+            ],
+        },
+    }
+});
+const markersViewIcon = registerIcon('markers-view-icon', Codicon.warning, ( localize('markersViewIcon', 'View icon of the markers view.')));
+const VIEW_CONTAINER = ( Registry.as(Extensions$1.ViewContainersRegistry)).registerViewContainer({
+    id: Markers.MARKERS_CONTAINER_ID,
+    title: Messages$1.MARKERS_PANEL_TITLE_PROBLEMS,
+    icon: markersViewIcon,
+    hideIfEmpty: true,
+    order: 0,
+    ctorDescriptor: ( new SyncDescriptor(
+        ViewPaneContainer,
+        [Markers.MARKERS_CONTAINER_ID, { mergeViewWithContainerWhenSingleView: true }]
+    )),
+    storageId: Markers.MARKERS_VIEW_STORAGE_ID,
+}, 1 , { doNotRegisterOpenCommand: true });
+( Registry.as(Extensions$1.ViewsRegistry)).registerViews([{
+        id: Markers.MARKERS_VIEW_ID,
+        containerIcon: markersViewIcon,
+        name: Messages$1.MARKERS_PANEL_TITLE_PROBLEMS,
+        canToggleVisibility: false,
+        canMoveView: true,
+        ctorDescriptor: ( new SyncDescriptor(MarkersView)),
+        openCommandActionDescriptor: {
+            id: 'workbench.actions.view.problems',
+            mnemonicTitle: ( localize({ key: 'miMarker', comment: ['&& denotes a mnemonic'] }, "&&Problems")),
+            keybindings: { primary: 2048  | 1024  | 43  },
+            order: 0,
+        }
+    }], VIEW_CONTAINER);
+const workbenchRegistry = ( Registry.as(Extensions$2.Workbench));
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: `workbench.actions.table.${Markers.MARKERS_VIEW_ID}.viewAsTree`,
+            title: ( localize('viewAsTree', "View as Tree")),
+            menu: {
+                id: MenuId.ViewTitle,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', Markers.MARKERS_VIEW_ID)), ( MarkersContextKeys.MarkersViewModeContextKey.isEqualTo("table" )))),
+                group: 'navigation',
+                order: 3
+            },
+            icon: Codicon.listTree,
+            viewId: Markers.MARKERS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, view) {
+        view.setViewMode("tree" );
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: `workbench.actions.table.${Markers.MARKERS_VIEW_ID}.viewAsTable`,
+            title: ( localize('viewAsTable', "View as Table")),
+            menu: {
+                id: MenuId.ViewTitle,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', Markers.MARKERS_VIEW_ID)), ( MarkersContextKeys.MarkersViewModeContextKey.isEqualTo("tree" )))),
+                group: 'navigation',
+                order: 3
+            },
+            icon: Codicon.listFlat,
+            viewId: Markers.MARKERS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, view) {
+        view.setViewMode("table" );
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: `workbench.actions.${Markers.MARKERS_VIEW_ID}.toggleErrors`,
+            title: ( localize('toggle errors', "Toggle Errors")),
+            category: ( localize('problems', "Problems")),
+            toggled: {
+                condition: MarkersContextKeys.ShowErrorsFilterContextKey,
+                title: ( localize('errors', "Show Errors"))
+            },
+            menu: {
+                id: viewFilterSubmenu,
+                group: '1_filter',
+                when: ( ContextKeyExpr.equals('view', Markers.MARKERS_VIEW_ID)),
+                order: 1
+            },
+            viewId: Markers.MARKERS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, view) {
+        view.filters.showErrors = !view.filters.showErrors;
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: `workbench.actions.${Markers.MARKERS_VIEW_ID}.toggleWarnings`,
+            title: ( localize('toggle warnings', "Toggle Warnings")),
+            category: ( localize('problems', "Problems")),
+            toggled: {
+                condition: MarkersContextKeys.ShowWarningsFilterContextKey,
+                title: ( localize('warnings', "Show Warnings"))
+            },
+            menu: {
+                id: viewFilterSubmenu,
+                group: '1_filter',
+                when: ( ContextKeyExpr.equals('view', Markers.MARKERS_VIEW_ID)),
+                order: 2
+            },
+            viewId: Markers.MARKERS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, view) {
+        view.filters.showWarnings = !view.filters.showWarnings;
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: `workbench.actions.${Markers.MARKERS_VIEW_ID}.toggleInfos`,
+            title: ( localize('toggle infos', "Toggle Infos")),
+            category: ( localize('problems', "Problems")),
+            toggled: {
+                condition: MarkersContextKeys.ShowInfoFilterContextKey,
+                title: ( localize('Infos', "Show Infos"))
+            },
+            menu: {
+                id: viewFilterSubmenu,
+                group: '1_filter',
+                when: ( ContextKeyExpr.equals('view', Markers.MARKERS_VIEW_ID)),
+                order: 3
+            },
+            viewId: Markers.MARKERS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, view) {
+        view.filters.showInfos = !view.filters.showInfos;
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: `workbench.actions.${Markers.MARKERS_VIEW_ID}.toggleActiveFile`,
+            title: ( localize('toggle active file', "Toggle Active File")),
+            category: ( localize('problems', "Problems")),
+            toggled: {
+                condition: MarkersContextKeys.ShowActiveFileFilterContextKey,
+                title: ( localize('Active File', "Show Active File Only"))
+            },
+            menu: {
+                id: viewFilterSubmenu,
+                group: '2_filter',
+                when: ( ContextKeyExpr.equals('view', Markers.MARKERS_VIEW_ID)),
+                order: 1
+            },
+            viewId: Markers.MARKERS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, view) {
+        view.filters.activeFile = !view.filters.activeFile;
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: `workbench.actions.${Markers.MARKERS_VIEW_ID}.toggleExcludedFiles`,
+            title: ( localize('toggle Excluded Files', "Toggle Excluded Files")),
+            category: ( localize('problems', "Problems")),
+            toggled: {
+                condition: MarkersContextKeys.ShowExcludedFilesFilterContextKey,
+                title: ( localize('Excluded Files', "Hide Excluded Files"))
+            },
+            menu: {
+                id: viewFilterSubmenu,
+                group: '2_filter',
+                when: ( ContextKeyExpr.equals('view', Markers.MARKERS_VIEW_ID)),
+                order: 2
+            },
+            viewId: Markers.MARKERS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, view) {
+        view.filters.excludedFiles = !view.filters.excludedFiles;
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.problems.focus',
+            title: { value: Messages$1.MARKERS_PANEL_SHOW_LABEL, original: 'Focus Problems (Errors, Warnings, Infos)' },
+            category: Categories.View,
+            f1: true,
+        });
+    }
+    async run(accessor) {
+        accessor.get(IViewsService).openView(Markers.MARKERS_VIEW_ID, true);
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        const when = ( ContextKeyExpr.and(( FocusedViewContext.isEqualTo(Markers.MARKERS_VIEW_ID)), MarkersContextKeys.MarkersTreeVisibilityContextKey, ( MarkersContextKeys.RelatedInformationFocusContextKey.toNegated())));
+        super({
+            id: Markers.MARKER_COPY_ACTION_ID,
+            title: { value: ( localize('copyMarker', "Copy")), original: 'Copy' },
+            menu: {
+                id: MenuId.ProblemsPanelContext,
+                when,
+                group: 'navigation'
+            },
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 33 ,
+                when
+            },
+            viewId: Markers.MARKERS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, markersView) {
+        const clipboardService = serviceAccessor.get(IClipboardService);
+        const selection = markersView.getFocusedSelectedElements() || markersView.getAllResourceMarkers();
+        const markers = [];
+        const addMarker = (marker) => {
+            if (!markers.includes(marker)) {
+                markers.push(marker);
+            }
+        };
+        for (const selected of selection) {
+            if (selected instanceof ResourceMarkers) {
+                selected.markers.forEach(addMarker);
+            }
+            else if (selected instanceof Marker) {
+                addMarker(selected);
+            }
+        }
+        if (markers.length) {
+            await clipboardService.writeText(`[${markers}]`);
+        }
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: Markers.MARKER_COPY_MESSAGE_ACTION_ID,
+            title: { value: ( localize('copyMessage', "Copy Message")), original: 'Copy Message' },
+            menu: {
+                id: MenuId.ProblemsPanelContext,
+                when: MarkersContextKeys.MarkerFocusContextKey,
+                group: 'navigation'
+            },
+            viewId: Markers.MARKERS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, markersView) {
+        const clipboardService = serviceAccessor.get(IClipboardService);
+        const element = markersView.getFocusElement();
+        if (element instanceof Marker) {
+            await clipboardService.writeText(element.marker.message);
+        }
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: Markers.RELATED_INFORMATION_COPY_MESSAGE_ACTION_ID,
+            title: { value: ( localize('copyMessage', "Copy Message")), original: 'Copy Message' },
+            menu: {
+                id: MenuId.ProblemsPanelContext,
+                when: MarkersContextKeys.RelatedInformationFocusContextKey,
+                group: 'navigation'
+            },
+            viewId: Markers.MARKERS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, markersView) {
+        const clipboardService = serviceAccessor.get(IClipboardService);
+        const element = markersView.getFocusElement();
+        if (element instanceof RelatedInformation) {
+            await clipboardService.writeText(element.raw.message);
+        }
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: Markers.FOCUS_PROBLEMS_FROM_FILTER,
+            title: ( localize('focusProblemsList', "Focus problems view")),
+            keybinding: {
+                when: MarkersContextKeys.MarkerViewFilterFocusContextKey,
+                weight: 200 ,
+                primary: 2048  | 18
+            },
+            viewId: Markers.MARKERS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, markersView) {
+        markersView.focus();
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: Markers.MARKERS_VIEW_FOCUS_FILTER,
+            title: ( localize('focusProblemsFilter', "Focus problems filter")),
+            keybinding: {
+                when: ( FocusedViewContext.isEqualTo(Markers.MARKERS_VIEW_ID)),
+                weight: 200 ,
+                primary: 2048  | 36
+            },
+            viewId: Markers.MARKERS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, markersView) {
+        markersView.focusFilter();
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: Markers.MARKERS_VIEW_SHOW_MULTILINE_MESSAGE,
+            title: { value: ( localize('show multiline', "Show message in multiple lines")), original: 'Problems: Show message in multiple lines' },
+            category: ( localize('problems', "Problems")),
+            menu: {
+                id: MenuId.CommandPalette,
+                when: ( ContextKeyExpr.has(getVisbileViewContextKey(Markers.MARKERS_VIEW_ID)))
+            },
+            viewId: Markers.MARKERS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, markersView) {
+        markersView.setMultiline(true);
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: Markers.MARKERS_VIEW_SHOW_SINGLELINE_MESSAGE,
+            title: { value: ( localize('show singleline', "Show message in single line")), original: 'Problems: Show message in single line' },
+            category: ( localize('problems', "Problems")),
+            menu: {
+                id: MenuId.CommandPalette,
+                when: ( ContextKeyExpr.has(getVisbileViewContextKey(Markers.MARKERS_VIEW_ID)))
+            },
+            viewId: Markers.MARKERS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, markersView) {
+        markersView.setMultiline(false);
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: Markers.MARKERS_VIEW_CLEAR_FILTER_TEXT,
+            title: ( localize('clearFiltersText', "Clear filters text")),
+            category: ( localize('problems', "Problems")),
+            keybinding: {
+                when: MarkersContextKeys.MarkerViewFilterFocusContextKey,
+                weight: 200 ,
+                primary: 9
+            },
+            viewId: Markers.MARKERS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, markersView) {
+        markersView.clearFilterText();
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: `workbench.actions.treeView.${Markers.MARKERS_VIEW_ID}.collapseAll`,
+            title: ( localize('collapseAll', "Collapse All")),
+            menu: {
+                id: MenuId.ViewTitle,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', Markers.MARKERS_VIEW_ID)), ( MarkersContextKeys.MarkersViewModeContextKey.isEqualTo("tree" )))),
+                group: 'navigation',
+                order: 2,
+            },
+            icon: Codicon.collapseAll,
+            viewId: Markers.MARKERS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, view) {
+        return view.collapseAll();
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: Markers.TOGGLE_MARKERS_VIEW_ACTION_ID,
+            title: Messages$1.MARKERS_PANEL_TOGGLE_LABEL,
+        });
+    }
+    async run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        if (viewsService.isViewVisible(Markers.MARKERS_VIEW_ID)) {
+            viewsService.closeView(Markers.MARKERS_VIEW_ID);
+        }
+        else {
+            viewsService.openView(Markers.MARKERS_VIEW_ID, true);
+        }
+    }
+});
+let MarkersStatusBarContributions = class MarkersStatusBarContributions extends Disposable {
+    constructor(markerService, statusbarService) {
+        super();
+        this.markerService = markerService;
+        this.statusbarService = statusbarService;
+        this.markersStatusItem = this._register(this.statusbarService.addEntry(this.getMarkersItem(), 'status.problems', 0 , 50 ));
+        this.markerService.onMarkerChanged(() => this.markersStatusItem.update(this.getMarkersItem()));
+    }
+    getMarkersItem() {
+        const markersStatistics = this.markerService.getStatistics();
+        const tooltip = this.getMarkersTooltip(markersStatistics);
+        return {
+            name: ( localize('status.problems', "Problems")),
+            text: this.getMarkersText(markersStatistics),
+            ariaLabel: tooltip,
+            tooltip,
+            command: 'workbench.actions.view.toggleProblems'
+        };
+    }
+    getMarkersTooltip(stats) {
+        const errorTitle = (n) => ( localize('totalErrors', "Errors: {0}", n));
+        const warningTitle = (n) => ( localize('totalWarnings', "Warnings: {0}", n));
+        const infoTitle = (n) => ( localize('totalInfos', "Infos: {0}", n));
+        const titles = [];
+        if (stats.errors > 0) {
+            titles.push(errorTitle(stats.errors));
+        }
+        if (stats.warnings > 0) {
+            titles.push(warningTitle(stats.warnings));
+        }
+        if (stats.infos > 0) {
+            titles.push(infoTitle(stats.infos));
+        }
+        if (titles.length === 0) {
+            return ( localize('noProblems', "No Problems"));
+        }
+        return titles.join(', ');
+    }
+    getMarkersText(stats) {
+        const problemsText = [];
+        problemsText.push('$(error) ' + this.packNumber(stats.errors));
+        problemsText.push('$(warning) ' + this.packNumber(stats.warnings));
+        if (stats.infos > 0) {
+            problemsText.push('$(info) ' + this.packNumber(stats.infos));
+        }
+        return problemsText.join(' ');
+    }
+    packNumber(n) {
+        const manyProblems = ( localize('manyProblems', "10K+"));
+        return n > 9999 ? manyProblems : n > 999 ? ( n.toString()).charAt(0) + 'K' : ( n.toString());
+    }
+};
+MarkersStatusBarContributions = ( __decorate([
+    ( __param(0, IMarkerService)),
+    ( __param(1, IStatusbarService))
+], MarkersStatusBarContributions));
+workbenchRegistry.registerWorkbenchContribution(MarkersStatusBarContributions, 3 );
+let ActivityUpdater = class ActivityUpdater extends Disposable {
+    constructor(activityService, markerService) {
+        super();
+        this.activityService = activityService;
+        this.markerService = markerService;
+        this.activity = this._register(( new MutableDisposable()));
+        this._register(this.markerService.onMarkerChanged(() => this.updateBadge()));
+        this.updateBadge();
+    }
+    updateBadge() {
+        const { errors, warnings, infos } = this.markerService.getStatistics();
+        const total = errors + warnings + infos;
+        const message = ( localize('totalProblems', 'Total {0} Problems', total));
+        this.activity.value = this.activityService.showViewActivity(Markers.MARKERS_VIEW_ID, { badge: ( new NumberBadge(total, () => message)) });
+    }
+};
+ActivityUpdater = ( __decorate([
+    ( __param(0, IActivityService)),
+    ( __param(1, IMarkerService))
+], ActivityUpdater));
+workbenchRegistry.registerWorkbenchContribution(ActivityUpdater, 3 );

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

@@ -0,0 +1,75 @@
+import { matchesFuzzy2, matchesFuzzy } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { getEmptyExpression, splitGlobAware, parse } from 'monaco-editor/esm/vs/base/common/glob.js';
+import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
+import { relativePath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/ternarySearchTree.js';
+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 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[`${strings.rtrim(pattern, '/')}/**`] = expression[pattern];
+                }
+            }
+        }
+        const negate = filter.startsWith('!');
+        this.textFilter = { text: (negate ? strings.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 = strings.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;
+    }
+}
+FilterOptions._filter = matchesFuzzy2;
+FilterOptions._messageFilter = matchesFuzzy;
+export { FilterOptions, ResourceGlobMatcher };