@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,322 @@
+import { localize2WithPath } from '../../../../nls.js';
+import { WorkbenchListFocusContextKey } from '../../../../platform/list/browser/listService.js';
+import { IViewsService } from '../../../services/views/common/viewsService.js';
+import { searchStopIcon, searchRefreshIcon, searchCollapseAllIcon, searchExpandAllIcon, searchClearIcon, searchShowAsList, searchShowAsTree } from './searchIcons.js';
+import { SearchContext } from '../common/constants.js';
+import { ISearchHistoryService } from '../common/searchHistoryService.js';
+import { FolderMatchWorkspaceRoot, Match, FolderMatch, FolderMatchNoRoot, SearchResult, FileMatch } from './searchModel.js';
+import { VIEW_ID } from '../../../services/search/common/search.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { registerAction2, Action2, MenuId } from '../../../../platform/actions/common/actions.js';
+import { SearchStateKey, SearchUIState } from '../common/search.js';
+import { category, getSearchView } from './searchActionsBase.js';
+registerAction2(class ClearSearchHistoryCommandAction extends Action2 {
+    constructor() {
+        super({
+            id: "search.action.clearHistory" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/search/browser/searchActionsTopBar',
+                'clearSearchHistoryLabel',
+                "Clear Search History"
+            )),
+            category,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        clearHistoryCommand(accessor);
+    }
+});
+registerAction2(class CancelSearchAction extends Action2 {
+    constructor() {
+        super({
+            id: "search.action.cancel" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/search/browser/searchActionsTopBar',
+                'CancelSearchAction.label',
+                "Cancel Search"
+            )),
+            icon: searchStopIcon,
+            category,
+            f1: true,
+            precondition: ( ( SearchStateKey.isEqualTo(SearchUIState.Idle)).negate()),
+            keybinding: {
+                weight: 200 ,
+                when: ( ContextKeyExpr.and(SearchContext.SearchViewVisibleKey, WorkbenchListFocusContextKey)),
+                primary: 9 ,
+            },
+            menu: [{
+                    id: MenuId.ViewTitle,
+                    group: 'navigation',
+                    order: 0,
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', VIEW_ID)), ( SearchStateKey.isEqualTo(SearchUIState.SlowSearch)))),
+                }]
+        });
+    }
+    run(accessor) {
+        return cancelSearch(accessor);
+    }
+});
+registerAction2(class RefreshAction extends Action2 {
+    constructor() {
+        super({
+            id: "search.action.refreshSearchResults" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/search/browser/searchActionsTopBar',
+                'RefreshAction.label',
+                "Refresh"
+            )),
+            icon: searchRefreshIcon,
+            precondition: SearchContext.ViewHasSearchPatternKey,
+            category,
+            f1: true,
+            menu: [{
+                    id: MenuId.ViewTitle,
+                    group: 'navigation',
+                    order: 0,
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', VIEW_ID)), ( ( SearchStateKey.isEqualTo(SearchUIState.SlowSearch)).negate()))),
+                }]
+        });
+    }
+    run(accessor, ...args) {
+        return refreshSearch(accessor);
+    }
+});
+registerAction2(class CollapseDeepestExpandedLevelAction extends Action2 {
+    constructor() {
+        super({
+            id: "search.action.collapseSearchResults" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/search/browser/searchActionsTopBar',
+                'CollapseDeepestExpandedLevelAction.label',
+                "Collapse All"
+            )),
+            category,
+            icon: searchCollapseAllIcon,
+            f1: true,
+            precondition: ( ContextKeyExpr.and(
+                SearchContext.HasSearchResults,
+                SearchContext.ViewHasSomeCollapsibleKey
+            )),
+            menu: [{
+                    id: MenuId.ViewTitle,
+                    group: 'navigation',
+                    order: 4,
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', VIEW_ID)), ( ContextKeyExpr.or(( SearchContext.HasSearchResults.negate()), SearchContext.ViewHasSomeCollapsibleKey)))),
+                }]
+        });
+    }
+    run(accessor, ...args) {
+        return collapseDeepestExpandedLevel(accessor);
+    }
+});
+registerAction2(class ExpandAllAction extends Action2 {
+    constructor() {
+        super({
+            id: "search.action.expandSearchResults" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/search/browser/searchActionsTopBar',
+                'ExpandAllAction.label',
+                "Expand All"
+            )),
+            category,
+            icon: searchExpandAllIcon,
+            f1: true,
+            precondition: ( ContextKeyExpr.and(SearchContext.HasSearchResults, ( SearchContext.ViewHasSomeCollapsibleKey.toNegated()))),
+            menu: [{
+                    id: MenuId.ViewTitle,
+                    group: 'navigation',
+                    order: 4,
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', VIEW_ID)), SearchContext.HasSearchResults, ( SearchContext.ViewHasSomeCollapsibleKey.toNegated()))),
+                }]
+        });
+    }
+    run(accessor, ...args) {
+        return expandAll(accessor);
+    }
+});
+registerAction2(class ClearSearchResultsAction extends Action2 {
+    constructor() {
+        super({
+            id: "search.action.clearSearchResults" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/search/browser/searchActionsTopBar',
+                'ClearSearchResultsAction.label',
+                "Clear Search Results"
+            )),
+            category,
+            icon: searchClearIcon,
+            f1: true,
+            precondition: ( ContextKeyExpr.or(
+                SearchContext.HasSearchResults,
+                SearchContext.ViewHasSearchPatternKey,
+                SearchContext.ViewHasReplacePatternKey,
+                SearchContext.ViewHasFilePatternKey
+            )),
+            menu: [{
+                    id: MenuId.ViewTitle,
+                    group: 'navigation',
+                    order: 1,
+                    when: ( ContextKeyExpr.equals('view', VIEW_ID)),
+                }]
+        });
+    }
+    run(accessor, ...args) {
+        return clearSearchResults(accessor);
+    }
+});
+registerAction2(class ViewAsTreeAction extends Action2 {
+    constructor() {
+        super({
+            id: "search.action.viewAsTree" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/search/browser/searchActionsTopBar',
+                'ViewAsTreeAction.label',
+                "View as Tree"
+            )),
+            category,
+            icon: searchShowAsList,
+            f1: true,
+            precondition: ( ContextKeyExpr.and(SearchContext.HasSearchResults, ( SearchContext.InTreeViewKey.toNegated()))),
+            menu: [{
+                    id: MenuId.ViewTitle,
+                    group: 'navigation',
+                    order: 2,
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', VIEW_ID)), ( SearchContext.InTreeViewKey.toNegated()))),
+                }]
+        });
+    }
+    run(accessor, ...args) {
+        const searchView = getSearchView(accessor.get(IViewsService));
+        if (searchView) {
+            searchView.setTreeView(true);
+        }
+    }
+});
+registerAction2(class ViewAsListAction extends Action2 {
+    constructor() {
+        super({
+            id: "search.action.viewAsList" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/search/browser/searchActionsTopBar',
+                'ViewAsListAction.label',
+                "View as List"
+            )),
+            category,
+            icon: searchShowAsTree,
+            f1: true,
+            precondition: ( ContextKeyExpr.and(
+                SearchContext.HasSearchResults,
+                SearchContext.InTreeViewKey
+            )),
+            menu: [{
+                    id: MenuId.ViewTitle,
+                    group: 'navigation',
+                    order: 2,
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', VIEW_ID)), SearchContext.InTreeViewKey)),
+                }]
+        });
+    }
+    run(accessor, ...args) {
+        const searchView = getSearchView(accessor.get(IViewsService));
+        if (searchView) {
+            searchView.setTreeView(false);
+        }
+    }
+});
+const clearHistoryCommand = accessor => {
+    const searchHistoryService = accessor.get(ISearchHistoryService);
+    searchHistoryService.clearHistory();
+};
+function expandAll(accessor) {
+    const viewsService = accessor.get(IViewsService);
+    const searchView = getSearchView(viewsService);
+    if (searchView) {
+        const viewer = searchView.getControl();
+        viewer.expandAll();
+    }
+}
+function clearSearchResults(accessor) {
+    const viewsService = accessor.get(IViewsService);
+    const searchView = getSearchView(viewsService);
+    searchView?.clearSearchResults();
+}
+function cancelSearch(accessor) {
+    const viewsService = accessor.get(IViewsService);
+    const searchView = getSearchView(viewsService);
+    searchView?.cancelSearch();
+}
+function refreshSearch(accessor) {
+    const viewsService = accessor.get(IViewsService);
+    const searchView = getSearchView(viewsService);
+    searchView?.triggerQueryChange({ preserveFocus: false });
+}
+function collapseDeepestExpandedLevel(accessor) {
+    const viewsService = accessor.get(IViewsService);
+    const searchView = getSearchView(viewsService);
+    if (searchView) {
+        const viewer = searchView.getControl();
+        const navigator = viewer.navigate();
+        let node = navigator.first();
+        let canCollapseFileMatchLevel = false;
+        let canCollapseFirstLevel = false;
+        if (node instanceof FolderMatchWorkspaceRoot || searchView.isTreeLayoutViewVisible) {
+            while (node = navigator.next()) {
+                if (node instanceof Match) {
+                    canCollapseFileMatchLevel = true;
+                    break;
+                }
+                if (searchView.isTreeLayoutViewVisible && !canCollapseFirstLevel) {
+                    let nodeToTest = node;
+                    if (node instanceof FolderMatch) {
+                        const compressionStartNode = viewer.getCompressedTreeNode(node).element?.elements[0];
+                        nodeToTest = (compressionStartNode && !(compressionStartNode instanceof Match)) ? compressionStartNode : node;
+                    }
+                    const immediateParent = nodeToTest.parent();
+                    if (!(immediateParent instanceof FolderMatchWorkspaceRoot || immediateParent instanceof FolderMatchNoRoot || immediateParent instanceof SearchResult)) {
+                        canCollapseFirstLevel = true;
+                    }
+                }
+            }
+        }
+        if (canCollapseFileMatchLevel) {
+            node = navigator.first();
+            do {
+                if (node instanceof FileMatch) {
+                    viewer.collapse(node);
+                }
+            } while (node = navigator.next());
+        }
+        else if (canCollapseFirstLevel) {
+            node = navigator.first();
+            if (node) {
+                do {
+                    let nodeToTest = node;
+                    if (node instanceof FolderMatch) {
+                        const compressionStartNode = viewer.getCompressedTreeNode(node).element?.elements[0];
+                        nodeToTest = (compressionStartNode && !(compressionStartNode instanceof Match)) ? compressionStartNode : node;
+                    }
+                    const immediateParent = nodeToTest.parent();
+                    if (immediateParent instanceof FolderMatchWorkspaceRoot || immediateParent instanceof FolderMatchNoRoot) {
+                        if (viewer.hasElement(node)) {
+                            viewer.collapse(node, true);
+                        }
+                        else {
+                            viewer.collapseAll();
+                        }
+                    }
+                } while (node = navigator.next());
+            }
+        }
+        else {
+            viewer.collapseAll();
+        }
+        const firstFocusParent = viewer.getFocus()[0]?.parent();
+        if (firstFocusParent && (firstFocusParent instanceof FolderMatch || firstFocusParent instanceof FileMatch) &&
+            viewer.hasElement(firstFocusParent) && viewer.isCollapsed(firstFocusParent)) {
+            viewer.domFocus();
+            viewer.focusFirst();
+            viewer.setSelection(viewer.getFocus());
+        }
+    }
+}

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

