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

package/vscode/src/vs/workbench/api/browser/mainThreadSearch.js

@@ -0,0 +1,168 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { dispose, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ISearchService } from 'vscode/vscode/vs/workbench/services/search/common/search';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { revive } from 'vscode/vscode/vs/base/common/marshalling';
+import { SearchContext } from 'vscode/vscode/vs/workbench/contrib/search/common/constants';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+
+let MainThreadSearch = class MainThreadSearch {
+    constructor(extHostContext, _searchService, _telemetryService, _configurationService, contextKeyService) {
+        this._searchService = _searchService;
+        this._telemetryService = _telemetryService;
+        this.contextKeyService = contextKeyService;
+        this._searchProvider = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostSearch));
+        this._proxy.$enableExtensionHostSearch();
+    }
+    dispose() {
+        this._searchProvider.forEach(value => value.dispose());
+        this._searchProvider.clear();
+    }
+    $registerTextSearchProvider(handle, scheme) {
+        this._searchProvider.set(handle, ( new RemoteSearchProvider(
+            this._searchService,
+            1 ,
+            scheme,
+            handle,
+            this._proxy
+        )));
+    }
+    $registerAITextSearchProvider(handle, scheme) {
+        SearchContext.hasAIResultProvider.bindTo(this.contextKeyService).set(true);
+        this._searchProvider.set(handle, ( new RemoteSearchProvider(
+            this._searchService,
+            2 ,
+            scheme,
+            handle,
+            this._proxy
+        )));
+    }
+    $registerFileSearchProvider(handle, scheme) {
+        this._searchProvider.set(handle, ( new RemoteSearchProvider(
+            this._searchService,
+            0 ,
+            scheme,
+            handle,
+            this._proxy
+        )));
+    }
+    $unregisterProvider(handle) {
+        dispose(this._searchProvider.get(handle));
+        this._searchProvider.delete(handle);
+    }
+    $handleFileMatch(handle, session, data) {
+        const provider = this._searchProvider.get(handle);
+        if (!provider) {
+            throw new Error('Got result for unknown provider');
+        }
+        provider.handleFindMatch(session, data);
+    }
+    $handleTextMatch(handle, session, data) {
+        const provider = this._searchProvider.get(handle);
+        if (!provider) {
+            throw new Error('Got result for unknown provider');
+        }
+        provider.handleFindMatch(session, data);
+    }
+    $handleTelemetry(eventName, data) {
+        this._telemetryService.publicLog(eventName, data);
+    }
+};
+MainThreadSearch = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadSearch),
+    ( __param(1, ISearchService)),
+    ( __param(2, ITelemetryService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IContextKeyService))
+], MainThreadSearch);
+class SearchOperation {
+    static { this._idPool = 0; }
+    constructor(progress, id = ++SearchOperation._idPool, matches = ( new Map())) {
+        this.progress = progress;
+        this.id = id;
+        this.matches = matches;
+    }
+    addMatch(match) {
+        const existingMatch = this.matches.get(( match.resource.toString()));
+        if (existingMatch) {
+            if (existingMatch.results && match.results) {
+                existingMatch.results.push(...match.results);
+            }
+        }
+        else {
+            this.matches.set(( match.resource.toString()), match);
+        }
+        this.progress?.(match);
+    }
+}
+class RemoteSearchProvider {
+    constructor(searchService, type, _scheme, _handle, _proxy) {
+        this._scheme = _scheme;
+        this._handle = _handle;
+        this._proxy = _proxy;
+        this._registrations = ( new DisposableStore());
+        this._searches = ( new Map());
+        this._registrations.add(searchService.registerSearchResultProvider(this._scheme, type, this));
+    }
+    dispose() {
+        this._registrations.dispose();
+    }
+    fileSearch(query, token = CancellationToken.None) {
+        return this.doSearch(query, undefined, token);
+    }
+    textSearch(query, onProgress, token = CancellationToken.None) {
+        return this.doSearch(query, onProgress, token);
+    }
+    doSearch(query, onProgress, token = CancellationToken.None) {
+        if (!query.folderQueries.length) {
+            throw new Error('Empty folderQueries');
+        }
+        const search = ( new SearchOperation(onProgress));
+        this._searches.set(search.id, search);
+        const searchP = this._provideSearchResults(query, search.id, token);
+        return Promise.resolve(searchP).then((result) => {
+            this._searches.delete(search.id);
+            return { results: Array.from(( search.matches.values())), stats: result.stats, limitHit: result.limitHit, messages: result.messages };
+        }, err => {
+            this._searches.delete(search.id);
+            return Promise.reject(err);
+        });
+    }
+    clearCache(cacheKey) {
+        return Promise.resolve(this._proxy.$clearCache(cacheKey));
+    }
+    handleFindMatch(session, dataOrUri) {
+        const searchOp = this._searches.get(session);
+        if (!searchOp) {
+            return;
+        }
+        dataOrUri.forEach(result => {
+            if (result.results) {
+                searchOp.addMatch(revive(result));
+            }
+            else {
+                searchOp.addMatch({
+                    resource: URI.revive(result)
+                });
+            }
+        });
+    }
+    _provideSearchResults(query, session, token) {
+        switch (query.type) {
+            case 1 :
+                return this._proxy.$provideFileSearchResults(this._handle, session, query, token);
+            case 2 :
+                return this._proxy.$provideTextSearchResults(this._handle, session, query, token);
+            default:
+                return this._proxy.$provideAITextSearchResults(this._handle, session, query, token);
+        }
+    }
+}
+
+export { MainThreadSearch };

