@codingame/monaco-vscode-extensions-service-override 25.1.2 → 26.0.1

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

@@ -14,7 +14,13 @@ import { SearchContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/
 import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
 
 let MainThreadSearch = class MainThreadSearch {
-    constructor(extHostContext, _searchService, _telemetryService, _configurationService, contextKeyService) {
+    constructor(
+        extHostContext,
+        _searchService,
+        _telemetryService,
+        _configurationService,
+        contextKeyService
+    ) {
         this._searchService = _searchService;
         this._telemetryService = _telemetryService;
         this.contextKeyService = contextKeyService;
@@ -56,21 +62,21 @@ let MainThreadSearch = class MainThreadSearch {
     $handleFileMatch(handle, session, data) {
         const provider = this._searchProvider.get(handle);
         if (!provider) {
-            throw ( new Error('Got result for unknown 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'));
+            throw ( new Error("Got result for unknown provider"));
         }
         provider.handleFindMatch(session, data);
     }
     $handleKeywordResult(handle, session, data) {
         const provider = this._searchProvider.get(handle);
         if (!provider) {
-            throw ( new Error('Got result for unknown provider'));
+            throw ( new Error("Got result for unknown provider"));
         }
         provider.handleKeywordResult(session, data);
     }
@@ -78,16 +84,17 @@ let MainThreadSearch = class MainThreadSearch {
         this._telemetryService.publicLog(eventName, data);
     }
 };
-MainThreadSearch = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadSearch),
-    ( __param(1, ISearchService)),
-    ( __param(2, ITelemetryService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IContextKeyService))
-], MainThreadSearch);
+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()), keywords = []) {
+    static {
+        this._idPool = 0;
+    }
+    constructor(
+        progress,
+        id = ++SearchOperation._idPool,
+        matches = ( new Map()),
+        keywords = []
+    ) {
         this.progress = progress;
         this.id = id;
         this.matches = matches;
@@ -99,8 +106,7 @@ class SearchOperation {
             if (existingMatch.results && match.results) {
                 existingMatch.results.push(...match.results);
             }
-        }
-        else {
+        } else {
             this.matches.set(( match.resource.toString()), match);
         }
         this.progress?.(match);
@@ -136,14 +142,20 @@ class RemoteSearchProvider {
     }
     doSearch(query, onProgress, token = CancellationToken.None) {
         if (!query.folderQueries.length) {
-            throw ( new Error('Empty folderQueries'));
+            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) => {
+        return Promise.resolve(searchP).then(result => {
             this._searches.delete(search.id);
-            return { results: Array.from(( search.matches.values())), aiKeywords: Array.from(search.keywords), stats: result.stats, limitHit: result.limitHit, messages: result.messages };
+            return {
+                results: Array.from(( search.matches.values())),
+                aiKeywords: Array.from(search.keywords),
+                stats: result.stats,
+                limitHit: result.limitHit,
+                messages: result.messages
+            };
         }, err => {
             this._searches.delete(search.id);
             return Promise.reject(err);
@@ -160,8 +172,7 @@ class RemoteSearchProvider {
         dataOrUri.forEach(result => {
             if (result.results) {
                 searchOp.addMatch(revive(result));
-            }
-            else {
+            } else {
                 searchOp.addMatch({
                     resource: URI.revive(result)
                 });
@@ -177,12 +188,12 @@ class RemoteSearchProvider {
     }
     _provideSearchResults(query, session, token) {
         switch (query.type) {
-            case QueryType.File:
-                return this._proxy.$provideFileSearchResults(this._handle, session, query, token);
-            case QueryType.Text:
-                return this._proxy.$provideTextSearchResults(this._handle, session, query, token);
-            default:
-                return this._proxy.$provideAITextSearchResults(this._handle, session, query, token);
+        case QueryType.File:
+            return this._proxy.$provideFileSearchResults(this._handle, session, query, token);
+        case QueryType.Text:
+            return this._proxy.$provideTextSearchResults(this._handle, session, query, token);
+        default:
+            return this._proxy.$provideAITextSearchResults(this._handle, session, query, token);
         }
     }
 }

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

@@ -15,7 +15,7 @@ let MainThreadSecretState = class MainThreadSecretState extends Disposable {
         this.logService = logService;
         this._sequencer = ( new SequencerByKey());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostSecretState));
-        this._register(this.secretStorageService.onDidChangeSecret((e) => {
+        this._register(this.secretStorageService.onDidChangeSecret(e => {
             const parsedKey = this.parseKey(e);
             if (parsedKey) {
                 this._proxy.$onDidChangePassword(parsedKey);
@@ -23,32 +23,45 @@ let MainThreadSecretState = class MainThreadSecretState extends Disposable {
         }));
     }
     $getPassword(extensionId, key) {
-        this.logService.trace(`[mainThreadSecretState] Getting password for ${extensionId} extension: `, 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);
+        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);
+        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);
+        this.logService.trace("[mainThreadSecretState] Password set for: ", extensionId, key);
     }
     $deletePassword(extensionId, key) {
-        this.logService.trace(`[mainThreadSecretState] Deleting password for ${extensionId} extension: `, 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);
+        this.logService.trace("[mainThreadSecretState] Password deleted for: ", extensionId, key);
     }
     $getKeys(extensionId) {
         this.logService.trace(`[mainThreadSecretState] Getting keys for ${extensionId} extension: `);
@@ -56,33 +69,33 @@ let MainThreadSecretState = class MainThreadSecretState extends Disposable {
     }
     async doGetKeys(extensionId) {
         if (!this.secretStorageService.keys) {
-            throw ( new Error('Secret storage service does not support keys() method'));
+            throw ( new Error("Secret storage service does not support keys() method"));
         }
         const allKeys = await ( this.secretStorageService.keys());
-        const keys = ( ( allKeys
-            .map(key => this.parseKey(key)))
-            .filter((parsedKey) => parsedKey !== undefined && parsedKey.extensionId === extensionId)
-            .map(({ key }) => key));
+        const keys = ( ( allKeys.map(key => this.parseKey(key))).filter(
+            parsedKey => parsedKey !== undefined && parsedKey.extensionId === extensionId
+        ).map((
+            {
+                key
+            }
+        ) => key));
         this.logService.trace(`[mainThreadSecretState] Got ${keys.length}key(s) for: `, extensionId);
         return keys;
     }
     getKey(extensionId, key) {
-        return JSON.stringify({ extensionId, key });
+        return JSON.stringify({
+            extensionId,
+            key
+        });
     }
     parseKey(key) {
         try {
             return JSON.parse(key);
-        }
-        catch {
+        } catch {
             return undefined;
         }
     }
 };
-MainThreadSecretState = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadSecretState),
-    ( __param(1, ISecretStorageService)),
-    ( __param(2, ILogService)),
-    ( __param(3, IBrowserWorkbenchEnvironmentService))
-], MainThreadSecretState);
+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

@@ -20,9 +20,9 @@ let MainThreadShare = class MainThreadShare {
             label,
             selector,
             priority,
-            provideShare: async (item) => {
+            provideShare: async item => {
                 const result = await this.proxy.$provideShare(handle, item, CancellationToken.None);
-                return typeof result === 'string' ? result : URI.revive(result);
+                return typeof result === "string" ? result : URI.revive(result);
             }
         };
         this.providers.set(handle, provider);
@@ -39,9 +39,6 @@ let MainThreadShare = class MainThreadShare {
         this.providerDisposables.clear();
     }
 };
-MainThreadShare = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadShare),
-    ( __param(1, IShareService))
-], MainThreadShare);
+MainThreadShare = __decorate([extHostNamedCustomer(MainContext.MainThreadShare), ( __param(1, IShareService))], MainThreadShare);
 
 export { MainThreadShare };

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

@@ -20,7 +20,7 @@ let MainThreadSpeech = class MainThreadSpeech {
         this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostSpeech));
     }
     $registerProvider(handle, identifier, metadata) {
-        this.logService.trace('[Speech] extension registered provider', metadata.extension.value);
+        this.logService.trace("[Speech] extension registered provider", metadata.extension.value);
         const registration = this.speechService.registerSpeechProvider(identifier, {
             metadata,
             createSpeechToTextSession: (token, options) => {
@@ -33,7 +33,9 @@ let MainThreadSpeech = class MainThreadSpeech {
                 const session = Math.random();
                 this.proxy.$createSpeechToTextSession(handle, session, options?.language);
                 const onDidChange = disposables.add(( new Emitter()));
-                this.speechToTextSessions.set(session, { onDidChange });
+                this.speechToTextSessions.set(session, {
+                    onDidChange
+                });
                 disposables.add(token.onCancellationRequested(() => {
                     this.proxy.$cancelSpeechToTextSession(session);
                     this.speechToTextSessions.delete(session);
@@ -47,14 +49,16 @@ let MainThreadSpeech = class MainThreadSpeech {
                 if (token.isCancellationRequested) {
                     return {
                         onDidChange: Event.None,
-                        synthesize: async () => { }
+                        synthesize: async () => {}
                     };
                 }
                 const disposables = ( new DisposableStore());
                 const session = Math.random();
                 this.proxy.$createTextToSpeechSession(handle, session, options?.language);
                 const onDidChange = disposables.add(( new Emitter()));
-                this.textToSpeechSessions.set(session, { onDidChange });
+                this.textToSpeechSessions.set(session, {
+                    onDidChange
+                });
                 disposables.add(token.onCancellationRequested(() => {
                     this.proxy.$cancelTextToSpeechSession(session);
                     this.textToSpeechSessions.delete(session);
@@ -62,13 +66,16 @@ let MainThreadSpeech = class MainThreadSpeech {
                 }));
                 return {
                     onDidChange: onDidChange.event,
-                    synthesize: async (text) => {
+                    synthesize: async text => {
                         await this.proxy.$synthesizeSpeech(session, text);
                         const disposable = ( new DisposableStore());
                         try {
-                            await raceCancellation(Event.toPromise(Event.filter(onDidChange.event, e => e.status === TextToSpeechStatus.Stopped, disposable), disposable), token);
-                        }
-                        finally {
+                            await raceCancellation(Event.toPromise(Event.filter(
+                                onDidChange.event,
+                                e => e.status === TextToSpeechStatus.Stopped,
+                                disposable
+                            ), disposable), token);
+                        } finally {
                             disposable.dispose();
                         }
                     }
@@ -84,7 +91,9 @@ let MainThreadSpeech = class MainThreadSpeech {
                 const session = Math.random();
                 this.proxy.$createKeywordRecognitionSession(handle, session);
                 const onDidChange = disposables.add(( new Emitter()));
-                this.keywordRecognitionSessions.set(session, { onDidChange });
+                this.keywordRecognitionSessions.set(session, {
+                    onDidChange
+                });
                 disposables.add(token.onCancellationRequested(() => {
                     this.proxy.$cancelKeywordRecognitionSession(session);
                     this.keywordRecognitionSessions.delete(session);
@@ -131,10 +140,6 @@ let MainThreadSpeech = class MainThreadSpeech {
         this.keywordRecognitionSessions.clear();
     }
 };
-MainThreadSpeech = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadSpeech),
-    ( __param(1, ISpeechService)),
-    ( __param(2, ILogService))
-], MainThreadSpeech);
+MainThreadSpeech = __decorate([extHostNamedCustomer(MainContext.MainThreadSpeech), ( __param(1, ISpeechService)), ( __param(2, ILogService))], MainThreadSpeech);
 
 export { MainThreadSpeech };

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

@@ -28,23 +28,51 @@ let MainThreadStatusBar = class MainThreadStatusBar extends Disposable {
                 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,
+                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 === StatusbarAlignment.LEFT,
-                accessibilityInformation: item.entry.ariaLabel ? { label: item.entry.ariaLabel, role: item.entry.role } : undefined
+                accessibilityInformation: item.entry.ariaLabel ? {
+                    label: item.entry.ariaLabel,
+                    role: item.entry.role
+                } : undefined
             };
         }
     }
-    $setEntry(entryId, id, extensionId, name, text, tooltip, hasTooltipProvider, command, color, backgroundColor, alignLeft, priority, accessibilityInformation) {
-        const tooltipOrTooltipProvider = hasTooltipProvider
-            ? {
-                markdown: (cancellation) => {
-                    return this._proxy.$provideTooltip(entryId, cancellation);
-                },
-                markdownNotSupportedFallback: undefined
-            }
-            : tooltip;
-        const kind = this.statusbarService.setOrUpdateEntry(entryId, id, extensionId, name, text, tooltipOrTooltipProvider, command, color, backgroundColor, alignLeft, priority, accessibilityInformation);
+    $setEntry(
+        entryId,
+        id,
+        extensionId,
+        name,
+        text,
+        tooltip,
+        hasTooltipProvider,
+        command,
+        color,
+        backgroundColor,
+        alignLeft,
+        priority,
+        accessibilityInformation
+    ) {
+        const tooltipOrTooltipProvider = hasTooltipProvider ? {
+            markdown: cancellation => {
+                return this._proxy.$provideTooltip(entryId, cancellation);
+            },
+            markdownNotSupportedFallback: undefined
+        } : tooltip;
+        const kind = this.statusbarService.setOrUpdateEntry(
+            entryId,
+            id,
+            extensionId,
+            name,
+            text,
+            tooltipOrTooltipProvider,
+            command,
+            color,
+            backgroundColor,
+            alignLeft,
+            priority,
+            accessibilityInformation
+        );
         if (kind === StatusBarUpdateKind.DidDefine) {
             const disposable = toDisposable(() => this.statusbarService.unsetEntry(entryId));
             this._entryDisposables.set(entryId, disposable);
@@ -54,9 +82,6 @@ let MainThreadStatusBar = class MainThreadStatusBar extends Disposable {
         this._entryDisposables.deleteAndDispose(entryId);
     }
 };
-MainThreadStatusBar = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadStatusBar),
-    ( __param(1, IExtensionStatusBarItemService))
-], MainThreadStatusBar);
+MainThreadStatusBar = __decorate([extHostNamedCustomer(MainContext.MainThreadStatusBar), ( __param(1, IExtensionStatusBarItemService))], MainThreadStatusBar);
 
 export { MainThreadStatusBar };

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

@@ -12,7 +12,13 @@ import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/pl
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 
 let MainThreadStorage = class MainThreadStorage {
-    constructor(extHostContext, _extensionStorageService, _storageService, _instantiationService, _logService) {
+    constructor(
+        extHostContext,
+        _extensionStorageService,
+        _storageService,
+        _instantiationService,
+        _logService
+    ) {
         this._extensionStorageService = _extensionStorageService;
         this._storageService = _storageService;
         this._instantiationService = _instantiationService;
@@ -20,14 +26,16 @@ let MainThreadStorage = class MainThreadStorage {
         this._storageListener = ( new DisposableStore());
         this._sharedStorageKeysToWatch = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostStorage));
-        this._storageListener.add(this._storageService.onDidChangeValue(StorageScope.PROFILE, 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);
+        this._storageListener.add(
+            this._storageService.onDidChangeValue(StorageScope.PROFILE, 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();
@@ -57,18 +65,11 @@ let MainThreadStorage = class MainThreadStorage {
                 }
                 await migrateExtensionStorage(sourceExtensionId, extensionId, shared, this._instantiationService);
             }
-        }
-        catch (error) {
+        } catch (error) {
             this._logService.error(error);
         }
     }
 };
-MainThreadStorage = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadStorage),
-    ( __param(1, IExtensionStorageService)),
-    ( __param(2, IStorageService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, ILogService))
-], MainThreadStorage);
+MainThreadStorage = __decorate([extHostNamedCustomer(MainContext.MainThreadStorage), ( __param(1, IExtensionStorageService)), ( __param(2, IStorageService)), ( __param(3, IInstantiationService)), ( __param(4, ILogService))], MainThreadStorage);
 
 export { MainThreadStorage };