@@ -0,0 +1,101 @@
+import { ContextScopedFindInput } from '../../../../platform/history/browser/contextScopedHistoryWidget.js';
+import { NotebookFindInputFilterButton } from '../../notebook/browser/contrib/find/notebookFindReplaceWidget.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
+import { Toggle } from '../../../../base/browser/ui/toggle/toggle.js';
+import { Emitter } from '../../../../base/common/event.js';
+const NLS_AI_TOGGLE_LABEL = ( localizeWithPath(
+    'vs/workbench/contrib/search/browser/searchFindInput',
+    'aiDescription',
+    "Use AI"
+));
+class SearchFindInput extends ContextScopedFindInput {
+    constructor(container, contextViewProvider, options, contextKeyService, contextMenuService, instantiationService, filters, _shouldShowAIButton,
+    filterStartVisiblitity) {
+        super(container, contextViewProvider, options, contextKeyService);
+        this.contextMenuService = contextMenuService;
+        this.instantiationService = instantiationService;
+        this.filters = filters;
+        this._shouldShowAIButton = _shouldShowAIButton;
+        this._filterChecked = false;
+        this._visible = false;
+        this._onDidChangeAIToggle = this._register(( new Emitter()));
+        this.onDidChangeAIToggle = this._onDidChangeAIToggle.event;
+        this._findFilter = this._register(( new NotebookFindInputFilterButton(filters, contextMenuService, instantiationService, options, ( localizeWithPath(
+            'vs/workbench/contrib/search/browser/searchFindInput',
+            'searchFindInputNotebookFilter.label',
+            "Notebook Find Filters"
+        )))));
+        this._aiButton = this._register(( new AIToggle({
+            appendTitle: '',
+            isChecked: false,
+            ...options.toggleStyles
+        })));
+        this.setAdditionalToggles([this._aiButton]);
+        this.inputBox.paddingRight = (this.caseSensitive?.width() ?? 0) + (this.wholeWords?.width() ?? 0) + (this.regex?.width() ?? 0) + this._findFilter.width;
+        this.controls.appendChild(this._findFilter.container);
+        this._findFilter.container.classList.add('monaco-custom-toggle');
+        this.filterVisible = filterStartVisiblitity;
+        this._register(this._aiButton.onChange(() => {
+            if (this._aiButton.checked) {
+                this.regex?.disable();
+                this.wholeWords?.disable();
+                this.caseSensitive?.disable();
+                this._findFilter.disable();
+            }
+            else {
+                this.regex?.enable();
+                this.wholeWords?.enable();
+                this.caseSensitive?.enable();
+                this._findFilter.enable();
+            }
+        }));
+        this._aiButton.domNode.style.display = _shouldShowAIButton ? '' : 'none';
+    }
+    set shouldShowAIButton(visible) {
+        if (this._shouldShowAIButton !== visible) {
+            this._shouldShowAIButton = visible;
+            this._aiButton.domNode.style.display = visible ? '' : 'none';
+        }
+    }
+    set filterVisible(visible) {
+        this._findFilter.container.style.display = visible ? '' : 'none';
+        this._visible = visible;
+        this.updateStyles();
+    }
+    setEnabled(enabled) {
+        super.setEnabled(enabled);
+        if (enabled && (!this._filterChecked || !this._visible)) {
+            this.regex?.enable();
+        }
+        else {
+            this.regex?.disable();
+        }
+    }
+    updateStyles() {
+        this._filterChecked =
+            !this.filters.markupInput ||
+                !this.filters.markupPreview ||
+                !this.filters.codeInput ||
+                !this.filters.codeOutput;
+        this._findFilter.applyStyles(this._filterChecked);
+    }
+    get isAIEnabled() {
+        return this._aiButton.checked;
+    }
+}
+class AIToggle extends Toggle {
+    constructor(opts) {
+        super({
+            icon: Codicon.sparkle,
+            title: NLS_AI_TOGGLE_LABEL + opts.appendTitle,
+            isChecked: opts.isChecked,
+            hoverDelegate: opts.hoverDelegate ?? getDefaultHoverDelegate('element'),
+            inputActiveOptionBorder: opts.inputActiveOptionBorder,
+            inputActiveOptionForeground: opts.inputActiveOptionForeground,
+            inputActiveOptionBackground: opts.inputActiveOptionBackground
+        });
+    }
+}
+export { SearchFindInput };

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

