@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.1

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

@@ -1,66 +0,0 @@
-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

@@ -1,372 +0,0 @@
-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 '../../../../platform/theme/common/tokenClassificationRegistry.js';
-import { ThemeSettings, ThemeSettingDefaults } from './workbenchThemeService.js';
-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 };