@codingame/monaco-vscode-theme-service-override 1.82.4 → 1.82.5-next.1

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

@@ -0,0 +1,68 @@
+import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
+import * as colors from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import * as editorColorRegistry from 'monaco-editor/esm/vs/editor/common/core/editorColorRegistry.js';
+
+const settingToColorIdMapping = {};
+function addSettingMapping(settingId, colorId) {
+    let colorIds = settingToColorIdMapping[settingId];
+    if (!colorIds) {
+        settingToColorIdMapping[settingId] = colorIds = [];
+    }
+    colorIds.push(colorId);
+}
+function convertSettings(oldSettings, result) {
+    for (const rule of oldSettings) {
+        result.textMateRules.push(rule);
+        if (!rule.scope) {
+            const settings = rule.settings;
+            if (!settings) {
+                rule.settings = {};
+            }
+            else {
+                for (const settingKey in settings) {
+                    const key = settingKey;
+                    const mappings = settingToColorIdMapping[key];
+                    if (mappings) {
+                        const colorHex = settings[key];
+                        if (typeof colorHex === 'string') {
+                            const color = ( Color.fromHex(colorHex));
+                            for (const colorId of mappings) {
+                                result.colors[colorId] = color;
+                            }
+                        }
+                    }
+                    if (key !== 'foreground' && key !== 'background' && key !== 'fontStyle') {
+                        delete settings[key];
+                    }
+                }
+            }
+        }
+    }
+}
+addSettingMapping('background', colors.editorBackground);
+addSettingMapping('foreground', colors.editorForeground);
+addSettingMapping('selection', colors.editorSelectionBackground);
+addSettingMapping('inactiveSelection', colors.editorInactiveSelection);
+addSettingMapping('selectionHighlightColor', colors.editorSelectionHighlight);
+addSettingMapping('findMatchHighlight', colors.editorFindMatchHighlight);
+addSettingMapping('currentFindMatchHighlight', colors.editorFindMatch);
+addSettingMapping('hoverHighlight', colors.editorHoverHighlight);
+addSettingMapping('wordHighlight', 'editor.wordHighlightBackground');
+addSettingMapping('wordHighlightStrong', 'editor.wordHighlightStrongBackground');
+addSettingMapping('findRangeHighlight', colors.editorFindRangeHighlight);
+addSettingMapping('findMatchHighlight', 'peekViewResult.matchHighlightBackground');
+addSettingMapping('referenceHighlight', 'peekViewEditor.matchHighlightBackground');
+addSettingMapping('lineHighlight', editorColorRegistry.editorLineHighlight);
+addSettingMapping('rangeHighlight', editorColorRegistry.editorRangeHighlight);
+addSettingMapping('caret', editorColorRegistry.editorCursorForeground);
+addSettingMapping('invisibles', editorColorRegistry.editorWhitespaces);
+addSettingMapping('guide', editorColorRegistry.editorIndentGuide1);
+addSettingMapping('activeGuide', editorColorRegistry.editorActiveIndentGuide1);
+const ansiColorMap = ['ansiBlack', 'ansiRed', 'ansiGreen', 'ansiYellow', 'ansiBlue', 'ansiMagenta', 'ansiCyan', 'ansiWhite',
+    'ansiBrightBlack', 'ansiBrightRed', 'ansiBrightGreen', 'ansiBrightYellow', 'ansiBrightBlue', 'ansiBrightMagenta', 'ansiBrightCyan', 'ansiBrightWhite'
+];
+for (const color of ansiColorMap) {
+    addSettingMapping(color, 'terminal.' + color);
+}
+
+export { convertSettings };

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

