@codingame/monaco-vscode-api 5.2.0 → 5.3.0

package/README.md

@@ -198,6 +198,8 @@ Additionally, several packages that include the VSCode version of some services
   - Support for [viewsWelcome contribution point](https://code.visualstudio.com/api/references/contribution-points#contributes.viewsWelcome). *Hint*: It only makes sense to enable it when *Views* or *Workbench* service are used.
 - **Walkthrough**: `@codingame/monaco-vscode-walkthrough-service-override`
   - Getting Started page and support for [walkthrough contribution point](https://code.visualstudio.com/api/references/contribution-points#contributes.walkthroughs). *Hint*: It only makes sense to enable it when *Views* or *Workbench* service are used.
+- **User data profile**: `@codingame/monaco-vscode-user-data-profile-service-override`
+  - User profiles support
 - **User data sync**: `@codingame/monaco-vscode-user-data-sync-service-override`
   - Support for user data sync. ⚠️ It can't really be used as it relies on a [closed source backend from microsoft](https://code.visualstudio.com/docs/editor/settings-sync#_can-i-use-a-different-backend-or-service-for-settings-sync) for the moment ⚠️
 - **Ai**: `@codingame/monaco-vscode-ai-service-override`

package/missing-services.js

@@ -206,6 +206,7 @@ import { NullExtensionService } from './vscode/src/vs/workbench/services/extensi
 import { toUserDataProfile } from './vscode/src/vs/platform/userDataProfile/common/userDataProfile.js';
 import { ILanguageModelStatsService } from './vscode/src/vs/workbench/contrib/chat/common/languageModelStats.service.js';
 import { IAccessibleViewInformationService } from './vscode/src/vs/workbench/services/accessibility/common/accessibleViewInformationService.service.js';
+import { IUserDataProfileStorageService } from './vscode/src/vs/platform/userDataProfile/common/userDataProfileStorageService.service.js';
 import { getExtensionIdProvidingCurrentLocale, getBuiltInExtensionTranslationsUris } from './l10n.js';
 import { unsupported } from './tools.js';
 var _a;
@@ -722,6 +723,14 @@ UserDataProfilesService = __decorate([
     ( __param(0, IUserDataProfileService))
 ], UserDataProfilesService);
 registerSingleton(IUserDataProfilesService, UserDataProfilesService, 0 );
+registerSingleton(IUserDataProfileStorageService, class UserDataProfileStorageService {
+    constructor() {
+        this.onDidChange = Event.None;
+        this.readStorageData = unsupported;
+        this.updateStorageData = unsupported;
+        this.withProfileScopedStorageService = unsupported;
+    }
+}, 0 );
 let InjectedUserDataProfileService = class InjectedUserDataProfileService extends UserDataProfileService {
     constructor(environmentService) {
         super({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "5.2.0",
+  "version": "5.3.0",
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
   "author": {
@@ -99,12 +99,12 @@
   "dependencies": {
     "@vscode/iconv-lite-umd": "0.7.0",
     "jschardet": "3.0.0",
-    "@codingame/monaco-vscode-quickaccess-service-override": "5.2.0",
-    "@codingame/monaco-vscode-files-service-override": "5.2.0",
-    "@codingame/monaco-vscode-extensions-service-override": "5.2.0",
-    "@codingame/monaco-vscode-environment-service-override": "5.2.0",
-    "@codingame/monaco-vscode-layout-service-override": "5.2.0",
-    "@codingame/monaco-vscode-host-service-override": "5.2.0",
-    "@codingame/monaco-vscode-base-service-override": "5.2.0"
+    "@codingame/monaco-vscode-files-service-override": "5.3.0",
+    "@codingame/monaco-vscode-quickaccess-service-override": "5.3.0",
+    "@codingame/monaco-vscode-extensions-service-override": "5.3.0",
+    "@codingame/monaco-vscode-environment-service-override": "5.3.0",
+    "@codingame/monaco-vscode-layout-service-override": "5.3.0",
+    "@codingame/monaco-vscode-host-service-override": "5.3.0",
+    "@codingame/monaco-vscode-base-service-override": "5.3.0"
   }
 }

package/service-override/userDataProfile.d.ts

@@ -0,0 +1,5 @@
+import { IEditorOverrideServices } from '../vscode/src/vs/editor/standalone/browser/standaloneServices.js';
+
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/vscode/src/vs/editor/editor.api.d.ts

@@ -6839,19 +6839,56 @@ export namespace languages {
          * current position itself.
          */
         range?: IRange;
+        /**
+         * Can increase the verbosity of the hover
+         */
+        canIncreaseVerbosity?: boolean;
+        /**
+         * Can decrease the verbosity of the hover
+         */
+        canDecreaseVerbosity?: boolean;
     }
 
     /**
      * The hover provider interface defines the contract between extensions and
      * the [hover](https://code.visualstudio.com/docs/editor/intellisense)-feature.
      */
-    export interface HoverProvider {
+    export interface HoverProvider<THover = Hover> {
         /**
-         * Provide a hover for the given position and document. Multiple hovers at the same
+         * Provide a hover for the given position, context and document. Multiple hovers at the same
          * position will be merged by the editor. A hover can have a range which defaults
          * to the word range at the position when omitted.
          */
-        provideHover(model: editor.ITextModel, position: Position, token: CancellationToken): ProviderResult<Hover>;
+        provideHover(model: editor.ITextModel, position: Position, token: CancellationToken, context?: HoverContext<THover>): ProviderResult<THover>;
+    }
+
+    export interface HoverContext<THover = Hover> {
+        /**
+         * Hover verbosity request
+         */
+        verbosityRequest?: HoverVerbosityRequest<THover>;
+    }
+
+    export interface HoverVerbosityRequest<THover = Hover> {
+        /**
+         * Whether to increase or decrease the hover's verbosity
+         */
+        action: HoverVerbosityAction;
+        /**
+         * The previous hover for the same position
+         */
+        previousHover: THover;
+    }
+
+    export enum HoverVerbosityAction {
+        /**
+         * Increase the verbosity of the hover
+         */
+        Increase = 0,
+        /**
+         * Decrease the verbosity of the hover
+         */
+        Decrease = 1
     }
 
     export enum CompletionItemKind {
@@ -7862,13 +7899,19 @@ export namespace languages {
         AIGenerated = 1
     }
 
+    export enum NewSymbolNameTriggerKind {
+        Invoke = 0,
+        Automatic = 1
+    }
+
     export interface NewSymbolName {
         readonly newSymbolName: string;
         readonly tags?: readonly NewSymbolNameTag[];
     }
 
     export interface NewSymbolNamesProvider {
-        provideNewSymbolNames(model: editor.ITextModel, range: IRange, token: CancellationToken): ProviderResult<NewSymbolName[]>;
+        supportsAutomaticNewSymbolNamesTriggerKind?: Promise<boolean | undefined>;
+        provideNewSymbolNames(model: editor.ITextModel, range: IRange, triggerKind: NewSymbolNameTriggerKind, token: CancellationToken): ProviderResult<NewSymbolName[]>;
     }
 
     export interface Command {

package/vscode/src/vs/platform/userDataProfile/common/userDataProfileStorageService.service.js

@@ -0,0 +1,3 @@
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+const IUserDataProfileStorageService = ( createDecorator('IUserDataProfileStorageService'));
+export { IUserDataProfileStorageService };

package/vscode/src/vs/workbench/services/storage/browser/storageService.js

@@ -0,0 +1,290 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { BroadcastDataChannel } from '../../../../base/browser/broadcast.js';
+import { isSafari } from '../../../../base/browser/browser.js';
+import { getActiveWindow } from '../../../../base/browser/dom.js';
+import { IndexedDB } from '../../../../base/browser/indexedDB.js';
+import { DeferredPromise, Promises } from '../../../../base/common/async.js';
+import { toErrorMessage } from '../../../../base/common/errorMessage.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { DisposableStore, Disposable } from '../../../../base/common/lifecycle.js';
+import { assertIsDefined } from '../../../../base/common/types.js';
+import { Storage, isStorageItemsChangeEvent, InMemoryStorageDatabase } from '../../../../base/parts/storage/common/storage.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { AbstractStorageService, isProfileUsingDefaultStorage, IS_NEW_KEY } from '../../../../platform/storage/common/storage.js';
+import { isUserDataProfile } from '../../../../platform/userDataProfile/common/userDataProfile.js';
+var BrowserStorageService_1;
+let BrowserStorageService = class BrowserStorageService extends AbstractStorageService {
+    static { BrowserStorageService_1 = this; }
+    static { this.BROWSER_DEFAULT_FLUSH_INTERVAL = 5 * 1000; }
+    get hasPendingUpdate() {
+        return Boolean(this.applicationStorageDatabase?.hasPendingUpdate ||
+            this.profileStorageDatabase?.hasPendingUpdate ||
+            this.workspaceStorageDatabase?.hasPendingUpdate);
+    }
+    constructor(workspace, userDataProfileService, logService) {
+        super({ flushInterval: BrowserStorageService_1.BROWSER_DEFAULT_FLUSH_INTERVAL });
+        this.workspace = workspace;
+        this.userDataProfileService = userDataProfileService;
+        this.logService = logService;
+        this.applicationStoragePromise = ( new DeferredPromise());
+        this.profileStorageProfile = this.userDataProfileService.currentProfile;
+        this.profileStorageDisposables = this._register(( new DisposableStore()));
+        this.workspaceStorageDisposables = this._register(( new DisposableStore()));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.userDataProfileService.onDidChangeCurrentProfile(e => e.join(this.switchToProfile(e.profile))));
+    }
+    async doInitialize() {
+        await Promises.settled([
+            this.createApplicationStorage(),
+            this.createProfileStorage(this.profileStorageProfile),
+            this.createWorkspaceStorage()
+        ]);
+    }
+    async createApplicationStorage() {
+        const applicationStorageIndexedDB = await IndexedDBStorageDatabase.createApplicationStorage(this.logService);
+        this.applicationStorageDatabase = this._register(applicationStorageIndexedDB);
+        this.applicationStorage = this._register(( new Storage(this.applicationStorageDatabase)));
+        this._register(this.applicationStorage.onDidChangeStorage(e => this.emitDidChangeValue(-1 , e)));
+        await this.applicationStorage.init();
+        this.updateIsNew(this.applicationStorage);
+        this.applicationStoragePromise.complete({ indexedDb: applicationStorageIndexedDB, storage: this.applicationStorage });
+    }
+    async createProfileStorage(profile) {
+        this.profileStorageDisposables.clear();
+        this.profileStorageProfile = profile;
+        if (isProfileUsingDefaultStorage(this.profileStorageProfile)) {
+            const { indexedDb: applicationStorageIndexedDB, storage: applicationStorage } = await this.applicationStoragePromise.p;
+            this.profileStorageDatabase = applicationStorageIndexedDB;
+            this.profileStorage = applicationStorage;
+            this.profileStorageDisposables.add(this.profileStorage.onDidChangeStorage(e => this.emitDidChangeValue(0 , e)));
+        }
+        else {
+            const profileStorageIndexedDB = await IndexedDBStorageDatabase.createProfileStorage(this.profileStorageProfile, this.logService);
+            this.profileStorageDatabase = this.profileStorageDisposables.add(profileStorageIndexedDB);
+            this.profileStorage = this.profileStorageDisposables.add(( new Storage(this.profileStorageDatabase)));
+            this.profileStorageDisposables.add(this.profileStorage.onDidChangeStorage(e => this.emitDidChangeValue(0 , e)));
+            await this.profileStorage.init();
+            this.updateIsNew(this.profileStorage);
+        }
+    }
+    async createWorkspaceStorage() {
+        this.workspaceStorageDisposables.clear();
+        const workspaceStorageIndexedDB = await IndexedDBStorageDatabase.createWorkspaceStorage(this.workspace.id, this.logService);
+        this.workspaceStorageDatabase = this.workspaceStorageDisposables.add(workspaceStorageIndexedDB);
+        this.workspaceStorage = this.workspaceStorageDisposables.add(( new Storage(this.workspaceStorageDatabase)));
+        this.workspaceStorageDisposables.add(this.workspaceStorage.onDidChangeStorage(e => this.emitDidChangeValue(1 , e)));
+        await this.workspaceStorage.init();
+        this.updateIsNew(this.workspaceStorage);
+    }
+    updateIsNew(storage) {
+        const firstOpen = storage.getBoolean(IS_NEW_KEY);
+        if (firstOpen === undefined) {
+            storage.set(IS_NEW_KEY, true);
+        }
+        else if (firstOpen) {
+            storage.set(IS_NEW_KEY, false);
+        }
+    }
+    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 this.applicationStorageDatabase?.name;
+            case 0 :
+                return this.profileStorageDatabase?.name;
+            default:
+                return this.workspaceStorageDatabase?.name;
+        }
+    }
+    async switchToProfile(toProfile) {
+        if (!this.canSwitchProfile(this.profileStorageProfile, toProfile)) {
+            return;
+        }
+        const oldProfileStorage = assertIsDefined(this.profileStorage);
+        const oldItems = oldProfileStorage.items;
+        if (oldProfileStorage !== this.applicationStorage) {
+            await oldProfileStorage.close();
+        }
+        await this.createProfileStorage(toProfile);
+        this.switchData(oldItems, assertIsDefined(this.profileStorage), 0 );
+    }
+    async switchToWorkspace(toWorkspace, preserveData) {
+        const oldWorkspaceStorage = assertIsDefined(this.workspaceStorage);
+        const oldItems = preserveData ? oldWorkspaceStorage.items : ( new Map());
+        await oldWorkspaceStorage.close();
+        this.workspace = toWorkspace;
+        await this.createWorkspaceStorage();
+        this.switchData(oldItems, assertIsDefined(this.workspaceStorage), 1 );
+    }
+    shouldFlushWhenIdle() {
+        return getActiveWindow().document.hasFocus() && !this.hasPendingUpdate;
+    }
+    close() {
+        if (isSafari) {
+            this.applicationStorage?.close();
+            this.profileStorageDatabase?.close();
+            this.workspaceStorageDatabase?.close();
+        }
+        this.dispose();
+    }
+    async clear() {
+        for (const scope of [-1 , 0 , 1 ]) {
+            for (const target of [0 , 1 ]) {
+                for (const key of ( this.keys(scope, target))) {
+                    this.remove(key, scope);
+                }
+            }
+            await this.getStorage(scope)?.whenFlushed();
+        }
+        await Promises.settled([
+            this.applicationStorageDatabase?.clear() ?? Promise.resolve(),
+            this.profileStorageDatabase?.clear() ?? Promise.resolve(),
+            this.workspaceStorageDatabase?.clear() ?? Promise.resolve()
+        ]);
+    }
+    hasScope(scope) {
+        if (isUserDataProfile(scope)) {
+            return this.profileStorageProfile.id === scope.id;
+        }
+        return this.workspace.id === scope.id;
+    }
+};
+BrowserStorageService = BrowserStorageService_1 = ( __decorate([
+    ( __param(2, ILogService))
+], BrowserStorageService));
+class InMemoryIndexedDBStorageDatabase extends InMemoryStorageDatabase {
+    constructor() {
+        super(...arguments);
+        this.hasPendingUpdate = false;
+        this.name = 'in-memory-indexedb-storage';
+    }
+    async clear() {
+        (await this.getItems()).clear();
+    }
+    dispose() {
+    }
+}
+class IndexedDBStorageDatabase extends Disposable {
+    static async createApplicationStorage(logService) {
+        return IndexedDBStorageDatabase.create({ id: 'global', broadcastChanges: true }, logService);
+    }
+    static async createProfileStorage(profile, logService) {
+        return IndexedDBStorageDatabase.create({ id: `global-${profile.id}`, broadcastChanges: true }, logService);
+    }
+    static async createWorkspaceStorage(workspaceId, logService) {
+        return IndexedDBStorageDatabase.create({ id: workspaceId }, logService);
+    }
+    static async create(options, logService) {
+        try {
+            const database = ( new IndexedDBStorageDatabase(options, logService));
+            await database.whenConnected;
+            return database;
+        }
+        catch (error) {
+            logService.error(`[IndexedDB Storage ${options.id}] create(): ${toErrorMessage(error, true)}`);
+            return ( new InMemoryIndexedDBStorageDatabase());
+        }
+    }
+    static { this.STORAGE_DATABASE_PREFIX = 'vscode-web-state-db-'; }
+    static { this.STORAGE_OBJECT_STORE = 'ItemTable'; }
+    get hasPendingUpdate() { return !!this.pendingUpdate; }
+    constructor(options, logService) {
+        super();
+        this.logService = logService;
+        this._onDidChangeItemsExternal = this._register(( new Emitter()));
+        this.onDidChangeItemsExternal = this._onDidChangeItemsExternal.event;
+        this.pendingUpdate = undefined;
+        this.name = `${IndexedDBStorageDatabase.STORAGE_DATABASE_PREFIX}${options.id}`;
+        this.broadcastChannel = options.broadcastChanges ? this._register(( new BroadcastDataChannel(this.name))) : undefined;
+        this.whenConnected = this.connect();
+        this.registerListeners();
+    }
+    registerListeners() {
+        if (this.broadcastChannel) {
+            this._register(this.broadcastChannel.onDidReceiveData(data => {
+                if (isStorageItemsChangeEvent(data)) {
+                    this._onDidChangeItemsExternal.fire(data);
+                }
+            }));
+        }
+    }
+    async connect() {
+        try {
+            return await IndexedDB.create(this.name, undefined, [IndexedDBStorageDatabase.STORAGE_OBJECT_STORE]);
+        }
+        catch (error) {
+            this.logService.error(`[IndexedDB Storage ${this.name}] connect() error: ${toErrorMessage(error)}`);
+            throw error;
+        }
+    }
+    async getItems() {
+        const db = await this.whenConnected;
+        function isValid(value) {
+            return typeof value === 'string';
+        }
+        return db.getKeyValues(IndexedDBStorageDatabase.STORAGE_OBJECT_STORE, isValid);
+    }
+    async updateItems(request) {
+        let didUpdate = false;
+        this.pendingUpdate = this.doUpdateItems(request);
+        try {
+            didUpdate = await this.pendingUpdate;
+        }
+        finally {
+            this.pendingUpdate = undefined;
+        }
+        if (this.broadcastChannel && didUpdate) {
+            const event = {
+                changed: request.insert,
+                deleted: request.delete
+            };
+            this.broadcastChannel.postData(event);
+        }
+    }
+    async doUpdateItems(request) {
+        const toInsert = request.insert;
+        const toDelete = request.delete;
+        if ((!toInsert && !toDelete) || (toInsert?.size === 0 && toDelete?.size === 0)) {
+            return false;
+        }
+        const db = await this.whenConnected;
+        await db.runInTransaction(IndexedDBStorageDatabase.STORAGE_OBJECT_STORE, 'readwrite', objectStore => {
+            const requests = [];
+            if (toInsert) {
+                for (const [key, value] of toInsert) {
+                    requests.push(objectStore.put(value, key));
+                }
+            }
+            if (toDelete) {
+                for (const key of toDelete) {
+                    requests.push(objectStore.delete(key));
+                }
+            }
+            return requests;
+        });
+        return true;
+    }
+    async optimize() {
+    }
+    async close() {
+        const db = await this.whenConnected;
+        await this.pendingUpdate;
+        return db.close();
+    }
+    async clear() {
+        const db = await this.whenConnected;
+        await db.runInTransaction(IndexedDBStorageDatabase.STORAGE_OBJECT_STORE, 'readwrite', objectStore => objectStore.clear());
+    }
+}
+export { BrowserStorageService, IndexedDBStorageDatabase };

package/vscode/src/vs/workbench/services/userDataProfile/common/userDataProfile.js

@@ -1,5 +1,5 @@
 import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
-import '../../../../platform/actions/common/actions.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
 import { URI } from '../../../../base/common/uri.js';
 import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
@@ -16,11 +16,16 @@ function toUserDataProfileUri(path, productService) {
     );
 }
 const defaultUserDataProfileIcon = registerIcon('defaultProfile-icon', Codicon.settings, ( localizeWithPath(_moduleId, 0, 'Icon for Default Profile.')));
+const ProfilesMenu = ( (new MenuId('Profiles')));
+const MANAGE_PROFILES_ACTION_ID = 'workbench.profiles.actions.manage';
 const PROFILES_TITLE = ( localize2WithPath(_moduleId, 1, 'Profiles'));
 const PROFILES_CATEGORY = { ...PROFILES_TITLE };
 const PROFILE_EXTENSION = 'code-profile';
 const PROFILE_FILTER = [{ name: ( localizeWithPath(_moduleId, 2, "Profile")), extensions: [PROFILE_EXTENSION] }];
+const PROFILES_ENABLEMENT_CONTEXT = ( (new RawContextKey('profiles.enabled', true)));
 const CURRENT_PROFILE_CONTEXT = ( (new RawContextKey('currentProfile', '')));
+const IS_CURRENT_PROFILE_TRANSIENT_CONTEXT = ( (new RawContextKey('isCurrentProfileTransient', false)));
+const HAS_PROFILES_CONTEXT = ( (new RawContextKey('hasProfiles', false)));
 const IS_PROFILE_EXPORT_IN_PROGRESS_CONTEXT = ( (new RawContextKey('isProfileExportInProgress', false)));
 const IS_PROFILE_IMPORT_IN_PROGRESS_CONTEXT = ( (new RawContextKey('isProfileImportInProgress', false)));
-export { CURRENT_PROFILE_CONTEXT, IS_PROFILE_EXPORT_IN_PROGRESS_CONTEXT, IS_PROFILE_IMPORT_IN_PROGRESS_CONTEXT, PROFILES_CATEGORY, PROFILES_TITLE, PROFILE_EXTENSION, PROFILE_FILTER, PROFILE_URL_AUTHORITY, defaultUserDataProfileIcon, toUserDataProfileUri };
+export { CURRENT_PROFILE_CONTEXT, HAS_PROFILES_CONTEXT, IS_CURRENT_PROFILE_TRANSIENT_CONTEXT, IS_PROFILE_EXPORT_IN_PROGRESS_CONTEXT, IS_PROFILE_IMPORT_IN_PROGRESS_CONTEXT, MANAGE_PROFILES_ACTION_ID, PROFILES_CATEGORY, PROFILES_ENABLEMENT_CONTEXT, PROFILES_TITLE, PROFILE_EXTENSION, PROFILE_FILTER, PROFILE_URL_AUTHORITY, ProfilesMenu, defaultUserDataProfileIcon, toUserDataProfileUri };