@codingame/monaco-vscode-api 1.80.2 → 1.80.3

package/dist/service-override/storage.d.ts

@@ -0,0 +1,18 @@
+import { IDisposable } from '../vscode/vs/base/common/lifecycle.js';
+import { IStorageItemsChangeEvent } from '../vscode/vs/base/parts/storage/common/storage.js';
+import { IEditorOverrideServices } from '../vscode/vs/editor/standalone/browser/standaloneServices.js';
+
+declare enum StorageScope {
+    APPLICATION = -1,
+    PROFILE = 0,
+    WORKSPACE = 1
+}
+interface IStorageProvider {
+    read(scope: StorageScope): Map<string, string> | undefined;
+    write(scope: StorageScope, data: Map<string, string>): Promise<void>;
+    close?(scope: StorageScope): Promise<void>;
+    onDidChange?(listener: (event: IStorageItemsChangeEvent) => void): IDisposable;
+}
+declare function getStorageServiceOverride(provider: IStorageProvider): IEditorOverrideServices;
+
+export { IStorageItemsChangeEvent, IStorageProvider, StorageScope, getStorageServiceOverride as default };

package/dist/service-override/storage.js

@@ -0,0 +1,87 @@
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Storage } from 'monaco-editor/esm/vs/base/parts/storage/common/storage.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IStorageService, AbstractStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+var StorageScope;
+( (function(StorageScope) {
+    StorageScope[StorageScope["APPLICATION"] = -1] = "APPLICATION";
+    StorageScope[StorageScope["PROFILE"] = 0] = "PROFILE";
+    StorageScope[StorageScope["WORKSPACE"] = 1] = "WORKSPACE";
+})(StorageScope || (StorageScope = {})));
+class ExternalStorage extends Storage {
+    constructor(scope, provider) {
+        const items = provider.read(scope);
+        super(new ExternalStorageDatabase(scope, provider, items));
+        if (items != null) {
+            for (const [key, value] of items) {
+                this.items.set(key, value);
+            }
+        }
+    }
+}
+class ExternalStorageDatabase {
+    constructor(scope, provider, items = new Map()) {
+        this.scope = scope;
+        this.provider = provider;
+        this.items = items;
+        this.onDidChangeItemsExternal = this.provider.onDidChange ?? Event.None;
+    }
+    async getItems() {
+        return this.items;
+    }
+    async updateItems(request) {
+        request.insert?.forEach((value, key) => this.items.set(key, value));
+        request.delete?.forEach(key => this.items.delete(key));
+        await this.provider.write(this.scope, this.items);
+    }
+    async close() {
+        return this.provider.close?.(this.scope);
+    }
+}
+class ExternalStorageService extends AbstractStorageService {
+    constructor(provider) {
+        super();
+        this.provider = provider;
+        this.applicationStorage = this._register(new ExternalStorage(StorageScope.APPLICATION, this.provider));
+        this.profileStorage = this._register(new ExternalStorage(StorageScope.PROFILE, this.provider));
+        this.workspaceStorage = this._register(new ExternalStorage(StorageScope.WORKSPACE, this.provider));
+        this._register(this.workspaceStorage.onDidChangeStorage(key => this.emitDidChangeValue(1 , key)));
+        this._register(this.profileStorage.onDidChangeStorage(key => this.emitDidChangeValue(0 , key)));
+        this._register(this.applicationStorage.onDidChangeStorage(key => this.emitDidChangeValue(-1 , key)));
+    }
+    getStorage(scope) {
+        switch (scope) {
+            case -1 :
+                return this.applicationStorage;
+            case 0 :
+                return this.profileStorage;
+            default:
+                return this.workspaceStorage;
+        }
+    }
+    getLogDetails(scope) {
+        switch (scope) {
+            case -1 :
+                return 'External (application)';
+            case 0 :
+                return 'External (profile)';
+            default:
+                return 'External (workspace)';
+        }
+    }
+    async doInitialize() {
+    }
+    async switchToProfile() {
+    }
+    async switchToWorkspace() {
+    }
+    hasScope(_scope) {
+        return false;
+    }
+}
+function getStorageServiceOverride(provider) {
+    return {
+        [( IStorageService.toString())]: new SyncDescriptor(ExternalStorageService, [provider])
+    };
+}
+export { StorageScope, getStorageServiceOverride as default };

package/dist/vscode/vs/base/parts/storage/common/storage.d.ts

@@ -1,3 +1,7 @@
+interface IStorageItemsChangeEvent {
+    readonly changed?: Map<string, string>;
+    readonly deleted?: Set<string>;
+}
 type StorageValue = string | boolean | number | undefined | null | object;
 
-export { StorageValue };
+export { IStorageItemsChangeEvent, StorageValue };