@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/services/userDataProfile/browser/extensionsResource.js

@@ -0,0 +1,340 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { GlobalExtensionEnablementService } from '../../../../platform/extensionManagement/common/extensionEnablementService.js';
+import { EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT, IExtensionManagementService, IExtensionGalleryService, IGlobalExtensionEnablementService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { areSameExtensions } from '../../../../platform/extensionManagement/common/extensionManagementUtil.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { IUserDataProfileStorageService } from '../../../../platform/userDataProfile/common/userDataProfileStorageService.js';
+import { TreeItemCollapsibleState } from '../../../common/views.js';
+import { IUserDataProfileService } from '../common/userDataProfile.js';
+let ExtensionsResourceInitializer = class ExtensionsResourceInitializer {
+    constructor(userDataProfileService, extensionManagementService, extensionGalleryService, extensionEnablementService, logService) {
+        this.userDataProfileService = userDataProfileService;
+        this.extensionManagementService = extensionManagementService;
+        this.extensionGalleryService = extensionGalleryService;
+        this.extensionEnablementService = extensionEnablementService;
+        this.logService = logService;
+    }
+    async initialize(content) {
+        const profileExtensions = JSON.parse(content);
+        const installedExtensions = await this.extensionManagementService.getInstalled(undefined, this.userDataProfileService.currentProfile.extensionsResource);
+        const extensionsToEnableOrDisable = [];
+        const extensionsToInstall = [];
+        for (const e of profileExtensions) {
+            const isDisabled = ( this.extensionEnablementService.getDisabledExtensions().some(disabledExtension => areSameExtensions(disabledExtension, e.identifier)));
+            const installedExtension = installedExtensions.find(installed => areSameExtensions(installed.identifier, e.identifier));
+            if (!installedExtension || (!installedExtension.isBuiltin && installedExtension.preRelease !== e.preRelease)) {
+                extensionsToInstall.push(e);
+            }
+            if (isDisabled !== !!e.disabled) {
+                extensionsToEnableOrDisable.push({ extension: e.identifier, enable: !e.disabled });
+            }
+        }
+        const extensionsToUninstall = installedExtensions.filter(extension => !extension.isBuiltin && !( profileExtensions.some(({ identifier }) => areSameExtensions(identifier, extension.identifier))));
+        for (const { extension, enable } of extensionsToEnableOrDisable) {
+            if (enable) {
+                this.logService.trace(`Initializing Profile: Enabling extension...`, extension.id);
+                await this.extensionEnablementService.enableExtension(extension);
+                this.logService.info(`Initializing Profile: Enabled extension...`, extension.id);
+            }
+            else {
+                this.logService.trace(`Initializing Profile: Disabling extension...`, extension.id);
+                await this.extensionEnablementService.disableExtension(extension);
+                this.logService.info(`Initializing Profile: Disabled extension...`, extension.id);
+            }
+        }
+        if (extensionsToInstall.length) {
+            const galleryExtensions = await this.extensionGalleryService.getExtensions(( extensionsToInstall.map(
+                e => ({ ...e.identifier, version: e.version, hasPreRelease: e.version ? undefined : e.preRelease })
+            )), CancellationToken.None);
+            await Promise.all(( extensionsToInstall.map(async (e) => {
+                const extension = galleryExtensions.find(galleryExtension => areSameExtensions(galleryExtension.identifier, e.identifier));
+                if (!extension) {
+                    return;
+                }
+                if (await this.extensionManagementService.canInstall(extension)) {
+                    this.logService.trace(`Initializing Profile: Installing extension...`, extension.identifier.id, extension.version);
+                    await this.extensionManagementService.installFromGallery(extension, {
+                        isMachineScoped: false,
+                        donotIncludePackAndDependencies: true,
+                        installGivenVersion: !!e.version,
+                        installPreReleaseVersion: e.preRelease,
+                        profileLocation: this.userDataProfileService.currentProfile.extensionsResource,
+                        context: { [EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT]: true }
+                    });
+                    this.logService.info(`Initializing Profile: Installed extension...`, extension.identifier.id, extension.version);
+                }
+                else {
+                    this.logService.info(`Initializing Profile: Skipped installing extension because it cannot be installed.`, extension.identifier.id);
+                }
+            })));
+        }
+        if (extensionsToUninstall.length) {
+            await Promise.all(( extensionsToUninstall.map(e => this.extensionManagementService.uninstall(e))));
+        }
+    }
+};
+ExtensionsResourceInitializer = ( __decorate([
+    ( __param(0, IUserDataProfileService)),
+    ( __param(1, IExtensionManagementService)),
+    ( __param(2, IExtensionGalleryService)),
+    ( __param(3, IGlobalExtensionEnablementService)),
+    ( __param(4, ILogService))
+], ExtensionsResourceInitializer));
+let ExtensionsResource = class ExtensionsResource {
+    constructor(extensionManagementService, extensionGalleryService, userDataProfileStorageService, instantiationService, logService) {
+        this.extensionManagementService = extensionManagementService;
+        this.extensionGalleryService = extensionGalleryService;
+        this.userDataProfileStorageService = userDataProfileStorageService;
+        this.instantiationService = instantiationService;
+        this.logService = logService;
+    }
+    async getContent(profile, exclude) {
+        const extensions = await this.getLocalExtensions(profile);
+        return this.toContent(extensions, exclude);
+    }
+    toContent(extensions, exclude) {
+        return JSON.stringify(exclude?.length ? extensions.filter(e => !exclude.includes(e.identifier.id.toLowerCase())) : extensions);
+    }
+    async apply(content, profile) {
+        return this.withProfileScopedServices(profile, async (extensionEnablementService) => {
+            const profileExtensions = await this.getProfileExtensions(content);
+            const installedExtensions = await this.extensionManagementService.getInstalled(undefined, profile.extensionsResource);
+            const extensionsToEnableOrDisable = [];
+            const extensionsToInstall = [];
+            for (const e of profileExtensions) {
+                const isDisabled = ( extensionEnablementService.getDisabledExtensions().some(disabledExtension => areSameExtensions(disabledExtension, e.identifier)));
+                const installedExtension = installedExtensions.find(installed => areSameExtensions(installed.identifier, e.identifier));
+                if (!installedExtension || (!installedExtension.isBuiltin && installedExtension.preRelease !== e.preRelease)) {
+                    extensionsToInstall.push(e);
+                }
+                if (isDisabled !== !!e.disabled) {
+                    extensionsToEnableOrDisable.push({ extension: e.identifier, enable: !e.disabled });
+                }
+            }
+            const extensionsToUninstall = installedExtensions.filter(extension => !extension.isBuiltin && !( profileExtensions.some(({ identifier }) => areSameExtensions(identifier, extension.identifier))) && !extension.isApplicationScoped);
+            for (const { extension, enable } of extensionsToEnableOrDisable) {
+                if (enable) {
+                    this.logService.trace(`Importing Profile (${profile.name}): Enabling extension...`, extension.id);
+                    await extensionEnablementService.enableExtension(extension);
+                    this.logService.info(`Importing Profile (${profile.name}): Enabled extension...`, extension.id);
+                }
+                else {
+                    this.logService.trace(`Importing Profile (${profile.name}): Disabling extension...`, extension.id);
+                    await extensionEnablementService.disableExtension(extension);
+                    this.logService.info(`Importing Profile (${profile.name}): Disabled extension...`, extension.id);
+                }
+            }
+            if (extensionsToInstall.length) {
+                this.logService.info(`Importing Profile (${profile.name}): Started installing extensions.`);
+                const galleryExtensions = await this.extensionGalleryService.getExtensions(( extensionsToInstall.map(
+                    e => ({ ...e.identifier, version: e.version, hasPreRelease: e.version ? undefined : e.preRelease })
+                )), CancellationToken.None);
+                const installExtensionInfos = [];
+                await Promise.all(( extensionsToInstall.map(async (e) => {
+                    const extension = galleryExtensions.find(galleryExtension => areSameExtensions(galleryExtension.identifier, e.identifier));
+                    if (!extension) {
+                        return;
+                    }
+                    if (await this.extensionManagementService.canInstall(extension)) {
+                        installExtensionInfos.push({
+                            extension,
+                            options: {
+                                isMachineScoped: false,
+                                donotIncludePackAndDependencies: true,
+                                installGivenVersion: !!e.version,
+                                installPreReleaseVersion: e.preRelease,
+                                profileLocation: profile.extensionsResource,
+                                context: { [EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT]: true }
+                            }
+                        });
+                    }
+                    else {
+                        this.logService.info(`Importing Profile (${profile.name}): Skipped installing extension because it cannot be installed.`, extension.identifier.id);
+                    }
+                })));
+                if (installExtensionInfos.length) {
+                    await this.extensionManagementService.installGalleryExtensions(installExtensionInfos);
+                }
+                this.logService.info(`Importing Profile (${profile.name}): Finished installing extensions.`);
+            }
+            if (extensionsToUninstall.length) {
+                await Promise.all(( extensionsToUninstall.map(e => this.extensionManagementService.uninstall(e))));
+            }
+        });
+    }
+    async copy(from, to, disableExtensions) {
+        await this.extensionManagementService.copyExtensions(from.extensionsResource, to.extensionsResource);
+        const extensionsToDisable = await this.withProfileScopedServices(from, async (extensionEnablementService) => extensionEnablementService.getDisabledExtensions());
+        if (disableExtensions) {
+            const extensions = await this.extensionManagementService.getInstalled(1 , to.extensionsResource);
+            for (const extension of extensions) {
+                extensionsToDisable.push(extension.identifier);
+            }
+        }
+        await this.withProfileScopedServices(to, async (extensionEnablementService) => Promise.all(( extensionsToDisable.map(extension => extensionEnablementService.disableExtension(extension)))));
+    }
+    async getLocalExtensions(profile) {
+        return this.withProfileScopedServices(profile, async (extensionEnablementService) => {
+            const result = [];
+            const installedExtensions = await this.extensionManagementService.getInstalled(undefined, profile.extensionsResource);
+            const disabledExtensions = extensionEnablementService.getDisabledExtensions();
+            for (const extension of installedExtensions) {
+                const { identifier, preRelease } = extension;
+                const disabled = ( disabledExtensions.some(disabledExtension => areSameExtensions(disabledExtension, identifier)));
+                if (extension.isBuiltin && !disabled) {
+                    continue;
+                }
+                if (!extension.isBuiltin) {
+                    if (!extension.identifier.uuid) {
+                        continue;
+                    }
+                }
+                const profileExtension = { identifier, displayName: extension.manifest.displayName };
+                if (disabled) {
+                    profileExtension.disabled = true;
+                }
+                if (!extension.isBuiltin && extension.pinned) {
+                    profileExtension.version = extension.manifest.version;
+                }
+                if (!profileExtension.version && preRelease) {
+                    profileExtension.preRelease = true;
+                }
+                result.push(profileExtension);
+            }
+            return result;
+        });
+    }
+    async getProfileExtensions(content) {
+        return JSON.parse(content);
+    }
+    async withProfileScopedServices(profile, fn) {
+        return this.userDataProfileStorageService.withProfileScopedStorageService(profile, async (storageService) => {
+            const disposables = ( new DisposableStore());
+            const instantiationService = this.instantiationService.createChild(( new ServiceCollection([IStorageService, storageService])));
+            const extensionEnablementService = disposables.add(instantiationService.createInstance(GlobalExtensionEnablementService));
+            try {
+                return await fn(extensionEnablementService);
+            }
+            finally {
+                disposables.dispose();
+            }
+        });
+    }
+};
+ExtensionsResource = ( __decorate([
+    ( __param(0, IExtensionManagementService)),
+    ( __param(1, IExtensionGalleryService)),
+    ( __param(2, IUserDataProfileStorageService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ILogService))
+], ExtensionsResource));
+class ExtensionsResourceTreeItem {
+    constructor() {
+        this.type = "extensions" ;
+        this.handle = "extensions" ;
+        this.label = { label: ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/extensionsResource',
+            'extensions',
+            "Extensions"
+        )) };
+        this.collapsibleState = TreeItemCollapsibleState.Expanded;
+        this.contextValue = "extensions" ;
+        this.excludedExtensions = ( new Set());
+    }
+    async getChildren() {
+        const extensions = (await this.getExtensions()).sort((a, b) => (a.displayName ?? a.identifier.id).localeCompare(b.displayName ?? b.identifier.id));
+        const that = this;
+        return ( extensions.map(e => ({
+            handle: e.identifier.id.toLowerCase(),
+            parent: this,
+            label: { label: e.displayName || e.identifier.id },
+            description: e.disabled ? ( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/extensionsResource',
+                'disabled',
+                "Disabled"
+            )) : undefined,
+            collapsibleState: TreeItemCollapsibleState.None,
+            checkbox: that.checkbox ? {
+                get isChecked() { return !( that.excludedExtensions.has(e.identifier.id.toLowerCase())); },
+                set isChecked(value) {
+                    if (value) {
+                        that.excludedExtensions.delete(e.identifier.id.toLowerCase());
+                    }
+                    else {
+                        that.excludedExtensions.add(e.identifier.id.toLowerCase());
+                    }
+                },
+                tooltip: ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/extensionsResource',
+                    'exclude',
+                    "Select {0} Extension",
+                    e.displayName || e.identifier.id
+                )),
+                accessibilityInformation: {
+                    label: ( localizeWithPath(
+                        'vs/workbench/services/userDataProfile/browser/extensionsResource',
+                        'exclude',
+                        "Select {0} Extension",
+                        e.displayName || e.identifier.id
+                    )),
+                }
+            } : undefined,
+            command: {
+                id: 'extension.open',
+                title: '',
+                arguments: [e.identifier.id, undefined, true]
+            }
+        })));
+    }
+    async hasContent() {
+        const extensions = await this.getExtensions();
+        return extensions.length > 0;
+    }
+}
+let ExtensionsResourceExportTreeItem = class ExtensionsResourceExportTreeItem extends ExtensionsResourceTreeItem {
+    constructor(profile, instantiationService) {
+        super();
+        this.profile = profile;
+        this.instantiationService = instantiationService;
+    }
+    isFromDefaultProfile() {
+        return !this.profile.isDefault && !!this.profile.useDefaultFlags?.extensions;
+    }
+    getExtensions() {
+        return this.instantiationService.createInstance(ExtensionsResource).getLocalExtensions(this.profile);
+    }
+    async getContent() {
+        return this.instantiationService.createInstance(ExtensionsResource).getContent(this.profile, [...( this.excludedExtensions.values())]);
+    }
+};
+ExtensionsResourceExportTreeItem = ( __decorate([
+    ( __param(1, IInstantiationService))
+], ExtensionsResourceExportTreeItem));
+let ExtensionsResourceImportTreeItem = class ExtensionsResourceImportTreeItem extends ExtensionsResourceTreeItem {
+    constructor(content, instantiationService) {
+        super();
+        this.content = content;
+        this.instantiationService = instantiationService;
+    }
+    isFromDefaultProfile() {
+        return false;
+    }
+    getExtensions() {
+        return this.instantiationService.createInstance(ExtensionsResource).getProfileExtensions(this.content);
+    }
+    async getContent() {
+        const extensionsResource = this.instantiationService.createInstance(ExtensionsResource);
+        const extensions = await extensionsResource.getProfileExtensions(this.content);
+        return extensionsResource.toContent(extensions, [...( this.excludedExtensions.values())]);
+    }
+};
+ExtensionsResourceImportTreeItem = ( __decorate([
+    ( __param(1, IInstantiationService))
+], ExtensionsResourceImportTreeItem));
+export { ExtensionsResource, ExtensionsResourceExportTreeItem, ExtensionsResourceImportTreeItem, ExtensionsResourceInitializer, ExtensionsResourceTreeItem };

