@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.1

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

@@ -1,204 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
-import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-import { IViewsService } from '../../../common/views.js';
-import { CopyMatchCommandId, FileMatchOrMatchFocusKey, CopyPathCommandId, FileMatchOrFolderMatchWithResourceFocusKey, CopyAllCommandId, HasSearchResults } from '../common/constants.js';
-import { FileMatch, FolderMatchWithResource, Match, FolderMatch, searchMatchComparer } from './searchModel.js';
-import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { category, getSearchView } from './searchActionsBase.js';
-import { isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
-registerAction2(class CopyMatchCommandAction extends Action2 {
-    constructor() {
-        super({
-            id: CopyMatchCommandId,
-            title: {
-                value: ( nls.localize('copyMatchLabel', "Copy")),
-                original: 'Copy'
-            },
-            category,
-            keybinding: {
-                weight: 200 ,
-                when: FileMatchOrMatchFocusKey,
-                primary: 2048  | 33 ,
-            },
-            menu: [{
-                    id: MenuId.SearchContext,
-                    when: FileMatchOrMatchFocusKey,
-                    group: 'search_2',
-                    order: 1
-                }]
-        });
-    }
-    async run(accessor, match) {
-        await copyMatchCommand(accessor, match);
-    }
-});
-registerAction2(class CopyPathCommandAction extends Action2 {
-    constructor() {
-        super({
-            id: CopyPathCommandId,
-            title: {
-                value: ( nls.localize('copyPathLabel', "Copy Path")),
-                original: 'Copy Path'
-            },
-            category,
-            keybinding: {
-                weight: 200 ,
-                when: FileMatchOrFolderMatchWithResourceFocusKey,
-                primary: 2048  | 512  | 33 ,
-                win: {
-                    primary: 1024  | 512  | 33
-                },
-            },
-            menu: [{
-                    id: MenuId.SearchContext,
-                    when: FileMatchOrFolderMatchWithResourceFocusKey,
-                    group: 'search_2',
-                    order: 2
-                }]
-        });
-    }
-    async run(accessor, fileMatch) {
-        await copyPathCommand(accessor, fileMatch);
-    }
-});
-registerAction2(class CopyAllCommandAction extends Action2 {
-    constructor() {
-        super({
-            id: CopyAllCommandId,
-            title: {
-                value: ( nls.localize('copyAllLabel', "Copy All")),
-                original: 'Copy All'
-            },
-            category,
-            menu: [{
-                    id: MenuId.SearchContext,
-                    when: HasSearchResults,
-                    group: 'search_2',
-                    order: 3
-                }]
-        });
-    }
-    async run(accessor) {
-        await copyAllCommand(accessor);
-    }
-});
-const lineDelimiter = isWindows ? '\r\n' : '\n';
-async function copyPathCommand(accessor, fileMatch) {
-    if (!fileMatch) {
-        const selection = getSelectedRow(accessor);
-        if (!(selection instanceof FileMatch || selection instanceof FolderMatchWithResource)) {
-            return;
-        }
-        fileMatch = selection;
-    }
-    const clipboardService = accessor.get(IClipboardService);
-    const labelService = accessor.get(ILabelService);
-    const text = labelService.getUriLabel(fileMatch.resource, { noPrefix: true });
-    await clipboardService.writeText(text);
-}
-async function copyMatchCommand(accessor, match) {
-    if (!match) {
-        const selection = getSelectedRow(accessor);
-        if (!selection) {
-            return;
-        }
-        match = selection;
-    }
-    const clipboardService = accessor.get(IClipboardService);
-    const labelService = accessor.get(ILabelService);
-    let text;
-    if (match instanceof Match) {
-        text = matchToString(match);
-    }
-    else if (match instanceof FileMatch) {
-        text = fileMatchToString(match, labelService).text;
-    }
-    else if (match instanceof FolderMatch) {
-        text = folderMatchToString(match, labelService).text;
-    }
-    if (text) {
-        await clipboardService.writeText(text);
-    }
-}
-async function copyAllCommand(accessor) {
-    const viewsService = accessor.get(IViewsService);
-    const clipboardService = accessor.get(IClipboardService);
-    const labelService = accessor.get(ILabelService);
-    const searchView = getSearchView(viewsService);
-    if (searchView) {
-        const root = searchView.searchResult;
-        const text = allFolderMatchesToString(root.folderMatches(), labelService);
-        await clipboardService.writeText(text);
-    }
-}
-function matchToString(match, indent = 0) {
-    const getFirstLinePrefix = () => `${match.range().startLineNumber},${match.range().startColumn}`;
-    const getOtherLinePrefix = (i) => match.range().startLineNumber + i + '';
-    const fullMatchLines = match.fullPreviewLines();
-    const largestPrefixSize = fullMatchLines.reduce((largest, _, i) => {
-        const thisSize = i === 0 ?
-            getFirstLinePrefix().length :
-            getOtherLinePrefix(i).length;
-        return Math.max(thisSize, largest);
-    }, 0);
-    const formattedLines = ( fullMatchLines
-        .map((line, i) => {
-        const prefix = i === 0 ?
-            getFirstLinePrefix() :
-            getOtherLinePrefix(i);
-        const paddingStr = ' '.repeat(largestPrefixSize - prefix.length);
-        const indentStr = ' '.repeat(indent);
-        return `${indentStr}${prefix}: ${paddingStr}${line}`;
-    }));
-    return formattedLines.join('\n');
-}
-function fileFolderMatchToString(match, labelService) {
-    if (match instanceof FileMatch) {
-        return fileMatchToString(match, labelService);
-    }
-    else {
-        return folderMatchToString(match, labelService);
-    }
-}
-function fileMatchToString(fileMatch, labelService) {
-    const matchTextRows = ( fileMatch.matches()
-        .sort(searchMatchComparer)
-        .map(match => matchToString(match, 2)));
-    const uriString = labelService.getUriLabel(fileMatch.resource, { noPrefix: true });
-    return {
-        text: `${uriString}${lineDelimiter}${matchTextRows.join(lineDelimiter)}`,
-        count: matchTextRows.length
-    };
-}
-function folderMatchToString(folderMatch, labelService) {
-    const results = [];
-    let numMatches = 0;
-    const matches = folderMatch.matches().sort(searchMatchComparer);
-    matches.forEach(match => {
-        const result = fileFolderMatchToString(match, labelService);
-        numMatches += result.count;
-        results.push(result.text);
-    });
-    return {
-        text: results.join(lineDelimiter + lineDelimiter),
-        count: numMatches
-    };
-}
-function allFolderMatchesToString(folderMatches, labelService) {
-    const folderResults = [];
-    folderMatches = folderMatches.sort(searchMatchComparer);
-    for (let i = 0; i < folderMatches.length; i++) {
-        const folderResult = folderMatchToString(folderMatches[i], labelService);
-        if (folderResult.count) {
-            folderResults.push(folderResult.text);
-        }
-    }
-    return folderResults.join(lineDelimiter + lineDelimiter);
-}
-function getSelectedRow(accessor) {
-    const viewsService = accessor.get(IViewsService);
-    const searchView = getSearchView(viewsService);
-    return searchView?.getControl().getSelection()[0];
-}
-export { lineDelimiter };

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

@@ -1,354 +0,0 @@
-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.localize('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.localize('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.localize('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.localize('findInFiles', "Find in Files")),
-                mnemonicTitle: ( nls.localize(
-                    { key: 'miFindInFiles', comment: ['&& denotes a mnemonic'] },
-                    "Find &&in Files"
-                )),
-                original: 'Find in Files'
-            },
-            description: {
-                description: ( nls.localize('findInFiles.description', "Open a workspace search")),
-                args: [
-                    {
-                        name: ( nls.localize('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.localize('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.localize('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 };