@codingame/monaco-vscode-theme-service-override 4.5.2 → 5.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-theme-service-override",
-  "version": "4.5.2",
+  "version": "5.0.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -26,7 +26,7 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.5.2",
-    "@codingame/monaco-vscode-files-service-override": "4.5.2"
+    "vscode": "npm:@codingame/monaco-vscode-api@5.0.0",
+    "@codingame/monaco-vscode-files-service-override": "5.0.0"
   }
 }

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

@@ -51,6 +51,10 @@ import { isWeb } from 'vscode/vscode/vs/base/common/platform';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
+import { IPreferencesService } from 'vscode/vscode/vs/workbench/services/preferences/common/preferences.service';
+import { Toggle } from 'vscode/vscode/vs/base/browser/ui/toggle/toggle';
+import { defaultToggleStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import Severity$1 from 'vscode/vscode/vs/base/common/severity';
 
 var DefaultThemeUpdatedNotificationContribution_1;
@@ -60,6 +64,12 @@ const manageExtensionIcon = registerIcon('theme-selection-manage-extension', Cod
     0,
     'Icon for the \'Manage\' action in the theme selection quick pick.'
 )));
+var ConfigureItem;
+( ((function(ConfigureItem) {
+    ConfigureItem["BROWSE_GALLERY"] = "marketplace";
+    ConfigureItem["EXTENSIONS_VIEW"] = "extensions";
+    ConfigureItem["CUSTOM_TOP_ENTRY"] = "customTopEntry";
+})(ConfigureItem || (ConfigureItem = {}))));
 let MarketplaceThemesPicker = class MarketplaceThemesPicker {
     constructor(getMarketplaceColorThemes, marketplaceQuery, extensionGalleryService, extensionManagementService, quickInputService, logService, progressService, paneCompositeService, dialogService) {
         this.getMarketplaceColorThemes = getMarketplaceColorThemes;
@@ -283,11 +293,8 @@ MarketplaceThemesPicker = ( (__decorate([
     ( (__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;
+    constructor(options, setTheme, getMarketplaceColorThemes, quickInputService, extensionGalleryService, paneCompositeService, extensionResourceLoaderService, instantiationService) {
+        this.options = options;
         this.setTheme = setTheme;
         this.getMarketplaceColorThemes = getMarketplaceColorThemes;
         this.quickInputService = quickInputService;
@@ -299,12 +306,12 @@ let InstalledThemesPicker = class InstalledThemesPicker {
     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];
+            if (this.extensionResourceLoaderService.supportsExtensionGalleryResources && this.options.browseMessage) {
+                marketplaceThemePicker = this.instantiationService.createInstance(MarketplaceThemesPicker, this.getMarketplaceColorThemes.bind(this), this.options.marketplaceTag);
+                picks = [configurationEntry(this.options.browseMessage, ConfigureItem.BROWSE_GALLERY), ...picks];
             }
             else {
-                picks = [...picks, ...configurationEntries(this.installMessage)];
+                picks = [...picks, { type: 'separator' }, configurationEntry(this.options.installMessage, ConfigureItem.EXTENSIONS_VIEW)];
             }
         }
         let selectThemeTimeout;
@@ -325,25 +332,34 @@ let InstalledThemesPicker = class InstalledThemesPicker {
             return (
                  (new Promise((s, _) => {
                     let isCompleted = false;
+                    const disposables = ( (new DisposableStore()));
                     const autoFocusIndex = picks.findIndex(p => isItem(p) && p.id === activeItemId);
                     const quickpick = this.quickInputService.createQuickPick();
                     quickpick.items = picks;
-                    quickpick.placeholder = this.placeholderMessage;
+                    quickpick.title = this.options.title;
+                    quickpick.description = this.options.description;
+                    quickpick.placeholder = this.options.placeholderMessage;
                     quickpick.activeItems = [picks[autoFocusIndex]];
                     quickpick.canSelectMany = false;
+                    quickpick.toggles = this.options.toggles;
+                    quickpick.toggles?.forEach(toggle => {
+                        toggle.onChange(() => this.options.onToggle?.(toggle, quickpick), undefined, disposables);
+                    });
                     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);
-                                }
+                        if (!theme || theme.configureItem) {
+                            if (!theme || theme.configureItem === ConfigureItem.EXTENSIONS_VIEW) {
+                                openExtensionViewlet(this.paneCompositeService, `${this.options.marketplaceTag} ${quickpick.value}`);
                             }
-                            else {
-                                openExtensionViewlet(this.paneCompositeService, `${this.marketplaceTag} ${quickpick.value}`);
+                            else if (theme.configureItem === ConfigureItem.BROWSE_GALLERY) {
+                                if (marketplaceThemePicker) {
+                                    const res = await marketplaceThemePicker.openQuickPick(quickpick.value, currentTheme, selectTheme);
+                                    if (res === 'back') {
+                                        await pickInstalledThemes(undefined);
+                                    }
+                                }
                             }
                         }
                         else {
@@ -359,6 +375,7 @@ let InstalledThemesPicker = class InstalledThemesPicker {
                             s();
                         }
                         quickpick.dispose();
+                        disposables.dispose();
                     });
                     quickpick.onDidTriggerItemButton(e => {
                         if (isItem(e.item)) {
@@ -367,7 +384,7 @@ let InstalledThemesPicker = class InstalledThemesPicker {
                                 openExtensionViewlet(this.paneCompositeService, `@id:${extensionId}`);
                             }
                             else {
-                                openExtensionViewlet(this.paneCompositeService, `${this.marketplaceTag} ${quickpick.value}`);
+                                openExtensionViewlet(this.paneCompositeService, `${this.options.marketplaceTag} ${quickpick.value}`);
                             }
                         }
                     });
@@ -380,11 +397,11 @@ let InstalledThemesPicker = class InstalledThemesPicker {
     }
 };
 InstalledThemesPicker = ( (__decorate([
-    ( (__param(6, IQuickInputService))),
-    ( (__param(7, IExtensionGalleryService))),
-    ( (__param(8, IPaneCompositePartService))),
-    ( (__param(9, IExtensionResourceLoaderService))),
-    ( (__param(10, IInstantiationService)))
+    ( (__param(3, IQuickInputService))),
+    ( (__param(4, IExtensionGalleryService))),
+    ( (__param(5, IPaneCompositePartService))),
+    ( (__param(6, IExtensionResourceLoaderService))),
+    ( (__param(7, IInstantiationService)))
 ], InstalledThemesPicker)));
 const SelectColorThemeCommandId = 'workbench.action.selectTheme';
 registerAction2(class extends Action2 {
@@ -400,23 +417,71 @@ registerAction2(class extends Action2 {
             }
         });
     }
+    getTitle(colorScheme) {
+        switch (colorScheme) {
+            case ColorScheme.DARK: return ( localizeWithPath(_moduleId, 7, "Select Color Theme for System Dark Mode"));
+            case ColorScheme.LIGHT: return ( localizeWithPath(_moduleId, 8, "Select Color Theme for System Light Mode"));
+            case ColorScheme.HIGH_CONTRAST_DARK: return ( localizeWithPath(_moduleId, 9, "Select Color Theme for High Contrast Dark Mode"));
+            case ColorScheme.HIGH_CONTRAST_LIGHT: return ( localizeWithPath(_moduleId, 10, "Select Color Theme for High Contrast Light Mode"));
+            default:
+                return ( localizeWithPath(_moduleId, 11, "Select Color Theme (detect system color mode disabled)"));
+        }
+    }
     async run(accessor) {
         const themeService = accessor.get(IWorkbenchThemeService);
-        const installMessage = ( localizeWithPath(_moduleId, 7, "Install Additional Color Themes..."));
-        const browseMessage = '$(plus) ' + ( localizeWithPath(_moduleId, 8, "Browse Additional Color Themes..."));
-        const placeholderMessage = ( localizeWithPath(_moduleId, 9, "Select Color Theme (Up/Down Keys to Preview)"));
-        const marketplaceTag = 'category:themes';
+        const preferencesService = accessor.get(IPreferencesService);
+        const preferredColorScheme = themeService.getPreferredColorScheme();
+        let modeConfigureToggle;
+        if (preferredColorScheme) {
+            modeConfigureToggle = ( (new Toggle({
+                title: ( localizeWithPath(_moduleId, 12, 'Detect system color mode enabled. Click to configure.')),
+                icon: Codicon.colorMode,
+                isChecked: false,
+                ...defaultToggleStyles
+            })));
+        }
+        else {
+            modeConfigureToggle = ( (new Toggle({
+                title: ( localizeWithPath(_moduleId, 13, 'Detect system color mode disabled. Click to configure.')),
+                icon: Codicon.colorMode,
+                isChecked: false,
+                ...defaultToggleStyles
+            })));
+        }
+        const options = {
+            installMessage: ( localizeWithPath(_moduleId, 14, "Install Additional Color Themes...")),
+            browseMessage: '$(plus) ' + ( localizeWithPath(_moduleId, 15, "Browse Additional Color Themes...")),
+            placeholderMessage: this.getTitle(preferredColorScheme),
+            marketplaceTag: 'category:themes',
+            toggles: [modeConfigureToggle],
+            onToggle: async (toggle, picker) => {
+                picker.hide();
+                await preferencesService.openSettings({ query: ThemeSettings.DETECT_COLOR_SCHEME });
+            }
+        };
         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 picker = instantiationService.createInstance(InstalledThemesPicker, options, setTheme, getMarketplaceColorThemes);
         const themes = await themeService.getColorThemes();
         const currentTheme = themeService.getColorTheme();
-        const picks = [
-            ...toEntries(themes.filter(t => t.type === ColorScheme.LIGHT), ( localizeWithPath(_moduleId, 10, "light themes"))),
-            ...toEntries(themes.filter(t => t.type === ColorScheme.DARK), ( localizeWithPath(_moduleId, 11, "dark themes"))),
-            ...toEntries(themes.filter(t => isHighContrast(t.type)), ( localizeWithPath(_moduleId, 12, "high contrast themes"))),
-        ];
+        const lightEntries = toEntries(themes.filter(t => t.type === ColorScheme.LIGHT), ( localizeWithPath(_moduleId, 16, "light themes")));
+        const darkEntries = toEntries(themes.filter(t => t.type === ColorScheme.DARK), ( localizeWithPath(_moduleId, 17, "dark themes")));
+        const hcEntries = toEntries(themes.filter(t => isHighContrast(t.type)), ( localizeWithPath(_moduleId, 18, "high contrast themes")));
+        let picks;
+        switch (preferredColorScheme) {
+            case ColorScheme.DARK:
+                picks = [...darkEntries, ...lightEntries, ...hcEntries];
+                break;
+            case ColorScheme.HIGH_CONTRAST_DARK:
+            case ColorScheme.HIGH_CONTRAST_LIGHT:
+                picks = [...hcEntries, ...lightEntries, ...darkEntries];
+                break;
+            case ColorScheme.LIGHT:
+            default:
+                picks = [...lightEntries, ...darkEntries, ...hcEntries];
+                break;
+        }
         await picker.openQuickPick(picks, currentTheme);
     }
 });
@@ -425,23 +490,25 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: SelectFileIconThemeCommandId,
-            title: ( localize2WithPath(_moduleId, 13, 'File Icon Theme')),
+            title: ( localize2WithPath(_moduleId, 19, 'File Icon Theme')),
             category: Categories.Preferences,
             f1: true
         });
     }
     async run(accessor) {
         const themeService = accessor.get(IWorkbenchThemeService);
-        const installMessage = ( localizeWithPath(_moduleId, 14, "Install Additional File Icon Themes..."));
-        const placeholderMessage = ( localizeWithPath(_moduleId, 15, "Select File Icon Theme (Up/Down Keys to Preview)"));
-        const marketplaceTag = 'tag:icon-theme';
+        const options = {
+            installMessage: ( localizeWithPath(_moduleId, 20, "Install Additional File Icon Themes...")),
+            placeholderMessage: ( localizeWithPath(_moduleId, 21, "Select File Icon Theme (Up/Down Keys to Preview)")),
+            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 picker = instantiationService.createInstance(InstalledThemesPicker, options, setTheme, getMarketplaceColorThemes);
         const picks = [
-            { type: 'separator', label: ( localizeWithPath(_moduleId, 16, 'file icon themes')) },
-            { id: '', theme: FileIconThemeData.noIconTheme, label: ( localizeWithPath(_moduleId, 17, 'None')), description: ( localizeWithPath(_moduleId, 18, 'Disable File Icons')) },
+            { type: 'separator', label: ( localizeWithPath(_moduleId, 22, 'file icon themes')) },
+            { id: '', theme: FileIconThemeData.noIconTheme, label: ( localizeWithPath(_moduleId, 23, 'None')), description: ( localizeWithPath(_moduleId, 24, 'Disable File Icons')) },
             ...toEntries(await themeService.getFileIconThemes()),
         ];
         await picker.openQuickPick(picks, themeService.getFileIconTheme());
@@ -452,24 +519,26 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: SelectProductIconThemeCommandId,
-            title: ( localize2WithPath(_moduleId, 19, 'Product Icon Theme')),
+            title: ( localize2WithPath(_moduleId, 25, 'Product Icon Theme')),
             category: Categories.Preferences,
             f1: true
         });
     }
     async run(accessor) {
         const themeService = accessor.get(IWorkbenchThemeService);
-        const installMessage = ( localizeWithPath(_moduleId, 20, "Install Additional Product Icon Themes..."));
-        const browseMessage = '$(plus) ' + ( localizeWithPath(_moduleId, 21, "Browse Additional Product Icon Themes..."));
-        const placeholderMessage = ( localizeWithPath(_moduleId, 22, "Select Product Icon Theme (Up/Down Keys to Preview)"));
-        const marketplaceTag = 'tag:product-icon-theme';
+        const options = {
+            installMessage: ( localizeWithPath(_moduleId, 26, "Install Additional Product Icon Themes...")),
+            browseMessage: '$(plus) ' + ( localizeWithPath(_moduleId, 27, "Browse Additional Product Icon Themes...")),
+            placeholderMessage: ( localizeWithPath(_moduleId, 28, "Select Product Icon Theme (Up/Down Keys to Preview)")),
+            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 picker = instantiationService.createInstance(InstalledThemesPicker, options, setTheme, getMarketplaceColorThemes);
         const picks = [
-            { type: 'separator', label: ( localizeWithPath(_moduleId, 23, 'product icon themes')) },
-            { id: DEFAULT_PRODUCT_ICON_THEME_ID, theme: ProductIconThemeData.defaultTheme, label: ( localizeWithPath(_moduleId, 24, 'Default')) },
+            { type: 'separator', label: ( localizeWithPath(_moduleId, 29, 'product icon themes')) },
+            { id: DEFAULT_PRODUCT_ICON_THEME_ID, theme: ProductIconThemeData.defaultTheme, label: ( localizeWithPath(_moduleId, 30, 'Default')) },
             ...toEntries(await themeService.getProductIconThemes()),
         ];
         await picker.openQuickPick(picks, themeService.getProductIconTheme());
@@ -492,18 +561,14 @@ CommandsRegistry.registerCommand('workbench.action.previewColorTheme', async fun
 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 configurationEntry(label, configureItem) {
+    return {
+        id: undefined,
+        label: label,
+        alwaysShow: true,
+        buttons: [configureButton],
+        configureItem: configureItem
+    };
 }
 function openExtensionViewlet(paneCompositeService, query) {
     return paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , true).then(viewlet => {
@@ -539,13 +604,13 @@ function toEntries(themes, label) {
 }
 const configureButton = {
     iconClass: ThemeIcon.asClassName(manageExtensionIcon),
-    tooltip: ( localizeWithPath(_moduleId, 25, "Manage Extension")),
+    tooltip: ( localizeWithPath(_moduleId, 31, "Manage Extension")),
 };
 registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'workbench.action.generateColorTheme',
-            title: ( localize2WithPath(_moduleId, 26, 'Generate Color Theme From Current Settings')),
+            title: ( localize2WithPath(_moduleId, 32, 'Generate Color Theme From Current Settings')),
             category: Categories.Developer,
             f1: true
         });
@@ -595,7 +660,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: toggleLightDarkThemesCommandId,
-            title: ( localize2WithPath(_moduleId, 27, 'Toggle between Light/Dark Themes')),
+            title: ( localize2WithPath(_moduleId, 33, 'Toggle between Light/Dark Themes')),
             category: Categories.Preferences,
             f1: true,
         });
@@ -603,6 +668,25 @@ registerAction2(class extends Action2 {
     async run(accessor) {
         const themeService = accessor.get(IWorkbenchThemeService);
         const configurationService = accessor.get(IConfigurationService);
+        const notificationService = accessor.get(INotificationService);
+        const preferencesService = accessor.get(IPreferencesService);
+        if (configurationService.getValue(ThemeSettings.DETECT_COLOR_SCHEME)) {
+            const message = ( localizeWithPath(
+                _moduleId,
+                34,
+                "Cannot toggle between light and dark themes when `{0}` is enabled in settings.",
+                ThemeSettings.DETECT_COLOR_SCHEME
+            ));
+            notificationService.prompt(Severity$1.Info, message, [
+                {
+                    label: ( localizeWithPath(_moduleId, 35, "Open Settings")),
+                    run: () => {
+                        return preferencesService.openUserSettings({ query: ThemeSettings.DETECT_COLOR_SCHEME });
+                    }
+                }
+            ]);
+            return;
+        }
         const currentTheme = themeService.getColorTheme();
         let newSettingsId = ThemeSettings.PREFERRED_DARK_THEME;
         switch (currentTheme.type) {
@@ -633,7 +717,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: browseColorThemesInMarketplaceCommandId,
-            title: ( localize2WithPath(_moduleId, 28, 'Browse Color Themes in Marketplace')),
+            title: ( localize2WithPath(_moduleId, 36, 'Browse Color Themes in Marketplace')),
             category: Categories.Preferences,
             f1: true,
         });
@@ -669,13 +753,13 @@ registerAction2(class extends Action2 {
 });
 const ThemesSubMenu = ( (new MenuId('ThemesSubMenu')));
 MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-    title: ( localizeWithPath(_moduleId, 29, "Themes")),
+    title: ( localizeWithPath(_moduleId, 37, "Themes")),
     submenu: ThemesSubMenu,
     group: '2_configuration',
     order: 7
 });
 MenuRegistry.appendMenuItem(MenuId.MenubarPreferencesMenu, {
-    title: ( localizeWithPath(_moduleId, 30, "&&Theme")),
+    title: ( localizeWithPath(_moduleId, 38, "&&Theme")),
     submenu: ThemesSubMenu,
     group: '2_configuration',
     order: 7
@@ -690,14 +774,14 @@ MenuRegistry.appendMenuItem(ThemesSubMenu, {
 MenuRegistry.appendMenuItem(ThemesSubMenu, {
     command: {
         id: SelectFileIconThemeCommandId,
-        title: ( localizeWithPath(_moduleId, 31, "File Icon Theme"))
+        title: ( localizeWithPath(_moduleId, 39, "File Icon Theme"))
     },
     order: 2
 });
 MenuRegistry.appendMenuItem(ThemesSubMenu, {
     command: {
         id: SelectProductIconThemeCommandId,
-        title: ( localizeWithPath(_moduleId, 32, "Product Icon Theme"))
+        title: ( localizeWithPath(_moduleId, 40, "Product Icon Theme"))
     },
     order: 3
 });
@@ -739,20 +823,20 @@ let DefaultThemeUpdatedNotificationContribution = class DefaultThemeUpdatedNotif
         if (newTheme) {
             const choices = [
                 {
-                    label: ( localizeWithPath(_moduleId, 33, "Keep New Theme")),
+                    label: ( localizeWithPath(_moduleId, 41, "Keep New Theme")),
                     run: () => {
                         this._writeTelemetry('keepNew');
                     }
                 },
                 {
-                    label: ( localizeWithPath(_moduleId, 34, "Browse Themes")),
+                    label: ( localizeWithPath(_moduleId, 42, "Browse Themes")),
                     run: () => {
                         this._writeTelemetry('browse');
                         this._commandService.executeCommand(SelectColorThemeCommandId);
                     }
                 },
                 {
-                    label: ( localizeWithPath(_moduleId, 35, "Revert")),
+                    label: ( localizeWithPath(_moduleId, 43, "Revert")),
                     run: async () => {
                         this._writeTelemetry('keepOld');
                         const oldSettingsId = usingLight ? ThemeSettingDefaults.COLOR_THEME_LIGHT_OLD : ThemeSettingDefaults.COLOR_THEME_DARK_OLD;
@@ -765,7 +849,7 @@ let DefaultThemeUpdatedNotificationContribution = class DefaultThemeUpdatedNotif
             ];
             await this._notificationService.prompt(Severity$1.Info, ( localizeWithPath(
                 _moduleId,
-                36,
+                44,
                 "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, {
@@ -778,21 +862,21 @@ let DefaultThemeUpdatedNotificationContribution = class DefaultThemeUpdatedNotif
         const theme = (await this._workbenchThemeService.getColorThemes()).find(theme => theme.settingsId === newThemeSettingsId);
         if (theme) {
             const choices = [{
-                    label: ( localizeWithPath(_moduleId, 37, "Try New Theme")),
+                    label: ( localizeWithPath(_moduleId, 45, "Try New Theme")),
                     run: () => {
                         this._writeTelemetry('tryNew');
                         this._workbenchThemeService.setColorTheme(theme, 'auto');
                     }
                 },
                 {
-                    label: ( localizeWithPath(_moduleId, 38, "Cancel")),
+                    label: ( localizeWithPath(_moduleId, 46, "Cancel")),
                     run: () => {
                         this._writeTelemetry('cancel');
                     }
                 }];
             await this._notificationService.prompt(Severity$1.Info, ( localizeWithPath(
                 _moduleId,
-                39,
+                47,
                 "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') });

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

@@ -49,8 +49,6 @@ import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/langu
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
 
 const _moduleId = "vs/workbench/services/themes/browser/workbenchThemeService";
-const PERSISTED_OS_COLOR_SCHEME = 'osColorScheme';
-const PERSISTED_OS_COLOR_SCHEME_SCOPE = -1 ;
 const defaultThemeExtensionId = 'vscode-theme-defaults';
 const DEFAULT_FILE_ICON_THEME_ID = 'vscode.vscode-theme-seti-vs-seti';
 const fileIconsEnabledClass = 'file-icons-enabled';
@@ -85,7 +83,7 @@ let WorkbenchThemeService = class WorkbenchThemeService extends Disposable {
         this.hasDefaultUpdated = false;
         this.themeExtensionsActivated = ( new Map());
         this.container = layoutService.mainContainer;
-        this.settings = ( new ThemeConfiguration(configurationService));
+        this.settings = ( new ThemeConfiguration(configurationService, hostColorService));
         this.colorThemeRegistry = this._register(( new ThemeRegistry(colorThemesExtPoint, ColorThemeData.fromExtensionTheme)));
         this.colorThemeWatcher = this._register(( new ThemeFileWatcher(fileService, environmentService, this.reloadCurrentColorTheme.bind(this))));
         this.onColorThemeChange = ( new Emitter({ leakWarningThreshold: 400 }));
@@ -126,11 +124,7 @@ let WorkbenchThemeService = class WorkbenchThemeService extends Disposable {
             this.hasDefaultUpdated = themeData.settingsId === ThemeSettingDefaults.COLOR_THEME_DARK_OLD || themeData.settingsId === ThemeSettingDefaults.COLOR_THEME_LIGHT_OLD;
             themeData = undefined;
         }
-        const preferredColorScheme = this.getPreferredColorScheme();
         const defaultColorMap = colorThemeSetting === ThemeSettingDefaults.COLOR_THEME_LIGHT ? COLOR_THEME_LIGHT_INITIAL_COLORS : colorThemeSetting === ThemeSettingDefaults.COLOR_THEME_DARK ? COLOR_THEME_DARK_INITIAL_COLORS : undefined;
-        if (preferredColorScheme && themeData?.type !== preferredColorScheme && this.storageService.get(PERSISTED_OS_COLOR_SCHEME, PERSISTED_OS_COLOR_SCHEME_SCOPE) !== preferredColorScheme) {
-            themeData = ColorThemeData.createUnloadedThemeForThemeType(preferredColorScheme, undefined);
-        }
         if (!themeData) {
             const initialColorTheme = environmentService.options?.initialColorTheme;
             if (initialColorTheme) {
@@ -175,14 +169,6 @@ let WorkbenchThemeService = class WorkbenchThemeService extends Disposable {
                 const matchedColorTheme = devThemes.find(theme => theme.type === this.currentColorTheme.type);
                 return this.setColorTheme(matchedColorTheme ? matchedColorTheme.id : devThemes[0].id, undefined);
             }
-            const preferredColorScheme = this.getPreferredColorScheme();
-            const prevScheme = this.storageService.get(PERSISTED_OS_COLOR_SCHEME, PERSISTED_OS_COLOR_SCHEME_SCOPE);
-            if (preferredColorScheme !== prevScheme) {
-                this.storageService.store(PERSISTED_OS_COLOR_SCHEME, preferredColorScheme, PERSISTED_OS_COLOR_SCHEME_SCOPE, 0 );
-                if (preferredColorScheme && this.currentColorTheme.type !== preferredColorScheme) {
-                    return this.applyPreferredColorTheme(preferredColorScheme);
-                }
-            }
             let theme = this.colorThemeRegistry.findThemeBySettingsId(this.settings.colorTheme, undefined);
             if (!theme) {
                 await this.userDataInitializationService.whenInitializationFinished();
@@ -219,31 +205,16 @@ let WorkbenchThemeService = class WorkbenchThemeService extends Disposable {
     }
     installConfigurationListener() {
         this._register(this.configurationService.onDidChangeConfiguration(e => {
-            let lazyPreferredColorScheme = null;
-            const getPreferredColorScheme = () => {
-                if (lazyPreferredColorScheme === null) {
-                    lazyPreferredColorScheme = this.getPreferredColorScheme();
-                }
-                return lazyPreferredColorScheme;
-            };
-            if (e.affectsConfiguration(ThemeSettings.COLOR_THEME)) {
+            if (e.affectsConfiguration(ThemeSettings.COLOR_THEME)
+                || e.affectsConfiguration(ThemeSettings.PREFERRED_DARK_THEME)
+                || e.affectsConfiguration(ThemeSettings.PREFERRED_LIGHT_THEME)
+                || e.affectsConfiguration(ThemeSettings.PREFERRED_HC_DARK_THEME)
+                || e.affectsConfiguration(ThemeSettings.PREFERRED_HC_LIGHT_THEME)
+                || e.affectsConfiguration(ThemeSettings.DETECT_COLOR_SCHEME)
+                || e.affectsConfiguration(ThemeSettings.DETECT_HC)
+                || e.affectsConfiguration(ThemeSettings.SYSTEM_COLOR_THEME)) {
                 this.restoreColorTheme();
             }
-            if (e.affectsConfiguration(ThemeSettings.DETECT_COLOR_SCHEME) || e.affectsConfiguration(ThemeSettings.DETECT_HC)) {
-                this.handlePreferredSchemeUpdated();
-            }
-            if (e.affectsConfiguration(ThemeSettings.PREFERRED_DARK_THEME) && getPreferredColorScheme() === ColorScheme.DARK) {
-                this.applyPreferredColorTheme(ColorScheme.DARK);
-            }
-            if (e.affectsConfiguration(ThemeSettings.PREFERRED_LIGHT_THEME) && getPreferredColorScheme() === ColorScheme.LIGHT) {
-                this.applyPreferredColorTheme(ColorScheme.LIGHT);
-            }
-            if (e.affectsConfiguration(ThemeSettings.PREFERRED_HC_DARK_THEME) && getPreferredColorScheme() === ColorScheme.HIGH_CONTRAST_DARK) {
-                this.applyPreferredColorTheme(ColorScheme.HIGH_CONTRAST_DARK);
-            }
-            if (e.affectsConfiguration(ThemeSettings.PREFERRED_HC_LIGHT_THEME) && getPreferredColorScheme() === ColorScheme.HIGH_CONTRAST_LIGHT) {
-                this.applyPreferredColorTheme(ColorScheme.HIGH_CONTRAST_LIGHT);
-            }
             if (e.affectsConfiguration(ThemeSettings.FILE_ICON_THEME)) {
                 this.restoreFileIconTheme();
             }
@@ -332,61 +303,7 @@ let WorkbenchThemeService = class WorkbenchThemeService extends Disposable {
         });
     }
     installPreferredSchemeListener() {
-        this._register(this.hostColorService.onDidChangeColorScheme(() => this.handlePreferredSchemeUpdated()));
-    }
-    async handlePreferredSchemeUpdated() {
-        const scheme = this.getPreferredColorScheme();
-        const prevScheme = this.storageService.get(PERSISTED_OS_COLOR_SCHEME, PERSISTED_OS_COLOR_SCHEME_SCOPE);
-        if (scheme !== prevScheme) {
-            this.storageService.store(PERSISTED_OS_COLOR_SCHEME, scheme, PERSISTED_OS_COLOR_SCHEME_SCOPE, 1 );
-            if (scheme) {
-                if (!prevScheme) {
-                    this.themeSettingIdBeforeSchemeSwitch = this.settings.colorTheme;
-                }
-                return this.applyPreferredColorTheme(scheme);
-            }
-            else if (prevScheme && this.themeSettingIdBeforeSchemeSwitch) {
-                const theme = this.colorThemeRegistry.findThemeBySettingsId(this.themeSettingIdBeforeSchemeSwitch, undefined);
-                if (theme) {
-                    this.setColorTheme(theme.id, 'auto');
-                }
-            }
-        }
-        return undefined;
-    }
-    getPreferredColorScheme() {
-        if (this.configurationService.getValue(ThemeSettings.DETECT_HC) && this.hostColorService.highContrast) {
-            return this.hostColorService.dark ? ColorScheme.HIGH_CONTRAST_DARK : ColorScheme.HIGH_CONTRAST_LIGHT;
-        }
-        if (this.configurationService.getValue(ThemeSettings.DETECT_COLOR_SCHEME)) {
-            return this.hostColorService.dark ? ColorScheme.DARK : ColorScheme.LIGHT;
-        }
-        return undefined;
-    }
-    async applyPreferredColorTheme(type) {
-        let settingId;
-        switch (type) {
-            case ColorScheme.LIGHT:
-                settingId = ThemeSettings.PREFERRED_LIGHT_THEME;
-                break;
-            case ColorScheme.HIGH_CONTRAST_DARK:
-                settingId = ThemeSettings.PREFERRED_HC_DARK_THEME;
-                break;
-            case ColorScheme.HIGH_CONTRAST_LIGHT:
-                settingId = ThemeSettings.PREFERRED_HC_LIGHT_THEME;
-                break;
-            default:
-                settingId = ThemeSettings.PREFERRED_DARK_THEME;
-        }
-        const themeSettingId = this.configurationService.getValue(settingId);
-        if (themeSettingId && typeof themeSettingId === 'string') {
-            const theme = this.colorThemeRegistry.findThemeBySettingsId(themeSettingId, undefined);
-            if (theme) {
-                const configurationTarget = this.settings.findAutoConfigurationTarget(settingId);
-                return this.setColorTheme(theme.id, configurationTarget);
-            }
-        }
-        return null;
+        this._register(this.hostColorService.onDidChangeColorScheme(() => this.restoreColorTheme()));
     }
     hasUpdatedDefaultThemes() {
         return this.hasDefaultUpdated;
@@ -397,6 +314,9 @@ let WorkbenchThemeService = class WorkbenchThemeService extends Disposable {
     async getColorThemes() {
         return this.colorThemeRegistry.getThemes();
     }
+    getPreferredColorScheme() {
+        return this.settings.getPreferredColorScheme();
+    }
     async getMarketplaceColorThemes(publisher, name, version) {
         const extensionLocation = this.extensionResourceLoaderService.getExtensionGalleryResourceURL({ publisher, name, version }, 'extension');
         if (extensionLocation) {

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

@@ -15,8 +15,9 @@ import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
 import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
 import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
 import { tokenStylingSchemaId } from 'vscode/vscode/vs/platform/theme/common/tokenClassificationRegistry';
-import { ThemeSettingDefaults, ThemeSettings } from 'vscode/vscode/vs/workbench/services/themes/common/workbenchThemeService';
+import { ThemeSettings, ThemeSettingDefaults } from 'vscode/vscode/vs/workbench/services/themes/common/workbenchThemeService';
 import { isWeb } from 'vscode/vscode/vs/base/common/platform';
+import { ColorScheme } from 'vscode/vscode/vs/platform/theme/common/theme';
 
 const _moduleId = "vs/workbench/services/themes/common/themeConfiguration";
 const configurationRegistry = ( (Registry.as(Extensions.Configuration)));
@@ -26,10 +27,17 @@ const colorThemeSettingEnumDescriptions = [];
 function formatSettingAsLink(str) {
     return `\`#${str}#\``;
 }
+const COLOR_THEME_CONFIGURATION_SETTINGS_TAG = 'colorThemeConfiguration';
 const colorThemeSettingSchema = {
     type: 'string',
-    description: ( localizeWithPath(_moduleId, 0, "Specifies the color theme used in the workbench.")),
+    markdownDescription: ( localizeWithPath(
+        _moduleId,
+        0,
+        "Specifies the color theme used in the workbench when {0} is not enabled.",
+        formatSettingAsLink(ThemeSettings.DETECT_COLOR_SCHEME)
+    )),
     default: isWeb ? ThemeSettingDefaults.COLOR_THEME_LIGHT : ThemeSettingDefaults.COLOR_THEME_DARK,
+    tags: [COLOR_THEME_CONFIGURATION_SETTINGS_TAG],
     enum: colorThemeSettingEnum,
     enumDescriptions: colorThemeSettingEnumDescriptions,
     enumItemLabels: colorThemeSettingEnumItemLabels,
@@ -40,10 +48,11 @@ const preferredDarkThemeSettingSchema = {
     markdownDescription: ( localizeWithPath(
         _moduleId,
         2,
-        'Specifies the preferred color theme for dark OS appearance when {0} is enabled.',
+        'Specifies the color theme when system color mode is dark and {0} is enabled.',
         formatSettingAsLink(ThemeSettings.DETECT_COLOR_SCHEME)
     )),
     default: ThemeSettingDefaults.COLOR_THEME_DARK,
+    tags: [COLOR_THEME_CONFIGURATION_SETTINGS_TAG],
     enum: colorThemeSettingEnum,
     enumDescriptions: colorThemeSettingEnumDescriptions,
     enumItemLabels: colorThemeSettingEnumItemLabels,
@@ -54,10 +63,11 @@ const preferredLightThemeSettingSchema = {
     markdownDescription: ( localizeWithPath(
         _moduleId,
         3,
-        'Specifies the preferred color theme for light OS appearance when {0} is enabled.',
+        'Specifies the color theme when system color mode is light and {0} is enabled.',
         formatSettingAsLink(ThemeSettings.DETECT_COLOR_SCHEME)
     )),
     default: ThemeSettingDefaults.COLOR_THEME_LIGHT,
+    tags: [COLOR_THEME_CONFIGURATION_SETTINGS_TAG],
     enum: colorThemeSettingEnum,
     enumDescriptions: colorThemeSettingEnumDescriptions,
     enumItemLabels: colorThemeSettingEnumItemLabels,
@@ -68,10 +78,11 @@ const preferredHCDarkThemeSettingSchema = {
     markdownDescription: ( localizeWithPath(
         _moduleId,
         4,
-        'Specifies the preferred color theme used in high contrast dark mode when {0} is enabled.',
+        'Specifies the color theme when in high contrast dark mode and {0} is enabled.',
         formatSettingAsLink(ThemeSettings.DETECT_HC)
     )),
     default: ThemeSettingDefaults.COLOR_THEME_HC_DARK,
+    tags: [COLOR_THEME_CONFIGURATION_SETTINGS_TAG],
     enum: colorThemeSettingEnum,
     enumDescriptions: colorThemeSettingEnumDescriptions,
     enumItemLabels: colorThemeSettingEnumItemLabels,
@@ -82,10 +93,11 @@ const preferredHCLightThemeSettingSchema = {
     markdownDescription: ( localizeWithPath(
         _moduleId,
         5,
-        'Specifies the preferred color theme used in high contrast light mode when {0} is enabled.',
+        'Specifies the color theme when in high contrast light mode and {0} is enabled.',
         formatSettingAsLink(ThemeSettings.DETECT_HC)
     )),
     default: ThemeSettingDefaults.COLOR_THEME_HC_LIGHT,
+    tags: [COLOR_THEME_CONFIGURATION_SETTINGS_TAG],
     enum: colorThemeSettingEnum,
     enumDescriptions: colorThemeSettingEnumDescriptions,
     enumItemLabels: colorThemeSettingEnumItemLabels,
@@ -96,11 +108,12 @@ const detectColorSchemeSettingSchema = {
     markdownDescription: ( localizeWithPath(
         _moduleId,
         6,
-        'If set, automatically switch to the preferred color theme based on the OS appearance. If the OS appearance is dark, the theme specified at {0} is used, for light {1}.',
+        'If enabled, will automatically select a color theme based on the system color mode. If the system color mode is dark, {0} is used, else {1}.',
         formatSettingAsLink(ThemeSettings.PREFERRED_DARK_THEME),
         formatSettingAsLink(ThemeSettings.PREFERRED_LIGHT_THEME)
     )),
-    default: false
+    default: false,
+    tags: [COLOR_THEME_CONFIGURATION_SETTINGS_TAG],
 };
 const colorCustomizationsSchema = {
     type: 'object',
@@ -143,7 +156,8 @@ const detectHCSchemeSettingSchema = {
         formatSettingAsLink(ThemeSettings.PREFERRED_HC_DARK_THEME),
         formatSettingAsLink(ThemeSettings.PREFERRED_HC_LIGHT_THEME)
     )),
-    scope: 1
+    scope: 1 ,
+    tags: [COLOR_THEME_CONFIGURATION_SETTINGS_TAG],
 };
 const themeSettingsConfiguration = {
     id: 'workbench',
@@ -314,12 +328,19 @@ function updateProductIconThemeConfigurationSchemas(themes) {
     productIconThemeSettingSchema.enumDescriptions.splice(1, Number.MAX_VALUE, ...( (themes.map(t => t.description || ''))));
     configurationRegistry.notifyConfigurationSchemaUpdated(themeSettingsConfiguration);
 }
+const colorSchemeToPreferred = {
+    [ColorScheme.DARK]: ThemeSettings.PREFERRED_DARK_THEME,
+    [ColorScheme.LIGHT]: ThemeSettings.PREFERRED_LIGHT_THEME,
+    [ColorScheme.HIGH_CONTRAST_DARK]: ThemeSettings.PREFERRED_HC_DARK_THEME,
+    [ColorScheme.HIGH_CONTRAST_LIGHT]: ThemeSettings.PREFERRED_HC_LIGHT_THEME
+};
 class ThemeConfiguration {
-    constructor(configurationService) {
+    constructor(configurationService, hostColorService) {
         this.configurationService = configurationService;
+        this.hostColorService = hostColorService;
     }
     get colorTheme() {
-        return this.configurationService.getValue(ThemeSettings.COLOR_THEME);
+        return this.configurationService.getValue(this.getColorThemeSettingId());
     }
     get fileIconTheme() {
         return this.configurationService.getValue(ThemeSettings.FILE_ICON_THEME);
@@ -336,8 +357,21 @@ class ThemeConfiguration {
     get semanticTokenColorCustomizations() {
         return this.configurationService.getValue(ThemeSettings.SEMANTIC_TOKEN_COLOR_CUSTOMIZATIONS);
     }
+    getPreferredColorScheme() {
+        if (this.configurationService.getValue(ThemeSettings.DETECT_HC) && this.hostColorService.highContrast) {
+            return this.hostColorService.dark ? ColorScheme.HIGH_CONTRAST_DARK : ColorScheme.HIGH_CONTRAST_LIGHT;
+        }
+        if (this.configurationService.getValue(ThemeSettings.DETECT_COLOR_SCHEME)) {
+            return this.hostColorService.dark ? ColorScheme.DARK : ColorScheme.LIGHT;
+        }
+        return undefined;
+    }
+    getColorThemeSettingId() {
+        const preferredScheme = this.getPreferredColorScheme();
+        return preferredScheme ? colorSchemeToPreferred[preferredScheme] : ThemeSettings.COLOR_THEME;
+    }
     async setColorTheme(theme, settingsTarget) {
-        await this.writeConfiguration(ThemeSettings.COLOR_THEME, theme.settingsId, settingsTarget);
+        await this.writeConfiguration(this.getColorThemeSettingId(), theme.settingsId, settingsTarget);
         return theme;
     }
     async setFileIconTheme(theme, settingsTarget) {
@@ -349,7 +383,7 @@ class ThemeConfiguration {
         return theme;
     }
     isDefaultColorTheme() {
-        const settings = this.configurationService.inspect(ThemeSettings.COLOR_THEME);
+        const settings = this.configurationService.inspect(this.getColorThemeSettingId());
         return settings && settings.default?.value === settings.value;
     }
     findAutoConfigurationTarget(key) {
@@ -393,4 +427,4 @@ class ThemeConfiguration {
     }
 }
 
-export { ThemeConfiguration, updateColorThemeConfigurationSchemas, updateFileIconThemeConfigurationSchemas, updateProductIconThemeConfigurationSchemas };
+export { COLOR_THEME_CONFIGURATION_SETTINGS_TAG, ThemeConfiguration, formatSettingAsLink, updateColorThemeConfigurationSchemas, updateFileIconThemeConfigurationSchemas, updateProductIconThemeConfigurationSchemas };