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

package/dist/vscode/vs/workbench/contrib/search/browser/searchNotebookHelpers.js

@@ -0,0 +1,49 @@
+import { TextSearchMatch } from '../../../services/search/common/search.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+function isIFileMatchWithCells(object) {
+    return 'cellResults' in object;
+}
+function contentMatchesToTextSearchMatches(contentMatches, cell) {
+    let previousEndLine = -1;
+    const contextGroupings = [];
+    let currentContextGrouping = [];
+    contentMatches.forEach((match) => {
+        if (match.range.startLineNumber !== previousEndLine) {
+            if (currentContextGrouping.length > 0) {
+                contextGroupings.push([...currentContextGrouping]);
+                currentContextGrouping = [];
+            }
+        }
+        currentContextGrouping.push(match);
+        previousEndLine = match.range.endLineNumber;
+    });
+    if (currentContextGrouping.length > 0) {
+        contextGroupings.push([...currentContextGrouping]);
+    }
+    const textSearchResults = ( contextGroupings.map((grouping) => {
+        const lineTexts = [];
+        const firstLine = grouping[0].range.startLineNumber;
+        const lastLine = grouping[grouping.length - 1].range.endLineNumber;
+        for (let i = firstLine; i <= lastLine; i++) {
+            lineTexts.push(cell.textBuffer.getLineContent(i));
+        }
+        return ( new TextSearchMatch(lineTexts.join('\n') + '\n', ( grouping.map(m => ( new Range(
+            m.range.startLineNumber - 1,
+            m.range.startColumn - 1,
+            m.range.endLineNumber - 1,
+            m.range.endColumn - 1
+        ))))));
+    }));
+    return textSearchResults;
+}
+function webviewMatchesToTextSearchMatches(webviewMatches) {
+    return ( webviewMatches
+        .map(rawMatch => (rawMatch.searchPreviewInfo) ?
+        ( new TextSearchMatch(rawMatch.searchPreviewInfo.line, ( new Range(
+            0,
+            rawMatch.searchPreviewInfo.range.start,
+            0,
+            rawMatch.searchPreviewInfo.range.end
+        )), undefined, rawMatch.index)) : undefined)).filter((e) => !!e);
+}
+export { contentMatchesToTextSearchMatches, isIFileMatchWithCells, webviewMatchesToTextSearchMatches };

package/dist/vscode/vs/workbench/contrib/search/browser/searchResultsView.js

