@codingame/monaco-vscode-extension-gallery-service-override 1.83.9

package/vscode/src/vs/platform/extensionManagement/common/extensionEnablementService.js

@@ -0,0 +1,142 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isUndefinedOrNull } from 'monaco-editor/esm/vs/base/common/types.js';
+import { DISABLED_EXTENSIONS_STORAGE_PATH, IExtensionManagementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+
+let GlobalExtensionEnablementService = class GlobalExtensionEnablementService extends Disposable {
+    constructor(storageService, extensionManagementService) {
+        super();
+        this._onDidChangeEnablement = ( new Emitter());
+        this.onDidChangeEnablement = this._onDidChangeEnablement.event;
+        this.storageManger = this._register(( new StorageManager(storageService)));
+        this._register(this.storageManger.onDidChange(extensions => this._onDidChangeEnablement.fire({ extensions, source: 'storage' })));
+        this._register(extensionManagementService.onDidInstallExtensions(e => e.forEach(({ local, operation }) => {
+            if (local && operation === 4 ) {
+                this._removeFromDisabledExtensions(local.identifier);
+            }
+        })));
+    }
+    async enableExtension(extension, source) {
+        if (this._removeFromDisabledExtensions(extension)) {
+            this._onDidChangeEnablement.fire({ extensions: [extension], source });
+            return true;
+        }
+        return false;
+    }
+    async disableExtension(extension, source) {
+        if (this._addToDisabledExtensions(extension)) {
+            this._onDidChangeEnablement.fire({ extensions: [extension], source });
+            return true;
+        }
+        return false;
+    }
+    getDisabledExtensions() {
+        return this._getExtensions(DISABLED_EXTENSIONS_STORAGE_PATH);
+    }
+    async getDisabledExtensionsAsync() {
+        return this.getDisabledExtensions();
+    }
+    _addToDisabledExtensions(identifier) {
+        const disabledExtensions = this.getDisabledExtensions();
+        if (disabledExtensions.every(e => !areSameExtensions(e, identifier))) {
+            disabledExtensions.push(identifier);
+            this._setDisabledExtensions(disabledExtensions);
+            return true;
+        }
+        return false;
+    }
+    _removeFromDisabledExtensions(identifier) {
+        const disabledExtensions = this.getDisabledExtensions();
+        for (let index = 0; index < disabledExtensions.length; index++) {
+            const disabledExtension = disabledExtensions[index];
+            if (areSameExtensions(disabledExtension, identifier)) {
+                disabledExtensions.splice(index, 1);
+                this._setDisabledExtensions(disabledExtensions);
+                return true;
+            }
+        }
+        return false;
+    }
+    _setDisabledExtensions(disabledExtensions) {
+        this._setExtensions(DISABLED_EXTENSIONS_STORAGE_PATH, disabledExtensions);
+    }
+    _getExtensions(storageId) {
+        return this.storageManger.get(storageId, 0 );
+    }
+    _setExtensions(storageId, extensions) {
+        this.storageManger.set(storageId, extensions, 0 );
+    }
+};
+GlobalExtensionEnablementService = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IExtensionManagementService))
+], GlobalExtensionEnablementService));
+class StorageManager extends Disposable {
+    constructor(storageService) {
+        super();
+        this.storageService = storageService;
+        this.storage = Object.create(null);
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._register(storageService.onDidChangeValue(0 , undefined, this._register(( new DisposableStore())))(e => this.onDidStorageChange(e)));
+    }
+    get(key, scope) {
+        let value;
+        if (scope === 0 ) {
+            if (isUndefinedOrNull(this.storage[key])) {
+                this.storage[key] = this._get(key, scope);
+            }
+            value = this.storage[key];
+        }
+        else {
+            value = this._get(key, scope);
+        }
+        return JSON.parse(value);
+    }
+    set(key, value, scope) {
+        const newValue = JSON.stringify(( value.map(({ id, uuid }) => ({ id, uuid }))));
+        const oldValue = this._get(key, scope);
+        if (oldValue !== newValue) {
+            if (scope === 0 ) {
+                if (value.length) {
+                    this.storage[key] = newValue;
+                }
+                else {
+                    delete this.storage[key];
+                }
+            }
+            this._set(key, value.length ? newValue : undefined, scope);
+        }
+    }
+    onDidStorageChange(storageChangeEvent) {
+        if (!isUndefinedOrNull(this.storage[storageChangeEvent.key])) {
+            const newValue = this._get(storageChangeEvent.key, storageChangeEvent.scope);
+            if (newValue !== this.storage[storageChangeEvent.key]) {
+                const oldValues = this.get(storageChangeEvent.key, storageChangeEvent.scope);
+                delete this.storage[storageChangeEvent.key];
+                const newValues = this.get(storageChangeEvent.key, storageChangeEvent.scope);
+                const added = oldValues.filter(oldValue => !( newValues.some(newValue => areSameExtensions(oldValue, newValue))));
+                const removed = newValues.filter(newValue => !( oldValues.some(oldValue => areSameExtensions(oldValue, newValue))));
+                if (added.length || removed.length) {
+                    this._onDidChange.fire([...added, ...removed]);
+                }
+            }
+        }
+    }
+    _get(key, scope) {
+        return this.storageService.get(key, scope, '[]');
+    }
+    _set(key, value, scope) {
+        if (value) {
+            this.storageService.store(key, value, scope, 1 );
+        }
+        else {
+            this.storageService.remove(key, scope);
+        }
+    }
+}
+
+export { GlobalExtensionEnablementService, StorageManager };