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

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

@@ -0,0 +1,796 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/anythingQuickAccess.css.js';
+import { QuickPickItemScorerAccessor, QuickInputHideReason, quickPickItemScorerAccessor, IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
+import { PickerQuickAccessProvider, TriggerAction } from 'vscode/vscode/vs/platform/quickinput/browser/pickerQuickAccess';
+import { prepareQuery, compareItemsByFuzzyScore, scoreItemFuzzy } from 'vscode/vscode/vs/base/common/fuzzyScorer';
+import { QueryBuilder } from 'vscode/vscode/vs/workbench/services/search/common/queryBuilder';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { extractRangeFromFilter, getOutOfWorkspaceEditorResources } from 'vscode/vscode/vs/workbench/contrib/search/common/search';
+import { ISearchService } from 'vscode/vscode/vs/workbench/services/search/common/search';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { untildify } from 'vscode/vscode/vs/base/common/labels';
+import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { toLocalResource, basenameOrAuthority, dirname } from 'vscode/vscode/vs/base/common/resources';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { Disposable, DisposableStore, MutableDisposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
+import { getIconClasses } from 'vscode/vscode/vs/editor/common/services/getIconClasses';
+import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
+import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { isEditorInput, EditorResourceAccessor } from 'vscode/vscode/vs/workbench/common/editor';
+import { SIDE_GROUP, ACTIVE_GROUP, IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { ThrottledDelayer } from 'vscode/vscode/vs/base/common/async';
+import { top } from 'vscode/vscode/vs/base/common/arrays';
+import { FileQueryCacheState } from '../common/cacheState.js';
+import { IHistoryService } from 'vscode/vscode/vs/workbench/services/history/common/history';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService';
+import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
+import { SymbolsQuickAccessProvider } from './symbolsQuickAccess.js';
+import { DefaultQuickAccessFilterValue, Extensions } from 'vscode/vscode/vs/platform/quickinput/common/quickAccess';
+import { PickerEditorState } from 'vscode/vscode/vs/workbench/browser/quickaccess';
+import { GotoSymbolQuickAccessProvider } from 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/quickaccess/gotoSymbolQuickAccess';
+import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+import { stripIcons } from 'vscode/vscode/vs/base/common/iconLabels';
+import { Lazy } from 'vscode/vscode/vs/base/common/lazy';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { ASK_QUICK_QUESTION_ACTION_ID } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatQuickInputActions';
+import { IQuickChatService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+
+var AnythingQuickAccessProvider_1;
+function isEditorSymbolQuickPickItem(pick) {
+    const candidate = pick;
+    return !!candidate?.range && !!candidate.resource;
+}
+let AnythingQuickAccessProvider = class AnythingQuickAccessProvider extends PickerQuickAccessProvider {
+    static { AnythingQuickAccessProvider_1 = this; }
+    static { this.PREFIX = ''; }
+    static { this.NO_RESULTS_PICK = {
+        label: ( localizeWithPath(
+            'vs/workbench/contrib/search/browser/anythingQuickAccess',
+            'noAnythingResults',
+            "No matching results"
+        ))
+    }; }
+    static { this.MAX_RESULTS = 512; }
+    static { this.TYPING_SEARCH_DELAY = 200; }
+    static { this.SYMBOL_PICKS_MERGE_DELAY = 200; }
+    get defaultFilterValue() {
+        if (this.configuration.preserveInput) {
+            return DefaultQuickAccessFilterValue.LAST;
+        }
+        return undefined;
+    }
+    constructor(instantiationService, searchService, contextService, pathService, environmentService, fileService, labelService, modelService, languageService, workingCopyService, configurationService, editorService, historyService, filesConfigurationService, textModelService, uriIdentityService, quickInputService, keybindingService, quickChatService, logService) {
+        super(AnythingQuickAccessProvider_1.PREFIX, {
+            canAcceptInBackground: true,
+            noResultsPick: AnythingQuickAccessProvider_1.NO_RESULTS_PICK
+        });
+        this.instantiationService = instantiationService;
+        this.searchService = searchService;
+        this.contextService = contextService;
+        this.pathService = pathService;
+        this.environmentService = environmentService;
+        this.fileService = fileService;
+        this.labelService = labelService;
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this.workingCopyService = workingCopyService;
+        this.configurationService = configurationService;
+        this.editorService = editorService;
+        this.historyService = historyService;
+        this.filesConfigurationService = filesConfigurationService;
+        this.textModelService = textModelService;
+        this.uriIdentityService = uriIdentityService;
+        this.quickInputService = quickInputService;
+        this.keybindingService = keybindingService;
+        this.quickChatService = quickChatService;
+        this.logService = logService;
+        this.pickState = this._register(new (class extends Disposable {
+            constructor(provider, instantiationService) {
+                super();
+                this.provider = provider;
+                this.instantiationService = instantiationService;
+                this.picker = undefined;
+                this.editorViewState = this._register(this.instantiationService.createInstance(PickerEditorState));
+                this.scorerCache = Object.create(null);
+                this.fileQueryCache = undefined;
+                this.lastOriginalFilter = undefined;
+                this.lastFilter = undefined;
+                this.lastRange = undefined;
+                this.lastGlobalPicks = undefined;
+                this.isQuickNavigating = undefined;
+            }
+            set(picker) {
+                this.picker = picker;
+                Event.once(picker.onDispose)(() => {
+                    if (picker === this.picker) {
+                        this.picker = undefined;
+                    }
+                });
+                const isQuickNavigating = !!picker.quickNavigate;
+                if (!isQuickNavigating) {
+                    this.fileQueryCache = this.provider.createFileQueryCache();
+                    this.scorerCache = Object.create(null);
+                }
+                this.isQuickNavigating = isQuickNavigating;
+                this.lastOriginalFilter = undefined;
+                this.lastFilter = undefined;
+                this.lastRange = undefined;
+                this.lastGlobalPicks = undefined;
+                this.editorViewState.reset();
+            }
+        })(this, this.instantiationService));
+        this.labelOnlyEditorHistoryPickAccessor = ( new QuickPickItemScorerAccessor({ skipDescription: true }));
+        this.fileQueryDelayer = this._register(( new ThrottledDelayer(AnythingQuickAccessProvider_1.TYPING_SEARCH_DELAY)));
+        this.fileQueryBuilder = this.instantiationService.createInstance(QueryBuilder);
+        this.lazyRegistry = ( new Lazy(() => ( Registry.as(Extensions.Quickaccess))));
+        this.workspaceSymbolsQuickAccess = this._register(this.instantiationService.createInstance(SymbolsQuickAccessProvider));
+        this.editorSymbolsQuickAccess = this.instantiationService.createInstance(GotoSymbolQuickAccessProvider);
+    }
+    get configuration() {
+        const editorConfig = this.configurationService.getValue().workbench?.editor;
+        const searchConfig = this.configurationService.getValue().search;
+        const quickAccessConfig = this.configurationService.getValue().workbench.quickOpen;
+        return {
+            openEditorPinned: !editorConfig?.enablePreviewFromQuickOpen || !editorConfig?.enablePreview,
+            openSideBySideDirection: editorConfig?.openSideBySideDirection,
+            includeSymbols: searchConfig?.quickOpen.includeSymbols,
+            includeHistory: searchConfig?.quickOpen.includeHistory,
+            historyFilterSortOrder: searchConfig?.quickOpen.history.filterSortOrder,
+            preserveInput: quickAccessConfig.preserveInput
+        };
+    }
+    provide(picker, token, runOptions) {
+        const disposables = ( new DisposableStore());
+        this.pickState.set(picker);
+        const editorDecorationsDisposable = disposables.add(( new MutableDisposable()));
+        disposables.add(picker.onDidChangeActive(() => {
+            editorDecorationsDisposable.value = undefined;
+            const [item] = picker.activeItems;
+            if (isEditorSymbolQuickPickItem(item)) {
+                editorDecorationsDisposable.value = this.decorateAndRevealSymbolRange(item);
+            }
+        }));
+        disposables.add(Event.once(picker.onDidHide)(({ reason }) => {
+            if (reason === QuickInputHideReason.Gesture) {
+                this.pickState.editorViewState.restore();
+            }
+        }));
+        disposables.add(super.provide(picker, token, runOptions));
+        return disposables;
+    }
+    decorateAndRevealSymbolRange(pick) {
+        const activeEditor = this.editorService.activeEditor;
+        if (!this.uriIdentityService.extUri.isEqual(pick.resource, activeEditor?.resource)) {
+            return Disposable.None;
+        }
+        const activeEditorControl = this.editorService.activeTextEditorControl;
+        if (!activeEditorControl) {
+            return Disposable.None;
+        }
+        this.pickState.editorViewState.set();
+        activeEditorControl.revealRangeInCenter(pick.range.selection, 0 );
+        this.addDecorations(activeEditorControl, pick.range.decoration);
+        return toDisposable(() => this.clearDecorations(activeEditorControl));
+    }
+    _getPicks(originalFilter, disposables, token, runOptions) {
+        const filterWithRange = extractRangeFromFilter(originalFilter, [GotoSymbolQuickAccessProvider.PREFIX]);
+        let filter;
+        if (filterWithRange) {
+            filter = filterWithRange.filter;
+        }
+        else {
+            filter = originalFilter;
+        }
+        this.pickState.lastRange = filterWithRange?.range;
+        if (originalFilter !== this.pickState.lastOriginalFilter && filter === this.pickState.lastFilter) {
+            return null;
+        }
+        const lastWasFiltering = !!this.pickState.lastOriginalFilter;
+        this.pickState.lastOriginalFilter = originalFilter;
+        this.pickState.lastFilter = filter;
+        const picks = this.pickState.picker?.items;
+        const activePick = this.pickState.picker?.activeItems[0];
+        if (picks && activePick) {
+            const activePickIsEditorSymbol = isEditorSymbolQuickPickItem(activePick);
+            const activePickIsNoResultsInEditorSymbols = activePick === AnythingQuickAccessProvider_1.NO_RESULTS_PICK && filter.indexOf(GotoSymbolQuickAccessProvider.PREFIX) >= 0;
+            if (!activePickIsEditorSymbol && !activePickIsNoResultsInEditorSymbols) {
+                this.pickState.lastGlobalPicks = {
+                    items: picks,
+                    active: activePick
+                };
+            }
+        }
+        return this.doGetPicks(filter, {
+            ...runOptions,
+            enableEditorSymbolSearch: lastWasFiltering
+        }, disposables, token);
+    }
+    doGetPicks(filter, options, disposables, token) {
+        const query = prepareQuery(filter);
+        if (options.enableEditorSymbolSearch) {
+            const editorSymbolPicks = this.getEditorSymbolPicks(query, disposables, token);
+            if (editorSymbolPicks) {
+                return editorSymbolPicks;
+            }
+        }
+        const activePick = this.pickState.picker?.activeItems[0];
+        if (isEditorSymbolQuickPickItem(activePick) && this.pickState.lastGlobalPicks) {
+            return this.pickState.lastGlobalPicks;
+        }
+        const historyEditorPicks = this.getEditorHistoryPicks(query);
+        let picks = ( new Array());
+        if (options.additionPicks) {
+            picks.push(...options.additionPicks);
+        }
+        if (this.pickState.isQuickNavigating) {
+            if (picks.length > 0) {
+                picks.push({ type: 'separator', label: ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/anythingQuickAccess',
+                    'recentlyOpenedSeparator',
+                    "recently opened"
+                )) });
+            }
+            picks = historyEditorPicks;
+        }
+        else {
+            if (options.includeHelp) {
+                picks.push(...this.getHelpPicks(query, token, options));
+            }
+            if (historyEditorPicks.length !== 0) {
+                picks.push({ type: 'separator', label: ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/anythingQuickAccess',
+                    'recentlyOpenedSeparator',
+                    "recently opened"
+                )) });
+                picks.push(...historyEditorPicks);
+            }
+        }
+        return {
+            picks,
+            additionalPicks: (async () => {
+                const additionalPicksExcludes = ( new ResourceMap());
+                for (const historyEditorPick of historyEditorPicks) {
+                    if (historyEditorPick.resource) {
+                        additionalPicksExcludes.set(historyEditorPick.resource, true);
+                    }
+                }
+                const additionalPicks = await this.getAdditionalPicks(query, additionalPicksExcludes, token);
+                if (token.isCancellationRequested) {
+                    return [];
+                }
+                return additionalPicks.length > 0 ? [
+                    { type: 'separator', label: this.configuration.includeSymbols ? ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/anythingQuickAccess',
+                        'fileAndSymbolResultsSeparator',
+                        "file and symbol results"
+                    )) : ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/anythingQuickAccess',
+                        'fileResultsSeparator',
+                        "file results"
+                    )) },
+                    ...additionalPicks
+                ] : [];
+            })(),
+            mergeDelay: AnythingQuickAccessProvider_1.SYMBOL_PICKS_MERGE_DELAY
+        };
+    }
+    async getAdditionalPicks(query, excludes, token) {
+        const [filePicks, symbolPicks] = await Promise.all([
+            this.getFilePicks(query, excludes, token),
+            this.getWorkspaceSymbolPicks(query, token)
+        ]);
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        const sortedAnythingPicks = top([...filePicks, ...symbolPicks], (anyPickA, anyPickB) => compareItemsByFuzzyScore(anyPickA, anyPickB, query, true, quickPickItemScorerAccessor, this.pickState.scorerCache), AnythingQuickAccessProvider_1.MAX_RESULTS);
+        const filteredAnythingPicks = [];
+        for (const anythingPick of sortedAnythingPicks) {
+            if (anythingPick.highlights) {
+                filteredAnythingPicks.push(anythingPick);
+            }
+            else {
+                const { score, labelMatch, descriptionMatch } = scoreItemFuzzy(anythingPick, query, true, quickPickItemScorerAccessor, this.pickState.scorerCache);
+                if (!score) {
+                    continue;
+                }
+                anythingPick.highlights = {
+                    label: labelMatch,
+                    description: descriptionMatch
+                };
+                filteredAnythingPicks.push(anythingPick);
+            }
+        }
+        return filteredAnythingPicks;
+    }
+    getEditorHistoryPicks(query) {
+        const configuration = this.configuration;
+        if (!query.normalized) {
+            return ( this.historyService.getHistory().map(editor => this.createAnythingPick(editor, configuration)));
+        }
+        if (!this.configuration.includeHistory) {
+            return [];
+        }
+        const editorHistoryScorerAccessor = query.containsPathSeparator ? quickPickItemScorerAccessor : this.labelOnlyEditorHistoryPickAccessor;
+        const editorHistoryPicks = [];
+        for (const editor of this.historyService.getHistory()) {
+            const resource = editor.resource;
+            if (!resource || (!this.fileService.hasProvider(resource) && resource.scheme !== Schemas.untitled && resource.scheme !== Schemas.vscodeTerminal)) {
+                continue;
+            }
+            const editorHistoryPick = this.createAnythingPick(editor, configuration);
+            const { score, labelMatch, descriptionMatch } = scoreItemFuzzy(editorHistoryPick, query, false, editorHistoryScorerAccessor, this.pickState.scorerCache);
+            if (!score) {
+                continue;
+            }
+            editorHistoryPick.highlights = {
+                label: labelMatch,
+                description: descriptionMatch
+            };
+            editorHistoryPicks.push(editorHistoryPick);
+        }
+        if (this.configuration.historyFilterSortOrder === 'recency') {
+            return editorHistoryPicks;
+        }
+        return editorHistoryPicks.sort((editorA, editorB) => compareItemsByFuzzyScore(editorA, editorB, query, false, editorHistoryScorerAccessor, this.pickState.scorerCache));
+    }
+    createFileQueryCache() {
+        return ( new FileQueryCacheState(
+            cacheKey => this.fileQueryBuilder.file(this.contextService.getWorkspace().folders, this.getFileQueryOptions({ cacheKey })),
+            query => this.searchService.fileSearch(query),
+            cacheKey => this.searchService.clearCache(cacheKey),
+            this.pickState.fileQueryCache
+        )).load();
+    }
+    async getFilePicks(query, excludes, token) {
+        if (!query.normalized) {
+            return [];
+        }
+        const absolutePathResult = await this.getAbsolutePathFileResult(query, token);
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        let fileMatches;
+        if (absolutePathResult) {
+            if (( excludes.has(absolutePathResult))) {
+                return [];
+            }
+            const absolutePathPick = this.createAnythingPick(absolutePathResult, this.configuration);
+            absolutePathPick.highlights = {
+                label: [{ start: 0, end: absolutePathPick.label.length }],
+                description: absolutePathPick.description ? [{ start: 0, end: absolutePathPick.description.length }] : undefined
+            };
+            return [absolutePathPick];
+        }
+        if (this.pickState.fileQueryCache?.isLoaded) {
+            fileMatches = await this.doFileSearch(query, token);
+        }
+        else {
+            fileMatches = await this.fileQueryDelayer.trigger(async () => {
+                if (token.isCancellationRequested) {
+                    return [];
+                }
+                return this.doFileSearch(query, token);
+            });
+        }
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        const configuration = this.configuration;
+        return ( fileMatches
+            .filter(resource => !( excludes.has(resource)))
+            .map(resource => this.createAnythingPick(resource, configuration)));
+    }
+    async doFileSearch(query, token) {
+        const [fileSearchResults, relativePathFileResults] = await Promise.all([
+            this.getFileSearchResults(query, token),
+            this.getRelativePathFileResults(query, token)
+        ]);
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        if (!relativePathFileResults) {
+            return fileSearchResults;
+        }
+        const relativePathFileResultsMap = ( new ResourceMap());
+        for (const relativePathFileResult of relativePathFileResults) {
+            relativePathFileResultsMap.set(relativePathFileResult, true);
+        }
+        return [
+            ...fileSearchResults.filter(result => !( relativePathFileResultsMap.has(result))),
+            ...relativePathFileResults
+        ];
+    }
+    async getFileSearchResults(query, token) {
+        let filePattern = '';
+        if (query.values && query.values.length > 1) {
+            filePattern = query.values[0].original;
+        }
+        else {
+            filePattern = query.original;
+        }
+        const fileSearchResults = await this.doGetFileSearchResults(filePattern, token);
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        if (fileSearchResults.limitHit && query.values && query.values.length > 1) {
+            const additionalFileSearchResults = await this.doGetFileSearchResults(query.original, token);
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            const existingFileSearchResultsMap = ( new ResourceMap());
+            for (const fileSearchResult of fileSearchResults.results) {
+                existingFileSearchResultsMap.set(fileSearchResult.resource, true);
+            }
+            for (const additionalFileSearchResult of additionalFileSearchResults.results) {
+                if (!( existingFileSearchResultsMap.has(additionalFileSearchResult.resource))) {
+                    fileSearchResults.results.push(additionalFileSearchResult);
+                }
+            }
+        }
+        return ( fileSearchResults.results.map(result => result.resource));
+    }
+    doGetFileSearchResults(filePattern, token) {
+        const start = Date.now();
+        return this.searchService.fileSearch(this.fileQueryBuilder.file(this.contextService.getWorkspace().folders, this.getFileQueryOptions({
+            filePattern,
+            cacheKey: this.pickState.fileQueryCache?.cacheKey,
+            maxResults: AnythingQuickAccessProvider_1.MAX_RESULTS
+        })), token).finally(() => {
+            this.logService.trace(`QuickAccess fileSearch ${Date.now() - start}ms`);
+        });
+    }
+    getFileQueryOptions(input) {
+        return {
+            _reason: 'openFileHandler',
+            extraFileResources: this.instantiationService.invokeFunction(getOutOfWorkspaceEditorResources),
+            filePattern: input.filePattern || '',
+            cacheKey: input.cacheKey,
+            maxResults: input.maxResults || 0,
+            sortByScore: true
+        };
+    }
+    async getAbsolutePathFileResult(query, token) {
+        if (!query.containsPathSeparator) {
+            return;
+        }
+        const userHome = await this.pathService.userHome();
+        const detildifiedQuery = untildify(query.original, userHome.scheme === Schemas.file ? userHome.fsPath : userHome.path);
+        if (token.isCancellationRequested) {
+            return;
+        }
+        const isAbsolutePathQuery = (await this.pathService.path).isAbsolute(detildifiedQuery);
+        if (token.isCancellationRequested) {
+            return;
+        }
+        if (isAbsolutePathQuery) {
+            const resource = toLocalResource(await this.pathService.fileURI(detildifiedQuery), this.environmentService.remoteAuthority, this.pathService.defaultUriScheme);
+            if (token.isCancellationRequested) {
+                return;
+            }
+            try {
+                if ((await this.fileService.stat(resource)).isFile) {
+                    return resource;
+                }
+            }
+            catch (error) {
+            }
+        }
+        return;
+    }
+    async getRelativePathFileResults(query, token) {
+        if (!query.containsPathSeparator) {
+            return;
+        }
+        const isAbsolutePathQuery = (await this.pathService.path).isAbsolute(query.original);
+        if (!isAbsolutePathQuery) {
+            const resources = [];
+            for (const folder of this.contextService.getWorkspace().folders) {
+                if (token.isCancellationRequested) {
+                    break;
+                }
+                const resource = toLocalResource(folder.toResource(query.original), this.environmentService.remoteAuthority, this.pathService.defaultUriScheme);
+                try {
+                    if ((await this.fileService.stat(resource)).isFile) {
+                        resources.push(resource);
+                    }
+                }
+                catch (error) {
+                }
+            }
+            return resources;
+        }
+        return;
+    }
+    getHelpPicks(query, token, runOptions) {
+        if (query.normalized) {
+            return [];
+        }
+        const providers = this.lazyRegistry.value.getQuickAccessProviders()
+            .filter(p => ( p.helpEntries.some(h => h.commandCenterOrder !== undefined)))
+            .flatMap(provider => ( provider.helpEntries
+            .filter(h => h.commandCenterOrder !== undefined)
+            .map(helpEntry => {
+            const providerSpecificOptions = {
+                ...runOptions,
+                includeHelp: provider.prefix === AnythingQuickAccessProvider_1.PREFIX ? false : runOptions?.includeHelp
+            };
+            const label = helpEntry.commandCenterLabel ?? helpEntry.description;
+            return {
+                label,
+                description: helpEntry.prefix ?? provider.prefix,
+                commandCenterOrder: helpEntry.commandCenterOrder,
+                keybinding: helpEntry.commandId ? this.keybindingService.lookupKeybinding(helpEntry.commandId) : undefined,
+                ariaLabel: ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/anythingQuickAccess',
+                    'helpPickAriaLabel',
+                    "{0}, {1}",
+                    label,
+                    helpEntry.description
+                )),
+                accept: () => {
+                    this.quickInputService.quickAccess.show(provider.prefix, {
+                        preserveValue: true,
+                        providerOptions: providerSpecificOptions
+                    });
+                }
+            };
+        })));
+        if (this.quickChatService.enabled) {
+            providers.push({
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/search/browser/anythingQuickAccess',
+                    'chat',
+                    "Open Quick Chat"
+                )),
+                commandCenterOrder: 30,
+                keybinding: this.keybindingService.lookupKeybinding(ASK_QUICK_QUESTION_ACTION_ID),
+                accept: () => this.quickChatService.toggle()
+            });
+        }
+        return providers.sort((a, b) => a.commandCenterOrder - b.commandCenterOrder);
+    }
+    async getWorkspaceSymbolPicks(query, token) {
+        const configuration = this.configuration;
+        if (!query.normalized ||
+            !configuration.includeSymbols ||
+            this.pickState.lastRange
+        ) {
+            return [];
+        }
+        return this.workspaceSymbolsQuickAccess.getSymbolPicks(query.original, {
+            skipLocal: true,
+            skipSorting: true,
+            delay: AnythingQuickAccessProvider_1.TYPING_SEARCH_DELAY
+        }, token);
+    }
+    getEditorSymbolPicks(query, disposables, token) {
+        const filterSegments = query.original.split(GotoSymbolQuickAccessProvider.PREFIX);
+        const filter = filterSegments.length > 1 ? filterSegments[filterSegments.length - 1].trim() : undefined;
+        if (typeof filter !== 'string') {
+            return null;
+        }
+        const activeGlobalPick = this.pickState.lastGlobalPicks?.active;
+        if (!activeGlobalPick) {
+            return null;
+        }
+        const activeGlobalResource = activeGlobalPick.resource;
+        if (!activeGlobalResource || (!this.fileService.hasProvider(activeGlobalResource) && activeGlobalResource.scheme !== Schemas.untitled)) {
+            return null;
+        }
+        if (activeGlobalPick.label.includes(GotoSymbolQuickAccessProvider.PREFIX) || activeGlobalPick.description?.includes(GotoSymbolQuickAccessProvider.PREFIX)) {
+            if (filterSegments.length < 3) {
+                return null;
+            }
+        }
+        return this.doGetEditorSymbolPicks(activeGlobalPick, activeGlobalResource, filter, disposables, token);
+    }
+    async doGetEditorSymbolPicks(activeGlobalPick, activeGlobalResource, filter, disposables, token) {
+        try {
+            this.pickState.editorViewState.set();
+            await this.pickState.editorViewState.openTransientEditor({
+                resource: activeGlobalResource,
+                options: { preserveFocus: true, revealIfOpened: true, ignoreError: true }
+            });
+        }
+        catch (error) {
+            return [];
+        }
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        let model = this.modelService.getModel(activeGlobalResource);
+        if (!model) {
+            try {
+                const modelReference = disposables.add(await this.textModelService.createModelReference(activeGlobalResource));
+                if (token.isCancellationRequested) {
+                    return [];
+                }
+                model = modelReference.object.textEditorModel;
+            }
+            catch (error) {
+                return [];
+            }
+        }
+        const editorSymbolPicks = (await this.editorSymbolsQuickAccess.getSymbolPicks(model, filter, { extraContainerLabel: stripIcons(activeGlobalPick.label) }, disposables, token));
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        return ( editorSymbolPicks.map(editorSymbolPick => {
+            if (editorSymbolPick.type === 'separator') {
+                return editorSymbolPick;
+            }
+            return {
+                ...editorSymbolPick,
+                resource: activeGlobalResource,
+                description: editorSymbolPick.description,
+                trigger: (buttonIndex, keyMods) => {
+                    this.openAnything(activeGlobalResource, { keyMods, range: editorSymbolPick.range?.selection, forceOpenSideBySide: true });
+                    return TriggerAction.CLOSE_PICKER;
+                },
+                accept: (keyMods, event) => this.openAnything(activeGlobalResource, { keyMods, range: editorSymbolPick.range?.selection, preserveFocus: event.inBackground, forcePinned: event.inBackground })
+            };
+        }));
+    }
+    addDecorations(editor, range) {
+        this.editorSymbolsQuickAccess.addDecorations(editor, range);
+    }
+    clearDecorations(editor) {
+        this.editorSymbolsQuickAccess.clearDecorations(editor);
+    }
+    createAnythingPick(resourceOrEditor, configuration) {
+        const isEditorHistoryEntry = !URI.isUri(resourceOrEditor);
+        let resource;
+        let label;
+        let description = undefined;
+        let isDirty = undefined;
+        let extraClasses;
+        let icon = undefined;
+        if (isEditorInput(resourceOrEditor)) {
+            resource = EditorResourceAccessor.getOriginalUri(resourceOrEditor);
+            label = resourceOrEditor.getName();
+            description = resourceOrEditor.getDescription();
+            isDirty = resourceOrEditor.isDirty() && !resourceOrEditor.isSaving();
+            extraClasses = resourceOrEditor.getLabelExtraClasses();
+            icon = resourceOrEditor.getIcon();
+        }
+        else {
+            resource = URI.isUri(resourceOrEditor) ? resourceOrEditor : resourceOrEditor.resource;
+            label = basenameOrAuthority(resource);
+            description = this.labelService.getUriLabel(dirname(resource), { relative: true });
+            isDirty = this.workingCopyService.isDirty(resource) && !this.filesConfigurationService.hasShortAutoSaveDelay(resource);
+            extraClasses = [];
+        }
+        const labelAndDescription = description ? `${label} ${description}` : label;
+        const iconClassesValue = ( new Lazy(
+            () => getIconClasses(this.modelService, this.languageService, resource, undefined, icon).concat(extraClasses)
+        ));
+        const buttonsValue = ( new Lazy(() => {
+            const openSideBySideDirection = configuration.openSideBySideDirection;
+            const buttons = [];
+            buttons.push({
+                iconClass: openSideBySideDirection === 'right' ? ThemeIcon.asClassName(Codicon.splitHorizontal) : ThemeIcon.asClassName(Codicon.splitVertical),
+                tooltip: openSideBySideDirection === 'right' ?
+                    ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/anythingQuickAccess',
+                        { key: 'openToSide', comment: ['Open this file in a split editor on the left/right side'] },
+                        "Open to the Side"
+                    )) :
+                    ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/anythingQuickAccess',
+                        { key: 'openToBottom', comment: ['Open this file in a split editor on the bottom'] },
+                        "Open to the Bottom"
+                    ))
+            });
+            if (isEditorHistoryEntry) {
+                buttons.push({
+                    iconClass: isDirty ? ('dirty-anything ' + ThemeIcon.asClassName(Codicon.circleFilled)) : ThemeIcon.asClassName(Codicon.close),
+                    tooltip: ( localizeWithPath(
+                        'vs/workbench/contrib/search/browser/anythingQuickAccess',
+                        'closeEditor',
+                        "Remove from Recently Opened"
+                    )),
+                    alwaysVisible: isDirty
+                });
+            }
+            return buttons;
+        }));
+        return {
+            resource,
+            label,
+            ariaLabel: isDirty ? ( localizeWithPath(
+                'vs/workbench/contrib/search/browser/anythingQuickAccess',
+                'filePickAriaLabelDirty',
+                "{0} unsaved changes",
+                labelAndDescription
+            )) : labelAndDescription,
+            description,
+            get iconClasses() { return iconClassesValue.value; },
+            get buttons() { return buttonsValue.value; },
+            trigger: (buttonIndex, keyMods) => {
+                switch (buttonIndex) {
+                    case 0:
+                        this.openAnything(resourceOrEditor, { keyMods, range: this.pickState.lastRange, forceOpenSideBySide: true });
+                        return TriggerAction.CLOSE_PICKER;
+                    case 1:
+                        if (!URI.isUri(resourceOrEditor)) {
+                            this.historyService.removeFromHistory(resourceOrEditor);
+                            return TriggerAction.REMOVE_ITEM;
+                        }
+                }
+                return TriggerAction.NO_ACTION;
+            },
+            accept: (keyMods, event) => this.openAnything(resourceOrEditor, { keyMods, range: this.pickState.lastRange, preserveFocus: event.inBackground, forcePinned: event.inBackground })
+        };
+    }
+    async openAnything(resourceOrEditor, options) {
+        const editorOptions = {
+            preserveFocus: options.preserveFocus,
+            pinned: options.keyMods?.ctrlCmd || options.forcePinned || this.configuration.openEditorPinned,
+            selection: options.range ? Range.collapseToStart(options.range) : undefined
+        };
+        const targetGroup = options.keyMods?.alt || (this.configuration.openEditorPinned && options.keyMods?.ctrlCmd) || options.forceOpenSideBySide ? SIDE_GROUP : ACTIVE_GROUP;
+        if (targetGroup === SIDE_GROUP) {
+            await this.pickState.editorViewState.restore();
+        }
+        if (isEditorInput(resourceOrEditor)) {
+            await this.editorService.openEditor(resourceOrEditor, editorOptions, targetGroup);
+        }
+        else {
+            let resourceEditorInput;
+            if (URI.isUri(resourceOrEditor)) {
+                resourceEditorInput = {
+                    resource: resourceOrEditor,
+                    options: editorOptions
+                };
+            }
+            else {
+                resourceEditorInput = {
+                    ...resourceOrEditor,
+                    options: {
+                        ...resourceOrEditor.options,
+                        ...editorOptions
+                    }
+                };
+            }
+            await this.editorService.openEditor(resourceEditorInput, targetGroup);
+        }
+    }
+};
+AnythingQuickAccessProvider = AnythingQuickAccessProvider_1 = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, ISearchService)),
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IPathService)),
+    ( __param(4, IWorkbenchEnvironmentService)),
+    ( __param(5, IFileService)),
+    ( __param(6, ILabelService)),
+    ( __param(7, IModelService)),
+    ( __param(8, ILanguageService)),
+    ( __param(9, IWorkingCopyService)),
+    ( __param(10, IConfigurationService)),
+    ( __param(11, IEditorService)),
+    ( __param(12, IHistoryService)),
+    ( __param(13, IFilesConfigurationService)),
+    ( __param(14, ITextModelService)),
+    ( __param(15, IUriIdentityService)),
+    ( __param(16, IQuickInputService)),
+    ( __param(17, IKeybindingService)),
+    ( __param(18, IQuickChatService)),
+    ( __param(19, ILogService))
+], AnythingQuickAccessProvider));
+
+export { AnythingQuickAccessProvider };