@codingame/monaco-vscode-testing-service-override 1.83.16

package/vscode/src/vs/workbench/contrib/testing/browser/testingExplorerFilter.js

@@ -0,0 +1,237 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { BaseActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionViewItems.js';
+import { DropdownMenuActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/dropdown/dropdownActionViewItem.js';
+import { Action, Separator } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { Delayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { ContextScopedSuggestEnabledInputWithHistory } from 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/suggestEnabledInput/suggestEnabledInput';
+import { testingFilterIcon } from './icons.js';
+import { StoredValue } from 'vscode/vscode/vs/workbench/contrib/testing/common/storedValue';
+import { ITestExplorerFilterState } from 'vscode/vscode/vs/workbench/contrib/testing/common/testExplorerFilterState';
+import { ITestService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testService';
+import { denamespaceTestTag } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
+
+const testFilterDescriptions = {
+    ["@failed" ]: ( localizeWithPath(
+        'vs/workbench/contrib/testing/browser/testingExplorerFilter',
+        'testing.filters.showOnlyFailed',
+        "Show Only Failed Tests"
+    )),
+    ["@executed" ]: ( localizeWithPath(
+        'vs/workbench/contrib/testing/browser/testingExplorerFilter',
+        'testing.filters.showOnlyExecuted',
+        "Show Only Executed Tests"
+    )),
+    ["@doc" ]: ( localizeWithPath(
+        'vs/workbench/contrib/testing/browser/testingExplorerFilter',
+        'testing.filters.currentFile',
+        "Show in Active File Only"
+    )),
+    ["@hidden" ]: ( localizeWithPath(
+        'vs/workbench/contrib/testing/browser/testingExplorerFilter',
+        'testing.filters.showExcludedTests',
+        "Show Hidden Tests"
+    )),
+};
+let TestingExplorerFilter = class TestingExplorerFilter extends BaseActionViewItem {
+    constructor(action, state, instantiationService, testService) {
+        super(null, action);
+        this.state = state;
+        this.instantiationService = instantiationService;
+        this.testService = testService;
+        this.focusEmitter = this._register(( new Emitter()));
+        this.onDidFocus = this.focusEmitter.event;
+        this.history = this._register(this.instantiationService.createInstance(StoredValue, {
+            key: 'testing.filterHistory2',
+            scope: 1 ,
+            target: 1
+        }));
+        this.filtersAction = ( new Action('markersFiltersAction', ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testingExplorerFilter',
+            'testing.filters.menu',
+            "More Filters..."
+        )), 'testing-filter-button ' + ThemeIcon.asClassName(testingFilterIcon)));
+        this.updateFilterActiveState();
+        this._register(testService.excluded.onTestExclusionsChanged(this.updateFilterActiveState, this));
+    }
+    render(container) {
+        container.classList.add('testing-filter-action-item');
+        const updateDelayer = this._register(( new Delayer(400)));
+        const wrapper = this.wrapper = dom.$('.testing-filter-wrapper');
+        container.appendChild(wrapper);
+        let history = this.history.get({ lastValue: '', values: [] });
+        if (history instanceof Array) {
+            history = { lastValue: '', values: history };
+        }
+        if (history.lastValue) {
+            this.state.setText(history.lastValue);
+        }
+        const input = this.input = this._register(this.instantiationService.createInstance(ContextScopedSuggestEnabledInputWithHistory, {
+            id: 'testing.explorer.filter',
+            ariaLabel: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingExplorerFilter',
+                'testExplorerFilterLabel',
+                "Filter text for tests in the explorer"
+            )),
+            parent: wrapper,
+            suggestionProvider: {
+                triggerCharacters: ['@'],
+                provideResults: () => [
+                    ...( Object.entries(testFilterDescriptions).map(([label, detail]) => ({ label, detail }))),
+                    ...( Iterable.map(( this.testService.collection.tags.values()), tag => {
+                        const { ctrlId, tagId } = denamespaceTestTag(tag.id);
+                        const insertText = `@${ctrlId}:${tagId}`;
+                        return ({
+                            label: `@${ctrlId}:${tagId}`,
+                            detail: this.testService.collection.getNodeById(ctrlId)?.item.label,
+                            insertText: tagId.includes(' ') ? `@${ctrlId}:"${tagId.replace(/(["\\])/g, '\\$1')}"` : insertText
+                        });
+                    })),
+                ].filter(r => !this.state.text.value.includes(r.label)),
+            },
+            resourceHandle: 'testing:filter',
+            suggestOptions: {
+                value: this.state.text.value,
+                placeholderText: ( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/testingExplorerFilter',
+                    'testExplorerFilter',
+                    "Filter (e.g. text, !exclude, @tag)"
+                )),
+            },
+            history: history.values
+        }));
+        this._register(this.state.text.onDidChange(newValue => {
+            if (input.getValue() !== newValue) {
+                input.setValue(newValue);
+            }
+        }));
+        this._register(this.state.onDidRequestInputFocus(() => {
+            input.focus();
+        }));
+        this._register(input.onDidFocus(() => {
+            this.focusEmitter.fire();
+        }));
+        this._register(input.onInputDidChange(() => updateDelayer.trigger(() => {
+            input.addToHistory();
+            this.state.setText(input.getValue());
+        })));
+        const actionbar = this._register(( new ActionBar(container, {
+            actionViewItemProvider: action => {
+                if (action.id === this.filtersAction.id) {
+                    return this.instantiationService.createInstance(FiltersDropdownMenuActionViewItem, action, this.state, this.actionRunner);
+                }
+                return undefined;
+            },
+        })));
+        actionbar.push(this.filtersAction, { icon: true, label: false });
+        this.layout(this.wrapper.clientWidth);
+    }
+    layout(width) {
+        this.input.layout(new dom.Dimension(width -  24 -  8 -  22, 20));
+    }
+    focus() {
+        this.input.focus();
+    }
+    saveState() {
+        this.history.store({ lastValue: this.input.getValue(), values: this.input.getHistory() });
+    }
+    dispose() {
+        this.saveState();
+        super.dispose();
+    }
+    updateFilterActiveState() {
+        this.filtersAction.checked = this.testService.excluded.hasAny;
+    }
+};
+TestingExplorerFilter = ( __decorate([
+    ( __param(1, ITestExplorerFilterState)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ITestService))
+], TestingExplorerFilter));
+let FiltersDropdownMenuActionViewItem = class FiltersDropdownMenuActionViewItem extends DropdownMenuActionViewItem {
+    constructor(action, filters, actionRunner, contextMenuService, testService) {
+        super(action, { getActions: () => this.getActions() }, contextMenuService, {
+            actionRunner,
+            classNames: action.class,
+            anchorAlignmentProvider: () => 1 ,
+            menuAsChild: true
+        });
+        this.filters = filters;
+        this.testService = testService;
+    }
+    render(container) {
+        super.render(container);
+        this.updateChecked();
+    }
+    getActions() {
+        return [
+            ...( ["@failed" , "@executed" , "@doc" ].map(term => ({
+                checked: this.filters.isFilteringFor(term),
+                class: undefined,
+                enabled: true,
+                id: term,
+                label: testFilterDescriptions[term],
+                run: () => this.filters.toggleFilteringFor(term),
+                tooltip: '',
+                dispose: () => null
+            }))),
+            ( new Separator()),
+            {
+                checked: this.filters.fuzzy.value,
+                class: undefined,
+                enabled: true,
+                id: 'fuzzy',
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/testingExplorerFilter',
+                    'testing.filters.fuzzyMatch',
+                    "Fuzzy Match"
+                )),
+                run: () => this.filters.fuzzy.value = !this.filters.fuzzy.value,
+                tooltip: ''
+            },
+            ( new Separator()),
+            {
+                checked: this.filters.isFilteringFor("@hidden" ),
+                class: undefined,
+                enabled: this.testService.excluded.hasAny,
+                id: 'showExcluded',
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/testingExplorerFilter',
+                    'testing.filters.showExcludedTests',
+                    "Show Hidden Tests"
+                )),
+                run: () => this.filters.toggleFilteringFor("@hidden" ),
+                tooltip: ''
+            },
+            {
+                checked: false,
+                class: undefined,
+                enabled: this.testService.excluded.hasAny,
+                id: 'removeExcluded',
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/testingExplorerFilter',
+                    'testing.filters.removeTestExclusions',
+                    "Unhide All Tests"
+                )),
+                run: async () => this.testService.excluded.clear(),
+                tooltip: ''
+            }
+        ];
+    }
+    updateChecked() {
+        this.element.classList.toggle('checked', this._action.checked);
+    }
+};
+FiltersDropdownMenuActionViewItem = ( __decorate([
+    ( __param(3, IContextMenuService)),
+    ( __param(4, ITestService))
+], FiltersDropdownMenuActionViewItem));
+
+export { TestingExplorerFilter };