@@ -0,0 +1,379 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { CountBadge } from 'monaco-editor/esm/vs/base/browser/ui/countBadge/countBadge.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { FileKind } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { FolderMatchNoRoot, MatchInNotebook, FolderMatch, FileMatch, Match, FolderMatchWorkspaceRoot } from './searchModel.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { MenuWorkbenchToolBar } from 'monaco-editor/esm/vs/platform/actions/browser/toolbar.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
+import { MatchFocusKey, FileFocusKey, FolderFocusKey, IsEditableItemKey } from '../common/constants.js';
+import { defaultCountBadgeStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+class SearchDelegate {
+    getHeight(element) {
+        return SearchDelegate.ITEM_HEIGHT;
+    }
+    getTemplateId(element) {
+        if (element instanceof FolderMatch) {
+            return FolderMatchRenderer.TEMPLATE_ID;
+        }
+        else if (element instanceof FileMatch) {
+            return FileMatchRenderer.TEMPLATE_ID;
+        }
+        else if (element instanceof Match) {
+            return MatchRenderer.TEMPLATE_ID;
+        }
+        console.error('Invalid search tree element', element);
+        throw new Error('Invalid search tree element');
+    }
+}
+SearchDelegate.ITEM_HEIGHT = 22;
+let FolderMatchRenderer = class FolderMatchRenderer extends Disposable {
+    constructor(searchView, labels, contextService, labelService, instantiationService, contextKeyService) {
+        super();
+        this.searchView = searchView;
+        this.labels = labels;
+        this.contextService = contextService;
+        this.labelService = labelService;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.templateId = FolderMatchRenderer.TEMPLATE_ID;
+    }
+    renderCompressedElements(node, index, templateData, height) {
+        const compressed = node.element;
+        const folder = compressed.elements[compressed.elements.length - 1];
+        const label = ( compressed.elements.map(e => e.name()));
+        if (folder.resource) {
+            const fileKind = (folder instanceof FolderMatchWorkspaceRoot) ? FileKind.ROOT_FOLDER : FileKind.FOLDER;
+            templateData.label.setResource({ resource: folder.resource, name: label }, {
+                fileKind,
+                separator: this.labelService.getSeparator(folder.resource.scheme),
+            });
+        }
+        else {
+            templateData.label.setLabel(( nls.localize('searchFolderMatch.other.label', "Other files")));
+        }
+        this.renderFolderDetails(folder, templateData);
+    }
+    renderTemplate(container) {
+        const disposables = ( new DisposableStore());
+        const folderMatchElement = dom.append(container, dom.$('.foldermatch'));
+        const label = this.labels.create(folderMatchElement, { supportDescriptionHighlights: true, supportHighlights: true });
+        disposables.add(label);
+        const badge = ( new CountBadge(
+            dom.append(folderMatchElement, dom.$('.badge')),
+            {},
+            defaultCountBadgeStyles
+        ));
+        const actionBarContainer = dom.append(folderMatchElement, dom.$('.actionBarContainer'));
+        const elementDisposables = ( new DisposableStore());
+        disposables.add(elementDisposables);
+        const contextKeyServiceMain = disposables.add(this.contextKeyService.createScoped(container));
+        MatchFocusKey.bindTo(contextKeyServiceMain).set(false);
+        FileFocusKey.bindTo(contextKeyServiceMain).set(false);
+        FolderFocusKey.bindTo(contextKeyServiceMain).set(true);
+        const instantiationService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyServiceMain])));
+        const actions = disposables.add(instantiationService.createInstance(MenuWorkbenchToolBar, actionBarContainer, MenuId.SearchActionMenu, {
+            menuOptions: {
+                shouldForwardArgs: true
+            },
+            hiddenItemStrategy: 0 ,
+            toolbarOptions: {
+                primaryGroup: (g) => /^inline/.test(g),
+            },
+        }));
+        return {
+            label,
+            badge,
+            actions,
+            disposables,
+            elementDisposables,
+            contextKeyService: contextKeyServiceMain
+        };
+    }
+    renderElement(node, index, templateData) {
+        const folderMatch = node.element;
+        if (folderMatch.resource) {
+            const workspaceFolder = this.contextService.getWorkspaceFolder(folderMatch.resource);
+            if (workspaceFolder && isEqual(workspaceFolder.uri, folderMatch.resource)) {
+                templateData.label.setFile(folderMatch.resource, { fileKind: FileKind.ROOT_FOLDER, hidePath: true });
+            }
+            else {
+                templateData.label.setFile(folderMatch.resource, { fileKind: FileKind.FOLDER, hidePath: this.searchView.isTreeLayoutViewVisible });
+            }
+        }
+        else {
+            templateData.label.setLabel(( nls.localize('searchFolderMatch.other.label', "Other files")));
+        }
+        IsEditableItemKey.bindTo(templateData.contextKeyService).set(!folderMatch.hasOnlyReadOnlyMatches());
+        templateData.elementDisposables.add(folderMatch.onChange(() => {
+            IsEditableItemKey.bindTo(templateData.contextKeyService).set(!folderMatch.hasOnlyReadOnlyMatches());
+        }));
+        this.renderFolderDetails(folderMatch, templateData);
+    }
+    disposeElement(element, index, templateData) {
+        templateData.elementDisposables.clear();
+    }
+    disposeCompressedElements(node, index, templateData, height) {
+        templateData.elementDisposables.clear();
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+    renderFolderDetails(folder, templateData) {
+        const count = folder.recursiveMatchCount();
+        templateData.badge.setCount(count);
+        templateData.badge.setTitleFormat(count > 1 ? ( nls.localize('searchFileMatches', "{0} files found", count)) : ( nls.localize('searchFileMatch', "{0} file found", count)));
+        templateData.actions.context = { viewer: this.searchView.getControl(), element: folder };
+    }
+};
+FolderMatchRenderer.TEMPLATE_ID = 'folderMatch';
+FolderMatchRenderer = ( __decorate([
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, ILabelService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IContextKeyService))
+], FolderMatchRenderer));
+let FileMatchRenderer = class FileMatchRenderer extends Disposable {
+    constructor(searchView, labels, contextService, configurationService, instantiationService, contextKeyService) {
+        super();
+        this.searchView = searchView;
+        this.labels = labels;
+        this.contextService = contextService;
+        this.configurationService = configurationService;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.templateId = FileMatchRenderer.TEMPLATE_ID;
+    }
+    renderCompressedElements(node, index, templateData, height) {
+        throw new Error('Should never happen since node is incompressible.');
+    }
+    renderTemplate(container) {
+        const disposables = ( new DisposableStore());
+        const elementDisposables = ( new DisposableStore());
+        disposables.add(elementDisposables);
+        const fileMatchElement = dom.append(container, dom.$('.filematch'));
+        const label = this.labels.create(fileMatchElement);
+        disposables.add(label);
+        const badge = ( new CountBadge(dom.append(fileMatchElement, dom.$('.badge')), {}, defaultCountBadgeStyles));
+        const actionBarContainer = dom.append(fileMatchElement, dom.$('.actionBarContainer'));
+        const contextKeyServiceMain = disposables.add(this.contextKeyService.createScoped(container));
+        MatchFocusKey.bindTo(contextKeyServiceMain).set(false);
+        FileFocusKey.bindTo(contextKeyServiceMain).set(true);
+        FolderFocusKey.bindTo(contextKeyServiceMain).set(false);
+        const instantiationService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyServiceMain])));
+        const actions = disposables.add(instantiationService.createInstance(MenuWorkbenchToolBar, actionBarContainer, MenuId.SearchActionMenu, {
+            menuOptions: {
+                shouldForwardArgs: true
+            },
+            hiddenItemStrategy: 0 ,
+            toolbarOptions: {
+                primaryGroup: (g) => /^inline/.test(g),
+            },
+        }));
+        return {
+            el: fileMatchElement,
+            label,
+            badge,
+            actions,
+            disposables,
+            elementDisposables,
+            contextKeyService: contextKeyServiceMain
+        };
+    }
+    renderElement(node, index, templateData) {
+        const fileMatch = node.element;
+        templateData.el.setAttribute('data-resource', ( fileMatch.resource.toString()));
+        const decorationConfig = this.configurationService.getValue('search').decorations;
+        templateData.label.setFile(fileMatch.resource, { hidePath: this.searchView.isTreeLayoutViewVisible && !(fileMatch.parent() instanceof FolderMatchNoRoot), hideIcon: false, fileDecorations: { colors: decorationConfig.colors, badges: decorationConfig.badges } });
+        const count = fileMatch.count();
+        templateData.badge.setCount(count);
+        templateData.badge.setTitleFormat(count > 1 ? ( nls.localize('searchMatches', "{0} matches found", count)) : ( nls.localize('searchMatch', "{0} match found", count)));
+        templateData.actions.context = { viewer: this.searchView.getControl(), element: fileMatch };
+        IsEditableItemKey.bindTo(templateData.contextKeyService).set(!fileMatch.hasOnlyReadOnlyMatches());
+        templateData.elementDisposables.add(fileMatch.onChange(() => {
+            IsEditableItemKey.bindTo(templateData.contextKeyService).set(!fileMatch.hasOnlyReadOnlyMatches());
+        }));
+        const twistieContainer = templateData.el.parentElement?.parentElement?.querySelector('.monaco-tl-twistie');
+        twistieContainer?.classList.add('force-twistie');
+    }
+    disposeElement(element, index, templateData) {
+        templateData.elementDisposables.clear();
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+};
+FileMatchRenderer.TEMPLATE_ID = 'fileMatch';
+FileMatchRenderer = ( __decorate([
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IContextKeyService))
+], FileMatchRenderer));
+let MatchRenderer = class MatchRenderer extends Disposable {
+    constructor(searchModel, searchView, contextService, configurationService, instantiationService, contextKeyService) {
+        super();
+        this.searchModel = searchModel;
+        this.searchView = searchView;
+        this.contextService = contextService;
+        this.configurationService = configurationService;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.templateId = MatchRenderer.TEMPLATE_ID;
+    }
+    renderCompressedElements(node, index, templateData, height) {
+        throw new Error('Should never happen since node is incompressible.');
+    }
+    renderTemplate(container) {
+        container.classList.add('linematch');
+        const parent = dom.append(container, dom.$('a.plain.match'));
+        const before = dom.append(parent, dom.$('span'));
+        const match = dom.append(parent, dom.$('span.findInFileMatch'));
+        const replace = dom.append(parent, dom.$('span.replaceMatch'));
+        const after = dom.append(parent, dom.$('span'));
+        const lineNumber = dom.append(container, dom.$('span.matchLineNum'));
+        const actionBarContainer = dom.append(container, dom.$('span.actionBarContainer'));
+        const disposables = ( new DisposableStore());
+        const contextKeyServiceMain = disposables.add(this.contextKeyService.createScoped(container));
+        MatchFocusKey.bindTo(contextKeyServiceMain).set(true);
+        FileFocusKey.bindTo(contextKeyServiceMain).set(false);
+        FolderFocusKey.bindTo(contextKeyServiceMain).set(false);
+        const instantiationService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyServiceMain])));
+        const actions = disposables.add(instantiationService.createInstance(MenuWorkbenchToolBar, actionBarContainer, MenuId.SearchActionMenu, {
+            menuOptions: {
+                shouldForwardArgs: true
+            },
+            hiddenItemStrategy: 0 ,
+            toolbarOptions: {
+                primaryGroup: (g) => /^inline/.test(g),
+            },
+        }));
+        return {
+            parent,
+            before,
+            match,
+            replace,
+            after,
+            lineNumber,
+            actions,
+            disposables,
+            contextKeyService: contextKeyServiceMain
+        };
+    }
+    renderElement(node, index, templateData) {
+        const match = node.element;
+        const preview = match.preview();
+        const replace = this.searchModel.isReplaceActive() && !!this.searchModel.replaceString && !(match instanceof MatchInNotebook && match.isWebviewMatch());
+        templateData.before.textContent = preview.before;
+        templateData.match.textContent = preview.inside;
+        templateData.match.classList.toggle('replace', replace);
+        templateData.replace.textContent = replace ? match.replaceString : '';
+        templateData.after.textContent = preview.after;
+        templateData.parent.title = (preview.before + (replace ? match.replaceString : preview.inside) + preview.after).trim().substr(0, 999);
+        IsEditableItemKey.bindTo(templateData.contextKeyService).set(!(match instanceof MatchInNotebook && match.isWebviewMatch()));
+        const numLines = match.range().endLineNumber - match.range().startLineNumber;
+        const extraLinesStr = numLines > 0 ? `+${numLines}` : '';
+        const showLineNumbers = this.configurationService.getValue('search').showLineNumbers;
+        const lineNumberStr = showLineNumbers ? `:${match.range().startLineNumber}` : '';
+        templateData.lineNumber.classList.toggle('show', (numLines > 0) || showLineNumbers);
+        templateData.lineNumber.textContent = lineNumberStr + extraLinesStr;
+        templateData.lineNumber.setAttribute('title', this.getMatchTitle(match, showLineNumbers));
+        templateData.actions.context = { viewer: this.searchView.getControl(), element: match };
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+    getMatchTitle(match, showLineNumbers) {
+        const startLine = match.range().startLineNumber;
+        const numLines = match.range().endLineNumber - match.range().startLineNumber;
+        const lineNumStr = showLineNumbers ?
+            ( nls.localize('lineNumStr', "From line {0}", startLine, numLines)) + ' ' :
+            '';
+        const numLinesStr = numLines > 0 ?
+            '+ ' + ( nls.localize('numLinesStr', "{0} more lines", numLines)) :
+            '';
+        return lineNumStr + numLinesStr;
+    }
+};
+MatchRenderer.TEMPLATE_ID = 'match';
+MatchRenderer = ( __decorate([
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IContextKeyService))
+], MatchRenderer));
+let SearchAccessibilityProvider = class SearchAccessibilityProvider {
+    constructor(searchModel, labelService) {
+        this.searchModel = searchModel;
+        this.labelService = labelService;
+    }
+    getWidgetAriaLabel() {
+        return ( nls.localize('search', "Search"));
+    }
+    getAriaLabel(element) {
+        if (element instanceof FolderMatch) {
+            const count = element.allDownstreamFileMatches().reduce((total, current) => total + current.count(), 0);
+            return element.resource ?
+                ( nls.localize(
+                    'folderMatchAriaLabel',
+                    "{0} matches in folder root {1}, Search result",
+                    count,
+                    element.name()
+                )) :
+                ( nls.localize(
+                    'otherFilesAriaLabel',
+                    "{0} matches outside of the workspace, Search result",
+                    count
+                ));
+        }
+        if (element instanceof FileMatch) {
+            const path$1 = this.labelService.getUriLabel(element.resource, { relative: true }) || element.resource.fsPath;
+            return ( nls.localize(
+                'fileMatchAriaLabel',
+                "{0} matches in file {1} of folder {2}, Search result",
+                element.count(),
+                element.name(),
+                path.dirname(path$1)
+            ));
+        }
+        if (element instanceof Match) {
+            const match = element;
+            const searchModel = this.searchModel;
+            const replace = searchModel.isReplaceActive() && !!searchModel.replaceString;
+            const matchString = match.getMatchString();
+            const range = match.range();
+            const matchText = match.text().substr(0, range.endColumn + 150);
+            if (replace) {
+                return ( nls.localize(
+                    'replacePreviewResultAria',
+                    "'{0}' at column {1} replace {2} with {3}",
+                    matchText,
+                    range.startColumn,
+                    matchString,
+                    match.replaceString
+                ));
+            }
+            return ( nls.localize(
+                'searchResultAria',
+                "'{0}' at column {1} found {2}",
+                matchText,
+                range.startColumn,
+                matchString
+            ));
+        }
+        return null;
+    }
+};
+SearchAccessibilityProvider = ( __decorate([
+    ( __param(1, ILabelService))
+], SearchAccessibilityProvider));
+export { FileMatchRenderer, FolderMatchRenderer, MatchRenderer, SearchAccessibilityProvider, SearchDelegate };