package/vscode/src/vs/workbench/services/userDataProfile/browser/globalStateResource.js

@@ -0,0 +1,145 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { IUserDataProfileStorageService } from '../../../../platform/userDataProfile/common/userDataProfileStorageService.js';
+import { API_OPEN_EDITOR_COMMAND_ID } from '../../../browser/parts/editor/editorCommands.js';
+import { TreeItemCollapsibleState } from '../../../common/views.js';
+let GlobalStateResourceInitializer = class GlobalStateResourceInitializer {
+    constructor(storageService) {
+        this.storageService = storageService;
+    }
+    async initialize(content) {
+        const globalState = JSON.parse(content);
+        const storageKeys = ( Object.keys(globalState.storage));
+        if (storageKeys.length) {
+            const storageEntries = [];
+            for (const key of storageKeys) {
+                storageEntries.push({ key, value: globalState.storage[key], scope: 0 , target: 0  });
+            }
+            this.storageService.storeAll(storageEntries, true);
+        }
+    }
+};
+GlobalStateResourceInitializer = ( __decorate([
+    ( __param(0, IStorageService))
+], GlobalStateResourceInitializer));
+let GlobalStateResource = class GlobalStateResource {
+    constructor(storageService, userDataProfileStorageService, logService) {
+        this.storageService = storageService;
+        this.userDataProfileStorageService = userDataProfileStorageService;
+        this.logService = logService;
+    }
+    async getContent(profile) {
+        const globalState = await this.getGlobalState(profile);
+        return JSON.stringify(globalState);
+    }
+    async apply(content, profile) {
+        const globalState = JSON.parse(content);
+        await this.writeGlobalState(globalState, profile);
+    }
+    async getGlobalState(profile) {
+        const storage = {};
+        const storageData = await this.userDataProfileStorageService.readStorageData(profile);
+        for (const [key, value] of storageData) {
+            if (value.value !== undefined && value.target === 0 ) {
+                storage[key] = value.value;
+            }
+        }
+        return { storage };
+    }
+    async writeGlobalState(globalState, profile) {
+        const storageKeys = ( Object.keys(globalState.storage));
+        if (storageKeys.length) {
+            const updatedStorage = ( new Map());
+            const nonProfileKeys = [
+                ...( this.storageService.keys(-1, 1 )),
+                ...( this.storageService.keys(1, 0 )),
+                ...( this.storageService.keys(1, 1 )),
+            ];
+            for (const key of storageKeys) {
+                if (nonProfileKeys.includes(key)) {
+                    this.logService.info(`Importing Profile (${profile.name}): Ignoring global state key '${key}' because it is not a profile key.`);
+                }
+                else {
+                    updatedStorage.set(key, globalState.storage[key]);
+                }
+            }
+            await this.userDataProfileStorageService.updateStorageData(profile, updatedStorage, 0 );
+        }
+    }
+};
+GlobalStateResource = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IUserDataProfileStorageService)),
+    ( __param(2, ILogService))
+], GlobalStateResource));
+class GlobalStateResourceTreeItem {
+    constructor(resource, uriIdentityService) {
+        this.resource = resource;
+        this.uriIdentityService = uriIdentityService;
+        this.type = "globalState" ;
+        this.handle = "globalState" ;
+        this.label = { label: ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/globalStateResource',
+            'globalState',
+            "UI State"
+        )) };
+        this.collapsibleState = TreeItemCollapsibleState.Collapsed;
+    }
+    async getChildren() {
+        return [{
+                handle: ( this.resource.toString()),
+                resourceUri: this.resource,
+                collapsibleState: TreeItemCollapsibleState.None,
+                accessibilityInformation: {
+                    label: this.uriIdentityService.extUri.basename(this.resource)
+                },
+                parent: this,
+                command: {
+                    id: API_OPEN_EDITOR_COMMAND_ID,
+                    title: '',
+                    arguments: [this.resource, undefined, undefined]
+                }
+            }];
+    }
+}
+let GlobalStateResourceExportTreeItem = class GlobalStateResourceExportTreeItem extends GlobalStateResourceTreeItem {
+    constructor(profile, resource, uriIdentityService, instantiationService) {
+        super(resource, uriIdentityService);
+        this.profile = profile;
+        this.instantiationService = instantiationService;
+    }
+    async hasContent() {
+        const globalState = await this.instantiationService.createInstance(GlobalStateResource).getGlobalState(this.profile);
+        return ( Object.keys(globalState.storage)).length > 0;
+    }
+    async getContent() {
+        return this.instantiationService.createInstance(GlobalStateResource).getContent(this.profile);
+    }
+    isFromDefaultProfile() {
+        return !this.profile.isDefault && !!this.profile.useDefaultFlags?.globalState;
+    }
+};
+GlobalStateResourceExportTreeItem = ( __decorate([
+    ( __param(2, IUriIdentityService)),
+    ( __param(3, IInstantiationService))
+], GlobalStateResourceExportTreeItem));
+let GlobalStateResourceImportTreeItem = class GlobalStateResourceImportTreeItem extends GlobalStateResourceTreeItem {
+    constructor(content, resource, uriIdentityService) {
+        super(resource, uriIdentityService);
+        this.content = content;
+    }
+    async getContent() {
+        return this.content;
+    }
+    isFromDefaultProfile() {
+        return false;
+    }
+};
+GlobalStateResourceImportTreeItem = ( __decorate([
+    ( __param(2, IUriIdentityService))
+], GlobalStateResourceImportTreeItem));
+export { GlobalStateResource, GlobalStateResourceExportTreeItem, GlobalStateResourceImportTreeItem, GlobalStateResourceInitializer, GlobalStateResourceTreeItem };