@@ -0,0 +1,374 @@
+import * as nls from 'monaco-editor/esm/vs/nls.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';
+import { workbenchColorsSchemaId } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { tokenStylingSchemaId } from 'vscode/vscode/vs/platform/theme/common/tokenClassificationRegistry';
+import { ThemeSettingDefaults, ThemeSettings } from 'vscode/vscode/vs/workbench/services/themes/common/workbenchThemeService';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+const colorThemeSettingEnum = [];
+const colorThemeSettingEnumItemLabels = [];
+const colorThemeSettingEnumDescriptions = [];
+function formatSettingAsLink(str) {
+    return `\`#${str}#\``;
+}
+const colorThemeSettingSchema = {
+    type: 'string',
+    description: ( nls.localize('colorTheme', "Specifies the color theme used in the workbench.")),
+    default: isWeb ? ThemeSettingDefaults.COLOR_THEME_LIGHT : ThemeSettingDefaults.COLOR_THEME_DARK,
+    enum: colorThemeSettingEnum,
+    enumDescriptions: colorThemeSettingEnumDescriptions,
+    enumItemLabels: colorThemeSettingEnumItemLabels,
+    errorMessage: ( nls.localize('colorThemeError', "Theme is unknown or not installed.")),
+};
+const preferredDarkThemeSettingSchema = {
+    type: 'string',
+    markdownDescription: ( nls.localize(
+        { key: 'preferredDarkColorTheme', comment: ['{0} will become a link to another setting.'] },
+        'Specifies the preferred color theme for dark OS appearance when {0} is enabled.',
+        formatSettingAsLink(ThemeSettings.DETECT_COLOR_SCHEME)
+    )),
+    default: ThemeSettingDefaults.COLOR_THEME_DARK,
+    enum: colorThemeSettingEnum,
+    enumDescriptions: colorThemeSettingEnumDescriptions,
+    enumItemLabels: colorThemeSettingEnumItemLabels,
+    errorMessage: ( nls.localize('colorThemeError', "Theme is unknown or not installed.")),
+};
+const preferredLightThemeSettingSchema = {
+    type: 'string',
+    markdownDescription: ( nls.localize(
+        { key: 'preferredLightColorTheme', comment: ['{0} will become a link to another setting.'] },
+        'Specifies the preferred color theme for light OS appearance when {0} is enabled.',
+        formatSettingAsLink(ThemeSettings.DETECT_COLOR_SCHEME)
+    )),
+    default: ThemeSettingDefaults.COLOR_THEME_LIGHT,
+    enum: colorThemeSettingEnum,
+    enumDescriptions: colorThemeSettingEnumDescriptions,
+    enumItemLabels: colorThemeSettingEnumItemLabels,
+    errorMessage: ( nls.localize('colorThemeError', "Theme is unknown or not installed.")),
+};
+const preferredHCDarkThemeSettingSchema = {
+    type: 'string',
+    markdownDescription: ( nls.localize(
+        { key: 'preferredHCDarkColorTheme', comment: ['{0} will become a link to another setting.'] },
+        'Specifies the preferred color theme used in high contrast dark mode when {0} is enabled.',
+        formatSettingAsLink(ThemeSettings.DETECT_HC)
+    )),
+    default: ThemeSettingDefaults.COLOR_THEME_HC_DARK,
+    enum: colorThemeSettingEnum,
+    enumDescriptions: colorThemeSettingEnumDescriptions,
+    enumItemLabels: colorThemeSettingEnumItemLabels,
+    errorMessage: ( nls.localize('colorThemeError', "Theme is unknown or not installed.")),
+};
+const preferredHCLightThemeSettingSchema = {
+    type: 'string',
+    markdownDescription: ( nls.localize(
+        { key: 'preferredHCLightColorTheme', comment: ['{0} will become a link to another setting.'] },
+        'Specifies the preferred color theme used in high contrast light mode when {0} is enabled.',
+        formatSettingAsLink(ThemeSettings.DETECT_HC)
+    )),
+    default: ThemeSettingDefaults.COLOR_THEME_HC_LIGHT,
+    enum: colorThemeSettingEnum,
+    enumDescriptions: colorThemeSettingEnumDescriptions,
+    enumItemLabels: colorThemeSettingEnumItemLabels,
+    errorMessage: ( nls.localize('colorThemeError', "Theme is unknown or not installed.")),
+};
+const detectColorSchemeSettingSchema = {
+    type: 'boolean',
+    markdownDescription: ( nls.localize(
+        { key: 'detectColorScheme', comment: ['{0} and {1} will become links to other settings.'] },
+        '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}.',
+        formatSettingAsLink(ThemeSettings.PREFERRED_DARK_THEME),
+        formatSettingAsLink(ThemeSettings.PREFERRED_LIGHT_THEME)
+    )),
+    default: false
+};
+const colorCustomizationsSchema = {
+    type: 'object',
+    description: ( nls.localize(
+        'workbenchColors',
+        "Overrides colors from the currently selected color theme."
+    )),
+    allOf: [{ $ref: workbenchColorsSchemaId }],
+    default: {},
+    defaultSnippets: [{
+            body: {}
+        }]
+};
+const fileIconThemeSettingSchema = {
+    type: ['string', 'null'],
+    default: ThemeSettingDefaults.FILE_ICON_THEME,
+    description: ( nls.localize(
+        'iconTheme',
+        "Specifies the file icon theme used in the workbench or 'null' to not show any file icons."
+    )),
+    enum: [null],
+    enumItemLabels: [( nls.localize('noIconThemeLabel', 'None'))],
+    enumDescriptions: [( nls.localize('noIconThemeDesc', 'No file icons'))],
+    errorMessage: ( nls.localize('iconThemeError', "File icon theme is unknown or not installed."))
+};
+const productIconThemeSettingSchema = {
+    type: ['string', 'null'],
+    default: ThemeSettingDefaults.PRODUCT_ICON_THEME,
+    description: ( nls.localize('productIconTheme', "Specifies the product icon theme used.")),
+    enum: [ThemeSettingDefaults.PRODUCT_ICON_THEME],
+    enumItemLabels: [( nls.localize('defaultProductIconThemeLabel', 'Default'))],
+    enumDescriptions: [( nls.localize('defaultProductIconThemeDesc', 'Default'))],
+    errorMessage: ( nls.localize('productIconThemeError', "Product icon theme is unknown or not installed."))
+};
+const detectHCSchemeSettingSchema = {
+    type: 'boolean',
+    default: true,
+    markdownDescription: ( nls.localize(
+        { key: 'autoDetectHighContrast', comment: ['{0} and {1} will become links to other settings.'] },
+        "If enabled, will automatically change to high contrast theme if the OS is using a high contrast theme. The high contrast theme to use is specified by {0} and {1}",
+        formatSettingAsLink(ThemeSettings.PREFERRED_HC_DARK_THEME),
+        formatSettingAsLink(ThemeSettings.PREFERRED_HC_LIGHT_THEME)
+    )),
+    scope: 1
+};
+const themeSettingsConfiguration = {
+    id: 'workbench',
+    order: 7.1,
+    type: 'object',
+    properties: {
+        [ThemeSettings.COLOR_THEME]: colorThemeSettingSchema,
+        [ThemeSettings.PREFERRED_DARK_THEME]: preferredDarkThemeSettingSchema,
+        [ThemeSettings.PREFERRED_LIGHT_THEME]: preferredLightThemeSettingSchema,
+        [ThemeSettings.PREFERRED_HC_DARK_THEME]: preferredHCDarkThemeSettingSchema,
+        [ThemeSettings.PREFERRED_HC_LIGHT_THEME]: preferredHCLightThemeSettingSchema,
+        [ThemeSettings.FILE_ICON_THEME]: fileIconThemeSettingSchema,
+        [ThemeSettings.COLOR_CUSTOMIZATIONS]: colorCustomizationsSchema,
+        [ThemeSettings.PRODUCT_ICON_THEME]: productIconThemeSettingSchema
+    }
+};
+configurationRegistry.registerConfiguration(themeSettingsConfiguration);
+const themeSettingsWindowConfiguration = {
+    id: 'window',
+    order: 8.1,
+    type: 'object',
+    properties: {
+        [ThemeSettings.DETECT_HC]: detectHCSchemeSettingSchema,
+        [ThemeSettings.DETECT_COLOR_SCHEME]: detectColorSchemeSettingSchema,
+    }
+};
+configurationRegistry.registerConfiguration(themeSettingsWindowConfiguration);
+function tokenGroupSettings(description) {
+    return {
+        description,
+        $ref: textmateColorGroupSchemaId
+    };
+}
+const themeSpecificSettingKey = '^\\[[^\\]]*(\\]\\s*\\[[^\\]]*)*\\]$';
+const tokenColorSchema = {
+    type: 'object',
+    properties: {
+        comments: tokenGroupSettings(( nls.localize('editorColors.comments', "Sets the colors and styles for comments"))),
+        strings: tokenGroupSettings(( nls.localize('editorColors.strings', "Sets the colors and styles for strings literals."))),
+        keywords: tokenGroupSettings(( nls.localize('editorColors.keywords', "Sets the colors and styles for keywords."))),
+        numbers: tokenGroupSettings(( nls.localize('editorColors.numbers', "Sets the colors and styles for number literals."))),
+        types: tokenGroupSettings(( nls.localize(
+            'editorColors.types',
+            "Sets the colors and styles for type declarations and references."
+        ))),
+        functions: tokenGroupSettings(( nls.localize(
+            'editorColors.functions',
+            "Sets the colors and styles for functions declarations and references."
+        ))),
+        variables: tokenGroupSettings(( nls.localize(
+            'editorColors.variables',
+            "Sets the colors and styles for variables declarations and references."
+        ))),
+        textMateRules: {
+            description: ( nls.localize(
+                'editorColors.textMateRules',
+                'Sets colors and styles using textmate theming rules (advanced).'
+            )),
+            $ref: textmateColorsSchemaId
+        },
+        semanticHighlighting: {
+            description: ( nls.localize(
+                'editorColors.semanticHighlighting',
+                'Whether semantic highlighting should be enabled for this theme.'
+            )),
+            deprecationMessage: ( nls.localize(
+                'editorColors.semanticHighlighting.deprecationMessage',
+                'Use `enabled` in `editor.semanticTokenColorCustomizations` setting instead.'
+            )),
+            markdownDeprecationMessage: ( nls.localize(
+                { key: 'editorColors.semanticHighlighting.deprecationMessageMarkdown', comment: ['{0} will become a link to another setting.'] },
+                'Use `enabled` in {0} setting instead.',
+                formatSettingAsLink('editor.semanticTokenColorCustomizations')
+            )),
+            type: 'boolean'
+        }
+    },
+    additionalProperties: false
+};
+const tokenColorCustomizationSchema = {
+    description: ( nls.localize(
+        'editorColors',
+        "Overrides editor syntax colors and font style from the currently selected color theme."
+    )),
+    default: {},
+    allOf: [{ ...tokenColorSchema, patternProperties: { '^\\[': {} } }]
+};
+const semanticTokenColorSchema = {
+    type: 'object',
+    properties: {
+        enabled: {
+            type: 'boolean',
+            description: ( nls.localize(
+                'editorColors.semanticHighlighting.enabled',
+                'Whether semantic highlighting is enabled or disabled for this theme'
+            )),
+            suggestSortText: '0_enabled'
+        },
+        rules: {
+            $ref: tokenStylingSchemaId,
+            description: ( nls.localize(
+                'editorColors.semanticHighlighting.rules',
+                'Semantic token styling rules for this theme.'
+            )),
+            suggestSortText: '0_rules'
+        }
+    },
+    additionalProperties: false
+};
+const semanticTokenColorCustomizationSchema = {
+    description: ( nls.localize(
+        'semanticTokenColors',
+        "Overrides editor semantic token color and styles from the currently selected color theme."
+    )),
+    default: {},
+    allOf: [{ ...semanticTokenColorSchema, patternProperties: { '^\\[': {} } }]
+};
+const tokenColorCustomizationConfiguration = {
+    id: 'editor',
+    order: 7.2,
+    type: 'object',
+    properties: {
+        [ThemeSettings.TOKEN_COLOR_CUSTOMIZATIONS]: tokenColorCustomizationSchema,
+        [ThemeSettings.SEMANTIC_TOKEN_COLOR_CUSTOMIZATIONS]: semanticTokenColorCustomizationSchema
+    }
+};
+configurationRegistry.registerConfiguration(tokenColorCustomizationConfiguration);
+function updateColorThemeConfigurationSchemas(themes) {
+    themes.sort((a, b) => a.label.localeCompare(b.label));
+    colorThemeSettingEnum.splice(0, colorThemeSettingEnum.length, ...( themes.map(t => t.settingsId)));
+    colorThemeSettingEnumDescriptions.splice(0, colorThemeSettingEnumDescriptions.length, ...( themes.map(t => t.description || '')));
+    colorThemeSettingEnumItemLabels.splice(0, colorThemeSettingEnumItemLabels.length, ...( themes.map(t => t.label || '')));
+    const themeSpecificWorkbenchColors = { properties: {} };
+    const themeSpecificTokenColors = { properties: {} };
+    const themeSpecificSemanticTokenColors = { properties: {} };
+    const workbenchColors = { $ref: workbenchColorsSchemaId, additionalProperties: false };
+    const tokenColors = { properties: tokenColorSchema.properties, additionalProperties: false };
+    for (const t of themes) {
+        const themeId = `[${t.settingsId}]`;
+        themeSpecificWorkbenchColors.properties[themeId] = workbenchColors;
+        themeSpecificTokenColors.properties[themeId] = tokenColors;
+        themeSpecificSemanticTokenColors.properties[themeId] = semanticTokenColorSchema;
+    }
+    themeSpecificWorkbenchColors.patternProperties = { [themeSpecificSettingKey]: workbenchColors };
+    themeSpecificTokenColors.patternProperties = { [themeSpecificSettingKey]: tokenColors };
+    themeSpecificSemanticTokenColors.patternProperties = { [themeSpecificSettingKey]: semanticTokenColorSchema };
+    colorCustomizationsSchema.allOf[1] = themeSpecificWorkbenchColors;
+    tokenColorCustomizationSchema.allOf[1] = themeSpecificTokenColors;
+    semanticTokenColorCustomizationSchema.allOf[1] = themeSpecificSemanticTokenColors;
+    configurationRegistry.notifyConfigurationSchemaUpdated(themeSettingsConfiguration, tokenColorCustomizationConfiguration);
+}
+function updateFileIconThemeConfigurationSchemas(themes) {
+    fileIconThemeSettingSchema.enum.splice(1, Number.MAX_VALUE, ...( themes.map(t => t.settingsId)));
+    fileIconThemeSettingSchema.enumItemLabels.splice(1, Number.MAX_VALUE, ...( themes.map(t => t.label)));
+    fileIconThemeSettingSchema.enumDescriptions.splice(1, Number.MAX_VALUE, ...( themes.map(t => t.description || '')));
+    configurationRegistry.notifyConfigurationSchemaUpdated(themeSettingsConfiguration);
+}
+function updateProductIconThemeConfigurationSchemas(themes) {
+    productIconThemeSettingSchema.enum.splice(1, Number.MAX_VALUE, ...( themes.map(t => t.settingsId)));
+    productIconThemeSettingSchema.enumItemLabels.splice(1, Number.MAX_VALUE, ...( themes.map(t => t.label)));
+    productIconThemeSettingSchema.enumDescriptions.splice(1, Number.MAX_VALUE, ...( themes.map(t => t.description || '')));
+    configurationRegistry.notifyConfigurationSchemaUpdated(themeSettingsConfiguration);
+}
+class ThemeConfiguration {
+    constructor(configurationService) {
+        this.configurationService = configurationService;
+    }
+    get colorTheme() {
+        return this.configurationService.getValue(ThemeSettings.COLOR_THEME);
+    }
+    get fileIconTheme() {
+        return this.configurationService.getValue(ThemeSettings.FILE_ICON_THEME);
+    }
+    get productIconTheme() {
+        return this.configurationService.getValue(ThemeSettings.PRODUCT_ICON_THEME);
+    }
+    get colorCustomizations() {
+        return this.configurationService.getValue(ThemeSettings.COLOR_CUSTOMIZATIONS) || {};
+    }
+    get tokenColorCustomizations() {
+        return this.configurationService.getValue(ThemeSettings.TOKEN_COLOR_CUSTOMIZATIONS) || {};
+    }
+    get semanticTokenColorCustomizations() {
+        return this.configurationService.getValue(ThemeSettings.SEMANTIC_TOKEN_COLOR_CUSTOMIZATIONS);
+    }
+    async setColorTheme(theme, settingsTarget) {
+        await this.writeConfiguration(ThemeSettings.COLOR_THEME, theme.settingsId, settingsTarget);
+        return theme;
+    }
+    async setFileIconTheme(theme, settingsTarget) {
+        await this.writeConfiguration(ThemeSettings.FILE_ICON_THEME, theme.settingsId, settingsTarget);
+        return theme;
+    }
+    async setProductIconTheme(theme, settingsTarget) {
+        await this.writeConfiguration(ThemeSettings.PRODUCT_ICON_THEME, theme.settingsId, settingsTarget);
+        return theme;
+    }
+    isDefaultColorTheme() {
+        const settings = this.configurationService.inspect(ThemeSettings.COLOR_THEME);
+        return settings && settings.default?.value === settings.value;
+    }
+    findAutoConfigurationTarget(key) {
+        const settings = this.configurationService.inspect(key);
+        if (!types.isUndefined(settings.workspaceFolderValue)) {
+            return 6 ;
+        }
+        else if (!types.isUndefined(settings.workspaceValue)) {
+            return 5 ;
+        }
+        else if (!types.isUndefined(settings.userRemote)) {
+            return 4 ;
+        }
+        return 2 ;
+    }
+    async writeConfiguration(key, value, settingsTarget) {
+        if (settingsTarget === undefined || settingsTarget === 'preview') {
+            return;
+        }
+        const settings = this.configurationService.inspect(key);
+        if (settingsTarget === 'auto') {
+            return this.configurationService.updateValue(key, value);
+        }
+        if (settingsTarget === 2 ) {
+            if (value === settings.userValue) {
+                return Promise.resolve(undefined);
+            }
+            else if (value === settings.defaultValue) {
+                if (types.isUndefined(settings.userValue)) {
+                    return Promise.resolve(undefined);
+                }
+                value = undefined;
+            }
+        }
+        else if (settingsTarget === 5  || settingsTarget === 6  || settingsTarget === 4 ) {
+            if (value === settings.value) {
+                return Promise.resolve(undefined);
+            }
+        }
+        return this.configurationService.updateValue(key, value, settingsTarget);
+    }
+}
+
+export { ThemeConfiguration, updateColorThemeConfigurationSchemas, updateFileIconThemeConfigurationSchemas, updateProductIconThemeConfigurationSchemas };