@codingame/monaco-vscode-api 5.1.2 → 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/extensions.d.ts

@@ -100,6 +100,7 @@ export { IExtensionContributions } from './vscode/src/vs/platform/extensions/com
 import { IDisposable } from './vscode/src/vs/base/common/lifecycle.js';
 export { ITranslations } from './vscode/src/vs/platform/extensionManagement/common/extensionNls.js';
 import { ExtensionHostKind } from './vscode/src/vs/workbench/services/extensions/common/extensionHostKind.js';
+export { ExtensionFileMetadata } from './service-override/files.js';
 
 type ApiFactory = (extensionId?: string) => Promise<typeof vscode>;
 declare function registerLocalApiFactory(_apiFactory: ApiFactory): void;

package/extensions.js

@@ -13,31 +13,20 @@ import { IWorkbenchExtensionEnablementService } from './vscode/src/vs/workbench/
 import { StandaloneServices } from './vscode/src/vs/editor/standalone/browser/standaloneServices.js';
 import { ExtensionManifestTranslator } from './vscode/src/vs/platform/extensionManagement/common/extensionsScannerService.js';
 import { language } from './vscode/src/vs/base/common/platform.js';
-import { CustomSchemas, registerExtensionFile } from '@codingame/monaco-vscode-files-service-override';
+import { CustomSchemas, registerExtensionFile, RegisteredUriFile } from '@codingame/monaco-vscode-files-service-override';
 import { waitServicesReady } from './lifecycle.js';
-import { throttle, memoized } from './tools.js';
+import { throttle } from './tools.js';
 import { setDefaultApi } from './api.js';
 import { getBuiltInExtensionTranslationsUris } from './l10n.js';
 let apiFactory;
 function registerLocalApiFactory(_apiFactory) {
     apiFactory = _apiFactory;
 }
