@codingame/monaco-vscode-api 1.85.0-next.2 → 1.85.1

package/vscode/src/vs/workbench/contrib/remote/browser/urlFinder.js

@@ -0,0 +1,107 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class UrlFinder extends Disposable {
+    static { this.terminalCodesRegex = /(?:\u001B|\u009B)[\[\]()#;?]*(?:(?:(?:[a-zA-Z0-9]*(?:;[a-zA-Z0-9]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[0-9A-PR-TZcf-ntqry=><~]))/g; }
+    static { this.localUrlRegex = /\b\w{2,20}:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|:\d{2,5})[\w\-\.\~:\/\?\#[\]\@!\$&\(\)\*\+\,\;\=]*/gim; }
+    static { this.extractPortRegex = /(localhost|127\.0\.0\.1|0\.0\.0\.0):(\d{1,5})/; }
+    static { this.localPythonServerRegex = /HTTP\son\s(127\.0\.0\.1|0\.0\.0\.0)\sport\s(\d+)/; }
+    static { this.excludeTerminals = ['Dev Containers']; }
+    constructor(terminalService, debugService) {
+        super();
+        this._onDidMatchLocalUrl = ( new Emitter());
+        this.onDidMatchLocalUrl = this._onDidMatchLocalUrl.event;
+        this.listeners = ( new Map());
+        this.replPositions = ( new Map());
+        terminalService.instances.forEach(instance => {
+            this.registerTerminalInstance(instance);
+        });
+        this._register(terminalService.onDidCreateInstance(instance => {
+            this.registerTerminalInstance(instance);
+        }));
+        this._register(terminalService.onDidDisposeInstance(instance => {
+            this.listeners.get(instance)?.dispose();
+            this.listeners.delete(instance);
+        }));
+        this._register(debugService.onDidNewSession(session => {
+            if (!session.parentSession || (session.parentSession && session.hasSeparateRepl())) {
+                this.listeners.set(session.getId(), session.onDidChangeReplElements(() => {
+                    this.processNewReplElements(session);
+                }));
+            }
+        }));
+        this._register(debugService.onDidEndSession(session => {
+            if (( this.listeners.has(session.getId()))) {
+                this.listeners.get(session.getId())?.dispose();
+                this.listeners.delete(session.getId());
+            }
+        }));
+    }
+    registerTerminalInstance(instance) {
+        if (!UrlFinder.excludeTerminals.includes(instance.title)) {
+            this.listeners.set(instance, instance.onData(data => {
+                this.processData(data);
+            }));
+        }
+    }
+    processNewReplElements(session) {
+        const oldReplPosition = this.replPositions.get(session.getId());
+        const replElements = session.getReplElements();
+        this.replPositions.set(session.getId(), { position: replElements.length - 1, tail: replElements[replElements.length - 1] });
+        if (!oldReplPosition && replElements.length > 0) {
+            replElements.forEach(element => this.processData(( element.toString())));
+        }
+        else if (oldReplPosition && (replElements.length - 1 !== oldReplPosition.position)) {
+            for (let i = replElements.length - 1; i >= 0; i--) {
+                const element = replElements[i];
+                if (element === oldReplPosition.tail) {
+                    break;
+                }
+                else {
+                    this.processData(( element.toString()));
+                }
+            }
+        }
+    }
+    dispose() {
+        super.dispose();
+        const listeners = ( this.listeners.values());
+        for (const listener of listeners) {
+            listener.dispose();
+        }
+    }
+    processData(data) {
+        data = data.replace(UrlFinder.terminalCodesRegex, '');
+        const urlMatches = data.match(UrlFinder.localUrlRegex) || [];
+        if (urlMatches && urlMatches.length > 0) {
+            urlMatches.forEach((match) => {
+                let serverUrl;
+                try {
+                    serverUrl = ( new URL(match));
+                }
+                catch (e) {
+                }
+                if (serverUrl) {
+                    const portMatch = match.match(UrlFinder.extractPortRegex);
+                    const port = parseFloat(serverUrl.port ? serverUrl.port : (portMatch ? portMatch[2] : 'NaN'));
+                    if (!isNaN(port) && Number.isInteger(port) && port > 0 && port <= 65535) {
+                        let host = serverUrl.hostname;
+                        if (host !== '0.0.0.0' && host !== '127.0.0.1') {
+                            host = 'localhost';
+                        }
+                        if (port !== 9229 && data.startsWith('Debugger listening on')) {
+                            return;
+                        }
+                        this._onDidMatchLocalUrl.fire({ port, host });
+                    }
+                }
+            });
+        }
+        else {
+            const pythonMatch = data.match(UrlFinder.localPythonServerRegex);
+            if (pythonMatch && pythonMatch.length === 3) {
+                this._onDidMatchLocalUrl.fire({ host: pythonMatch[1], port: Number(pythonMatch[2]) });
+            }
+        }
+    }
+}
+export { UrlFinder };

package/vscode/src/vs/workbench/contrib/search/browser/searchActionsBase.js

@@ -0,0 +1,49 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { searchComparer, FileMatch, Match, FolderMatch } from './searchModel.js';
+import { VIEW_ID } from '../../../services/search/common/search.js';
+const category = { value: ( nls.localizeWithPath(
+    'vs/workbench/contrib/search/browser/searchActionsBase',
+    'search',
+    "Search"
+)), original: 'Search' };
+function isSearchViewFocused(viewsService) {
+    const searchView = getSearchView(viewsService);
+    return !!(searchView && dom.isAncestorOfActiveElement(searchView.getContainer()));
+}
+function appendKeyBindingLabel(label, inputKeyBinding) {
+    return doAppendKeyBindingLabel(label, inputKeyBinding);
+}
+function getSearchView(viewsService) {
+    return viewsService.getActiveViewWithId(VIEW_ID);
+}
+function getElementsToOperateOn(viewer, currElement, sortConfig) {
+    let elements = viewer.getSelection().filter((x) => x !== null).sort((a, b) => searchComparer(a, b, sortConfig.sortOrder));
+    if (currElement && !(elements.length > 1 && elements.includes(currElement))) {
+        elements = [currElement];
+    }
+    return elements;
+}
+function shouldRefocus(elements, focusElement) {
+    if (!focusElement) {
+        return false;
+    }
+    return !focusElement || elements.includes(focusElement) || hasDownstreamMatch(elements, focusElement);
+}
+function hasDownstreamMatch(elements, focusElement) {
+    for (const elem of elements) {
+        if ((elem instanceof FileMatch && focusElement instanceof Match && elem.matches().includes(focusElement)) ||
+            (elem instanceof FolderMatch && ((focusElement instanceof FileMatch && elem.getDownstreamFileMatch(focusElement.resource)) ||
+                (focusElement instanceof Match && elem.getDownstreamFileMatch(focusElement.parent().resource))))) {
+            return true;
+        }
+    }
+    return false;
+}
+function openSearchView(viewsService, focus) {
+    return viewsService.openView(VIEW_ID, focus).then(view => (view ?? undefined));
+}
+function doAppendKeyBindingLabel(label, keyBinding) {
+    return keyBinding ? label + ' (' + keyBinding.getLabel() + ')' : label;
+}
+export { appendKeyBindingLabel, category, getElementsToOperateOn, getSearchView, isSearchViewFocused, openSearchView, shouldRefocus };

package/vscode/src/vs/workbench/contrib/search/browser/searchActionsFind.js

@@ -0,0 +1,387 @@
+import { dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IListService } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { IViewsService } from '../../../common/views.js';
+import { RestrictSearchToFolderId, SearchViewVisibleKey, ResourceFolderFocusKey, ExcludeFolderFromSearchId, RevealInSideBarForSearchResults, FileFocusKey, HasSearchResults, FindInFilesActionId, FindInFolderId, FindInWorkspaceId } from '../common/constants.js';
+import { OpenEditorCommandId } from '../../searchEditor/browser/constants.js';
+import { FileMatch, Match } from './searchModel.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { resolveResourcesForSearchIncludes } from '../../../services/search/common/queryBuilder.js';
+import { IExplorerService, getMultiSelectedResources } from '../../files/browser/files.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { VIEWLET_ID, FilesExplorerFocusCondition, ExplorerFolderContext, ExplorerRootContext } from '../../files/common/files.js';
+import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { category, getSearchView, openSearchView, getElementsToOperateOn } from './searchActionsBase.js';
+import { IConfigurationResolverService } from '../../../services/configurationResolver/common/configurationResolver.js';
+import { IHistoryService } from '../../../services/history/common/history.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+registerAction2(class RestrictSearchToFolderAction extends Action2 {
+    constructor() {
+        super({
+            id: RestrictSearchToFolderId,
+            title: {
+                value: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchActionsFind',
+                    'restrictResultsToFolder',
+                    "Restrict Search to Folder"
+                )),
+                original: 'Restrict Search to Folder'
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: ( ContextKeyExpr.and(SearchViewVisibleKey, ResourceFolderFocusKey)),
+                primary: 1024  | 512  | 36 ,
+            },
+            menu: [
+                {
+                    id: MenuId.SearchContext,
+                    group: 'search',
+                    order: 3,
+                    when: ( ContextKeyExpr.and(ResourceFolderFocusKey))
+                }
+            ]
+        });
+    }
+    async run(accessor, folderMatch) {
+        await searchWithFolderCommand(accessor, false, true, undefined, folderMatch);
+    }
+});
+registerAction2(class ExcludeFolderFromSearchAction extends Action2 {
+    constructor() {
+        super({
+            id: ExcludeFolderFromSearchId,
+            title: {
+                value: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchActionsFind',
+                    'excludeFolderFromSearch',
+                    "Exclude Folder from Search"
+                )),
+                original: 'Exclude Folder from Search'
+            },
+            category,
+            menu: [
+                {
+                    id: MenuId.SearchContext,
+                    group: 'search',
+                    order: 4,
+                    when: ( ContextKeyExpr.and(ResourceFolderFocusKey))
+                }
+            ]
+        });
+    }
+    async run(accessor, folderMatch) {
+        await searchWithFolderCommand(accessor, false, false, undefined, folderMatch);
+    }
+});
+registerAction2(class RevealInSideBarForSearchResultsAction extends Action2 {
+    constructor() {
+        super({
+            id: RevealInSideBarForSearchResults,
+            title: {
+                value: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchActionsFind',
+                    'revealInSideBar',
+                    "Reveal in Explorer View"
+                )),
+                original: 'Reveal in Explorer View'
+            },
+            category,
+            menu: [{
+                    id: MenuId.SearchContext,
+                    when: ( ContextKeyExpr.and(FileFocusKey, HasSearchResults)),
+                    group: 'search_3',
+                    order: 1
+                }]
+        });
+    }
+    async run(accessor, args) {
+        const paneCompositeService = accessor.get(IPaneCompositePartService);
+        const explorerService = accessor.get(IExplorerService);
+        const contextService = accessor.get(IWorkspaceContextService);
+        const searchView = getSearchView(accessor.get(IViewsService));
+        if (!searchView) {
+            return;
+        }
+        let fileMatch;
+        if (!(args instanceof FileMatch)) {
+            args = searchView.getControl().getFocus()[0];
+        }
+        if (args instanceof FileMatch) {
+            fileMatch = args;
+        }
+        else {
+            return;
+        }
+        paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , false).then((viewlet) => {
+            if (!viewlet) {
+                return;
+            }
+            const explorerViewContainer = viewlet.getViewPaneContainer();
+            const uri = fileMatch.resource;
+            if (uri && contextService.isInsideWorkspace(uri)) {
+                const explorerView = explorerViewContainer.getExplorerView();
+                explorerView.setExpanded(true);
+                explorerService.select(uri, true).then(() => explorerView.focus(), onUnexpectedError);
+            }
+        });
+    }
+});
+registerAction2(class FindInFilesAction extends Action2 {
+    constructor() {
+        super({
+            id: FindInFilesActionId,
+            title: {
+                value: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchActionsFind',
+                    'findInFiles',
+                    "Find in Files"
+                )),
+                mnemonicTitle: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchActionsFind',
+                    { key: 'miFindInFiles', comment: ['&& denotes a mnemonic'] },
+                    "Find &&in Files"
+                )),
+                original: 'Find in Files'
+            },
+            metadata: {
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchActionsFind',
+                    'findInFiles.description',
+                    "Open a workspace search"
+                )),
+                args: [
+                    {
+                        name: ( nls.localizeWithPath(
+                            'vs/workbench/contrib/search/browser/searchActionsFind',
+                            'findInFiles.args',
+                            "A set of options for the search"
+                        )),
+                        schema: {
+                            type: 'object',
+                            properties: {
+                                query: { 'type': 'string' },
+                                replace: { 'type': 'string' },
+                                preserveCase: { 'type': 'boolean' },
+                                triggerSearch: { 'type': 'boolean' },
+                                filesToInclude: { 'type': 'string' },
+                                filesToExclude: { 'type': 'string' },
+                                isRegex: { 'type': 'boolean' },
+                                isCaseSensitive: { 'type': 'boolean' },
+                                matchWholeWord: { 'type': 'boolean' },
+                                useExcludeSettingsAndIgnoreFiles: { 'type': 'boolean' },
+                                onlyOpenEditors: { 'type': 'boolean' },
+                            }
+                        }
+                    },
+                ]
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 1024  | 36 ,
+            },
+            menu: [{
+                    id: MenuId.MenubarEditMenu,
+                    group: '4_find_global',
+                    order: 1,
+                }],
+            f1: true
+        });
+    }
+    async run(accessor, args = {}) {
+        findInFilesCommand(accessor, args);
+    }
+});
+registerAction2(class FindInFolderAction extends Action2 {
+    constructor() {
+        super({
+            id: FindInFolderId,
+            title: {
+                value: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchActionsFind',
+                    'findInFolder',
+                    "Find in Folder..."
+                )),
+                original: 'Find in Folder...'
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: ( ContextKeyExpr.and(FilesExplorerFocusCondition, ExplorerFolderContext)),
+                primary: 1024  | 512  | 36 ,
+            },
+            menu: [
+                {
+                    id: MenuId.ExplorerContext,
+                    group: '4_search',
+                    order: 10,
+                    when: ( ContextKeyExpr.and(ExplorerFolderContext))
+                }
+            ]
+        });
+    }
+    async run(accessor, resource) {
+        await searchWithFolderCommand(accessor, true, true, resource);
+    }
+});
+registerAction2(class FindInWorkspaceAction extends Action2 {
+    constructor() {
+        super({
+            id: FindInWorkspaceId,
+            title: {
+                value: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchActionsFind',
+                    'findInWorkspace',
+                    "Find in Workspace..."
+                )),
+                original: 'Find in Workspace...'
+            },
+            category,
+            menu: [
+                {
+                    id: MenuId.ExplorerContext,
+                    group: '4_search',
+                    order: 10,
+                    when: ( ContextKeyExpr.and(ExplorerRootContext, ( ExplorerFolderContext.toNegated())))
+                }
+            ]
+        });
+    }
+    async run(accessor) {
+        const searchConfig = accessor.get(IConfigurationService).getValue().search;
+        const mode = searchConfig.mode;
+        if (mode === 'view') {
+            const searchView = await openSearchView(accessor.get(IViewsService), true);
+            searchView?.searchInFolders();
+        }
+        else {
+            return accessor.get(ICommandService).executeCommand(OpenEditorCommandId, {
+                location: mode === 'newEditor' ? 'new' : 'reuse',
+                filesToInclude: '',
+            });
+        }
+    }
+});
+async function searchWithFolderCommand(accessor, isFromExplorer, isIncludes, resource, folderMatch) {
+    const listService = accessor.get(IListService);
+    const fileService = accessor.get(IFileService);
+    const viewsService = accessor.get(IViewsService);
+    const contextService = accessor.get(IWorkspaceContextService);
+    const commandService = accessor.get(ICommandService);
+    const searchConfig = accessor.get(IConfigurationService).getValue().search;
+    const mode = searchConfig.mode;
+    let resources;
+    if (isFromExplorer) {
+        resources = getMultiSelectedResources(resource, listService, accessor.get(IEditorService), accessor.get(IExplorerService));
+    }
+    else {
+        const searchView = getSearchView(accessor.get(IViewsService));
+        if (!searchView) {
+            return;
+        }
+        resources = getMultiSelectedSearchResources(searchView.getControl(), folderMatch, searchConfig);
+    }
+    const resolvedResources = fileService.resolveAll(( resources.map(resource => ({ resource })))).then(results => {
+        const folders = [];
+        results.forEach(result => {
+            if (result.success && result.stat) {
+                folders.push(result.stat.isDirectory ? result.stat.resource : dirname(result.stat.resource));
+            }
+        });
+        return resolveResourcesForSearchIncludes(folders, contextService);
+    });
+    if (mode === 'view') {
+        const searchView = await openSearchView(viewsService, true);
+        if (resources && resources.length && searchView) {
+            if (isIncludes) {
+                searchView.searchInFolders(await resolvedResources);
+            }
+            else {
+                searchView.searchOutsideOfFolders(await resolvedResources);
+            }
+        }
+        return undefined;
+    }
+    else {
+        if (isIncludes) {
+            return commandService.executeCommand(OpenEditorCommandId, {
+                filesToInclude: (await resolvedResources).join(', '),
+                showIncludesExcludes: true,
+                location: mode === 'newEditor' ? 'new' : 'reuse',
+            });
+        }
+        else {
+            return commandService.executeCommand(OpenEditorCommandId, {
+                filesToExclude: (await resolvedResources).join(', '),
+                showIncludesExcludes: true,
+                location: mode === 'newEditor' ? 'new' : 'reuse',
+            });
+        }
+    }
+}
+function getMultiSelectedSearchResources(viewer, currElement, sortConfig) {
+    return ( getElementsToOperateOn(viewer, currElement, sortConfig)
+        .map(
+        (renderableMatch) => ((renderableMatch instanceof Match) ? null : renderableMatch.resource)
+    ))
+        .filter((renderableMatch) => (renderableMatch !== null));
+}
+async function findInFilesCommand(accessor, _args = {}) {
+    const searchConfig = accessor.get(IConfigurationService).getValue().search;
+    const viewsService = accessor.get(IViewsService);
+    const commandService = accessor.get(ICommandService);
+    const args = {};
+    if (( Object.keys(_args)).length !== 0) {
+        const configurationResolverService = accessor.get(IConfigurationResolverService);
+        const historyService = accessor.get(IHistoryService);
+        const workspaceContextService = accessor.get(IWorkspaceContextService);
+        const activeWorkspaceRootUri = historyService.getLastActiveWorkspaceRoot();
+        const filteredActiveWorkspaceRootUri = activeWorkspaceRootUri?.scheme === Schemas.file || activeWorkspaceRootUri?.scheme === Schemas.vscodeRemote ? activeWorkspaceRootUri : undefined;
+        const lastActiveWorkspaceRoot = filteredActiveWorkspaceRootUri ? workspaceContextService.getWorkspaceFolder(filteredActiveWorkspaceRootUri) ?? undefined : undefined;
+        for (const entry of Object.entries(_args)) {
+            const name = entry[0];
+            const value = entry[1];
+            if (value !== undefined) {
+                args[name] = (typeof value === 'string') ? await configurationResolverService.resolveAsync(lastActiveWorkspaceRoot, value) : value;
+            }
+        }
+    }
+    const mode = searchConfig.mode;
+    if (mode === 'view') {
+        openSearchView(viewsService, false).then(openedView => {
+            if (openedView) {
+                const searchAndReplaceWidget = openedView.searchAndReplaceWidget;
+                searchAndReplaceWidget.toggleReplace(typeof args.replace === 'string');
+                let updatedText = false;
+                if (typeof args.query !== 'string') {
+                    updatedText = openedView.updateTextFromFindWidgetOrSelection({ allowUnselectedWord: typeof args.replace !== 'string' });
+                }
+                openedView.setSearchParameters(args);
+                openedView.searchAndReplaceWidget.focus(undefined, updatedText, updatedText);
+            }
+        });
+    }
+    else {
+        const convertArgs = (args) => ({
+            location: mode === 'newEditor' ? 'new' : 'reuse',
+            query: args.query,
+            filesToInclude: args.filesToInclude,
+            filesToExclude: args.filesToExclude,
+            matchWholeWord: args.matchWholeWord,
+            isCaseSensitive: args.isCaseSensitive,
+            isRegexp: args.isRegex,
+            useExcludeSettingsAndIgnoreFiles: args.useExcludeSettingsAndIgnoreFiles,
+            onlyOpenEditors: args.onlyOpenEditors,
+            showIncludesExcludes: !!(args.filesToExclude || args.filesToExclude || !args.useExcludeSettingsAndIgnoreFiles),
+        });
+        commandService.executeCommand(OpenEditorCommandId, convertArgs(args));
+    }
+}
+export { findInFilesCommand };