package/vscode/src/vs/workbench/services/userDataProfile/browser/iconSelectBox.js

@@ -0,0 +1,96 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IconSelectBox } from '../../../../base/browser/ui/icons/iconSelectBox.js';
+import { trackFocus } from '../../../../base/browser/dom.js';
+import { ContextKeyExpr, RawContextKey, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { KeybindingsRegistry } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
+var WorkbenchIconSelectBox_1;
+const WorkbenchIconSelectBoxFocusContextKey = ( new RawContextKey('iconSelectBoxFocus', true));
+const WorkbenchIconSelectBoxInputFocusContextKey = ( new RawContextKey('iconSelectBoxInputFocus', true));
+const WorkbenchIconSelectBoxInputEmptyContextKey = ( new RawContextKey('iconSelectBoxInputEmpty', true));
+let WorkbenchIconSelectBox = class WorkbenchIconSelectBox extends IconSelectBox {
+    static { WorkbenchIconSelectBox_1 = this; }
+    static getFocusedWidget() {
+        return WorkbenchIconSelectBox_1.focusedWidget;
+    }
+    constructor(options, contextKeyService) {
+        super(options);
+        this.contextKeyService = this._register(contextKeyService.createScoped(this.domNode));
+        WorkbenchIconSelectBoxFocusContextKey.bindTo(this.contextKeyService);
+        this.inputFocusContextKey = WorkbenchIconSelectBoxInputFocusContextKey.bindTo(this.contextKeyService);
+        this.inputEmptyContextKey = WorkbenchIconSelectBoxInputEmptyContextKey.bindTo(this.contextKeyService);
+        if (this.inputBox) {
+            const focusTracker = this._register(trackFocus(this.inputBox.inputElement));
+            this._register(focusTracker.onDidFocus(() => this.inputFocusContextKey.set(true)));
+            this._register(focusTracker.onDidBlur(() => this.inputFocusContextKey.set(false)));
+            this._register(this.inputBox.onDidChange(() => this.inputEmptyContextKey.set(this.inputBox?.value.length === 0)));
+        }
+    }
+    focus() {
+        super.focus();
+        WorkbenchIconSelectBox_1.focusedWidget = this;
+    }
+};
+WorkbenchIconSelectBox = WorkbenchIconSelectBox_1 = ( __decorate([
+    ( __param(1, IContextKeyService))
+], WorkbenchIconSelectBox));
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'iconSelectBox.focusUp',
+    weight: 200 ,
+    when: WorkbenchIconSelectBoxFocusContextKey,
+    primary: 16 ,
+    handler: () => {
+        const selectBox = WorkbenchIconSelectBox.getFocusedWidget();
+        if (selectBox) {
+            selectBox.focusPreviousRow();
+        }
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'iconSelectBox.focusDown',
+    weight: 200 ,
+    when: WorkbenchIconSelectBoxFocusContextKey,
+    primary: 18 ,
+    handler: () => {
+        const selectBox = WorkbenchIconSelectBox.getFocusedWidget();
+        if (selectBox) {
+            selectBox.focusNextRow();
+        }
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'iconSelectBox.focusNext',
+    weight: 200 ,
+    when: ( ContextKeyExpr.and(WorkbenchIconSelectBoxFocusContextKey, ( ContextKeyExpr.or(WorkbenchIconSelectBoxInputEmptyContextKey, ( WorkbenchIconSelectBoxInputFocusContextKey.toNegated()))))),
+    primary: 17 ,
+    handler: () => {
+        const selectBox = WorkbenchIconSelectBox.getFocusedWidget();
+        if (selectBox) {
+            selectBox.focusNext();
+        }
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'iconSelectBox.focusPrevious',
+    weight: 200 ,
+    when: ( ContextKeyExpr.and(WorkbenchIconSelectBoxFocusContextKey, ( ContextKeyExpr.or(WorkbenchIconSelectBoxInputEmptyContextKey, ( WorkbenchIconSelectBoxInputFocusContextKey.toNegated()))))),
+    primary: 15 ,
+    handler: () => {
+        const selectBox = WorkbenchIconSelectBox.getFocusedWidget();
+        if (selectBox) {
+            selectBox.focusPrevious();
+        }
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'iconSelectBox.selectFocused',
+    weight: 200 ,
+    when: WorkbenchIconSelectBoxFocusContextKey,
+    primary: 3 ,
+    handler: () => {
+        const selectBox = WorkbenchIconSelectBox.getFocusedWidget();
+        if (selectBox) {
+            selectBox.setSelection(selectBox.getFocus()[0]);
+        }
+    }
+});
+export { WorkbenchIconSelectBox, WorkbenchIconSelectBoxFocusContextKey, WorkbenchIconSelectBoxInputEmptyContextKey, WorkbenchIconSelectBoxInputFocusContextKey };