@codingame/monaco-vscode-theme-service-override 1.85.0 → 1.85.2

package/override/vs/platform/dialogs/common/dialogs.js

@@ -0,0 +1,8 @@
+var ConfirmResult;
+( (function(ConfirmResult) {
+    ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";
+    ConfirmResult[ConfirmResult["DONT_SAVE"] = 1] = "DONT_SAVE";
+    ConfirmResult[ConfirmResult["CANCEL"] = 2] = "CANCEL";
+})(ConfirmResult || (ConfirmResult = {})));
+
+export { ConfirmResult };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-theme-service-override",
-  "version": "1.85.0",
+  "version": "1.85.2",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,8 +18,8 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.85.0",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.85.2",
     "monaco-editor": "0.45.0",
-    "@codingame/monaco-vscode-files-service-override": "1.85.0"
+    "@codingame/monaco-vscode-files-service-override": "1.85.2"
   }
 }

package/theme.js

@@ -2,6 +2,7 @@ import { WorkbenchThemeService } from './vscode/src/vs/workbench/services/themes
 import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import getServiceOverride$1 from '@codingame/monaco-vscode-files-service-override';
+import './vscode/src/vs/workbench/contrib/themes/browser/themes.contribution.js';
 
 class StandaloneWorkbenchThemeService extends WorkbenchThemeService {
     registerEditorContainer() {

package/vscode/src/vs/workbench/contrib/themes/browser/themes.contribution.js

@@ -0,0 +1,947 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
+import { registerAction2, Action2, MenuId, MenuRegistry } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { equalsIgnoreCase } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { IWorkbenchThemeService, ThemeSettings, ThemeSettingDefaults } from 'vscode/vscode/vs/workbench/services/themes/common/workbenchThemeService';
+import { VIEWLET_ID } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { IExtensionGalleryService, IExtensionManagementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { Extensions } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
+import { ColorScheme, isHighContrast } from 'monaco-editor/esm/vs/platform/theme/common/theme.js';
+import { colorThemeSchemaId } from '../../../services/themes/common/colorThemeSchema.js';
+import { onUnexpectedError, isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { DEFAULT_PRODUCT_ICON_THEME_ID, ProductIconThemeData } from '../../../services/themes/browser/productIconThemeData.js';
+import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite';
+import { ThrottledDelayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IExtensionResourceLoaderService } from 'vscode/vscode/vs/platform/extensionResourceLoader/common/extensionResourceLoader';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { CommandsRegistry, ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { FileIconThemeData } from '../../../services/themes/browser/fileIconThemeData.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { Extensions as Extensions$1 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+import { mainWindow } from 'monaco-editor/esm/vs/base/browser/window.js';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+var DefaultThemeUpdatedNotificationContribution_1;
+const manageExtensionIcon = registerIcon('theme-selection-manage-extension', Codicon.gear, ( localizeWithPath(
+    'vs/workbench/contrib/themes/browser/themes.contribution',
+    'manageExtensionIcon',
+    'Icon for the \'Manage\' action in the theme selection quick pick.'
+)));
+let MarketplaceThemesPicker = class MarketplaceThemesPicker {
+    constructor(getMarketplaceColorThemes, marketplaceQuery, extensionGalleryService, extensionManagementService, quickInputService, logService, progressService, paneCompositeService, dialogService) {
+        this.getMarketplaceColorThemes = getMarketplaceColorThemes;
+        this.marketplaceQuery = marketplaceQuery;
+        this.extensionGalleryService = extensionGalleryService;
+        this.extensionManagementService = extensionManagementService;
+        this.quickInputService = quickInputService;
+        this.logService = logService;
+        this.progressService = progressService;
+        this.paneCompositeService = paneCompositeService;
+        this.dialogService = dialogService;
+        this._marketplaceExtensions = ( new Set());
+        this._marketplaceThemes = [];
+        this._searchOngoing = false;
+        this._searchError = undefined;
+        this._onDidChange = ( new Emitter());
+        this._queryDelayer = ( new ThrottledDelayer(200));
+        this._installedExtensions = extensionManagementService.getInstalled().then(installed => {
+            const result = ( new Set());
+            for (const ext of installed) {
+                result.add(ext.identifier.id);
+            }
+            return result;
+        });
+    }
+    get themes() {
+        return this._marketplaceThemes;
+    }
+    get onDidChange() {
+        return this._onDidChange.event;
+    }
+    trigger(value) {
+        if (this._tokenSource) {
+            this._tokenSource.cancel();
+            this._tokenSource = undefined;
+        }
+        this._queryDelayer.trigger(() => {
+            this._tokenSource = ( new CancellationTokenSource());
+            return this.doSearch(value, this._tokenSource.token);
+        });
+    }
+    async doSearch(value, token) {
+        this._searchOngoing = true;
+        this._onDidChange.fire();
+        try {
+            const installedExtensions = await this._installedExtensions;
+            const options = { text: `${this.marketplaceQuery} ${value}`, pageSize: 20 };
+            const pager = await this.extensionGalleryService.query(options, token);
+            for (let i = 0; i < pager.total && i < 1; i++) {
+                if (token.isCancellationRequested) {
+                    break;
+                }
+                const nThemes = this._marketplaceThemes.length;
+                const gallery = i === 0 ? pager.firstPage : await pager.getPage(i, token);
+                const promises = [];
+                const promisesGalleries = [];
+                for (let i = 0; i < gallery.length; i++) {
+                    if (token.isCancellationRequested) {
+                        break;
+                    }
+                    const ext = gallery[i];
+                    if (!( installedExtensions.has(ext.identifier.id)) && !( this._marketplaceExtensions.has(ext.identifier.id))) {
+                        this._marketplaceExtensions.add(ext.identifier.id);
+                        promises.push(this.getMarketplaceColorThemes(ext.publisher, ext.name, ext.version));
+                        promisesGalleries.push(ext);
+                    }
+                }
+                const allThemes = await Promise.all(promises);
+                for (let i = 0; i < allThemes.length; i++) {
+                    const ext = promisesGalleries[i];
+                    for (const theme of allThemes[i]) {
+                        this._marketplaceThemes.push({ id: theme.id, theme: theme, label: theme.label, description: `${ext.displayName} · ${ext.publisherDisplayName}`, galleryExtension: ext, buttons: [configureButton] });
+                    }
+                }
+                if (nThemes !== this._marketplaceThemes.length) {
+                    this._marketplaceThemes.sort((t1, t2) => t1.label.localeCompare(t2.label));
+                    this._onDidChange.fire();
+                }
+            }
+        }
+        catch (e) {
+            if (!isCancellationError(e)) {
+                this.logService.error(`Error while searching for themes:`, e);
+                this._searchError = 'message' in e ? e.message : String(e);
+            }
+        }
+        finally {
+            this._searchOngoing = false;
+            this._onDidChange.fire();
+        }
+    }
+    openQuickPick(value, currentTheme, selectTheme) {
+        let result = undefined;
+        return ( new Promise((s, _) => {
+            const quickpick = this.quickInputService.createQuickPick();
+            quickpick.items = [];
+            quickpick.sortByLabel = false;
+            quickpick.matchOnDescription = true;
+            quickpick.buttons = [this.quickInputService.backButton];
+            quickpick.title = 'Marketplace Themes';
+            quickpick.placeholder = ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'themes.selectMarketplaceTheme',
+                "Type to Search More. Select to Install. Up/Down Keys to Preview"
+            ));
+            quickpick.canSelectMany = false;
+            quickpick.onDidChangeValue(() => this.trigger(quickpick.value));
+            quickpick.onDidAccept(async (_) => {
+                const themeItem = quickpick.selectedItems[0];
+                if (themeItem?.galleryExtension) {
+                    result = 'selected';
+                    quickpick.hide();
+                    const success = await this.installExtension(themeItem.galleryExtension);
+                    if (success) {
+                        selectTheme(themeItem.theme, true);
+                    }
+                    else {
+                        selectTheme(currentTheme, true);
+                    }
+                }
+            });
+            quickpick.onDidTriggerItemButton(e => {
+                if (isItem(e.item)) {
+                    const extensionId = e.item.theme?.extensionData?.extensionId;
+                    if (extensionId) {
+                        openExtensionViewlet(this.paneCompositeService, `@id:${extensionId}`);
+                    }
+                    else {
+                        openExtensionViewlet(this.paneCompositeService, `${this.marketplaceQuery} ${quickpick.value}`);
+                    }
+                }
+            });
+            quickpick.onDidChangeActive(themes => {
+                if (result === undefined) {
+                    selectTheme(themes[0]?.theme, false);
+                }
+            });
+            quickpick.onDidHide(() => {
+                if (result === undefined) {
+                    selectTheme(currentTheme, true);
+                    result = 'cancelled';
+                }
+                quickpick.dispose();
+                s(result);
+            });
+            quickpick.onDidTriggerButton(e => {
+                if (e === this.quickInputService.backButton) {
+                    result = 'back';
+                    quickpick.hide();
+                }
+            });
+            this.onDidChange(() => {
+                let items = this.themes;
+                if (this._searchOngoing) {
+                    items = items.concat({ label: '$(sync~spin) Searching for themes...', id: undefined, alwaysShow: true });
+                }
+                else if (items.length === 0 && this._searchError) {
+                    items = [{ label: `$(error) ${( localizeWithPath(
+                        'vs/workbench/contrib/themes/browser/themes.contribution',
+                        'search.error',
+                        'Error while searching for themes: {0}',
+                        this._searchError
+                    ))}`, id: undefined, alwaysShow: true }];
+                }
+                const activeItemId = quickpick.activeItems[0]?.id;
+                const newActiveItem = activeItemId ? items.find(i => isItem(i) && i.id === activeItemId) : undefined;
+                quickpick.items = items;
+                if (newActiveItem) {
+                    quickpick.activeItems = [newActiveItem];
+                }
+            });
+            this.trigger(value);
+            quickpick.show();
+        }));
+    }
+    async installExtension(galleryExtension) {
+        openExtensionViewlet(this.paneCompositeService, `@id:${galleryExtension.identifier.id}`);
+        const result = await this.dialogService.confirm({
+            message: ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'installExtension.confirm',
+                "This will install extension '{0}' published by '{1}'. Do you want to continue?",
+                galleryExtension.displayName,
+                galleryExtension.publisherDisplayName
+            )),
+            primaryButton: ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'installExtension.button.ok',
+                "OK"
+            ))
+        });
+        if (!result.confirmed) {
+            return false;
+        }
+        try {
+            await this.progressService.withProgress({
+                location: 15 ,
+                title: ( localizeWithPath(
+                    'vs/workbench/contrib/themes/browser/themes.contribution',
+                    'installing extensions',
+                    "Installing Extension {0}...",
+                    galleryExtension.displayName
+                ))
+            }, async () => {
+                await this.extensionManagementService.installFromGallery(galleryExtension, {
+                    isMachineScoped: false,
+                });
+            });
+            return true;
+        }
+        catch (e) {
+            this.logService.error(`Problem installing extension ${galleryExtension.identifier.id}`, e);
+            return false;
+        }
+    }
+    dispose() {
+        if (this._tokenSource) {
+            this._tokenSource.cancel();
+            this._tokenSource = undefined;
+        }
+        this._queryDelayer.dispose();
+        this._marketplaceExtensions.clear();
+        this._marketplaceThemes.length = 0;
+    }
+};
+MarketplaceThemesPicker = ( __decorate([
+    ( __param(2, IExtensionGalleryService)),
+    ( __param(3, IExtensionManagementService)),
+    ( __param(4, IQuickInputService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IProgressService)),
+    ( __param(7, IPaneCompositePartService)),
+    ( __param(8, IDialogService))
+], MarketplaceThemesPicker));
+let InstalledThemesPicker = class InstalledThemesPicker {
+    constructor(installMessage, browseMessage, placeholderMessage, marketplaceTag, setTheme, getMarketplaceColorThemes, quickInputService, extensionGalleryService, paneCompositeService, extensionResourceLoaderService, instantiationService) {
+        this.installMessage = installMessage;
+        this.browseMessage = browseMessage;
+        this.placeholderMessage = placeholderMessage;
+        this.marketplaceTag = marketplaceTag;
+        this.setTheme = setTheme;
+        this.getMarketplaceColorThemes = getMarketplaceColorThemes;
+        this.quickInputService = quickInputService;
+        this.extensionGalleryService = extensionGalleryService;
+        this.paneCompositeService = paneCompositeService;
+        this.extensionResourceLoaderService = extensionResourceLoaderService;
+        this.instantiationService = instantiationService;
+    }
+    async openQuickPick(picks, currentTheme) {
+        let marketplaceThemePicker;
+        if (this.extensionGalleryService.isEnabled()) {
+            if (this.extensionResourceLoaderService.supportsExtensionGalleryResources && this.browseMessage) {
+                marketplaceThemePicker = this.instantiationService.createInstance(MarketplaceThemesPicker, this.getMarketplaceColorThemes.bind(this), this.marketplaceTag);
+                picks = [...configurationEntries(this.browseMessage), ...picks];
+            }
+            else {
+                picks = [...picks, ...configurationEntries(this.installMessage)];
+            }
+        }
+        let selectThemeTimeout;
+        const selectTheme = (theme, applyTheme) => {
+            if (selectThemeTimeout) {
+                clearTimeout(selectThemeTimeout);
+            }
+            selectThemeTimeout = mainWindow.setTimeout(() => {
+                selectThemeTimeout = undefined;
+                const newTheme = (theme ?? currentTheme);
+                this.setTheme(newTheme, applyTheme ? 'auto' : 'preview').then(undefined, err => {
+                    onUnexpectedError(err);
+                    this.setTheme(currentTheme, undefined);
+                });
+            }, applyTheme ? 0 : 200);
+        };
+        const pickInstalledThemes = (activeItemId) => {
+            return ( new Promise((s, _) => {
+                let isCompleted = false;
+                const autoFocusIndex = picks.findIndex(p => isItem(p) && p.id === activeItemId);
+                const quickpick = this.quickInputService.createQuickPick();
+                quickpick.items = picks;
+                quickpick.placeholder = this.placeholderMessage;
+                quickpick.activeItems = [picks[autoFocusIndex]];
+                quickpick.canSelectMany = false;
+                quickpick.matchOnDescription = true;
+                quickpick.onDidAccept(async (_) => {
+                    isCompleted = true;
+                    const theme = quickpick.selectedItems[0];
+                    if (!theme || typeof theme.id === 'undefined') {
+                        if (marketplaceThemePicker) {
+                            const res = await marketplaceThemePicker.openQuickPick(quickpick.value, currentTheme, selectTheme);
+                            if (res === 'back') {
+                                await pickInstalledThemes(undefined);
+                            }
+                        }
+                        else {
+                            openExtensionViewlet(this.paneCompositeService, `${this.marketplaceTag} ${quickpick.value}`);
+                        }
+                    }
+                    else {
+                        selectTheme(theme.theme, true);
+                    }
+                    quickpick.hide();
+                    s();
+                });
+                quickpick.onDidChangeActive(themes => selectTheme(themes[0]?.theme, false));
+                quickpick.onDidHide(() => {
+                    if (!isCompleted) {
+                        selectTheme(currentTheme, true);
+                        s();
+                    }
+                    quickpick.dispose();
+                });
+                quickpick.onDidTriggerItemButton(e => {
+                    if (isItem(e.item)) {
+                        const extensionId = e.item.theme?.extensionData?.extensionId;
+                        if (extensionId) {
+                            openExtensionViewlet(this.paneCompositeService, `@id:${extensionId}`);
+                        }
+                        else {
+                            openExtensionViewlet(this.paneCompositeService, `${this.marketplaceTag} ${quickpick.value}`);
+                        }
+                    }
+                });
+                quickpick.show();
+            }));
+        };
+        await pickInstalledThemes(currentTheme.id);
+        marketplaceThemePicker?.dispose();
+    }
+};
+InstalledThemesPicker = ( __decorate([
+    ( __param(6, IQuickInputService)),
+    ( __param(7, IExtensionGalleryService)),
+    ( __param(8, IPaneCompositePartService)),
+    ( __param(9, IExtensionResourceLoaderService)),
+    ( __param(10, IInstantiationService))
+], InstalledThemesPicker));
+const SelectColorThemeCommandId = 'workbench.action.selectTheme';
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: SelectColorThemeCommandId,
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'selectTheme.label',
+                "Color Theme"
+            )), original: 'Color Theme' },
+            category: Categories.Preferences,
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 2048  | 50 )
+            }
+        });
+    }
+    async run(accessor) {
+        const themeService = accessor.get(IWorkbenchThemeService);
+        const installMessage = ( localizeWithPath(
+            'vs/workbench/contrib/themes/browser/themes.contribution',
+            'installColorThemes',
+            "Install Additional Color Themes..."
+        ));
+        const browseMessage = '$(plus) ' + ( localizeWithPath(
+            'vs/workbench/contrib/themes/browser/themes.contribution',
+            'browseColorThemes',
+            "Browse Additional Color Themes..."
+        ));
+        const placeholderMessage = ( localizeWithPath(
+            'vs/workbench/contrib/themes/browser/themes.contribution',
+            'themes.selectTheme',
+            "Select Color Theme (Up/Down Keys to Preview)"
+        ));
+        const marketplaceTag = 'category:themes';
+        const setTheme = (theme, settingsTarget) => themeService.setColorTheme(theme, settingsTarget);
+        const getMarketplaceColorThemes = (publisher, name, version) => themeService.getMarketplaceColorThemes(publisher, name, version);
+        const instantiationService = accessor.get(IInstantiationService);
+        const picker = instantiationService.createInstance(InstalledThemesPicker, installMessage, browseMessage, placeholderMessage, marketplaceTag, setTheme, getMarketplaceColorThemes);
+        const themes = await themeService.getColorThemes();
+        const currentTheme = themeService.getColorTheme();
+        const picks = [
+            ...toEntries(themes.filter(t => t.type === ColorScheme.LIGHT), ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'themes.category.light',
+                "light themes"
+            ))),
+            ...toEntries(themes.filter(t => t.type === ColorScheme.DARK), ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'themes.category.dark',
+                "dark themes"
+            ))),
+            ...toEntries(themes.filter(t => isHighContrast(t.type)), ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'themes.category.hc',
+                "high contrast themes"
+            ))),
+        ];
+        await picker.openQuickPick(picks, currentTheme);
+    }
+});
+const SelectFileIconThemeCommandId = 'workbench.action.selectIconTheme';
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: SelectFileIconThemeCommandId,
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'selectIconTheme.label',
+                "File Icon Theme"
+            )), original: 'File Icon Theme' },
+            category: Categories.Preferences,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const themeService = accessor.get(IWorkbenchThemeService);
+        const installMessage = ( localizeWithPath(
+            'vs/workbench/contrib/themes/browser/themes.contribution',
+            'installIconThemes',
+            "Install Additional File Icon Themes..."
+        ));
+        const placeholderMessage = ( localizeWithPath(
+            'vs/workbench/contrib/themes/browser/themes.contribution',
+            'themes.selectIconTheme',
+            "Select File Icon Theme (Up/Down Keys to Preview)"
+        ));
+        const marketplaceTag = 'tag:icon-theme';
+        const setTheme = (theme, settingsTarget) => themeService.setFileIconTheme(theme, settingsTarget);
+        const getMarketplaceColorThemes = (publisher, name, version) => themeService.getMarketplaceFileIconThemes(publisher, name, version);
+        const instantiationService = accessor.get(IInstantiationService);
+        const picker = instantiationService.createInstance(InstalledThemesPicker, installMessage, undefined, placeholderMessage, marketplaceTag, setTheme, getMarketplaceColorThemes);
+        const picks = [
+            { type: 'separator', label: ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'fileIconThemeCategory',
+                'file icon themes'
+            )) },
+            { id: '', theme: FileIconThemeData.noIconTheme, label: ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'noIconThemeLabel',
+                'None'
+            )), description: ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'noIconThemeDesc',
+                'Disable File Icons'
+            )) },
+            ...toEntries(await themeService.getFileIconThemes()),
+        ];
+        await picker.openQuickPick(picks, themeService.getFileIconTheme());
+    }
+});
+const SelectProductIconThemeCommandId = 'workbench.action.selectProductIconTheme';
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: SelectProductIconThemeCommandId,
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'selectProductIconTheme.label',
+                "Product Icon Theme"
+            )), original: 'Product Icon Theme' },
+            category: Categories.Preferences,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const themeService = accessor.get(IWorkbenchThemeService);
+        const installMessage = ( localizeWithPath(
+            'vs/workbench/contrib/themes/browser/themes.contribution',
+            'installProductIconThemes',
+            "Install Additional Product Icon Themes..."
+        ));
+        const browseMessage = '$(plus) ' + ( localizeWithPath(
+            'vs/workbench/contrib/themes/browser/themes.contribution',
+            'browseProductIconThemes',
+            "Browse Additional Product Icon Themes..."
+        ));
+        const placeholderMessage = ( localizeWithPath(
+            'vs/workbench/contrib/themes/browser/themes.contribution',
+            'themes.selectProductIconTheme',
+            "Select Product Icon Theme (Up/Down Keys to Preview)"
+        ));
+        const marketplaceTag = 'tag:product-icon-theme';
+        const setTheme = (theme, settingsTarget) => themeService.setProductIconTheme(theme, settingsTarget);
+        const getMarketplaceColorThemes = (publisher, name, version) => themeService.getMarketplaceProductIconThemes(publisher, name, version);
+        const instantiationService = accessor.get(IInstantiationService);
+        const picker = instantiationService.createInstance(InstalledThemesPicker, installMessage, browseMessage, placeholderMessage, marketplaceTag, setTheme, getMarketplaceColorThemes);
+        const picks = [
+            { type: 'separator', label: ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'productIconThemeCategory',
+                'product icon themes'
+            )) },
+            { id: DEFAULT_PRODUCT_ICON_THEME_ID, theme: ProductIconThemeData.defaultTheme, label: ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'defaultProductIconThemeLabel',
+                'Default'
+            )) },
+            ...toEntries(await themeService.getProductIconThemes()),
+        ];
+        await picker.openQuickPick(picks, themeService.getProductIconTheme());
+    }
+});
+CommandsRegistry.registerCommand('workbench.action.previewColorTheme', async function (accessor, extension, themeSettingsId) {
+    const themeService = accessor.get(IWorkbenchThemeService);
+    let themes = findBuiltInThemes(await themeService.getColorThemes(), extension);
+    if (themes.length === 0) {
+        themes = await themeService.getMarketplaceColorThemes(extension.publisher, extension.name, extension.version);
+    }
+    for (const theme of themes) {
+        if (!themeSettingsId || theme.settingsId === themeSettingsId) {
+            await themeService.setColorTheme(theme, 'preview');
+            return theme.settingsId;
+        }
+    }
+    return undefined;
+});
+function findBuiltInThemes(themes, extension) {
+    return themes.filter(({ extensionData }) => extensionData && extensionData.extensionIsBuiltin && equalsIgnoreCase(extensionData.extensionPublisher, extension.publisher) && equalsIgnoreCase(extensionData.extensionName, extension.name));
+}
+function configurationEntries(label) {
+    return [
+        {
+            type: 'separator'
+        },
+        {
+            id: undefined,
+            label: label,
+            alwaysShow: true,
+            buttons: [configureButton]
+        }
+    ];
+}
+function openExtensionViewlet(paneCompositeService, query) {
+    return paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , true).then(viewlet => {
+        if (viewlet) {
+            (viewlet?.getViewPaneContainer()).search(query);
+            viewlet.focus();
+        }
+    });
+}
+function isItem(i) {
+    return i['type'] !== 'separator';
+}
+function toEntry(theme) {
+    const settingId = theme.settingsId ?? undefined;
+    const item = {
+        id: theme.id,
+        theme: theme,
+        label: theme.label,
+        description: theme.description || (theme.label === settingId ? undefined : settingId),
+    };
+    if (theme.extensionData) {
+        item.buttons = [configureButton];
+    }
+    return item;
+}
+function toEntries(themes, label) {
+    const sorter = (t1, t2) => t1.label.localeCompare(t2.label);
+    const entries = ( themes.map(toEntry)).sort(sorter);
+    if (entries.length > 0 && label) {
+        entries.unshift({ type: 'separator', label });
+    }
+    return entries;
+}
+const configureButton = {
+    iconClass: ThemeIcon.asClassName(manageExtensionIcon),
+    tooltip: ( localizeWithPath(
+        'vs/workbench/contrib/themes/browser/themes.contribution',
+        'manage extension',
+        "Manage Extension"
+    )),
+};
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.generateColorTheme',
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'generateColorTheme.label',
+                "Generate Color Theme From Current Settings"
+            )), original: 'Generate Color Theme From Current Settings' },
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    run(accessor) {
+        const themeService = accessor.get(IWorkbenchThemeService);
+        const theme = themeService.getColorTheme();
+        const colors = ( Registry.as(Extensions.ColorContribution)).getColors();
+        const colorIds = ( colors.map(c => c.id)).sort();
+        const resultingColors = {};
+        const inherited = [];
+        for (const colorId of colorIds) {
+            const color = theme.getColor(colorId, false);
+            if (color) {
+                resultingColors[colorId] = Color.Format.CSS.formatHexA(color, true);
+            }
+            else {
+                inherited.push(colorId);
+            }
+        }
+        const nullDefaults = [];
+        for (const id of inherited) {
+            const color = theme.getColor(id);
+            if (color) {
+                resultingColors['__' + id] = Color.Format.CSS.formatHexA(color, true);
+            }
+            else {
+                nullDefaults.push(id);
+            }
+        }
+        for (const id of nullDefaults) {
+            resultingColors['__' + id] = null;
+        }
+        let contents = JSON.stringify({
+            '$schema': colorThemeSchemaId,
+            type: theme.type,
+            colors: resultingColors,
+            tokenColors: theme.tokenColors.filter(t => !!t.scope)
+        }, null, '\t');
+        contents = contents.replace(/\"__/g, '//"');
+        const editorService = accessor.get(IEditorService);
+        return editorService.openEditor({ resource: undefined, contents, languageId: 'jsonc', options: { pinned: true } });
+    }
+});
+const toggleLightDarkThemesCommandId = 'workbench.action.toggleLightDarkThemes';
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: toggleLightDarkThemesCommandId,
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'toggleLightDarkThemes.label',
+                "Toggle between Light/Dark Themes"
+            )), original: 'Toggle between Light/Dark Themes' },
+            category: Categories.Preferences,
+            f1: true,
+        });
+    }
+    async run(accessor) {
+        const themeService = accessor.get(IWorkbenchThemeService);
+        const configurationService = accessor.get(IConfigurationService);
+        const currentTheme = themeService.getColorTheme();
+        let newSettingsId = ThemeSettings.PREFERRED_DARK_THEME;
+        switch (currentTheme.type) {
+            case ColorScheme.LIGHT:
+                newSettingsId = ThemeSettings.PREFERRED_DARK_THEME;
+                break;
+            case ColorScheme.DARK:
+                newSettingsId = ThemeSettings.PREFERRED_LIGHT_THEME;
+                break;
+            case ColorScheme.HIGH_CONTRAST_LIGHT:
+                newSettingsId = ThemeSettings.PREFERRED_HC_DARK_THEME;
+                break;
+            case ColorScheme.HIGH_CONTRAST_DARK:
+                newSettingsId = ThemeSettings.PREFERRED_HC_LIGHT_THEME;
+                break;
+        }
+        const themeSettingId = configurationService.getValue(newSettingsId);
+        if (themeSettingId && typeof themeSettingId === 'string') {
+            const theme = (await themeService.getColorThemes()).find(t => t.settingsId === themeSettingId);
+            if (theme) {
+                themeService.setColorTheme(theme.id, 'auto');
+            }
+        }
+    }
+});
+const browseColorThemesInMarketplaceCommandId = 'workbench.action.browseColorThemesInMarketplace';
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: browseColorThemesInMarketplaceCommandId,
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                'browseColorThemeInMarketPlace.label',
+                "Browse Color Themes in Marketplace"
+            )), original: 'Browse Color Themes in Marketplace' },
+            category: Categories.Preferences,
+            f1: true,
+        });
+    }
+    async run(accessor) {
+        const marketplaceTag = 'category:themes';
+        const themeService = accessor.get(IWorkbenchThemeService);
+        const extensionGalleryService = accessor.get(IExtensionGalleryService);
+        const extensionResourceLoaderService = accessor.get(IExtensionResourceLoaderService);
+        const instantiationService = accessor.get(IInstantiationService);
+        if (!extensionGalleryService.isEnabled() || !extensionResourceLoaderService.supportsExtensionGalleryResources) {
+            return;
+        }
+        const currentTheme = themeService.getColorTheme();
+        const getMarketplaceColorThemes = (publisher, name, version) => themeService.getMarketplaceColorThemes(publisher, name, version);
+        let selectThemeTimeout;
+        const selectTheme = (theme, applyTheme) => {
+            if (selectThemeTimeout) {
+                clearTimeout(selectThemeTimeout);
+            }
+            selectThemeTimeout = mainWindow.setTimeout(() => {
+                selectThemeTimeout = undefined;
+                const newTheme = (theme ?? currentTheme);
+                themeService.setColorTheme(newTheme, applyTheme ? 'auto' : 'preview').then(undefined, err => {
+                    onUnexpectedError(err);
+                    themeService.setColorTheme(currentTheme, undefined);
+                });
+            }, applyTheme ? 0 : 200);
+        };
+        const marketplaceThemePicker = instantiationService.createInstance(MarketplaceThemesPicker, getMarketplaceColorThemes, marketplaceTag);
+        await marketplaceThemePicker.openQuickPick('', themeService.getColorTheme(), selectTheme).then(undefined, onUnexpectedError);
+    }
+});
+const ThemesSubMenu = ( new MenuId('ThemesSubMenu'));
+MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
+    title: ( localizeWithPath(
+        'vs/workbench/contrib/themes/browser/themes.contribution',
+        'themes',
+        "Themes"
+    )),
+    submenu: ThemesSubMenu,
+    group: '2_configuration',
+    order: 7
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarPreferencesMenu, {
+    title: ( localizeWithPath(
+        'vs/workbench/contrib/themes/browser/themes.contribution',
+        { key: 'miSelectTheme', comment: ['&& denotes a mnemonic'] },
+        "&&Theme"
+    )),
+    submenu: ThemesSubMenu,
+    group: '2_configuration',
+    order: 7
+});
+MenuRegistry.appendMenuItem(ThemesSubMenu, {
+    command: {
+        id: SelectColorThemeCommandId,
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/themes/browser/themes.contribution',
+            'selectTheme.label',
+            "Color Theme"
+        ))
+    },
+    order: 1
+});
+MenuRegistry.appendMenuItem(ThemesSubMenu, {
+    command: {
+        id: SelectFileIconThemeCommandId,
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/themes/browser/themes.contribution',
+            'themes.selectIconTheme.label',
+            "File Icon Theme"
+        ))
+    },
+    order: 2
+});
+MenuRegistry.appendMenuItem(ThemesSubMenu, {
+    command: {
+        id: SelectProductIconThemeCommandId,
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/themes/browser/themes.contribution',
+            'themes.selectProductIconTheme.label',
+            "Product Icon Theme"
+        ))
+    },
+    order: 3
+});
+let DefaultThemeUpdatedNotificationContribution = class DefaultThemeUpdatedNotificationContribution {
+    static { DefaultThemeUpdatedNotificationContribution_1 = this; }
+    static { this.STORAGE_KEY = 'themeUpdatedNotificationShown'; }
+    constructor(_notificationService, _workbenchThemeService, _storageService, _commandService, _telemetryService, _hostService) {
+        this._notificationService = _notificationService;
+        this._workbenchThemeService = _workbenchThemeService;
+        this._storageService = _storageService;
+        this._commandService = _commandService;
+        this._telemetryService = _telemetryService;
+        this._hostService = _hostService;
+        if (_storageService.getBoolean(DefaultThemeUpdatedNotificationContribution_1.STORAGE_KEY, -1 )) {
+            return;
+        }
+        setTimeout(async () => {
+            if (_storageService.getBoolean(DefaultThemeUpdatedNotificationContribution_1.STORAGE_KEY, -1 )) {
+                return;
+            }
+            if (await this._hostService.hadLastFocus()) {
+                this._storageService.store(DefaultThemeUpdatedNotificationContribution_1.STORAGE_KEY, true, -1 , 0 );
+                if (this._workbenchThemeService.hasUpdatedDefaultThemes()) {
+                    this._showYouGotMigratedNotification();
+                }
+                else {
+                    const currentTheme = this._workbenchThemeService.getColorTheme().settingsId;
+                    if (currentTheme === ThemeSettingDefaults.COLOR_THEME_LIGHT_OLD || currentTheme === ThemeSettingDefaults.COLOR_THEME_DARK_OLD) {
+                        this._tryNewThemeNotification();
+                    }
+                }
+            }
+        }, 3000);
+    }
+    async _showYouGotMigratedNotification() {
+        const usingLight = this._workbenchThemeService.getColorTheme().type === ColorScheme.LIGHT;
+        const newThemeSettingsId = usingLight ? ThemeSettingDefaults.COLOR_THEME_LIGHT : ThemeSettingDefaults.COLOR_THEME_DARK;
+        const newTheme = (await this._workbenchThemeService.getColorThemes()).find(theme => theme.settingsId === newThemeSettingsId);
+        if (newTheme) {
+            const choices = [
+                {
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/themes/browser/themes.contribution',
+                        'button.keep',
+                        "Keep New Theme"
+                    )),
+                    run: () => {
+                        this._writeTelemetry('keepNew');
+                    }
+                },
+                {
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/themes/browser/themes.contribution',
+                        'button.browse',
+                        "Browse Themes"
+                    )),
+                    run: () => {
+                        this._writeTelemetry('browse');
+                        this._commandService.executeCommand(SelectColorThemeCommandId);
+                    }
+                },
+                {
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/themes/browser/themes.contribution',
+                        'button.revert',
+                        "Revert"
+                    )),
+                    run: async () => {
+                        this._writeTelemetry('keepOld');
+                        const oldSettingsId = usingLight ? ThemeSettingDefaults.COLOR_THEME_LIGHT_OLD : ThemeSettingDefaults.COLOR_THEME_DARK_OLD;
+                        const oldTheme = (await this._workbenchThemeService.getColorThemes()).find(theme => theme.settingsId === oldSettingsId);
+                        if (oldTheme) {
+                            this._workbenchThemeService.setColorTheme(oldTheme, 'auto');
+                        }
+                    }
+                }
+            ];
+            await this._notificationService.prompt(Severity.Info, ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                { key: 'themeUpdatedNotification', comment: ['{0} is the name of the new default theme'] },
+                "Visual Studio Code now ships with a new default theme '{0}'. If you prefer, you can switch back to the old theme or try one of the many other color themes available.",
+                newTheme.label
+            )), choices, {
+                onCancel: () => this._writeTelemetry('cancel')
+            });
+        }
+    }
+    async _tryNewThemeNotification() {
+        const newThemeSettingsId = this._workbenchThemeService.getColorTheme().type === ColorScheme.LIGHT ? ThemeSettingDefaults.COLOR_THEME_LIGHT : ThemeSettingDefaults.COLOR_THEME_DARK;
+        const theme = (await this._workbenchThemeService.getColorThemes()).find(theme => theme.settingsId === newThemeSettingsId);
+        if (theme) {
+            const choices = [{
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/themes/browser/themes.contribution',
+                        'button.tryTheme',
+                        "Try New Theme"
+                    )),
+                    run: () => {
+                        this._writeTelemetry('tryNew');
+                        this._workbenchThemeService.setColorTheme(theme, 'auto');
+                    }
+                },
+                {
+                    label: ( localizeWithPath(
+                        'vs/workbench/contrib/themes/browser/themes.contribution',
+                        'button.cancel',
+                        "Cancel"
+                    )),
+                    run: () => {
+                        this._writeTelemetry('cancel');
+                    }
+                }];
+            await this._notificationService.prompt(Severity.Info, ( localizeWithPath(
+                'vs/workbench/contrib/themes/browser/themes.contribution',
+                { key: 'newThemeNotification', comment: ['{0} is the name of the new default theme'] },
+                "Visual Studio Code now ships with a new default theme '{0}'. Do you want to give it a try?",
+                theme.label
+            )), choices, { onCancel: () => this._writeTelemetry('cancel') });
+        }
+    }
+    _writeTelemetry(outcome) {
+        this._telemetryService.publicLog2('themeUpdatedNotication', {
+            web: isWeb,
+            reaction: outcome
+        });
+    }
+};
+DefaultThemeUpdatedNotificationContribution = DefaultThemeUpdatedNotificationContribution_1 = ( __decorate([
+    ( __param(0, INotificationService)),
+    ( __param(1, IWorkbenchThemeService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, ICommandService)),
+    ( __param(4, ITelemetryService)),
+    ( __param(5, IHostService))
+], DefaultThemeUpdatedNotificationContribution));
+const workbenchRegistry = ( Registry.as(Extensions$1.Workbench));
+workbenchRegistry.registerWorkbenchContribution(DefaultThemeUpdatedNotificationContribution, 4 );
+
+export { manageExtensionIcon };

