@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

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

@@ -0,0 +1,477 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { extname, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ToggleCaseSensitiveKeybinding, ToggleWholeWordKeybinding, ToggleRegexKeybinding } from 'monaco-editor/esm/vs/editor/contrib/find/browser/findModel.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IContextKeyService, ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { EditorPaneDescriptor } from '../../../browser/editor.js';
+import { Extensions } from '../../../common/contributions.js';
+import { EditorExtensions, DEFAULT_EDITOR_ASSOCIATION } from '../../../common/editor.js';
+import { ActiveEditorContext } from '../../../common/contextkeys.js';
+import { IViewsService } from '../../../common/views.js';
+import { getSearchView } from '../../search/browser/searchActionsBase.js';
+import { searchRefreshIcon, searchNewEditorIcon } from '../../search/browser/searchIcons.js';
+import { HasSearchResults, SearchViewFocusedKey, SearchInputBoxFocusedKey } from '../../search/common/constants.js';
+import { InSearchEditor, OpenNewEditorCommandId, OpenEditorCommandId, SearchEditorID, ToggleSearchEditorContextLinesCommandId, SearchEditorScheme } from './constants.js';
+import { SearchEditor } from './searchEditor.js';
+import { openNewSearchEditor, createEditorFromSearchResult, toggleSearchEditorCaseSensitiveCommand, toggleSearchEditorWholeWordCommand, toggleSearchEditorRegexCommand, toggleSearchEditorContextLinesCommand, modifySearchEditorContextLinesCommand, selectAllSearchEditorMatchesCommand, openSearchEditor } from './searchEditorActions.js';
+import { SearchEditorInput, SEARCH_EDITOR_EXT, getOrMakeSearchEditorInput } from './searchEditorInput.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { VIEW_ID } from '../../../services/search/common/search.js';
+import { RegisteredEditorPriority, IEditorResolverService } from '../../../services/editor/common/editorResolverService.js';
+import { IWorkingCopyEditorService } from '../../../services/workingCopy/common/workingCopyEditorService.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+const OpenInEditorCommandId = 'search.action.openInEditor';
+const OpenNewEditorToSideCommandId = 'search.action.openNewEditorToSide';
+const FocusQueryEditorWidgetCommandId = 'search.action.focusQueryEditorWidget';
+const FocusQueryEditorFilesToIncludeCommandId = 'search.action.focusFilesToInclude';
+const FocusQueryEditorFilesToExcludeCommandId = 'search.action.focusFilesToExclude';
+const ToggleSearchEditorCaseSensitiveCommandId = 'toggleSearchEditorCaseSensitive';
+const ToggleSearchEditorWholeWordCommandId = 'toggleSearchEditorWholeWord';
+const ToggleSearchEditorRegexCommandId = 'toggleSearchEditorRegex';
+const IncreaseSearchEditorContextLinesCommandId = 'increaseSearchEditorContextLines';
+const DecreaseSearchEditorContextLinesCommandId = 'decreaseSearchEditorContextLines';
+const RerunSearchEditorSearchCommandId = 'rerunSearchEditorSearch';
+const CleanSearchEditorStateCommandId = 'cleanSearchEditorState';
+const SelectAllSearchEditorMatchesCommandId = 'selectAllSearchEditorMatches';
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(SearchEditor, SearchEditor.ID, ( localize('searchEditor', "Search Editor"))), [
+    ( new SyncDescriptor(SearchEditorInput))
+]);
+let SearchEditorContribution = class SearchEditorContribution {
+    constructor(editorResolverService, instantiationService) {
+        editorResolverService.registerEditor('*' + SEARCH_EDITOR_EXT, {
+            id: SearchEditorInput.ID,
+            label: ( localize('promptOpenWith.searchEditor.displayName', "Search Editor")),
+            detail: DEFAULT_EDITOR_ASSOCIATION.providerDisplayName,
+            priority: RegisteredEditorPriority.default,
+        }, {
+            singlePerResource: true,
+            canSupportResource: resource => (extname(resource) === SEARCH_EDITOR_EXT)
+        }, {
+            createEditorInput: ({ resource }) => {
+                return { editor: instantiationService.invokeFunction(getOrMakeSearchEditorInput, { from: 'existingFile', fileUri: resource }) };
+            }
+        });
+    }
+};
+SearchEditorContribution = ( __decorate([
+    ( __param(0, IEditorResolverService)),
+    ( __param(1, IInstantiationService))
+], SearchEditorContribution));
+const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(SearchEditorContribution, 1 );
+CommandsRegistry.registerCommand(CleanSearchEditorStateCommandId, (accessor) => {
+    const activeEditorPane = accessor.get(IEditorService).activeEditorPane;
+    if (activeEditorPane instanceof SearchEditor) {
+        activeEditorPane.cleanState();
+    }
+});
+const category = { value: ( localize('search', "Search Editor")), original: 'Search Editor' };
+const translateLegacyConfig = (legacyConfig = {}) => {
+    const config = {};
+    const overrides = {
+        includes: 'filesToInclude',
+        excludes: 'filesToExclude',
+        wholeWord: 'matchWholeWord',
+        caseSensitive: 'isCaseSensitive',
+        regexp: 'isRegexp',
+        useIgnores: 'useExcludeSettingsAndIgnoreFiles',
+    };
+    Object.entries(legacyConfig).forEach(([key, value]) => {
+        config[overrides[key] ?? key] = value;
+    });
+    return config;
+};
+const openArgDescription = {
+    description: 'Open a new search editor. Arguments passed can include variables like ${relativeFileDirname}.',
+    args: [{
+            name: 'Open new Search Editor args',
+            schema: {
+                properties: {
+                    query: { type: 'string' },
+                    filesToInclude: { type: 'string' },
+                    filesToExclude: { type: 'string' },
+                    contextLines: { type: 'number' },
+                    matchWholeWord: { type: 'boolean' },
+                    isCaseSensitive: { type: 'boolean' },
+                    isRegexp: { type: 'boolean' },
+                    useExcludeSettingsAndIgnoreFiles: { type: 'boolean' },
+                    showIncludesExcludes: { type: 'boolean' },
+                    triggerSearch: { type: 'boolean' },
+                    focusResults: { type: 'boolean' },
+                    onlyOpenEditors: { type: 'boolean' },
+                }
+            }
+        }]
+};
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'search.searchEditor.action.deleteFileResults',
+            title: { value: ( localize('searchEditor.deleteResultBlock', "Delete File Results")), original: 'Delete File Results' },
+            keybinding: {
+                weight: 100 ,
+                primary: 2048  | 1024  | 1 ,
+            },
+            precondition: InSearchEditor,
+            category,
+            f1: true,
+        });
+    }
+    async run(accessor) {
+        const contextService = accessor.get(IContextKeyService).getContext(document.activeElement);
+        if (contextService.getValue(InSearchEditor.serialize())) {
+            accessor.get(IEditorService).activeEditorPane.deleteResultBlock();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: OpenNewEditorCommandId,
+            title: { value: ( localize('search.openNewSearchEditor', "New Search Editor")), original: 'New Search Editor' },
+            category,
+            f1: true,
+            description: openArgDescription
+        });
+    }
+    async run(accessor, args) {
+        await accessor.get(IInstantiationService).invokeFunction(openNewSearchEditor, translateLegacyConfig({ location: 'new', ...args }));
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: OpenEditorCommandId,
+            title: { value: ( localize('search.openSearchEditor', "Open Search Editor")), original: 'Open Search Editor' },
+            category,
+            f1: true,
+            description: openArgDescription
+        });
+    }
+    async run(accessor, args) {
+        await accessor.get(IInstantiationService).invokeFunction(openNewSearchEditor, translateLegacyConfig({ location: 'reuse', ...args }));
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: OpenNewEditorToSideCommandId,
+            title: { value: ( localize('search.openNewEditorToSide', "Open New Search Editor to the Side")), original: 'Open new Search Editor to the Side' },
+            category,
+            f1: true,
+            description: openArgDescription
+        });
+    }
+    async run(accessor, args) {
+        await accessor.get(IInstantiationService).invokeFunction(openNewSearchEditor, translateLegacyConfig(args), true);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: OpenInEditorCommandId,
+            title: { value: ( localize('search.openResultsInEditor', "Open Results in Editor")), original: 'Open Results in Editor' },
+            category,
+            f1: true,
+            keybinding: {
+                primary: 512  | 3 ,
+                when: ( ContextKeyExpr.and(HasSearchResults, SearchViewFocusedKey)),
+                weight: 200 ,
+                mac: {
+                    primary: 2048  | 3
+                }
+            },
+        });
+    }
+    async run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const instantiationService = accessor.get(IInstantiationService);
+        const searchView = getSearchView(viewsService);
+        if (searchView) {
+            await instantiationService.invokeFunction(createEditorFromSearchResult, searchView.searchResult, searchView.searchIncludePattern.getValue(), searchView.searchExcludePattern.getValue(), searchView.searchIncludePattern.onlySearchInOpenEditors());
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: RerunSearchEditorSearchCommandId,
+            title: { value: ( localize('search.rerunSearchInEditor', "Search Again")), original: 'Search Again' },
+            category,
+            keybinding: {
+                primary: 2048  | 1024  | 48 ,
+                when: InSearchEditor,
+                weight: 100
+            },
+            icon: searchRefreshIcon,
+            menu: [{
+                    id: MenuId.EditorTitle,
+                    group: 'navigation',
+                    when: ( ActiveEditorContext.isEqualTo(SearchEditorID))
+                },
+                {
+                    id: MenuId.CommandPalette,
+                    when: ( ActiveEditorContext.isEqualTo(SearchEditorID))
+                }]
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const input = editorService.activeEditor;
+        if (input instanceof SearchEditorInput) {
+            editorService.activeEditorPane.triggerSearch({ resetCursor: false });
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: FocusQueryEditorWidgetCommandId,
+            title: { value: ( localize('search.action.focusQueryEditorWidget', "Focus Search Editor Input")), original: 'Focus Search Editor Input' },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+            keybinding: {
+                primary: 9 ,
+                weight: 100
+            }
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const input = editorService.activeEditor;
+        if (input instanceof SearchEditorInput) {
+            editorService.activeEditorPane.focusSearchInput();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: FocusQueryEditorFilesToIncludeCommandId,
+            title: { value: ( localize(
+                'search.action.focusFilesToInclude',
+                "Focus Search Editor Files to Include"
+            )), original: 'Focus Search Editor Files to Include' },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const input = editorService.activeEditor;
+        if (input instanceof SearchEditorInput) {
+            editorService.activeEditorPane.focusFilesToIncludeInput();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: FocusQueryEditorFilesToExcludeCommandId,
+            title: { value: ( localize(
+                'search.action.focusFilesToExclude',
+                "Focus Search Editor Files to Exclude"
+            )), original: 'Focus Search Editor Files to Exclude' },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const input = editorService.activeEditor;
+        if (input instanceof SearchEditorInput) {
+            editorService.activeEditorPane.focusFilesToExcludeInput();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: ToggleSearchEditorCaseSensitiveCommandId,
+            title: { value: ( localize('searchEditor.action.toggleSearchEditorCaseSensitive', "Toggle Match Case")), original: 'Toggle Match Case' },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+            keybinding: Object.assign({
+                weight: 200 ,
+                when: SearchInputBoxFocusedKey,
+            }, ToggleCaseSensitiveKeybinding)
+        });
+    }
+    run(accessor) {
+        toggleSearchEditorCaseSensitiveCommand(accessor);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: ToggleSearchEditorWholeWordCommandId,
+            title: { value: ( localize(
+                'searchEditor.action.toggleSearchEditorWholeWord',
+                "Toggle Match Whole Word"
+            )), original: 'Toggle Match Whole Word' },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+            keybinding: Object.assign({
+                weight: 200 ,
+                when: SearchInputBoxFocusedKey,
+            }, ToggleWholeWordKeybinding)
+        });
+    }
+    run(accessor) {
+        toggleSearchEditorWholeWordCommand(accessor);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: ToggleSearchEditorRegexCommandId,
+            title: { value: ( localize(
+                'searchEditor.action.toggleSearchEditorRegex',
+                "Toggle Use Regular Expression"
+            )), original: 'Toggle Use Regular Expression"' },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+            keybinding: Object.assign({
+                weight: 200 ,
+                when: SearchInputBoxFocusedKey,
+            }, ToggleRegexKeybinding)
+        });
+    }
+    run(accessor) {
+        toggleSearchEditorRegexCommand(accessor);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: ToggleSearchEditorContextLinesCommandId,
+            title: { value: ( localize(
+                'searchEditor.action.toggleSearchEditorContextLines',
+                "Toggle Context Lines"
+            )), original: 'Toggle Context Lines"' },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+            keybinding: {
+                weight: 200 ,
+                primary: 512  | 42 ,
+                mac: { primary: 2048  | 512  | 42  }
+            }
+        });
+    }
+    run(accessor) {
+        toggleSearchEditorContextLinesCommand(accessor);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: IncreaseSearchEditorContextLinesCommandId,
+            title: { original: 'Increase Context Lines', value: ( localize(
+                'searchEditor.action.increaseSearchEditorContextLines',
+                "Increase Context Lines"
+            )) },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+            keybinding: {
+                weight: 200 ,
+                primary: 512  | 86
+            }
+        });
+    }
+    run(accessor) { modifySearchEditorContextLinesCommand(accessor, true); }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: DecreaseSearchEditorContextLinesCommandId,
+            title: { original: 'Decrease Context Lines', value: ( localize(
+                'searchEditor.action.decreaseSearchEditorContextLines',
+                "Decrease Context Lines"
+            )) },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+            keybinding: {
+                weight: 200 ,
+                primary: 512  | 88
+            }
+        });
+    }
+    run(accessor) { modifySearchEditorContextLinesCommand(accessor, false); }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: SelectAllSearchEditorMatchesCommandId,
+            title: { original: 'Select All Matches', value: ( localize('searchEditor.action.selectAllSearchEditorMatches', "Select All Matches")) },
+            category,
+            f1: true,
+            precondition: InSearchEditor,
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 1024  | 42 ,
+            }
+        });
+    }
+    run(accessor) {
+        selectAllSearchEditorMatchesCommand(accessor);
+    }
+});
+registerAction2(class OpenSearchEditorAction extends Action2 {
+    constructor() {
+        super({
+            id: 'search.action.openNewEditorFromView',
+            title: ( localize('search.openNewEditor', "Open New Search Editor")),
+            category,
+            icon: searchNewEditorIcon,
+            menu: [{
+                    id: MenuId.ViewTitle,
+                    group: 'navigation',
+                    order: 2,
+                    when: ( ContextKeyExpr.equals('view', VIEW_ID)),
+                }]
+        });
+    }
+    run(accessor, ...args) {
+        return openSearchEditor(accessor);
+    }
+});
+let SearchEditorWorkingCopyEditorHandler = class SearchEditorWorkingCopyEditorHandler extends Disposable {
+    constructor(instantiationService, workingCopyEditorService) {
+        super();
+        this.instantiationService = instantiationService;
+        this._register(workingCopyEditorService.registerHandler(this));
+    }
+    handles(workingCopy) {
+        return workingCopy.resource.scheme === SearchEditorScheme;
+    }
+    isOpen(workingCopy, editor) {
+        if (!this.handles(workingCopy)) {
+            return false;
+        }
+        return editor instanceof SearchEditorInput && isEqual(workingCopy.resource, editor.modelUri);
+    }
+    createEditor(workingCopy) {
+        const input = this.instantiationService.invokeFunction(getOrMakeSearchEditorInput, { from: 'model', modelUri: workingCopy.resource });
+        input.setDirty(true);
+        return input;
+    }
+};
+SearchEditorWorkingCopyEditorHandler = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IWorkingCopyEditorService))
+], SearchEditorWorkingCopyEditorHandler));
+workbenchContributionsRegistry.registerWorkbenchContribution(SearchEditorWorkingCopyEditorHandler, 2 );