@codingame/monaco-vscode-api 1.79.0-next.0 → 1.79.1

package/dist/vscode/vs/workbench/services/search/common/searchService.js

@@ -1,355 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import * as arrays from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
-import { CancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
-import { isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
-import { IEditorService } from '../../editor/common/editorService.js';
-import { IExtensionService } from '../../extensions/common/extensions.js';
-import { deserializeSearchError, pathIncludedInQuery, isFileMatch, isProgressMessage, SearchErrorCode, FileMatch } from './search.js';
-import { editorMatchesToTextSearchResults, addContextToEditorMatches } from './searchHelpers.js';
-let SearchService = class SearchService extends Disposable {
-    constructor(modelService, editorService, telemetryService, logService, extensionService, fileService, uriIdentityService) {
-        super();
-        this.modelService = modelService;
-        this.editorService = editorService;
-        this.telemetryService = telemetryService;
-        this.logService = logService;
-        this.extensionService = extensionService;
-        this.fileService = fileService;
-        this.uriIdentityService = uriIdentityService;
-        this.fileSearchProviders = ( new Map());
-        this.textSearchProviders = ( new Map());
-        this.deferredFileSearchesByScheme = ( new Map());
-        this.deferredTextSearchesByScheme = ( new Map());
-        this.loggedSchemesMissingProviders = ( new Set());
-    }
-    registerSearchResultProvider(scheme, type, provider) {
-        let list;
-        let deferredMap;
-        if (type === 0 ) {
-            list = this.fileSearchProviders;
-            deferredMap = this.deferredFileSearchesByScheme;
-        }
-        else if (type === 1 ) {
-            list = this.textSearchProviders;
-            deferredMap = this.deferredTextSearchesByScheme;
-        }
-        else {
-            throw new Error('Unknown SearchProviderType');
-        }
-        list.set(scheme, provider);
-        if (( deferredMap.has(scheme))) {
-            deferredMap.get(scheme).complete(provider);
-            deferredMap.delete(scheme);
-        }
-        return toDisposable(() => {
-            list.delete(scheme);
-        });
-    }
-    async textSearch(query, token, onProgress, notebookURIs) {
-        const localResults = this.getLocalResults(query);
-        if (onProgress) {
-            arrays.coalesce([...( localResults.results.values())]).forEach(onProgress);
-        }
-        const onProviderProgress = (progress) => {
-            if (isFileMatch(progress)) {
-                if (!( localResults.results.has(progress.resource)) && !(notebookURIs && ( notebookURIs.has(progress.resource))) && onProgress) {
-                    onProgress(progress);
-                }
-            }
-            else if (onProgress) {
-                onProgress(progress);
-            }
-            if (isProgressMessage(progress)) {
-                this.logService.debug('SearchService#search', progress.message);
-            }
-        };
-        const otherResults = await this.doSearch(query, token, onProviderProgress);
-        return {
-            ...otherResults,
-            ...{
-                limitHit: otherResults.limitHit || localResults.limitHit
-            },
-            results: [...otherResults.results, ...arrays.coalesce([...( localResults.results.values())])]
-        };
-    }
-    fileSearch(query, token) {
-        return this.doSearch(query, token);
-    }
-    doSearch(query, token, onProgress) {
-        this.logService.trace('SearchService#search', JSON.stringify(query));
-        const schemesInQuery = this.getSchemesInQuery(query);
-        const providerActivations = [Promise.resolve(null)];
-        schemesInQuery.forEach(scheme => providerActivations.push(this.extensionService.activateByEvent(`onSearch:${scheme}`)));
-        providerActivations.push(this.extensionService.activateByEvent('onSearch:file'));
-        const providerPromise = (async () => {
-            await Promise.all(providerActivations);
-            await this.extensionService.whenInstalledExtensionsRegistered();
-            if (token && token.isCancellationRequested) {
-                return Promise.reject(( new CancellationError()));
-            }
-            const progressCallback = (item) => {
-                if (token && token.isCancellationRequested) {
-                    return;
-                }
-                onProgress?.(item);
-            };
-            const exists = await Promise.all(( query.folderQueries.map(query => this.fileService.exists(query.folder))));
-            query.folderQueries = query.folderQueries.filter((_, i) => exists[i]);
-            let completes = await this.searchWithProviders(query, progressCallback, token);
-            completes = arrays.coalesce(completes);
-            if (!completes.length) {
-                return {
-                    limitHit: false,
-                    results: [],
-                    messages: [],
-                };
-            }
-            return {
-                limitHit: completes[0] && completes[0].limitHit,
-                stats: completes[0].stats,
-                messages: arrays.coalesce(arrays.flatten(( completes.map(i => i.messages)))).filter(arrays.uniqueFilter(message => message.type + message.text + message.trusted)),
-                results: arrays.flatten(( completes.map((c) => c.results)))
-            };
-        })();
-        return ( new Promise((resolve, reject) => {
-            if (token) {
-                token.onCancellationRequested(() => {
-                    reject(( new CancellationError()));
-                });
-            }
-            providerPromise.then(resolve, reject);
-        }));
-    }
-    getSchemesInQuery(query) {
-        const schemes = ( new Set());
-        query.folderQueries?.forEach(fq => schemes.add(fq.folder.scheme));
-        query.extraFileResources?.forEach(extraFile => schemes.add(extraFile.scheme));
-        return schemes;
-    }
-    async waitForProvider(queryType, scheme) {
-        const deferredMap = queryType === 1  ?
-            this.deferredFileSearchesByScheme :
-            this.deferredTextSearchesByScheme;
-        if (( deferredMap.has(scheme))) {
-            return deferredMap.get(scheme).p;
-        }
-        else {
-            const deferred = ( new DeferredPromise());
-            deferredMap.set(scheme, deferred);
-            return deferred.p;
-        }
-    }
-    async searchWithProviders(query, onProviderProgress, token) {
-        const e2eSW = StopWatch.create(false);
-        const searchPs = [];
-        const fqs = this.groupFolderQueriesByScheme(query);
-        const someSchemeHasProvider = ( [...( fqs.keys())].some(scheme => {
-            return query.type === 1  ?
-                ( this.fileSearchProviders.has(scheme)) :
-                ( this.textSearchProviders.has(scheme));
-        }));
-        await Promise.all(( [...( fqs.keys())].map(async (scheme) => {
-            const schemeFQs = fqs.get(scheme);
-            let provider = query.type === 1  ?
-                this.fileSearchProviders.get(scheme) :
-                this.textSearchProviders.get(scheme);
-            if (!provider) {
-                if (someSchemeHasProvider) {
-                    if (!( this.loggedSchemesMissingProviders.has(scheme))) {
-                        this.logService.warn(`No search provider registered for scheme: ${scheme}. Another scheme has a provider, not waiting for ${scheme}`);
-                        this.loggedSchemesMissingProviders.add(scheme);
-                    }
-                    return;
-                }
-                else {
-                    if (!( this.loggedSchemesMissingProviders.has(scheme))) {
-                        this.logService.warn(`No search provider registered for scheme: ${scheme}, waiting`);
-                        this.loggedSchemesMissingProviders.add(scheme);
-                    }
-                    provider = await this.waitForProvider(query.type, scheme);
-                }
-            }
-            const oneSchemeQuery = {
-                ...query,
-                ...{
-                    folderQueries: schemeFQs
-                }
-            };
-            searchPs.push(query.type === 1  ?
-                provider.fileSearch(oneSchemeQuery, token) :
-                provider.textSearch(oneSchemeQuery, onProviderProgress, token));
-        })));
-        return Promise.all(searchPs).then(completes => {
-            const endToEndTime = e2eSW.elapsed();
-            this.logService.trace(`SearchService#search: ${endToEndTime}ms`);
-            completes.forEach(complete => {
-                this.sendTelemetry(query, endToEndTime, complete);
-            });
-            return completes;
-        }, err => {
-            const endToEndTime = e2eSW.elapsed();
-            this.logService.trace(`SearchService#search: ${endToEndTime}ms`);
-            const searchError = deserializeSearchError(err);
-            this.logService.trace(`SearchService#searchError: ${searchError.message}`);
-            this.sendTelemetry(query, endToEndTime, undefined, searchError);
-            throw searchError;
-        });
-    }
-    groupFolderQueriesByScheme(query) {
-        const queries = ( new Map());
-        query.folderQueries.forEach(fq => {
-            const schemeFQs = queries.get(fq.folder.scheme) || [];
-            schemeFQs.push(fq);
-            queries.set(fq.folder.scheme, schemeFQs);
-        });
-        return queries;
-    }
-    sendTelemetry(query, endToEndTime, complete, err) {
-        const fileSchemeOnly = query.folderQueries.every(fq => fq.folder.scheme === Schemas.file);
-        const otherSchemeOnly = query.folderQueries.every(fq => fq.folder.scheme !== Schemas.file);
-        const scheme = fileSchemeOnly ? Schemas.file :
-            otherSchemeOnly ? 'other' :
-                'mixed';
-        if (query.type === 1  && complete && complete.stats) {
-            const fileSearchStats = complete.stats;
-            if (fileSearchStats.fromCache) {
-                const cacheStats = fileSearchStats.detailStats;
-                this.telemetryService.publicLog2('cachedSearchComplete', {
-                    reason: query._reason,
-                    resultCount: fileSearchStats.resultCount,
-                    workspaceFolderCount: query.folderQueries.length,
-                    endToEndTime: endToEndTime,
-                    sortingTime: fileSearchStats.sortingTime,
-                    cacheWasResolved: cacheStats.cacheWasResolved,
-                    cacheLookupTime: cacheStats.cacheLookupTime,
-                    cacheFilterTime: cacheStats.cacheFilterTime,
-                    cacheEntryCount: cacheStats.cacheEntryCount,
-                    scheme
-                });
-            }
-            else {
-                const searchEngineStats = fileSearchStats.detailStats;
-                this.telemetryService.publicLog2('searchComplete', {
-                    reason: query._reason,
-                    resultCount: fileSearchStats.resultCount,
-                    workspaceFolderCount: query.folderQueries.length,
-                    endToEndTime: endToEndTime,
-                    sortingTime: fileSearchStats.sortingTime,
-                    fileWalkTime: searchEngineStats.fileWalkTime,
-                    directoriesWalked: searchEngineStats.directoriesWalked,
-                    filesWalked: searchEngineStats.filesWalked,
-                    cmdTime: searchEngineStats.cmdTime,
-                    cmdResultCount: searchEngineStats.cmdResultCount,
-                    scheme
-                });
-            }
-        }
-        else if (query.type === 2 ) {
-            let errorType;
-            if (err) {
-                errorType = err.code === SearchErrorCode.regexParseError ? 'regex' :
-                    err.code === SearchErrorCode.unknownEncoding ? 'encoding' :
-                        err.code === SearchErrorCode.globParseError ? 'glob' :
-                            err.code === SearchErrorCode.invalidLiteral ? 'literal' :
-                                err.code === SearchErrorCode.other ? 'other' :
-                                    err.code === SearchErrorCode.canceled ? 'canceled' :
-                                        'unknown';
-            }
-            this.telemetryService.publicLog2('textSearchComplete', {
-                reason: query._reason,
-                workspaceFolderCount: query.folderQueries.length,
-                endToEndTime: endToEndTime,
-                scheme,
-                error: errorType,
-            });
-        }
-    }
-    getLocalResults(query) {
-        const localResults = ( new ResourceMap(uri => this.uriIdentityService.extUri.getComparisonKey(uri)));
-        let limitHit = false;
-        if (query.type === 2 ) {
-            const canonicalToOriginalResources = ( new ResourceMap());
-            for (const editorInput of this.editorService.editors) {
-                const canonical = EditorResourceAccessor.getCanonicalUri(editorInput, { supportSideBySide: SideBySideEditor.PRIMARY });
-                const original = EditorResourceAccessor.getOriginalUri(editorInput, { supportSideBySide: SideBySideEditor.PRIMARY });
-                if (canonical) {
-                    canonicalToOriginalResources.set(canonical, original ?? canonical);
-                }
-            }
-            const models = this.modelService.getModels();
-            models.forEach((model) => {
-                const resource = model.uri;
-                if (!resource) {
-                    return;
-                }
-                if (limitHit) {
-                    return;
-                }
-                const originalResource = canonicalToOriginalResources.get(resource);
-                if (!originalResource) {
-                    return;
-                }
-                if (model.getLanguageId() === 'search-result' && !(query.includePattern && query.includePattern['**/*.code-search'])) {
-                    return;
-                }
-                if (originalResource.scheme !== Schemas.untitled && !this.fileService.hasProvider(originalResource)) {
-                    return;
-                }
-                if (originalResource.scheme === 'git') {
-                    return;
-                }
-                if (!this.matches(originalResource, query)) {
-                    return;
-                }
-                const askMax = isNumber(query.maxResults) ? query.maxResults + 1 : Number.MAX_SAFE_INTEGER;
-                let matches = model.findMatches(query.contentPattern.pattern, false, !!query.contentPattern.isRegExp, !!query.contentPattern.isCaseSensitive, query.contentPattern.isWordMatch ? query.contentPattern.wordSeparators : null, false, askMax);
-                if (matches.length) {
-                    if (askMax && matches.length >= askMax) {
-                        limitHit = true;
-                        matches = matches.slice(0, askMax - 1);
-                    }
-                    const fileMatch = ( new FileMatch(originalResource));
-                    localResults.set(originalResource, fileMatch);
-                    const textSearchResults = editorMatchesToTextSearchResults(matches, model, query.previewOptions);
-                    fileMatch.results = addContextToEditorMatches(textSearchResults, model, query);
-                }
-                else {
-                    localResults.set(originalResource, null);
-                }
-            });
-        }
-        return {
-            results: localResults,
-            limitHit
-        };
-    }
-    matches(resource, query) {
-        return pathIncludedInQuery(query, resource.fsPath);
-    }
-    async clearCache(cacheKey) {
-        const clearPs = ( Array.from(( this.fileSearchProviders.values()))
-            .map(provider => provider && provider.clearCache(cacheKey)));
-        await Promise.all(clearPs);
-    }
-};
-SearchService = ( __decorate([
-    ( __param(0, IModelService)),
-    ( __param(1, IEditorService)),
-    ( __param(2, ITelemetryService)),
-    ( __param(3, ILogService)),
-    ( __param(4, IExtensionService)),
-    ( __param(5, IFileService)),
-    ( __param(6, IUriIdentityService))
-], SearchService));
-export { SearchService };