package/vscode/src/vs/workbench/api/browser/mainThreadSecretState.js

@@ -0,0 +1,70 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { SequencerByKey } from 'vscode/vscode/vs/base/common/async';
+import { ISecretStorageService } from 'vscode/vscode/vs/platform/secrets/common/secrets';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
+
+let MainThreadSecretState = class MainThreadSecretState extends Disposable {
+    constructor(extHostContext, secretStorageService, logService, environmentService) {
+        super();
+        this.secretStorageService = secretStorageService;
+        this.logService = logService;
+        this._sequencer = ( new SequencerByKey());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostSecretState));
+        this._register(this.secretStorageService.onDidChangeSecret((e) => {
+            try {
+                const { extensionId, key } = this.parseKey(e);
+                if (extensionId && key) {
+                    this._proxy.$onDidChangePassword({ extensionId, key });
+                }
+            }
+            catch (e) {
+            }
+        }));
+    }
+    $getPassword(extensionId, key) {
+        this.logService.trace(`[mainThreadSecretState] Getting password for ${extensionId} extension: `, key);
+        return this._sequencer.queue(extensionId, () => this.doGetPassword(extensionId, key));
+    }
+    async doGetPassword(extensionId, key) {
+        const fullKey = this.getKey(extensionId, key);
+        const password = await this.secretStorageService.get(fullKey);
+        this.logService.trace(`[mainThreadSecretState] ${password ? 'P' : 'No p'}assword found for: `, extensionId, key);
+        return password;
+    }
+    $setPassword(extensionId, key, value) {
+        this.logService.trace(`[mainThreadSecretState] Setting password for ${extensionId} extension: `, key);
+        return this._sequencer.queue(extensionId, () => this.doSetPassword(extensionId, key, value));
+    }
+    async doSetPassword(extensionId, key, value) {
+        const fullKey = this.getKey(extensionId, key);
+        await this.secretStorageService.set(fullKey, value);
+        this.logService.trace('[mainThreadSecretState] Password set for: ', extensionId, key);
+    }
+    $deletePassword(extensionId, key) {
+        this.logService.trace(`[mainThreadSecretState] Deleting password for ${extensionId} extension: `, key);
+        return this._sequencer.queue(extensionId, () => this.doDeletePassword(extensionId, key));
+    }
+    async doDeletePassword(extensionId, key) {
+        const fullKey = this.getKey(extensionId, key);
+        await this.secretStorageService.delete(fullKey);
+        this.logService.trace('[mainThreadSecretState] Password deleted for: ', extensionId, key);
+    }
+    getKey(extensionId, key) {
+        return JSON.stringify({ extensionId, key });
+    }
+    parseKey(key) {
+        return JSON.parse(key);
+    }
+};
+MainThreadSecretState = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadSecretState),
+    ( __param(1, ISecretStorageService)),
+    ( __param(2, ILogService)),
+    ( __param(3, IBrowserWorkbenchEnvironmentService))
+], MainThreadSecretState);
+
+export { MainThreadSecretState };

package/vscode/src/vs/workbench/api/browser/mainThreadShare.js

@@ -0,0 +1,50 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { dispose } from 'vscode/vscode/vs/base/common/lifecycle';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IShareService } from 'vscode/vscode/vs/workbench/contrib/share/common/share';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadShare = class MainThreadShare {
+    constructor(extHostContext, shareService) {
+        this.shareService = shareService;
+        this.providers = ( new Map());
+        this.providerDisposables = ( new Map());
+        this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostShare));
+    }
+    $registerShareProvider(handle, selector, id, label, priority) {
+        const provider = {
+            id,
+            label,
+            selector,
+            priority,
+            provideShare: async (item) => {
+                const result = await this.proxy.$provideShare(handle, item, CancellationToken.None);
+                return typeof result === 'string' ? result : URI.revive(result);
+            }
+        };
+        this.providers.set(handle, provider);
+        const disposable = this.shareService.registerShareProvider(provider);
+        this.providerDisposables.set(handle, disposable);
+    }
+    $unregisterShareProvider(handle) {
+        if (( this.providers.has(handle))) {
+            this.providers.delete(handle);
+        }
+        if (( this.providerDisposables.has(handle))) {
+            this.providerDisposables.delete(handle);
+        }
+    }
+    dispose() {
+        this.providers.clear();
+        dispose(( this.providerDisposables.values()));
+        this.providerDisposables.clear();
+    }
+};
+MainThreadShare = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadShare),
+    ( __param(1, IShareService))
+], MainThreadShare);
+
+export { MainThreadShare };