-function registerExtensionFileUrl(extensionLocation, filePath, url, mimeType) {
+function registerExtensionFileUrl(extensionLocation, filePath, url, metadataOrMimeType) {
     const fileDisposable = new DisposableStore();
     fileDisposable.add(FileAccess.registerStaticBrowserUri(joinPath(extensionLocation, filePath), ( URI.parse(url))));
-    fileDisposable.add(registerExtensionFile(extensionLocation, filePath, memoized(async () => {
-        const response = await fetch(url, {
-            headers: mimeType != null
-                ? {
-                    Accept: mimeType
-                }
-                : {}
-        });
-        if (response.status !== 200) {
-            throw new Error(response.statusText);
-        }
-        return new Uint8Array(await response.arrayBuffer());
-    })));
+    const metadata = typeof metadataOrMimeType === 'string' ? { mimeType: metadataOrMimeType } : metadataOrMimeType;
+    fileDisposable.add(registerExtensionFile(new RegisteredUriFile(joinPath(extensionLocation, filePath), url, metadata)));
     return fileDisposable;
 }
 const deltaExtensions = throttle(async ({ toAdd, toRemove }) => {
@@ -129,8 +118,8 @@ function registerExtension(manifest, extHostKind, { path = '/', system = false,
         }
     };
     if (extHostKind !== 3 ) {
-        function registerFileUrl(path, url, mimeType) {
-            return registerExtensionFileUrl(location, path, url, mimeType);
+        function registerFileUrl(path, url, metadataOrMimeType) {
+            return registerExtensionFileUrl(location, path, url, metadataOrMimeType);
         }
         api = {
             ...api,

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.1.2",
+  "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.1.2",
-    "@codingame/monaco-vscode-files-service-override": "5.1.2",
-    "@codingame/monaco-vscode-extensions-service-override": "5.1.2",
-    "@codingame/monaco-vscode-environment-service-override": "5.1.2",
-    "@codingame/monaco-vscode-layout-service-override": "5.1.2",
-    "@codingame/monaco-vscode-host-service-override": "5.1.2",
-    "@codingame/monaco-vscode-base-service-override": "5.1.2"
+    "@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/files.d.ts

@@ -1,72 +1,120 @@
 import { IEditorOverrideServices } from '../vscode/src/vs/editor/standalone/browser/standaloneServices.js';
 export { InMemoryFileSystemProvider } from '../vscode/src/vs/platform/files/common/inMemoryFilesystemProvider.js';
 import { URI } from '../vscode/src/vs/base/common/uri.js';
-import { FileType, IStat, IFileSystemProviderWithFileReadWriteCapability, IFileChange, IWatchOptions, IFileWriteOptions, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProvider, FileSystemProviderCapabilities, FileChangeType } from '../vscode/src/vs/platform/files/common/files.js';
+import { FileType, IStat, IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithOpenReadWriteCloseCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileAtomicWriteCapability, IFileSystemProviderWithFileAtomicDeleteCapability, IFileChange, IFileReadStreamOptions, IFileWriteOptions, IWatchOptions, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProvider, FileSystemProviderCapabilities, FileChangeType } from '../vscode/src/vs/platform/files/common/files.js';
 export { FilePermission, FileSystemProviderError, FileSystemProviderErrorCode } from '../vscode/src/vs/platform/files/common/files.js';
 import { Disposable, IDisposable } from '../vscode/src/vs/base/common/lifecycle.js';
 import { Emitter, Event } from '../vscode/src/vs/base/common/event.js';
 export { HTMLFileSystemProvider } from '../vscode/src/vs/platform/files/browser/htmlFileSystemProvider.js';
 import { IndexedDBFileSystemProvider } from '../vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js';
 export { IndexedDB } from '../vscode/src/vs/base/browser/indexedDB.js';
+import { ReadableStreamEvents } from '../vscode/src/vs/base/common/stream.js';
+import { CancellationToken } from '../vscode/src/vs/base/common/cancellation.js';
 
-declare abstract class RegisteredFile {
+interface _RegisteredNode {
+    type: FileType;
+    stats(): Promise<IStat>;
+    onDidDelete: Event<void>;
+    onDidChange: Event<void>;
+}
+interface RegisteredFileNode extends _RegisteredNode {
+    type: FileType.File;
+    uri: URI;
+    read(): Promise<Uint8Array>;
+    readStream?(): Promise<ReadableStream<Uint8Array>>;
+    write(content: Uint8Array): Promise<void>;
+    delete(): void;
+}
+interface RegisteredDirectoryNode extends _RegisteredNode {
+    type: FileType.Directory;
+    addChild(name: string, node: RegisteredNode): IDisposable;
+    deleteChild(name: string): boolean;
+    getChildren(name: string): RegisteredNode | undefined;
+    read(): [string, FileType][];
+}
+type RegisteredNode = RegisteredFileNode | RegisteredDirectoryNode;
+declare abstract class RegisteredFile implements RegisteredFileNode {
     uri: URI;
     private readonly;
     protected ctime: number;
     protected mtime: number;
-    readonly type: FileType;
+    readonly type = FileType.File;
     protected _onDidChange: Emitter<void>;
     onDidChange: Event<void>;
     protected _onDidDelete: Emitter<void>;
     onDidDelete: Event<void>;
-    protected _onDidRename: Emitter<{
-        from: URI;
-        to: URI;
-    }>;
-    onDidRename: Event<{
-        from: URI;
-        to: URI;
-    }>;
     constructor(uri: URI, readonly: boolean);
     stats(): Promise<IStat>;
-    getSize(): Promise<number>;
-    abstract read(): Promise<string | Uint8Array>;
-    abstract write(content: string): Promise<void>;
+    abstract getSize(): Promise<number>;
     delete(): Promise<void>;
-    rename(to: URI): Promise<void>;
+    abstract read(): Promise<Uint8Array>;
+    abstract write(content: Uint8Array): Promise<void>;
 }
 declare class RegisteredReadOnlyFile extends RegisteredFile {
-    read: () => Promise<string | Uint8Array>;
-    constructor(uri: URI, read: () => Promise<string | Uint8Array>);
+    read: () => Promise<Uint8Array>;
+    private size;
+    constructor(uri: URI, read: () => Promise<Uint8Array>, size: number);
+    getSize(): Promise<number>;
+    write(): Promise<void>;
+    delete(): Promise<void>;
+}
+interface ExtensionFileMetadata {
+    mimeType?: string;
+    size?: number;
+}
+declare class RegisteredUriFile extends RegisteredFile {
+    private url;
+    private metadata?;
+    constructor(location: URI, url: string, metadata?: ExtensionFileMetadata | undefined);
+    private fetch;
+    getSize(): Promise<number>;
+    read(): Promise<Uint8Array>;
+    readStream(): Promise<ReadableStream<Uint8Array>>;
     write(): Promise<void>;
     delete(): Promise<void>;
-    rename(): Promise<void>;
 }
 declare class RegisteredMemoryFile extends RegisteredFile {
     private content;
-    constructor(uri: URI, content: string);
-    read(): Promise<string | Uint8Array>;
-    write(content: string): Promise<void>;
+    constructor(uri: URI, content: string | Uint8Array);
+    getSize(): Promise<number>;
+    read(): Promise<Uint8Array>;
+    write(content: Uint8Array): Promise<void>;
 }
-declare class RegisteredFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability {
-    private files;
-    capabilities: number;
-    constructor(readonly: boolean);
+declare class RegisteredFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithOpenReadWriteCloseCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileAtomicWriteCapability, IFileSystemProviderWithFileAtomicDeleteCapability {
+    private memoryFdCounter;
+    private readonly fdMemory;
+    private rootByAuthority;
     onDidChangeCapabilities: Event<any>;
     _onDidChangeFile: Emitter<readonly IFileChange[]>;
     onDidChangeFile: Event<readonly IFileChange[]>;
-    private formatUri;
-    registerFile(file: RegisteredFile): IDisposable;
+    capabilities: number;
+    constructor(readonly: boolean);
+    open(resource: URI): Promise<number>;
+    close(fd: number): Promise<void>;
+    read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    private _lookupRoot;
+    private _lookup;
+    private _lookupAsDirectory;
+    private _lookupAsFile;
+    registerFile(file: RegisteredFileNode): IDisposable;
     stat(resource: URI): Promise<IStat>;
+    readdirSync(resource: URI): [string, FileType][];
     readdir(resource: URI): Promise<[string, FileType][]>;
     readFile(resource: URI): Promise<Uint8Array>;
+    readFileStream(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
     watch(): IDisposable;
-    writeFile(resource: URI, content: Uint8Array): Promise<void>;
+    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
+    rename(): Promise<void>;
+    mkdirSync(resource: URI): RegisteredDirectoryNode;
+    mkdir(): Promise<void>;
+    private deleteSync;
     delete(resource: URI): Promise<void>;
-    rename(from: URI, to: URI): Promise<void>;
-    mkdir(): Promise<never>;
+    private _bufferedChanges;
+    private _fireSoonHandle?;
+    private _fireSoon;
 }
-declare class OverlayFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability {
+declare class OverlayFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileAtomicWriteCapability, IFileSystemProviderWithFileAtomicDeleteCapability {
     private providers;
     register(priority: number, provider: IFileSystemProviderWithFileReadWriteCapability): IDisposable;
     get delegates(): IFileSystemProviderWithFileReadWriteCapability[];
@@ -77,9 +125,11 @@ declare class OverlayFileSystemProvider implements IFileSystemProviderWithFileRe
     onDidChangeOverlays: Event<void>;
     capabilities: number;
     private readFromDelegates;
+    private readFromDelegatesSync;
     private writeToDelegates;
     stat(resource: URI): Promise<IStat>;
     readFile(resource: URI): Promise<Uint8Array>;
+    readFileStream(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
     readdir(resource: URI): Promise<[string, FileType][]>;
     watch(resource: URI, opts: IWatchOptions): IDisposable;
     writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
@@ -135,7 +185,7 @@ declare function getServiceOverride(): IEditorOverrideServices;
  * the default file system provider for a given scheme.
  */
 declare function registerCustomProvider(scheme: string, provider: IFileSystemProvider): void;
-declare function registerExtensionFile(extensionLocation: URI, filePath: string, getContent: () => Promise<string | Uint8Array>): IDisposable;
+declare function registerExtensionFile(file: RegisteredFileNode): IDisposable;
 /**
  * Can be used to create a file before the fileService is initialized
  */
@@ -162,4 +212,4 @@ declare function registerHTMLFileSystemProvider(): void;
  */
 declare function registerFileSystemOverlay(priority: number, provider: IFileSystemProviderWithFileReadWriteCapability): IDisposable;
 
-export { CustomSchemas, DelegateFileSystemProvider, EmptyFileSystemProvider, FileChangeType, FileSystemProviderCapabilities, FileType, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions, IndexedDBFileSystemProvider, OverlayFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, createIndexedDBProviders, getServiceOverride as default, initFile, registerCustomProvider, registerExtensionFile, registerFileSystemOverlay, registerHTMLFileSystemProvider };
+export { CustomSchemas, DelegateFileSystemProvider, EmptyFileSystemProvider, type ExtensionFileMetadata, FileChangeType, FileSystemProviderCapabilities, FileType, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions, IndexedDBFileSystemProvider, OverlayFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, RegisteredUriFile, createIndexedDBProviders, getServiceOverride as default, initFile, registerCustomProvider, registerExtensionFile, registerFileSystemOverlay, registerHTMLFileSystemProvider };

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 };