@codingame/monaco-vscode-api 1.82.4-next.1 → 1.82.5-next.0

package/vscode/src/vs/workbench/services/remote/common/remoteAgentEnvironmentChannel.js

@@ -1,51 +0,0 @@
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
-class RemoteExtensionEnvironmentChannelClient {
-    static async getEnvironmentData(channel, remoteAuthority, profile) {
-        const args = {
-            remoteAuthority,
-            profile
-        };
-        const data = await channel.call('getEnvironmentData', args);
-        return {
-            pid: data.pid,
-            connectionToken: data.connectionToken,
-            appRoot: URI.revive(data.appRoot),
-            settingsPath: URI.revive(data.settingsPath),
-            logsPath: URI.revive(data.logsPath),
-            extensionHostLogsPath: URI.revive(data.extensionHostLogsPath),
-            globalStorageHome: URI.revive(data.globalStorageHome),
-            workspaceStorageHome: URI.revive(data.workspaceStorageHome),
-            localHistoryHome: URI.revive(data.localHistoryHome),
-            userHome: URI.revive(data.userHome),
-            os: data.os,
-            arch: data.arch,
-            marks: data.marks,
-            useHostProxy: data.useHostProxy,
-            profiles: revive(data.profiles)
-        };
-    }
-    static async getExtensionHostExitInfo(channel, remoteAuthority, reconnectionToken) {
-        const args = {
-            remoteAuthority,
-            reconnectionToken
-        };
-        return channel.call('getExtensionHostExitInfo', args);
-    }
-    static getDiagnosticInfo(channel, options) {
-        return channel.call('getDiagnosticInfo', options);
-    }
-    static updateTelemetryLevel(channel, telemetryLevel) {
-        return channel.call('updateTelemetryLevel', { telemetryLevel });
-    }
-    static logTelemetry(channel, eventName, data) {
-        return channel.call('logTelemetry', { eventName, data });
-    }
-    static flushTelemetry(channel) {
-        return channel.call('flushTelemetry');
-    }
-    static async ping(channel) {
-        await channel.call('ping');
-    }
-}
-export { RemoteExtensionEnvironmentChannelClient };

package/vscode/src/vs/workbench/services/remote/common/remoteFileSystemProviderClient.js

@@ -1,38 +0,0 @@
-import { getErrorMessage } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { DiskFileSystemProviderClient } from '../../../../platform/files/common/diskFileSystemProviderClient.js';
-const REMOTE_FILE_SYSTEM_CHANNEL_NAME = 'remoteFilesystem';
-class RemoteFileSystemProviderClient extends DiskFileSystemProviderClient {
-    static register(remoteAgentService, fileService, logService) {
-        const connection = remoteAgentService.getConnection();
-        if (!connection) {
-            return Disposable.None;
-        }
-        const disposables = ( new DisposableStore());
-        const environmentPromise = (async () => {
-            try {
-                const environment = await remoteAgentService.getRawEnvironment();
-                if (environment) {
-                    fileService.registerProvider(Schemas.vscodeRemote, disposables.add(( new RemoteFileSystemProviderClient(environment, connection))));
-                }
-                else {
-                    logService.error('Cannot register remote filesystem provider. Remote environment doesnot exist.');
-                }
-            }
-            catch (error) {
-                logService.error('Cannot register remote filesystem provider. Error while fetching remote environment.', getErrorMessage(error));
-            }
-        })();
-        disposables.add(fileService.onWillActivateFileSystemProvider(e => {
-            if (e.scheme === Schemas.vscodeRemote) {
-                e.join(environmentPromise);
-            }
-        }));
-        return disposables;
-    }
-    constructor(remoteAgentEnvironment, connection) {
-        super(connection.getChannel(REMOTE_FILE_SYSTEM_CHANNEL_NAME), { pathCaseSensitive: remoteAgentEnvironment.os === 3  });
-    }
-}
-export { REMOTE_FILE_SYSTEM_CHANNEL_NAME, RemoteFileSystemProviderClient };

package/vscode/src/vs/workbench/services/search/common/queryBuilder.d.ts

@@ -1,35 +0,0 @@
-import { URI } from '../../../../base/common/uri.js';
-import { ITextSearchPreviewOptions } from './search.js';
-
-interface ICommonQueryBuilderOptions {
-    _reason?: string;
-    excludePattern?: string | string[];
-    includePattern?: string | string[];
-    extraFileResources?: URI[];
-    /** Parse the special ./ syntax supported by the searchview, and expand foo to ** /foo */
-    expandPatterns?: boolean;
-    maxResults?: number;
-    maxFileSize?: number;
-    disregardIgnoreFiles?: boolean;
-    disregardGlobalIgnoreFiles?: boolean;
-    disregardParentIgnoreFiles?: boolean;
-    disregardExcludeSettings?: boolean;
-    disregardSearchExcludeSettings?: boolean;
-    ignoreSymlinks?: boolean;
-    onlyOpenEditors?: boolean;
-}
-interface ITextQueryBuilderOptions extends ICommonQueryBuilderOptions {
-    previewOptions?: ITextSearchPreviewOptions;
-    fileEncoding?: string;
-    beforeContext?: number;
-    afterContext?: number;
-    isSmartCase?: boolean;
-    notebookSearchConfig?: {
-        includeMarkupInput: boolean;
-        includeMarkupPreview: boolean;
-        includeCodeInput: boolean;
-        includeOutput: boolean;
-    };
-}
-
-export type { ITextQueryBuilderOptions };

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