package/vscode/src/vs/workbench/api/browser/mainThreadSpeech.js

@@ -0,0 +1,99 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { ISpeechService } from 'vscode/vscode/vs/workbench/contrib/speech/common/speechService';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadSpeech = class MainThreadSpeech {
+    constructor(extHostContext, speechService, logService) {
+        this.speechService = speechService;
+        this.logService = logService;
+        this.providerRegistrations = ( new Map());
+        this.speechToTextSessions = ( new Map());
+        this.keywordRecognitionSessions = ( new Map());
+        this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostSpeech));
+    }
+    $registerProvider(handle, identifier, metadata) {
+        this.logService.trace('[Speech] extension registered provider', metadata.extension.value);
+        const registration = this.speechService.registerSpeechProvider(identifier, {
+            metadata,
+            createSpeechToTextSession: (token, options) => {
+                if (token.isCancellationRequested) {
+                    return {
+                        onDidChange: Event.None
+                    };
+                }
+                const disposables = ( new DisposableStore());
+                const session = Math.random();
+                this.proxy.$createSpeechToTextSession(handle, session, options?.language);
+                const onDidChange = disposables.add(( new Emitter()));
+                this.speechToTextSessions.set(session, { onDidChange });
+                disposables.add(token.onCancellationRequested(() => {
+                    this.proxy.$cancelSpeechToTextSession(session);
+                    this.speechToTextSessions.delete(session);
+                    disposables.dispose();
+                }));
+                return {
+                    onDidChange: onDidChange.event
+                };
+            },
+            createKeywordRecognitionSession: token => {
+                if (token.isCancellationRequested) {
+                    return {
+                        onDidChange: Event.None
+                    };
+                }
+                const disposables = ( new DisposableStore());
+                const session = Math.random();
+                this.proxy.$createKeywordRecognitionSession(handle, session);
+                const onDidChange = disposables.add(( new Emitter()));
+                this.keywordRecognitionSessions.set(session, { onDidChange });
+                disposables.add(token.onCancellationRequested(() => {
+                    this.proxy.$cancelKeywordRecognitionSession(session);
+                    this.keywordRecognitionSessions.delete(session);
+                    disposables.dispose();
+                }));
+                return {
+                    onDidChange: onDidChange.event
+                };
+            }
+        });
+        this.providerRegistrations.set(handle, {
+            dispose: () => {
+                registration.dispose();
+            }
+        });
+    }
+    $unregisterProvider(handle) {
+        const registration = this.providerRegistrations.get(handle);
+        if (registration) {
+            registration.dispose();
+            this.providerRegistrations.delete(handle);
+        }
+    }
+    $emitSpeechToTextEvent(session, event) {
+        const providerSession = this.speechToTextSessions.get(session);
+        providerSession?.onDidChange.fire(event);
+    }
+    $emitKeywordRecognitionEvent(session, event) {
+        const providerSession = this.keywordRecognitionSessions.get(session);
+        providerSession?.onDidChange.fire(event);
+    }
+    dispose() {
+        this.providerRegistrations.forEach(disposable => disposable.dispose());
+        this.providerRegistrations.clear();
+        this.speechToTextSessions.forEach(session => session.onDidChange.dispose());
+        this.speechToTextSessions.clear();
+        this.keywordRecognitionSessions.forEach(session => session.onDidChange.dispose());
+        this.keywordRecognitionSessions.clear();
+    }
+};
+MainThreadSpeech = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadSpeech),
+    ( __param(1, ISpeechService)),
+    ( __param(2, ILogService))
+], MainThreadSpeech);
+
+export { MainThreadSpeech };

package/vscode/src/vs/workbench/api/browser/mainThreadStatusBar.js