package/vscode/src/vs/workbench/contrib/search/browser/searchModel.js

@@ -24,8 +24,8 @@ import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/commo
 import { overviewRulerFindMatchForeground, minimapFindMatch } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
 import { themeColorFromId } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { FindMatchDecorationModel } from '../../../../../../../override/vs/workbench/contrib/notebook/browser/contrib/find/findMatchDecorationModel.js';
-import { NotebookEditorWidget } from '../../../../../../../override/vs/workbench/contrib/notebook/browser/notebookEditorWidget.js';
+import { FindMatchDecorationModel } from '../../notebook/browser/contrib/find/findMatchDecorationModel.js';
+import { NotebookEditorWidget } from '../../notebook/browser/notebookEditorWidget.js';
 import { INotebookEditorService } from '../../notebook/browser/services/notebookEditorService.js';
 import { NotebookCellsChangeType } from '../../notebook/common/notebookCommon.js';
 import { IReplaceService } from './replace.js';

package/vscode/src/vs/workbench/contrib/search/common/constants.js

@@ -0,0 +1,66 @@
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+const FindInFilesActionId = 'workbench.action.findInFiles';
+const FocusSearchFromResults = 'search.action.focusSearchFromResults';
+const OpenMatch = 'search.action.openResult';
+const OpenMatchToSide = 'search.action.openResultToSide';
+const RemoveActionId = 'search.action.remove';
+const CopyPathCommandId = 'search.action.copyPath';
+const CopyMatchCommandId = 'search.action.copyMatch';
+const CopyAllCommandId = 'search.action.copyAll';
+const OpenInEditorCommandId = 'search.action.openInEditor';
+const ClearSearchHistoryCommandId = 'search.action.clearHistory';
+const FocusSearchListCommandID = 'search.action.focusSearchList';
+const ReplaceActionId = 'search.action.replace';
+const ReplaceAllInFileActionId = 'search.action.replaceAllInFile';
+const ReplaceAllInFolderActionId = 'search.action.replaceAllInFolder';
+const CloseReplaceWidgetActionId = 'closeReplaceInFilesWidget';
+const ToggleCaseSensitiveCommandId = 'toggleSearchCaseSensitive';
+const ToggleWholeWordCommandId = 'toggleSearchWholeWord';
+const ToggleRegexCommandId = 'toggleSearchRegex';
+const TogglePreserveCaseId = 'toggleSearchPreserveCase';
+const AddCursorsAtSearchResults = 'addCursorsAtSearchResults';
+const RevealInSideBarForSearchResults = 'search.action.revealInSideBar';
+const ReplaceInFilesActionId = 'workbench.action.replaceInFiles';
+const ShowAllSymbolsActionId = 'workbench.action.showAllSymbols';
+const QuickTextSearchActionId = 'workbench.action.experimental.quickTextSearch';
+const CancelSearchActionId = 'search.action.cancel';
+const RefreshSearchResultsActionId = 'search.action.refreshSearchResults';
+const FocusNextSearchResultActionId = 'search.action.focusNextSearchResult';
+const FocusPreviousSearchResultActionId = 'search.action.focusPreviousSearchResult';
+const ToggleSearchOnTypeActionId = 'workbench.action.toggleSearchOnType';
+const CollapseSearchResultsActionId = 'search.action.collapseSearchResults';
+const ExpandSearchResultsActionId = 'search.action.expandSearchResults';
+const ClearSearchResultsActionId = 'search.action.clearSearchResults';
+const ViewAsTreeActionId = 'search.action.viewAsTree';
+const ViewAsListActionId = 'search.action.viewAsList';
+const ToggleQueryDetailsActionId = 'workbench.action.search.toggleQueryDetails';
+const ExcludeFolderFromSearchId = 'search.action.excludeFromSearch';
+const FocusNextInputActionId = 'search.focus.nextInputBox';
+const FocusPreviousInputActionId = 'search.focus.previousInputBox';
+const RestrictSearchToFolderId = 'search.action.restrictSearchToFolder';
+const FindInFolderId = 'filesExplorer.findInFolder';
+const FindInWorkspaceId = 'filesExplorer.findInWorkspace';
+const SearchViewVisibleKey = ( new RawContextKey('searchViewletVisible', true));
+const SearchViewFocusedKey = ( new RawContextKey('searchViewletFocus', false));
+const InputBoxFocusedKey = ( new RawContextKey('inputBoxFocus', false));
+const SearchInputBoxFocusedKey = ( new RawContextKey('searchInputBoxFocus', false));
+const ReplaceInputBoxFocusedKey = ( new RawContextKey('replaceInputBoxFocus', false));
+const PatternIncludesFocusedKey = ( new RawContextKey('patternIncludesInputBoxFocus', false));
+const PatternExcludesFocusedKey = ( new RawContextKey('patternExcludesInputBoxFocus', false));
+const ReplaceActiveKey = ( new RawContextKey('replaceActive', false));
+const HasSearchResults = ( new RawContextKey('hasSearchResult', false));
+const FirstMatchFocusKey = ( new RawContextKey('firstMatchFocus', false));
+const FileMatchOrMatchFocusKey = ( new RawContextKey('fileMatchOrMatchFocus', false));
+const FileMatchOrFolderMatchFocusKey = ( new RawContextKey('fileMatchOrFolderMatchFocus', false));
+const FileMatchOrFolderMatchWithResourceFocusKey = ( new RawContextKey('fileMatchOrFolderMatchWithResourceFocus', false));
+const FileFocusKey = ( new RawContextKey('fileMatchFocus', false));
+const FolderFocusKey = ( new RawContextKey('folderMatchFocus', false));
+const ResourceFolderFocusKey = ( new RawContextKey('folderMatchWithResourceFocus', false));
+const IsEditableItemKey = ( new RawContextKey('isEditableItem', true));
+const MatchFocusKey = ( new RawContextKey('matchFocus', false));
+const ViewHasSearchPatternKey = ( new RawContextKey('viewHasSearchPattern', false));
+const ViewHasReplacePatternKey = ( new RawContextKey('viewHasReplacePattern', false));
+const ViewHasFilePatternKey = ( new RawContextKey('viewHasFilePattern', false));
+const ViewHasSomeCollapsibleKey = ( new RawContextKey('viewHasSomeCollapsibleResult', false));
+const InTreeViewKey = ( new RawContextKey('inTreeView', false));
+export { AddCursorsAtSearchResults, CancelSearchActionId, ClearSearchHistoryCommandId, ClearSearchResultsActionId, CloseReplaceWidgetActionId, CollapseSearchResultsActionId, CopyAllCommandId, CopyMatchCommandId, CopyPathCommandId, ExcludeFolderFromSearchId, ExpandSearchResultsActionId, FileFocusKey, FileMatchOrFolderMatchFocusKey, FileMatchOrFolderMatchWithResourceFocusKey, FileMatchOrMatchFocusKey, FindInFilesActionId, FindInFolderId, FindInWorkspaceId, FirstMatchFocusKey, FocusNextInputActionId, FocusNextSearchResultActionId, FocusPreviousInputActionId, FocusPreviousSearchResultActionId, FocusSearchFromResults, FocusSearchListCommandID, FolderFocusKey, HasSearchResults, InTreeViewKey, InputBoxFocusedKey, IsEditableItemKey, MatchFocusKey, OpenInEditorCommandId, OpenMatch, OpenMatchToSide, PatternExcludesFocusedKey, PatternIncludesFocusedKey, QuickTextSearchActionId, RefreshSearchResultsActionId, RemoveActionId, ReplaceActionId, ReplaceActiveKey, ReplaceAllInFileActionId, ReplaceAllInFolderActionId, ReplaceInFilesActionId, ReplaceInputBoxFocusedKey, ResourceFolderFocusKey, RestrictSearchToFolderId, RevealInSideBarForSearchResults, SearchInputBoxFocusedKey, SearchViewFocusedKey, SearchViewVisibleKey, ShowAllSymbolsActionId, ToggleCaseSensitiveCommandId, TogglePreserveCaseId, ToggleQueryDetailsActionId, ToggleRegexCommandId, ToggleSearchOnTypeActionId, ToggleWholeWordCommandId, ViewAsListActionId, ViewAsTreeActionId, ViewHasFilePatternKey, ViewHasReplacePatternKey, ViewHasSearchPatternKey, ViewHasSomeCollapsibleKey };

