@codingame/monaco-vscode-search-service-override 4.1.0 → 4.1.2

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

@@ -0,0 +1,437 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { append, $ } from 'vscode/vscode/vs/base/browser/dom';
+import { CountBadge } from 'vscode/vscode/vs/base/browser/ui/countBadge/countBadge';
+import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { dirname } from 'vscode/vscode/vs/base/common/path';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { FileKind } from 'vscode/vscode/vs/platform/files/common/files';
+import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { FolderMatchWorkspaceRoot, FolderMatchNoRoot, MatchInNotebook, FolderMatch, FileMatch, Match } from 'vscode/vscode/vs/workbench/contrib/search/browser/searchModel';
+import { isEqual } from 'vscode/vscode/vs/base/common/resources';
+import { MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { MenuWorkbenchToolBar } from 'vscode/vscode/vs/platform/actions/browser/toolbar';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/common/serviceCollection';
+import { defaultCountBadgeStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
+import { SearchContext } from 'vscode/vscode/vs/workbench/contrib/search/common/constants';
+import { setupCustomHover } from 'vscode/vscode/vs/base/browser/ui/hover/updatableHoverWidget';
+import { getDefaultHoverDelegate } from 'vscode/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+
+var FolderMatchRenderer_1, FileMatchRenderer_1, MatchRenderer_1;
+class SearchDelegate {
+    static { this.ITEM_HEIGHT = 22; }
+    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');
+    }
+}
+let FolderMatchRenderer = class FolderMatchRenderer extends Disposable {
+    static { FolderMatchRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'folderMatch'; }
+    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_1.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(( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchResultsView',
+                'searchFolderMatch.other.label',
+                "Other files"
+            )));
+        }
+        this.renderFolderDetails(folder, templateData);
+    }
+    renderTemplate(container) {
+        const disposables = ( new DisposableStore());
+        const folderMatchElement = append(container, $('.foldermatch'));
+        const label = this.labels.create(folderMatchElement, { supportDescriptionHighlights: true, supportHighlights: true });
+        disposables.add(label);
+        const badge = ( new CountBadge(
+            append(folderMatchElement, $('.badge')),
+            {},
+            defaultCountBadgeStyles
+        ));
+        const actionBarContainer = append(folderMatchElement, $('.actionBarContainer'));
+        const elementDisposables = ( new DisposableStore());
+        disposables.add(elementDisposables);
+        const contextKeyServiceMain = disposables.add(this.contextKeyService.createScoped(container));
+        SearchContext.MatchFocusKey.bindTo(contextKeyServiceMain).set(false);
+        SearchContext.FileFocusKey.bindTo(contextKeyServiceMain).set(false);
+        SearchContext.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(( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchResultsView',
+                'searchFolderMatch.other.label',
+                "Other files"
+            )));
+        }
+        SearchContext.IsEditableItemKey.bindTo(templateData.contextKeyService).set(!folderMatch.hasOnlyReadOnlyMatches());
+        templateData.elementDisposables.add(folderMatch.onChange(() => {
+            SearchContext.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 ? ( localizeWithPath(
+            'vs/workbench/contrib/search/browser/searchResultsView',
+            'searchFileMatches',
+            "{0} files found",
+            count
+        )) : ( localizeWithPath(
+            'vs/workbench/contrib/search/browser/searchResultsView',
+            'searchFileMatch',
+            "{0} file found",
+            count
+        )));
+        templateData.actions.context = { viewer: this.searchView.getControl(), element: folder };
+    }
+};
+FolderMatchRenderer = FolderMatchRenderer_1 = ( __decorate([
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, ILabelService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IContextKeyService))
+], FolderMatchRenderer));
+let FileMatchRenderer = class FileMatchRenderer extends Disposable {
+    static { FileMatchRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'fileMatch'; }
+    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_1.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 = append(container, $('.filematch'));
+        const label = this.labels.create(fileMatchElement);
+        disposables.add(label);
+        const badge = ( new CountBadge(append(fileMatchElement, $('.badge')), {}, defaultCountBadgeStyles));
+        const actionBarContainer = append(fileMatchElement, $('.actionBarContainer'));
+        const contextKeyServiceMain = disposables.add(this.contextKeyService.createScoped(container));
+        SearchContext.MatchFocusKey.bindTo(contextKeyServiceMain).set(false);
+        SearchContext.FileFocusKey.bindTo(contextKeyServiceMain).set(true);
+        SearchContext.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 ? ( localizeWithPath(
+            'vs/workbench/contrib/search/browser/searchResultsView',
+            'searchMatches',
+            "{0} matches found",
+            count
+        )) : ( localizeWithPath(
+            'vs/workbench/contrib/search/browser/searchResultsView',
+            'searchMatch',
+            "{0} match found",
+            count
+        )));
+        templateData.actions.context = { viewer: this.searchView.getControl(), element: fileMatch };
+        SearchContext.IsEditableItemKey.bindTo(templateData.contextKeyService).set(!fileMatch.hasOnlyReadOnlyMatches());
+        templateData.elementDisposables.add(fileMatch.onChange(() => {
+            SearchContext.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 = FileMatchRenderer_1 = ( __decorate([
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IContextKeyService))
+], FileMatchRenderer));
+let MatchRenderer = class MatchRenderer extends Disposable {
+    static { MatchRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'match'; }
+    constructor(searchView, contextService, configurationService, instantiationService, contextKeyService) {
+        super();
+        this.searchView = searchView;
+        this.contextService = contextService;
+        this.configurationService = configurationService;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.templateId = MatchRenderer_1.TEMPLATE_ID;
+    }
+    renderCompressedElements(node, index, templateData, height) {
+        throw new Error('Should never happen since node is incompressible.');
+    }
+    renderTemplate(container) {
+        container.classList.add('linematch');
+        const lineNumber = append(container, $('span.matchLineNum'));
+        const parent = append(container, $('a.plain.match'));
+        const before = append(parent, $('span'));
+        const match = append(parent, $('span.findInFileMatch'));
+        const replace = append(parent, $('span.replaceMatch'));
+        const after = append(parent, $('span'));
+        const actionBarContainer = append(container, $('span.actionBarContainer'));
+        const disposables = ( new DisposableStore());
+        const contextKeyServiceMain = disposables.add(this.contextKeyService.createScoped(container));
+        SearchContext.MatchFocusKey.bindTo(contextKeyServiceMain).set(true);
+        SearchContext.FileFocusKey.bindTo(contextKeyServiceMain).set(false);
+        SearchContext.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.searchView.model.isReplaceActive() &&
+            !!this.searchView.model.replaceString &&
+            !(match instanceof MatchInNotebook && match.isReadonly());
+        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;
+        const title = (preview.fullBefore + (replace ? match.replaceString : preview.inside) + preview.after).trim().substr(0, 999);
+        templateData.disposables.add(setupCustomHover(getDefaultHoverDelegate('mouse'), templateData.parent, title));
+        SearchContext.IsEditableItemKey.bindTo(templateData.contextKeyService).set(!(match instanceof MatchInNotebook && match.isReadonly()));
+        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.disposables.add(setupCustomHover(getDefaultHoverDelegate('mouse'), templateData.lineNumber, 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 ?
+            ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchResultsView',
+                'lineNumStr',
+                "From line {0}",
+                startLine,
+                numLines
+            )) + ' ' :
+            '';
+        const numLinesStr = numLines > 0 ?
+            '+ ' + ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchResultsView',
+                'numLinesStr',
+                "{0} more lines",
+                numLines
+            )) :
+            '';
+        return lineNumStr + numLinesStr;
+    }
+};
+MatchRenderer = MatchRenderer_1 = ( __decorate([
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IContextKeyService))
+], MatchRenderer));
+let SearchAccessibilityProvider = class SearchAccessibilityProvider {
+    constructor(searchView, labelService) {
+        this.searchView = searchView;
+        this.labelService = labelService;
+    }
+    getWidgetAriaLabel() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/search/browser/searchResultsView',
+            'search',
+            "Search"
+        ));
+    }
+    getAriaLabel(element) {
+        if (element instanceof FolderMatch) {
+            const count = element.allDownstreamFileMatches().reduce((total, current) => total + current.count(), 0);
+            return element.resource ?
+                ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchResultsView',
+                    'folderMatchAriaLabel',
+                    "{0} matches in folder root {1}, Search result",
+                    count,
+                    element.name()
+                )) :
+                ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchResultsView',
+                    'otherFilesAriaLabel',
+                    "{0} matches outside of the workspace, Search result",
+                    count
+                ));
+        }
+        if (element instanceof FileMatch) {
+            const path = this.labelService.getUriLabel(element.resource, { relative: true }) || element.resource.fsPath;
+            return ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchResultsView',
+                'fileMatchAriaLabel',
+                "{0} matches in file {1} of folder {2}, Search result",
+                element.count(),
+                element.name(),
+                dirname(path)
+            ));
+        }
+        if (element instanceof Match) {
+            const match = element;
+            const searchModel = this.searchView.model;
+            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 ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/searchResultsView',
+                    'replacePreviewResultAria',
+                    "'{0}' at column {1} replace {2} with {3}",
+                    matchText,
+                    range.startColumn,
+                    matchString,
+                    match.replaceString
+                ));
+            }
+            return ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/searchResultsView',
+                '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 };