@@ -0,0 +1,104 @@
+import { Codicon } from '../../../../base/common/codicons.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
+const searchDetailsIcon = registerIcon('search-details', Codicon.ellipsis, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchDetailsIcon',
+ 'Icon to make search details visible.'
+)));
+const searchActivityBarIcon = registerIcon('search-see-more', Codicon.linkExternal, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchSeeMoreIcon',
+ 'Icon to view more context in the search view.'
+)));
+const searchShowContextIcon = registerIcon('search-show-context', Codicon.listSelection, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchShowContextIcon',
+ 'Icon for toggle the context in the search editor.'
+)));
+const searchHideReplaceIcon = registerIcon('search-hide-replace', Codicon.chevronRight, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchHideReplaceIcon',
+ 'Icon to collapse the replace section in the search view.'
+)));
+const searchShowReplaceIcon = registerIcon('search-show-replace', Codicon.chevronDown, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchShowReplaceIcon',
+ 'Icon to expand the replace section in the search view.'
+)));
+const searchReplaceAllIcon = registerIcon('search-replace-all', Codicon.replaceAll, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchReplaceAllIcon',
+ 'Icon for replace all in the search view.'
+)));
+const searchReplaceIcon = registerIcon('search-replace', Codicon.replace, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchReplaceIcon',
+ 'Icon for replace in the search view.'
+)));
+const searchRemoveIcon = registerIcon('search-remove', Codicon.close, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchRemoveIcon',
+ 'Icon to remove a search result.'
+)));
+const searchRefreshIcon = registerIcon('search-refresh', Codicon.refresh, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchRefreshIcon',
+ 'Icon for refresh in the search view.'
+)));
+const searchCollapseAllIcon = registerIcon('search-collapse-results', Codicon.collapseAll, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchCollapseAllIcon',
+ 'Icon for collapse results in the search view.'
+)));
+const searchExpandAllIcon = registerIcon('search-expand-results', Codicon.expandAll, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchExpandAllIcon',
+ 'Icon for expand results in the search view.'
+)));
+const searchShowAsTree = registerIcon('search-tree', Codicon.listTree, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchShowAsTree',
+ 'Icon for viewing results as a tree in the search view.'
+)));
+const searchShowAsList = registerIcon('search-list', Codicon.listFlat, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchShowAsList',
+ 'Icon for viewing results as a list in the search view.'
+)));
+const searchClearIcon = registerIcon('search-clear-results', Codicon.clearAll, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchClearIcon',
+ 'Icon for clear results in the search view.'
+)));
+const searchStopIcon = registerIcon('search-stop', Codicon.searchStop, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchStopIcon',
+ 'Icon for stop in the search view.'
+)));
+const searchViewIcon = registerIcon('search-view-icon', Codicon.search, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchViewIcon',
+ 'View icon of the search view.'
+)));
+const searchNewEditorIcon = registerIcon('search-new-editor', Codicon.newFile, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchNewEditorIcon',
+ 'Icon for the action to open a new search editor.'
+)));
+const searchOpenInFileIcon = registerIcon('search-open-in-file', Codicon.goToFile, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchOpenInFile',
+ 'Icon for the action to go to the file of the current search result.'
+)));
+registerIcon('search-sparkle-filled', Codicon.sparkleFilled, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchSparkleFilled',
+ 'Icon to show AI results in search.'
+)));
+registerIcon('search-sparkle-empty', Codicon.sparkle, ( localizeWithPath(
+ 'vs/workbench/contrib/search/browser/searchIcons',
+ 'searchSparkleEmpty',
+ 'Icon to hide AI results in search.'
+)));
+export { searchActivityBarIcon, searchClearIcon, searchCollapseAllIcon, searchDetailsIcon, searchExpandAllIcon, searchHideReplaceIcon, searchNewEditorIcon, searchOpenInFileIcon, searchRefreshIcon, searchRemoveIcon, searchReplaceAllIcon, searchReplaceIcon, searchShowAsList, searchShowAsTree, searchShowContextIcon, searchShowReplaceIcon, searchStopIcon, searchViewIcon };

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

