@codingame/monaco-vscode-user-data-profile-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/services/userDataSync/browser/userDataSyncInit.js

@@ -36,7 +36,18 @@ import { IBrowserWorkbenchEnvironmentService } from '@codingame/monaco-vscode-ap
 import { ISecretStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/secrets/common/secrets.service';
 
 let UserDataSyncInitializer = class UserDataSyncInitializer {
-    constructor(environmentService, secretStorageService, userDataSyncStoreManagementService, fileService, userDataProfilesService, storageService, productService, requestService, logService, uriIdentityService) {
+    constructor(
+        environmentService,
+        secretStorageService,
+        userDataSyncStoreManagementService,
+        fileService,
+        userDataProfilesService,
+        storageService,
+        productService,
+        requestService,
+        logService,
+        uriIdentityService
+    ) {
         this.environmentService = environmentService;
         this.secretStorageService = secretStorageService;
         this.userDataSyncStoreManagementService = userDataSyncStoreManagementService;
@@ -79,8 +90,7 @@ let UserDataSyncInitializer = class UserDataSyncInitializer {
                     let authenticationSession;
                     try {
                         authenticationSession = await getCurrentAuthenticationSessionInfo(this.secretStorageService, this.productService);
-                    }
-                    catch (error) {
+                    } catch (error) {
                         this.logService.error(error);
                     }
                     if (!authenticationSession) {
@@ -111,8 +121,7 @@ let UserDataSyncInitializer = class UserDataSyncInitializer {
                     }
                     this.logService.info(`Using settings sync service ${( userDataSyncStore.url.toString())} for initialization`);
                     return userDataSyncStoreClient;
-                }
-                catch (error) {
+                } catch (error) {
                     this.logService.error(error);
                     return;
                 }
@@ -148,14 +157,16 @@ let UserDataSyncInitializer = class UserDataSyncInitializer {
                 )).getSyncStoreType(this.globalStateUserData);
                 if (userDataSyncStoreType) {
                     await this.userDataSyncStoreManagementService.switch(userDataSyncStoreType);
-                    if (!isEqual(userDataSyncStore.url, this.userDataSyncStoreManagementService.userDataSyncStore?.url)) {
-                        this.logService.info('Switched settings sync store');
+                    if (!isEqual(
+                        userDataSyncStore.url,
+                        this.userDataSyncStoreManagementService.userDataSyncStore?.url
+                    )) {
+                        this.logService.info("Switched settings sync store");
                         this.globalStateUserData = null;
                     }
                 }
             }
-        }
-        finally {
+        } finally {
             disposables.dispose();
         }
     }
@@ -174,17 +185,21 @@ let UserDataSyncInitializer = class UserDataSyncInitializer {
     async initializeOtherResources(instantiationService) {
         try {
             this.logService.trace(`UserDataInitializationService#initializeOtherResources`);
-            await Promise.allSettled([this.initialize([SyncResource.Keybindings, SyncResource.Snippets, SyncResource.Tasks]), this.initializeExtensions(instantiationService)]);
-        }
-        finally {
+            await Promise.allSettled([
+                this.initialize([SyncResource.Keybindings, SyncResource.Snippets, SyncResource.Tasks]),
+                this.initializeExtensions(instantiationService)
+            ]);
+        } finally {
             this.initializationFinished.open();
         }
     }
     async initializeExtensions(instantiationService) {
         try {
-            await Promise.all([this.initializeInstalledExtensions(instantiationService), this.initializeNewExtensions(instantiationService)]);
-        }
-        finally {
+            await Promise.all([
+                this.initializeInstalledExtensions(instantiationService),
+                this.initializeNewExtensions(instantiationService)
+            ]);
+        } finally {
             this.initialized.push(SyncResource.Extensions);
         }
     }
@@ -230,7 +245,7 @@ let UserDataSyncInitializer = class UserDataSyncInitializer {
         if (!userDataSyncStoreClient) {
             return;
         }
-        await Promises.settled(( syncResources.map(async (syncResource) => {
+        await Promises.settled(( syncResources.map(async syncResource => {
             try {
                 if (this.initialized.includes(syncResource)) {
                     this.logService.info(`${getSyncAreaLabel(syncResource)} initialized already.`);
@@ -239,11 +254,13 @@ let UserDataSyncInitializer = class UserDataSyncInitializer {
                 this.initialized.push(syncResource);
                 this.logService.trace(`Initializing ${getSyncAreaLabel(syncResource)}`);
                 const initializer = this.createSyncResourceInitializer(syncResource);
-                const userData = await userDataSyncStoreClient.readResource(syncResource, syncResource === SyncResource.GlobalState ? this.globalStateUserData : null);
+                const userData = await userDataSyncStoreClient.readResource(
+                    syncResource,
+                    syncResource === SyncResource.GlobalState ? this.globalStateUserData : null
+                );
                 await initializer.initialize(userData);
                 this.logService.info(`Initialized ${getSyncAreaLabel(syncResource)}`);
-            }
-            catch (error) {
+            } catch (error) {
                 this.logService.info(`Error while initializing ${getSyncAreaLabel(syncResource)}`);
                 this.logService.error(error);
             }
@@ -251,7 +268,8 @@ let UserDataSyncInitializer = class UserDataSyncInitializer {
     }
     createSyncResourceInitializer(syncResource) {
         switch (syncResource) {
-            case SyncResource.Settings: return ( new SettingsInitializer(
+        case SyncResource.Settings:
+            return ( new SettingsInitializer(
                 this.fileService,
                 this.userDataProfilesService,
                 this.environmentService,
@@ -259,7 +277,8 @@ let UserDataSyncInitializer = class UserDataSyncInitializer {
                 this.storageService,
                 this.uriIdentityService
             ));
-            case SyncResource.Keybindings: return ( new KeybindingsInitializer(
+        case SyncResource.Keybindings:
+            return ( new KeybindingsInitializer(
                 this.fileService,
                 this.userDataProfilesService,
                 this.environmentService,
@@ -267,7 +286,8 @@ let UserDataSyncInitializer = class UserDataSyncInitializer {
                 this.storageService,
                 this.uriIdentityService
             ));
-            case SyncResource.Tasks: return ( new TasksInitializer(
+        case SyncResource.Tasks:
+            return ( new TasksInitializer(
                 this.fileService,
                 this.userDataProfilesService,
                 this.environmentService,
@@ -275,7 +295,8 @@ let UserDataSyncInitializer = class UserDataSyncInitializer {
                 this.storageService,
                 this.uriIdentityService
             ));
-            case SyncResource.Snippets: return ( new SnippetsInitializer(
+        case SyncResource.Snippets:
+            return ( new SnippetsInitializer(
                 this.fileService,
                 this.userDataProfilesService,
                 this.environmentService,
@@ -283,7 +304,8 @@ let UserDataSyncInitializer = class UserDataSyncInitializer {
                 this.storageService,
                 this.uriIdentityService
             ));
-            case SyncResource.GlobalState: return ( new GlobalStateInitializer(
+        case SyncResource.GlobalState:
+            return ( new GlobalStateInitializer(
                 this.storageService,
                 this.fileService,
                 this.userDataProfilesService,
@@ -295,21 +317,29 @@ let UserDataSyncInitializer = class UserDataSyncInitializer {
         throw ( new Error(`Cannot create initializer for ${syncResource}`));
     }
 };
-UserDataSyncInitializer = ( __decorate([
-    ( __param(0, IBrowserWorkbenchEnvironmentService)),
-    ( __param(1, ISecretStorageService)),
-    ( __param(2, IUserDataSyncStoreManagementService)),
-    ( __param(3, IFileService)),
-    ( __param(4, IUserDataProfilesService)),
-    ( __param(5, IStorageService)),
-    ( __param(6, IProductService)),
-    ( __param(7, IRequestService)),
-    ( __param(8, ILogService)),
-    ( __param(9, IUriIdentityService))
-], UserDataSyncInitializer));
+UserDataSyncInitializer = ( __decorate([( __param(0, IBrowserWorkbenchEnvironmentService)), ( __param(1, ISecretStorageService)), ( __param(2, IUserDataSyncStoreManagementService)), ( __param(3, IFileService)), ( __param(4, IUserDataProfilesService)), ( __param(5, IStorageService)), ( __param(6, IProductService)), ( __param(7, IRequestService)), ( __param(8, ILogService)), ( __param(9, IUriIdentityService))], UserDataSyncInitializer));
 let ExtensionsPreviewInitializer = class ExtensionsPreviewInitializer extends AbstractExtensionsInitializer {
-    constructor(extensionsData, extensionManagementService, ignoredExtensionsManagementService, fileService, userDataProfilesService, environmentService, logService, storageService, uriIdentityService) {
-        super(extensionManagementService, ignoredExtensionsManagementService, fileService, userDataProfilesService, environmentService, logService, storageService, uriIdentityService);
+    constructor(
+        extensionsData,
+        extensionManagementService,
+        ignoredExtensionsManagementService,
+        fileService,
+        userDataProfilesService,
+        environmentService,
+        logService,
+        storageService,
+        uriIdentityService
+    ) {
+        super(
+            extensionManagementService,
+            ignoredExtensionsManagementService,
+            fileService,
+            userDataProfilesService,
+            environmentService,
+            logService,
+            storageService,
+            uriIdentityService
+        );
         this.extensionsData = extensionsData;
         this.preview = null;
     }
@@ -320,30 +350,28 @@ let ExtensionsPreviewInitializer = class ExtensionsPreviewInitializer extends Ab
         return this.previewPromise;
     }
     initialize() {
-        throw ( new Error('should not be called directly'));
+        throw ( new Error("should not be called directly"));
     }
     async doInitialize(remoteUserData) {
         const remoteExtensions = await this.parseExtensions(remoteUserData);
         if (!remoteExtensions) {
-            this.logService.info('Skipping initializing extensions because remote extensions does not exist.');
+            this.logService.info(
+                "Skipping initializing extensions because remote extensions does not exist."
+            );
             return;
         }
         const installedExtensions = await this.extensionManagementService.getInstalled();
         this.preview = this.generatePreview(remoteExtensions, installedExtensions);
     }
 };
-ExtensionsPreviewInitializer = ( __decorate([
-    ( __param(1, IExtensionManagementService)),
-    ( __param(2, IIgnoredExtensionsManagementService)),
-    ( __param(3, IFileService)),
-    ( __param(4, IUserDataProfilesService)),
-    ( __param(5, IEnvironmentService)),
-    ( __param(6, IUserDataSyncLogService)),
-    ( __param(7, IStorageService)),
-    ( __param(8, IUriIdentityService))
-], ExtensionsPreviewInitializer));
+ExtensionsPreviewInitializer = ( __decorate([( __param(1, IExtensionManagementService)), ( __param(2, IIgnoredExtensionsManagementService)), ( __param(3, IFileService)), ( __param(4, IUserDataProfilesService)), ( __param(5, IEnvironmentService)), ( __param(6, IUserDataSyncLogService)), ( __param(7, IStorageService)), ( __param(8, IUriIdentityService))], ExtensionsPreviewInitializer));
 let InstalledExtensionsInitializer = class InstalledExtensionsInitializer {
-    constructor(extensionsPreviewInitializer, extensionEnablementService, extensionStorageService, logService) {
+    constructor(
+        extensionsPreviewInitializer,
+        extensionEnablementService,
+        extensionStorageService,
+        logService
+    ) {
         this.extensionsPreviewInitializer = extensionsPreviewInitializer;
         this.extensionEnablementService = extensionEnablementService;
         this.extensionStorageService = extensionStorageService;
@@ -355,7 +383,11 @@ let InstalledExtensionsInitializer = class InstalledExtensionsInitializer {
             return;
         }
         for (const installedExtension of preview.installedExtensions) {
-            const syncExtension = preview.remoteExtensions.find(({ identifier }) => areSameExtensions(identifier, installedExtension.identifier));
+            const syncExtension = preview.remoteExtensions.find((
+                {
+                    identifier
+                }
+            ) => areSameExtensions(identifier, installedExtension.identifier));
             if (syncExtension?.state) {
                 const extensionState = this.extensionStorageService.getExtensionState(installedExtension, true) || {};
                 ( Object.keys(syncExtension.state)).forEach(key => extensionState[key] = syncExtension.state[key]);
@@ -371,13 +403,16 @@ let InstalledExtensionsInitializer = class InstalledExtensionsInitializer {
         }
     }
 };
-InstalledExtensionsInitializer = ( __decorate([
-    ( __param(1, IGlobalExtensionEnablementService)),
-    ( __param(2, IExtensionStorageService)),
-    ( __param(3, IUserDataSyncLogService))
-], InstalledExtensionsInitializer));
+InstalledExtensionsInitializer = ( __decorate([( __param(1, IGlobalExtensionEnablementService)), ( __param(2, IExtensionStorageService)), ( __param(3, IUserDataSyncLogService))], InstalledExtensionsInitializer));
 let NewExtensionsInitializer = class NewExtensionsInitializer {
-    constructor(extensionsPreviewInitializer, extensionService, extensionStorageService, galleryService, extensionManagementService, logService) {
+    constructor(
+        extensionsPreviewInitializer,
+        extensionService,
+        extensionStorageService,
+        galleryService,
+        extensionManagementService,
+        logService
+    ) {
         this.extensionsPreviewInitializer = extensionsPreviewInitializer;
         this.extensionService = extensionService;
         this.extensionStorageService = extensionStorageService;
@@ -392,10 +427,17 @@ let NewExtensionsInitializer = class NewExtensionsInitializer {
         }
         const newlyEnabledExtensions = [];
         const targetPlatform = await this.extensionManagementService.getTargetPlatform();
-        const galleryExtensions = await this.galleryService.getExtensions(preview.newExtensions, { targetPlatform, compatible: true }, CancellationToken.None);
+        const galleryExtensions = await this.galleryService.getExtensions(preview.newExtensions, {
+            targetPlatform,
+            compatible: true
+        }, CancellationToken.None);
         for (const galleryExtension of galleryExtensions) {
             try {
-                const extensionToSync = preview.remoteExtensions.find(({ identifier }) => areSameExtensions(identifier, galleryExtension.identifier));
+                const extensionToSync = preview.remoteExtensions.find((
+                    {
+                        identifier
+                    }
+                ) => areSameExtensions(identifier, galleryExtension.identifier));
                 if (!extensionToSync) {
                     continue;
                 }
@@ -408,14 +450,15 @@ let NewExtensionsInitializer = class NewExtensionsInitializer {
                     donotIncludePackAndDependencies: true,
                     installGivenVersion: !!extensionToSync.version,
                     installPreReleaseVersion: extensionToSync.preRelease,
-                    context: { [EXTENSION_INSTALL_SKIP_PUBLISHER_TRUST_CONTEXT]: true }
+                    context: {
+                        [EXTENSION_INSTALL_SKIP_PUBLISHER_TRUST_CONTEXT]: true
+                    }
                 });
                 if (!( preview.disabledExtensions.some(identifier => areSameExtensions(identifier, galleryExtension.identifier)))) {
                     newlyEnabledExtensions.push(local);
                 }
                 this.logService.info(`Installed extension.`, galleryExtension.identifier.id);
-            }
-            catch (error) {
+            } catch (error) {
                 this.logService.error(error);
             }
         }
@@ -428,8 +471,7 @@ let NewExtensionsInitializer = class NewExtensionsInitializer {
                             disposable.dispose();
                             c();
                         }
-                    }
-                    catch (error) {
+                    } catch (error) {
                         e(error);
                     }
                 });
@@ -439,15 +481,11 @@ let NewExtensionsInitializer = class NewExtensionsInitializer {
     async areExtensionsRunning(extensions) {
         await this.extensionService.whenInstalledExtensionsRegistered();
         const runningExtensions = this.extensionService.extensions;
-        return extensions.every(e => ( runningExtensions.some(r => areSameExtensions({ id: r.identifier.value }, e.identifier))));
+        return extensions.every(e => ( runningExtensions.some(r => areSameExtensions({
+            id: r.identifier.value
+        }, e.identifier))));
     }
 };
-NewExtensionsInitializer = ( __decorate([
-    ( __param(1, IExtensionService)),
-    ( __param(2, IExtensionStorageService)),
-    ( __param(3, IExtensionGalleryService)),
-    ( __param(4, IExtensionManagementService)),
-    ( __param(5, IUserDataSyncLogService))
-], NewExtensionsInitializer));
+NewExtensionsInitializer = ( __decorate([( __param(1, IExtensionService)), ( __param(2, IExtensionStorageService)), ( __param(3, IExtensionGalleryService)), ( __param(4, IExtensionManagementService)), ( __param(5, IUserDataSyncLogService))], NewExtensionsInitializer));
 
 export { UserDataSyncInitializer };

package/vscode/src/vs/workbench/services/userDataSync/common/userDataSyncUtil.js

@@ -8,7 +8,12 @@ import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor
 import { ITextResourcePropertiesService, ITextResourceConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/textResourceConfiguration.service';
 
 let UserDataSyncUtilService = class UserDataSyncUtilService {
-    constructor(keybindingsService, textModelService, textResourcePropertiesService, textResourceConfigurationService) {
+    constructor(
+        keybindingsService,
+        textModelService,
+        textResourcePropertiesService,
+        textResourceConfigurationService
+    ) {
         this.keybindingsService = keybindingsService;
         this.textModelService = textModelService;
         this.textResourcePropertiesService = textResourcePropertiesService;
@@ -20,32 +25,32 @@ let UserDataSyncUtilService = class UserDataSyncUtilService {
     async resolveUserBindings(userBindings) {
         const keys = {};
         for (const userbinding of userBindings) {
-            keys[userbinding] = ( this.keybindingsService.resolveUserBinding(userbinding).map(part => part.getUserSettingsLabel())).join(' ');
+            keys[userbinding] = ( this.keybindingsService.resolveUserBinding(userbinding).map(part => part.getUserSettingsLabel())).join(" ");
         }
         return keys;
     }
     async resolveFormattingOptions(resource) {
         try {
             const modelReference = await this.textModelService.createModelReference(resource);
-            const { insertSpaces, tabSize } = modelReference.object.textEditorModel.getOptions();
+            const {
+                insertSpaces,
+                tabSize
+            } = modelReference.object.textEditorModel.getOptions();
             const eol = modelReference.object.textEditorModel.getEOL();
             modelReference.dispose();
-            return { eol, insertSpaces, tabSize };
-        }
-        catch (e) {
-        }
+            return {
+                eol,
+                insertSpaces,
+                tabSize
+            };
+        } catch (e) {}
         return {
             eol: this.textResourcePropertiesService.getEOL(resource),
-            insertSpaces: !!this.textResourceConfigurationService.getValue(resource, 'editor.insertSpaces'),
-            tabSize: this.textResourceConfigurationService.getValue(resource, 'editor.tabSize')
+            insertSpaces: !!this.textResourceConfigurationService.getValue(resource, "editor.insertSpaces"),
+            tabSize: this.textResourceConfigurationService.getValue(resource, "editor.tabSize")
         };
     }
 };
-UserDataSyncUtilService = ( __decorate([
-    ( __param(0, IKeybindingService)),
-    ( __param(1, ITextModelService)),
-    ( __param(2, ITextResourcePropertiesService)),
-    ( __param(3, ITextResourceConfigurationService))
-], UserDataSyncUtilService));
+UserDataSyncUtilService = ( __decorate([( __param(0, IKeybindingService)), ( __param(1, ITextModelService)), ( __param(2, ITextResourcePropertiesService)), ( __param(3, ITextResourceConfigurationService))], UserDataSyncUtilService));
 
 export { UserDataSyncUtilService };

package/vscode/src/vs/base/browser/ui/radio/radio.css

@@ -1,69 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-.monaco-custom-radio {
-	display: flex;
-}
-
-.monaco-custom-radio > .monaco-button {
-	border-radius: 0;
-	font-size: 0.9em;
-	line-height: 1em;
-	padding-left: 0.5em;
-	padding-right: 0.5em;
-}
-
-.monaco-custom-radio > .monaco-button:first-child {
-	border-top-left-radius: 3px;
-	border-bottom-left-radius: 3px;
-}
-
-.monaco-custom-radio > .monaco-button:last-child {
-	border-top-right-radius: 3px;
-	border-bottom-right-radius: 3px;
-}
-
-.monaco-custom-radio > .monaco-button:not(.active):not(:last-child) {
-	border-right: none;
-}
-
-.monaco-custom-radio > .monaco-button.previous-active {
-	border-left: none;
-}
-
-/* default color styles - based on CSS variables */
-
-.monaco-custom-radio > .monaco-button {
-	color: var(--vscode-radio-inactiveForeground);
-	background-color: var(--vscode-radio-inactiveBackground);
-	border-color: var(--vscode-radio-inactiveBorder, transparent);
-}
-
-.monaco-custom-radio > .monaco-button.active:hover,
-.monaco-custom-radio > .monaco-button.active {
-	color: var(--vscode-radio-activeForeground);
-	background-color: var(--vscode-radio-activeBackground);
-	border-color: var(--vscode-radio-activeBorder, transparent);
-}
-
-.hc-black .monaco-custom-radio > .monaco-button.active,
-.hc-light .monaco-custom-radio > .monaco-button.active {
-	border-color: var(--vscode-radio-activeBorder, transparent);
-}
-
-.hc-black .monaco-custom-radio > .monaco-button:not(.active),
-.hc-light .monaco-custom-radio > .monaco-button:not(.active) {
-	border-color: var(--vscode-radio-inactiveBorder, transparent);
-}
-
-.hc-black .monaco-custom-radio > .monaco-button:not(.active):hover,
-.hc-light .monaco-custom-radio > .monaco-button:not(.active):hover {
-	outline: 1px dashed var(--vscode-toolbar-hoverOutline);
-	outline-offset: -1px
-}
-
-.monaco-custom-radio > .monaco-button:hover:not(.active) {
-	background-color: var(--vscode-radio-inactiveHoverBackground);
-}

package/vscode/src/vs/base/browser/ui/radio/radio.d.ts

@@ -1,37 +0,0 @@
-import { Widget } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/widget";
-import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
-import { IHoverDelegate } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegate";
-export interface IRadioStyles {
-    readonly activeForeground?: string;
-    readonly activeBackground?: string;
-    readonly activeBorder?: string;
-    readonly inactiveForeground?: string;
-    readonly inactiveBackground?: string;
-    readonly inactiveHoverBackground?: string;
-    readonly inactiveBorder?: string;
-}
-export interface IRadioOptionItem {
-    readonly text: string;
-    readonly tooltip?: string;
-    readonly isActive?: boolean;
-    readonly disabled?: boolean;
-}
-export interface IRadioOptions {
-    readonly items: ReadonlyArray<IRadioOptionItem>;
-    readonly activeIcon?: ThemeIcon;
-    readonly hoverDelegate?: IHoverDelegate;
-}
-export declare class Radio extends Widget {
-    private readonly _onDidSelect;
-    readonly onDidSelect: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<number>;
-    readonly domNode: HTMLElement;
-    private readonly hoverDelegate;
-    private items;
-    private activeItem;
-    private readonly buttons;
-    constructor(opts: IRadioOptions);
-    setItems(items: ReadonlyArray<IRadioOptionItem>): void;
-    setActiveItem(index: number): void;
-    setEnabled(enabled: boolean): void;
-    private updateButtons;
-}

package/vscode/src/vs/base/browser/ui/radio/radio.js

@@ -1,72 +0,0 @@
-
-import { registerCss } from '@codingame/monaco-vscode-api/css';
-import { Widget } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/widget';
-import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import * as radio from './radio.css';
-import { $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
-import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
-import { DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { createInstantHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
-
-registerCss(radio);
-class Radio extends Widget {
-    constructor(opts) {
-        super();
-        this._onDidSelect = this._register(( new Emitter()));
-        this.onDidSelect = this._onDidSelect.event;
-        this.items = [];
-        this.buttons = this._register(( new DisposableMap()));
-        this.hoverDelegate = opts.hoverDelegate ?? this._register(createInstantHoverDelegate());
-        this.domNode = $('.monaco-custom-radio');
-        this.domNode.setAttribute('role', 'radio');
-        this.setItems(opts.items);
-    }
-    setItems(items) {
-        this.buttons.clearAndDisposeAll();
-        this.items = items;
-        this.activeItem = this.items.find(item => item.isActive) ?? this.items[0];
-        for (let index = 0; index < this.items.length; index++) {
-            const item = this.items[index];
-            const disposables = ( new DisposableStore());
-            const button = disposables.add(( new Button(this.domNode, {
-                hoverDelegate: this.hoverDelegate,
-                title: item.tooltip,
-                supportIcons: true,
-            })));
-            button.enabled = !item.disabled;
-            disposables.add(button.onDidClick(() => {
-                if (this.activeItem !== item) {
-                    this.activeItem = item;
-                    this.updateButtons();
-                    this._onDidSelect.fire(index);
-                }
-            }));
-            this.buttons.set(button, { item, dispose: () => disposables.dispose() });
-        }
-        this.updateButtons();
-    }
-    setActiveItem(index) {
-        if (index < 0 || index >= this.items.length) {
-            throw ( new Error('Invalid Index'));
-        }
-        this.activeItem = this.items[index];
-        this.updateButtons();
-    }
-    setEnabled(enabled) {
-        for (const [button] of this.buttons) {
-            button.enabled = enabled;
-        }
-    }
-    updateButtons() {
-        let isActive = false;
-        for (const [button, { item }] of this.buttons) {
-            const isPreviousActive = isActive;
-            isActive = item === this.activeItem;
-            button.element.classList.toggle('active', isActive);
-            button.element.classList.toggle('previous-active', isPreviousActive);
-            button.label = item.text;
-        }
-    }
-}
-
-export { Radio };