package/vscode/src/vs/workbench/contrib/searchEditor/browser/constants.js

@@ -0,0 +1,11 @@
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+const InSearchEditor = ( new RawContextKey('inSearchEditor', false));
+const SearchEditorScheme = 'search-editor';
+const SearchEditorWorkingCopyTypeId = 'search/editor';
+const SearchEditorFindMatchClass = 'searchEditorFindMatch';
+const SearchEditorID = 'workbench.editor.searchEditor';
+const OpenNewEditorCommandId = 'search.action.openNewEditor';
+const OpenEditorCommandId = 'search.action.openEditor';
+const ToggleSearchEditorContextLinesCommandId = 'toggleSearchEditorContextLines';
+const SearchEditorInputTypeId = 'workbench.editorinputs.searchEditorInput';
+export { InSearchEditor, OpenEditorCommandId, OpenNewEditorCommandId, SearchEditorFindMatchClass, SearchEditorID, SearchEditorInputTypeId, SearchEditorScheme, SearchEditorWorkingCopyTypeId, ToggleSearchEditorContextLinesCommandId };

package/vscode/src/vs/workbench/contrib/snippets/browser/commands/abstractSnippetsActions.js

@@ -0,0 +1,24 @@
+import { EditorAction2 } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+const defaultOptions = {
+    category: {
+        value: ( localizeWithPath(
+            'vs/workbench/contrib/snippets/browser/commands/abstractSnippetsActions',
+            'snippets',
+            'Snippets'
+        )),
+        original: 'Snippets'
+    },
+};
+class SnippetsAction extends Action2 {
+    constructor(desc) {
+        super({ ...defaultOptions, ...desc });
+    }
+}
+class SnippetEditorAction extends EditorAction2 {
+    constructor(desc) {
+        super({ ...defaultOptions, ...desc });
+    }
+}
+export { SnippetEditorAction, SnippetsAction };