@@ -0,0 +1,64 @@
+import { localizeWithPath } from '../../../../nls.js';
+import { $, append } from '../../../../base/browser/dom.js';
+import { parseLinkedText } from '../../../../base/common/linkedText.js';
+import Severity$1 from '../../../../base/common/severity.js';
+import { SeverityIcon } from '../../../../platform/severityIcon/browser/severityIcon.js';
+import { TextSearchCompleteMessageType } from '../../../services/search/common/searchExtTypes.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { Link } from '../../../../platform/opener/browser/link.js';
+import { URI } from '../../../../base/common/uri.js';
+const renderSearchMessage = (message, instantiationService, notificationService, openerService, commandService, disposableStore, triggerSearch) => {
+    const div = $('div.providerMessage');
+    const linkedText = parseLinkedText(message.text);
+    append(div, $('.' +
+        SeverityIcon.className(message.type === TextSearchCompleteMessageType.Information
+            ? Severity$1.Info
+            : Severity$1.Warning)
+            .split(' ')
+            .join('.')));
+    for (const node of linkedText.nodes) {
+        if (typeof node === 'string') {
+            append(div, document.createTextNode(node));
+        }
+        else {
+            const link = instantiationService.createInstance(Link, div, node, {
+                opener: async (href) => {
+                    if (!message.trusted) {
+                        return;
+                    }
+                    const parsed = ( URI.parse(href, true));
+                    if (parsed.scheme === Schemas.command && message.trusted) {
+                        const result = await commandService.executeCommand(parsed.path);
+                        if (result?.triggerSearch) {
+                            triggerSearch();
+                        }
+                    }
+                    else if (parsed.scheme === Schemas.https) {
+                        openerService.open(parsed);
+                    }
+                    else {
+                        if (parsed.scheme === Schemas.command && !message.trusted) {
+                            notificationService.error(( localizeWithPath(
+                                'vs/workbench/contrib/search/browser/searchMessage',
+                                'unable to open trust',
+                                "Unable to open command link from untrusted source: {0}",
+                                href
+                            )));
+                        }
+                        else {
+                            notificationService.error(( localizeWithPath(
+                                'vs/workbench/contrib/search/browser/searchMessage',
+                                'unable to open',
+                                "Unable to open unknown link: {0}",
+                                href
+                            )));
+                        }
+                    }
+                }
+            });
+            disposableStore.add(link);
+        }
+    }
+    return div;
+};
+export { renderSearchMessage };