@@ -0,0 +1,53 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IExtensionStatusBarItemService } from 'vscode/vscode/vs/workbench/api/browser/statusBarExtensionPoint';
+
+let MainThreadStatusBar = class MainThreadStatusBar {
+    constructor(extHostContext, statusbarService) {
+        this.statusbarService = statusbarService;
+        this._store = ( new DisposableStore());
+        const proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostStatusBar));
+        const entries = [];
+        for (const [entryId, item] of statusbarService.getEntries()) {
+            entries.push(asDto(entryId, item));
+        }
+        proxy.$acceptStaticEntries(entries);
+        this._store.add(statusbarService.onDidChange(e => {
+            if (e.added) {
+                proxy.$acceptStaticEntries([asDto(e.added[0], e.added[1])]);
+            }
+        }));
+        function asDto(entryId, item) {
+            return {
+                entryId,
+                name: item.entry.name,
+                text: item.entry.text,
+                tooltip: item.entry.tooltip,
+                command: typeof item.entry.command === 'string' ? item.entry.command : typeof item.entry.command === 'object' ? item.entry.command.id : undefined,
+                priority: item.priority,
+                alignLeft: item.alignment === 0 ,
+                accessibilityInformation: item.entry.ariaLabel ? { label: item.entry.ariaLabel, role: item.entry.role } : undefined
+            };
+        }
+    }
+    dispose() {
+        this._store.dispose();
+    }
+    $setEntry(entryId, id, extensionId, name, text, tooltip, command, color, backgroundColor, alignLeft, priority, accessibilityInformation) {
+        const kind = this.statusbarService.setOrUpdateEntry(entryId, id, extensionId, name, text, tooltip, command, color, backgroundColor, alignLeft, priority, accessibilityInformation);
+        if (kind === 0 ) {
+            this._store.add(toDisposable(() => this.statusbarService.unsetEntry(entryId)));
+        }
+    }
+    $disposeEntry(entryId) {
+        this.statusbarService.unsetEntry(entryId);
+    }
+};
+MainThreadStatusBar = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadStatusBar),
+    ( __param(1, IExtensionStatusBarItemService))
+], MainThreadStatusBar);
+
+export { MainThreadStatusBar };

package/vscode/src/vs/workbench/api/browser/mainThreadStorage.js

@@ -0,0 +1,72 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { isWeb } from 'vscode/vscode/vs/base/common/platform';
+import { IExtensionStorageService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionStorage';
+import { migrateExtensionStorage } from '../../services/extensions/common/extensionStorageMigration.js';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+
+let MainThreadStorage = class MainThreadStorage {
+    constructor(extHostContext, _extensionStorageService, _storageService, _instantiationService, _logService) {
+        this._extensionStorageService = _extensionStorageService;
+        this._storageService = _storageService;
+        this._instantiationService = _instantiationService;
+        this._logService = _logService;
+        this._storageListener = ( new DisposableStore());
+        this._sharedStorageKeysToWatch = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostStorage));
+        this._storageListener.add(this._storageService.onDidChangeValue(0 , undefined, this._storageListener)(e => {
+            if (( this._sharedStorageKeysToWatch.has(e.key))) {
+                const rawState = this._extensionStorageService.getExtensionStateRaw(e.key, true);
+                if (typeof rawState === 'string') {
+                    this._proxy.$acceptValue(true, e.key, rawState);
+                }
+            }
+        }));
+    }
+    dispose() {
+        this._storageListener.dispose();
+    }
+    async $initializeExtensionStorage(shared, extensionId) {
+        await this.checkAndMigrateExtensionStorage(extensionId, shared);
+        if (shared) {
+            this._sharedStorageKeysToWatch.set(extensionId, true);
+        }
+        return this._extensionStorageService.getExtensionStateRaw(extensionId, shared);
+    }
+    async $setValue(shared, key, value) {
+        this._extensionStorageService.setExtensionState(key, value, shared);
+    }
+    $registerExtensionStorageKeysToSync(extension, keys) {
+        this._extensionStorageService.setKeysForSync(extension, keys);
+    }
+    async checkAndMigrateExtensionStorage(extensionId, shared) {
+        try {
+            let sourceExtensionId = this._extensionStorageService.getSourceExtensionToMigrate(extensionId);
+            if (!sourceExtensionId && isWeb && extensionId !== extensionId.toLowerCase()) {
+                sourceExtensionId = extensionId.toLowerCase();
+            }
+            if (sourceExtensionId) {
+                if (isWeb && sourceExtensionId !== sourceExtensionId.toLowerCase() && this._extensionStorageService.getExtensionState(sourceExtensionId.toLowerCase(), shared) && !this._extensionStorageService.getExtensionState(sourceExtensionId, shared)) {
+                    sourceExtensionId = sourceExtensionId.toLowerCase();
+                }
+                await migrateExtensionStorage(sourceExtensionId, extensionId, shared, this._instantiationService);
+            }
+        }
+        catch (error) {
+            this._logService.error(error);
+        }
+    }
+};
+MainThreadStorage = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadStorage),
+    ( __param(1, IExtensionStorageService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ILogService))
+], MainThreadStorage);
+
+export { MainThreadStorage };