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

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

@@ -1,70 +0,0 @@
-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

@@ -1,50 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { CancellationTokenSource } 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, ( new CancellationTokenSource()).token);
-                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

@@ -1,99 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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 };