package/vscode/src/vs/workbench/services/themes/browser/workbenchThemeService.js

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
-import * as types from 'monaco-editor/esm/vs/base/common/types.js';
+import * as Types from 'monaco-editor/esm/vs/base/common/types.js';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 import { ThemeSettingDefaults, COLOR_THEME_LIGHT_INITIAL_COLORS, COLOR_THEME_DARK_INITIAL_COLORS, ThemeSettings, ExtensionData, VS_DARK_THEME, VS_LIGHT_THEME, VS_HC_THEME, VS_HC_LIGHT_THEME } from 'vscode/vscode/vs/workbench/services/themes/common/workbenchThemeService';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
@@ -261,7 +261,7 @@ let WorkbenchThemeService = class WorkbenchThemeService {
         this.colorThemeRegistry.onDidChange(async (event) => {
             updateColorThemeConfigurationSchemas(event.themes);
             if (await this.restoreColorTheme()) {
-                if (this.currentColorTheme.settingsId === ThemeSettingDefaults.COLOR_THEME_DARK && !types.isUndefined(prevColorId) && (await this.colorThemeRegistry.findThemeById(prevColorId))) {
+                if (this.currentColorTheme.settingsId === ThemeSettingDefaults.COLOR_THEME_DARK && !Types.isUndefined(prevColorId) && (await this.colorThemeRegistry.findThemeById(prevColorId))) {
                     await this.setColorTheme(prevColorId, 'auto');
                     prevColorId = undefined;
                 }
@@ -279,7 +279,7 @@ let WorkbenchThemeService = class WorkbenchThemeService {
         this.fileIconThemeRegistry.onDidChange(async (event) => {
             updateFileIconThemeConfigurationSchemas(event.themes);
             if (await this.restoreFileIconTheme()) {
-                if (this.currentFileIconTheme.id === DEFAULT_FILE_ICON_THEME_ID && !types.isUndefined(prevFileIconId) && this.fileIconThemeRegistry.findThemeById(prevFileIconId)) {
+                if (this.currentFileIconTheme.id === DEFAULT_FILE_ICON_THEME_ID && !Types.isUndefined(prevFileIconId) && this.fileIconThemeRegistry.findThemeById(prevFileIconId)) {
                     await this.setFileIconTheme(prevFileIconId, 'auto');
                     prevFileIconId = undefined;
                 }
@@ -296,7 +296,7 @@ let WorkbenchThemeService = class WorkbenchThemeService {
         this.productIconThemeRegistry.onDidChange(async (event) => {
             updateProductIconThemeConfigurationSchemas(event.themes);
             if (await this.restoreProductIconTheme()) {
-                if (this.currentProductIconTheme.id === DEFAULT_PRODUCT_ICON_THEME_ID && !types.isUndefined(prevProductIconId) && this.productIconThemeRegistry.findThemeById(prevProductIconId)) {
+                if (this.currentProductIconTheme.id === DEFAULT_PRODUCT_ICON_THEME_ID && !Types.isUndefined(prevProductIconId) && this.productIconThemeRegistry.findThemeById(prevProductIconId)) {
                     await this.setProductIconTheme(prevProductIconId, 'auto');
                     prevProductIconId = undefined;
                 }
@@ -406,7 +406,7 @@ let WorkbenchThemeService = class WorkbenchThemeService {
         if (!themeIdOrTheme) {
             return null;
         }
-        const themeId = types.isString(themeIdOrTheme) ? validateThemeId(themeIdOrTheme) : themeIdOrTheme.id;
+        const themeId = Types.isString(themeIdOrTheme) ? validateThemeId(themeIdOrTheme) : themeIdOrTheme.id;
         if (this.currentColorTheme.isLoaded && themeId === this.currentColorTheme.id) {
             if (settingsTarget !== 'preview') {
                 this.currentColorTheme.toStorage(this.storageService);
@@ -541,7 +541,7 @@ let WorkbenchThemeService = class WorkbenchThemeService {
         if (iconThemeOrId === undefined) {
             iconThemeOrId = '';
         }
-        const themeId = types.isString(iconThemeOrId) ? iconThemeOrId : iconThemeOrId.id;
+        const themeId = Types.isString(iconThemeOrId) ? iconThemeOrId : iconThemeOrId.id;
         if (themeId !== this.currentFileIconTheme.id || !this.currentFileIconTheme.isLoaded) {
             let newThemeData = this.fileIconThemeRegistry.findThemeById(themeId);
             if (!newThemeData && iconThemeOrId instanceof FileIconThemeData) {
@@ -631,7 +631,7 @@ let WorkbenchThemeService = class WorkbenchThemeService {
         if (iconThemeOrId === undefined) {
             iconThemeOrId = '';
         }
-        const themeId = types.isString(iconThemeOrId) ? iconThemeOrId : iconThemeOrId.id;
+        const themeId = Types.isString(iconThemeOrId) ? iconThemeOrId : iconThemeOrId.id;
         if (themeId !== this.currentProductIconTheme.id || !this.currentProductIconTheme.isLoaded) {
             let newThemeData = this.productIconThemeRegistry.findThemeById(themeId);
             if (!newThemeData && iconThemeOrId instanceof ProductIconThemeData) {

package/vscode/src/vs/workbench/services/themes/common/colorThemeData.js

@@ -4,7 +4,7 @@ import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
 import { THEME_SCOPE_OPEN_PAREN, THEME_SCOPE_CLOSE_PAREN, THEME_SCOPE_WILDCARD, themeScopeRegex, ExtensionData, VS_HC_LIGHT_THEME, VS_HC_THEME, VS_LIGHT_THEME } from 'vscode/vscode/vs/workbench/services/themes/common/workbenchThemeService';
 import { convertSettings } from './themeCompatibility.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
-import * as types from 'monaco-editor/esm/vs/base/common/types.js';
+import * as Types from 'monaco-editor/esm/vs/base/common/types.js';
 import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
 import { Extensions, editorForeground, editorBackground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
 import { getThemeTypeSelector } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
@@ -86,7 +86,7 @@ class ColorThemeData {
             return color;
         }
         color = this.colorMap[colorId];
-        if (useDefault !== false && types.isUndefined(color)) {
+        if (useDefault !== false && Types.isUndefined(color)) {
             color = this.getDefault(colorId);
         }
         return color;
@@ -251,7 +251,7 @@ class ColorThemeData {
                             foregroundScore = score;
                             foregroundThemingRule = themingRule;
                         }
-                        if (score >= fontStyleScore && types.isString(settings.fontStyle)) {
+                        if (score >= fontStyleScore && Types.isString(settings.fontStyle)) {
                             fontStyle = settings.fontStyle;
                             fontStyleScore = score;
                             fontStyleThemingRule = themingRule;
@@ -284,7 +284,7 @@ class ColorThemeData {
         this.customColorMap = {};
         this.overwriteCustomColors(colors);
         const themeSpecificColors = this.getThemeSpecificColors(colors);
-        if (types.isObject(themeSpecificColors)) {
+        if (Types.isObject(themeSpecificColors)) {
             this.overwriteCustomColors(themeSpecificColors);
         }
         this.tokenColorIndex = undefined;
@@ -304,7 +304,7 @@ class ColorThemeData {
         this.customSemanticHighlightingDeprecated = undefined;
         this.addCustomTokenColors(customTokenColors);
         const themeSpecificTokenColors = this.getThemeSpecificColors(customTokenColors);
-        if (types.isObject(themeSpecificTokenColors)) {
+        if (Types.isObject(themeSpecificTokenColors)) {
             this.addCustomTokenColors(themeSpecificTokenColors);
         }
         this.tokenColorIndex = undefined;
@@ -320,7 +320,7 @@ class ColorThemeData {
                 this.readSemanticTokenRules(semanticTokenColors.rules);
             }
             const themeSpecificColors = this.getThemeSpecificColors(semanticTokenColors);
-            if (types.isObject(themeSpecificColors)) {
+            if (Types.isObject(themeSpecificColors)) {
                 if (themeSpecificColors.enabled !== undefined) {
                     this.customSemanticHighlighting = themeSpecificColors.enabled;
                 }
@@ -799,8 +799,8 @@ function readSemanticTokenRule(selectorString, settings) {
     return undefined;
 }
 function isSemanticTokenColorizationSetting(style) {
-    return style && (types.isString(style.foreground) || types.isString(style.fontStyle) || types.isBoolean(style.italic)
-        || types.isBoolean(style.underline) || types.isBoolean(style.strikethrough) || types.isBoolean(style.bold));
+    return style && (Types.isString(style.foreground) || Types.isString(style.fontStyle) || Types.isBoolean(style.italic)
+        || Types.isBoolean(style.underline) || Types.isBoolean(style.strikethrough) || Types.isBoolean(style.bold));
 }
 class TokenColorIndex {
     constructor() {

package/vscode/src/vs/workbench/services/themes/common/themeConfiguration.js

@@ -1,5 +1,5 @@
 import * as nls from 'monaco-editor/esm/vs/nls.js';
-import * as types from 'monaco-editor/esm/vs/base/common/types.js';
+import * as Types from 'monaco-editor/esm/vs/base/common/types.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { textmateColorsSchemaId, textmateColorGroupSchemaId } from './colorThemeSchema.js';
@@ -419,13 +419,13 @@ class ThemeConfiguration {
     }
     findAutoConfigurationTarget(key) {
         const settings = this.configurationService.inspect(key);
-        if (!types.isUndefined(settings.workspaceFolderValue)) {
+        if (!Types.isUndefined(settings.workspaceFolderValue)) {
             return 6 ;
         }
-        else if (!types.isUndefined(settings.workspaceValue)) {
+        else if (!Types.isUndefined(settings.workspaceValue)) {
             return 5 ;
         }
-        else if (!types.isUndefined(settings.userRemote)) {
+        else if (!Types.isUndefined(settings.userRemote)) {
             return 4 ;
         }
         return 2 ;
@@ -443,7 +443,7 @@ class ThemeConfiguration {
                 return Promise.resolve(undefined);
             }
             else if (value === settings.defaultValue) {
-                if (types.isUndefined(settings.userValue)) {
+                if (Types.isUndefined(settings.userValue)) {
                     return Promise.resolve(undefined);
                 }
                 value = undefined;

package/vscode/src/vs/workbench/services/themes/common/themeExtensionPoints.js

@@ -1,5 +1,5 @@
 import * as nls from 'monaco-editor/esm/vs/nls.js';
-import * as types from 'monaco-editor/esm/vs/base/common/types.js';
+import * as Types from 'monaco-editor/esm/vs/base/common/types.js';
 import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
 import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
 import { VS_DARK_THEME, VS_LIGHT_THEME, VS_HC_THEME, VS_HC_LIGHT_THEME, ExtensionData } from 'vscode/vscode/vs/workbench/services/themes/common/workbenchThemeService';
@@ -191,7 +191,7 @@ class ThemeRegistry {
             return resultingThemes;
         }
         themeContributions.forEach(theme => {
-            if (!theme.path || !types.isString(theme.path)) {
+            if (!theme.path || !Types.isString(theme.path)) {
                 log?.error(( nls.localizeWithPath(
                     'vs/workbench/services/themes/common/themeExtensionPoints',
                     'reqpath',
@@ -201,7 +201,7 @@ class ThemeRegistry {
                 )));
                 return;
             }
-            if (this.idRequired && (!theme.id || !types.isString(theme.id))) {
+            if (this.idRequired && (!theme.id || !Types.isString(theme.id))) {
                 log?.error(( nls.localizeWithPath(
                     'vs/workbench/services/themes/common/themeExtensionPoints',
                     'reqid',