@@ -1,370 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/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 { ResourceSet, 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, SearchErrorCode, FileMatch, isFileMatch, isProgressMessage } 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) {
-        const results = this.textSearchSplitSyncAsync(query, token, onProgress);
-        const openEditorResults = results.syncResults;
-        const otherResults = await results.asyncResults;
-        return {
-            limitHit: otherResults.limitHit || openEditorResults.limitHit,
-            results: [...otherResults.results, ...openEditorResults.results],
-            messages: [...otherResults.messages, ...openEditorResults.messages]
-        };
-    }
-    textSearchSplitSyncAsync(query, token, onProgress, notebookFilesToIgnore, asyncNotebookFilesToIgnore) {
-        const openEditorResults = this.getOpenEditorResults(query);
-        if (onProgress) {
-            arrays.coalesce([...( openEditorResults.results.values())]).filter(e => !(notebookFilesToIgnore && ( notebookFilesToIgnore.has(e.resource)))).forEach(onProgress);
-        }
-        const syncResults = {
-            results: arrays.coalesce([...( openEditorResults.results.values())]),
-            limitHit: openEditorResults.limitHit ?? false,
-            messages: []
-        };
-        const getAsyncResults = async () => {
-            const resolvedAsyncNotebookFilesToIgnore = (await asyncNotebookFilesToIgnore) ?? ( new ResourceSet());
-            const onProviderProgress = (progress) => {
-                if (isFileMatch(progress)) {
-                    if (!( openEditorResults.results.has(progress.resource)) && !( resolvedAsyncNotebookFilesToIgnore.has(progress.resource)) && onProgress) {
-                        onProgress(progress);
-                    }
-                }
-                else if (onProgress) {
-                    onProgress(progress);
-                }
-                if (isProgressMessage(progress)) {
-                    this.logService.debug('SearchService#search', progress.message);
-                }
-            };
-            return await this.doSearch(query, token, onProviderProgress);
-        };
-        return {
-            syncResults,
-            asyncResults: getAsyncResults()
-        };
-    }
-    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,
-            });
-        }
-    }
-    getOpenEditorResults(query) {
-        const openEditorResults = ( 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));
-                    openEditorResults.set(originalResource, fileMatch);
-                    const textSearchResults = editorMatchesToTextSearchResults(matches, model, query.previewOptions);
-                    fileMatch.results = addContextToEditorMatches(textSearchResults, model, query);
-                }
-                else {
-                    openEditorResults.set(originalResource, null);
-                }
-            });
-        }
-        return {
-            results: openEditorResults,
-            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 };

package/vscode/src/vs/workbench/services/storage/browser/storageService.d.ts

@@ -1,40 +0,0 @@
-import { IStorage } from '../../../../base/parts/storage/common/storage.js';
-import { ILogService } from '../../../../platform/log/common/log.js';
-import { AbstractStorageService, StorageScope } from '../../../../platform/storage/common/storage.js';
-import { IUserDataProfile } from '../../../../platform/userDataProfile/common/userDataProfile.js';
-import { IAnyWorkspaceIdentifier } from '../../../../platform/workspace/common/workspace.js';
-import { IUserDataProfileService } from '../../userDataProfile/common/userDataProfile.js';
-
-declare class BrowserStorageService extends AbstractStorageService {
-    private readonly workspace;
-    private readonly userDataProfileService;
-    private readonly logService;
-    private static BROWSER_DEFAULT_FLUSH_INTERVAL;
-    private applicationStorage;
-    private applicationStorageDatabase;
-    private readonly applicationStoragePromise;
-    private profileStorage;
-    private profileStorageDatabase;
-    private profileStorageProfile;
-    private readonly profileStorageDisposables;
-    private workspaceStorage;
-    private workspaceStorageDatabase;
-    get hasPendingUpdate(): boolean;
-    constructor(workspace: IAnyWorkspaceIdentifier, userDataProfileService: IUserDataProfileService, logService: ILogService);
-    private registerListeners;
-    protected doInitialize(): Promise<void>;
-    private createApplicationStorage;
-    private createProfileStorage;
-    private createWorkspaceStorage;
-    private updateIsNew;
-    protected getStorage(scope: StorageScope): IStorage | undefined;
-    protected getLogDetails(scope: StorageScope): string | undefined;
-    protected switchToProfile(toProfile: IUserDataProfile): Promise<void>;
-    protected switchToWorkspace(toWorkspace: IAnyWorkspaceIdentifier, preserveData: boolean): Promise<void>;
-    protected shouldFlushWhenIdle(): boolean;
-    close(): void;
-    clear(): Promise<void>;
-    hasScope(scope: IAnyWorkspaceIdentifier | IUserDataProfile): boolean;
-}
-
-export { BrowserStorageService };