@codingame/monaco-vscode-api 1.78.4-next.3 → 1.78.5-next.0

package/dist/vscode/vs/workbench/services/themes/common/colorThemeSchema.js

@@ -0,0 +1,265 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
+import { workbenchColorsSchemaId } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { tokenStylingSchemaId } from '../../../../platform/theme/common/tokenClassificationRegistry.js';
+const textMateScopes = [
+    'comment',
+    'comment.block',
+    'comment.block.documentation',
+    'comment.line',
+    'constant',
+    'constant.character',
+    'constant.character.escape',
+    'constant.numeric',
+    'constant.numeric.integer',
+    'constant.numeric.float',
+    'constant.numeric.hex',
+    'constant.numeric.octal',
+    'constant.other',
+    'constant.regexp',
+    'constant.rgb-value',
+    'emphasis',
+    'entity',
+    'entity.name',
+    'entity.name.class',
+    'entity.name.function',
+    'entity.name.method',
+    'entity.name.section',
+    'entity.name.selector',
+    'entity.name.tag',
+    'entity.name.type',
+    'entity.other',
+    'entity.other.attribute-name',
+    'entity.other.inherited-class',
+    'invalid',
+    'invalid.deprecated',
+    'invalid.illegal',
+    'keyword',
+    'keyword.control',
+    'keyword.operator',
+    'keyword.operator.new',
+    'keyword.operator.assignment',
+    'keyword.operator.arithmetic',
+    'keyword.operator.logical',
+    'keyword.other',
+    'markup',
+    'markup.bold',
+    'markup.changed',
+    'markup.deleted',
+    'markup.heading',
+    'markup.inline.raw',
+    'markup.inserted',
+    'markup.italic',
+    'markup.list',
+    'markup.list.numbered',
+    'markup.list.unnumbered',
+    'markup.other',
+    'markup.quote',
+    'markup.raw',
+    'markup.underline',
+    'markup.underline.link',
+    'meta',
+    'meta.block',
+    'meta.cast',
+    'meta.class',
+    'meta.function',
+    'meta.function-call',
+    'meta.preprocessor',
+    'meta.return-type',
+    'meta.selector',
+    'meta.tag',
+    'meta.type.annotation',
+    'meta.type',
+    'punctuation.definition.string.begin',
+    'punctuation.definition.string.end',
+    'punctuation.separator',
+    'punctuation.separator.continuation',
+    'punctuation.terminator',
+    'storage',
+    'storage.modifier',
+    'storage.type',
+    'string',
+    'string.interpolated',
+    'string.other',
+    'string.quoted',
+    'string.quoted.double',
+    'string.quoted.other',
+    'string.quoted.single',
+    'string.quoted.triple',
+    'string.regexp',
+    'string.unquoted',
+    'strong',
+    'support',
+    'support.class',
+    'support.constant',
+    'support.function',
+    'support.other',
+    'support.type',
+    'support.type.property-name',
+    'support.variable',
+    'variable',
+    'variable.language',
+    'variable.name',
+    'variable.other',
+    'variable.other.readwrite',
+    'variable.parameter'
+];
+const textmateColorsSchemaId = 'vscode://schemas/textmate-colors';
+const textmateColorGroupSchemaId = `${textmateColorsSchemaId}#/definitions/colorGroup`;
+const textmateColorSchema = {
+    type: 'array',
+    definitions: {
+        colorGroup: {
+            default: '#FF0000',
+            anyOf: [
+                {
+                    type: 'string',
+                    format: 'color-hex'
+                },
+                {
+                    $ref: '#/definitions/settings'
+                }
+            ]
+        },
+        settings: {
+            type: 'object',
+            description: ( nls.localize('schema.token.settings', 'Colors and styles for the token.')),
+            properties: {
+                foreground: {
+                    type: 'string',
+                    description: ( nls.localize('schema.token.foreground', 'Foreground color for the token.')),
+                    format: 'color-hex',
+                    default: '#ff0000'
+                },
+                background: {
+                    type: 'string',
+                    deprecationMessage: ( nls.localize(
+                        'schema.token.background.warning',
+                        'Token background colors are currently not supported.'
+                    ))
+                },
+                fontStyle: {
+                    type: 'string',
+                    description: ( nls.localize(
+                        'schema.token.fontStyle',
+                        'Font style of the rule: \'italic\', \'bold\', \'underline\', \'strikethrough\' or a combination. The empty string unsets inherited settings.'
+                    )),
+                    pattern: '^(\\s*\\b(italic|bold|underline|strikethrough))*\\s*$',
+                    patternErrorMessage: ( nls.localize(
+                        'schema.fontStyle.error',
+                        'Font style must be \'italic\', \'bold\', \'underline\', \'strikethrough\' or a combination or the empty string.'
+                    )),
+                    defaultSnippets: [
+                        { label: ( nls.localize('schema.token.fontStyle.none', 'None (clear inherited style)')), bodyText: '""' },
+                        { body: 'italic' },
+                        { body: 'bold' },
+                        { body: 'underline' },
+                        { body: 'strikethrough' },
+                        { body: 'italic bold' },
+                        { body: 'italic underline' },
+                        { body: 'italic strikethrough' },
+                        { body: 'bold underline' },
+                        { body: 'bold strikethrough' },
+                        { body: 'underline strikethrough' },
+                        { body: 'italic bold underline' },
+                        { body: 'italic bold strikethrough' },
+                        { body: 'italic underline strikethrough' },
+                        { body: 'bold underline strikethrough' },
+                        { body: 'italic bold underline strikethrough' }
+                    ]
+                }
+            },
+            additionalProperties: false,
+            defaultSnippets: [{ body: { foreground: '${1:#FF0000}', fontStyle: '${2:bold}' } }]
+        }
+    },
+    items: {
+        type: 'object',
+        defaultSnippets: [{ body: { scope: '${1:keyword.operator}', settings: { foreground: '${2:#FF0000}' } } }],
+        properties: {
+            name: {
+                type: 'string',
+                description: ( nls.localize('schema.properties.name', 'Description of the rule.'))
+            },
+            scope: {
+                description: ( nls.localize(
+                    'schema.properties.scope',
+                    'Scope selector against which this rule matches.'
+                )),
+                anyOf: [
+                    {
+                        enum: textMateScopes
+                    },
+                    {
+                        type: 'string'
+                    },
+                    {
+                        type: 'array',
+                        items: {
+                            enum: textMateScopes
+                        }
+                    },
+                    {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    }
+                ]
+            },
+            settings: {
+                $ref: '#/definitions/settings'
+            }
+        },
+        required: [
+            'settings'
+        ],
+        additionalProperties: false
+    }
+};
+const colorThemeSchemaId = 'vscode://schemas/color-theme';
+const colorThemeSchema = {
+    type: 'object',
+    allowComments: true,
+    allowTrailingCommas: true,
+    properties: {
+        colors: {
+            description: ( nls.localize('schema.workbenchColors', 'Colors in the workbench')),
+            $ref: workbenchColorsSchemaId,
+            additionalProperties: false
+        },
+        tokenColors: {
+            anyOf: [{
+                    type: 'string',
+                    description: ( nls.localize(
+                        'schema.tokenColors.path',
+                        'Path to a tmTheme file (relative to the current file).'
+                    ))
+                },
+                {
+                    description: ( nls.localize('schema.colors', 'Colors for syntax highlighting')),
+                    $ref: textmateColorsSchemaId
+                }
+            ]
+        },
+        semanticHighlighting: {
+            type: 'boolean',
+            description: ( nls.localize(
+                'schema.supportsSemanticHighlighting',
+                'Whether semantic highlighting should be enabled for this theme.'
+            ))
+        },
+        semanticTokenColors: {
+            type: 'object',
+            description: ( nls.localize('schema.semanticTokenColors', 'Colors for semantic tokens')),
+            $ref: tokenStylingSchemaId
+        }
+    }
+};
+function registerColorThemeSchemas() {
+    const schemaRegistry = ( Registry.as(Extensions.JSONContribution));
+    schemaRegistry.registerSchema(colorThemeSchemaId, colorThemeSchema);
+    schemaRegistry.registerSchema(textmateColorsSchemaId, textmateColorSchema);
+}
+export { colorThemeSchemaId, registerColorThemeSchemas, textmateColorGroupSchemaId, textmateColorsSchemaId };

package/dist/vscode/vs/workbench/services/themes/common/fileIconThemeSchema.js

@@ -0,0 +1,303 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
+import { fontIdRegex, fontWeightRegex, fontStyleRegex, fontSizeRegex } from './productIconThemeSchema.js';
+const schemaId = 'vscode://schemas/icon-theme';
+const schema = {
+    type: 'object',
+    allowComments: true,
+    allowTrailingCommas: true,
+    definitions: {
+        folderExpanded: {
+            type: 'string',
+            description: ( nls.localize(
+                'schema.folderExpanded',
+                'The folder icon for expanded folders. The expanded folder icon is optional. If not set, the icon defined for folder will be shown.'
+            ))
+        },
+        folder: {
+            type: 'string',
+            description: ( nls.localize(
+                'schema.folder',
+                'The folder icon for collapsed folders, and if folderExpanded is not set, also for expanded folders.'
+            ))
+        },
+        file: {
+            type: 'string',
+            description: ( nls.localize(
+                'schema.file',
+                'The default file icon, shown for all files that don\'t match any extension, filename or language id.'
+            ))
+        },
+        folderNames: {
+            type: 'object',
+            description: ( nls.localize(
+                'schema.folderNames',
+                'Associates folder names to icons. The object key is the folder name, not including any path segments. No patterns or wildcards are allowed. Folder name matching is case insensitive.'
+            )),
+            additionalProperties: {
+                type: 'string',
+                description: ( nls.localize('schema.folderName', 'The ID of the icon definition for the association.'))
+            }
+        },
+        folderNamesExpanded: {
+            type: 'object',
+            description: ( nls.localize(
+                'schema.folderNamesExpanded',
+                'Associates folder names to icons for expanded folders. The object key is the folder name, not including any path segments. No patterns or wildcards are allowed. Folder name matching is case insensitive.'
+            )),
+            additionalProperties: {
+                type: 'string',
+                description: ( nls.localize(
+                    'schema.folderNameExpanded',
+                    'The ID of the icon definition for the association.'
+                ))
+            }
+        },
+        fileExtensions: {
+            type: 'object',
+            description: ( nls.localize(
+                'schema.fileExtensions',
+                'Associates file extensions to icons. The object key is the file extension name. The extension name is the last segment of a file name after the last dot (not including the dot). Extensions are compared case insensitive.'
+            )),
+            additionalProperties: {
+                type: 'string',
+                description: ( nls.localize(
+                    'schema.fileExtension',
+                    'The ID of the icon definition for the association.'
+                ))
+            }
+        },
+        fileNames: {
+            type: 'object',
+            description: ( nls.localize(
+                'schema.fileNames',
+                'Associates file names to icons. The object key is the full file name, but not including any path segments. File name can include dots and a possible file extension. No patterns or wildcards are allowed. File name matching is case insensitive.'
+            )),
+            additionalProperties: {
+                type: 'string',
+                description: ( nls.localize('schema.fileName', 'The ID of the icon definition for the association.'))
+            }
+        },
+        languageIds: {
+            type: 'object',
+            description: ( nls.localize(
+                'schema.languageIds',
+                'Associates languages to icons. The object key is the language id as defined in the language contribution point.'
+            )),
+            additionalProperties: {
+                type: 'string',
+                description: ( nls.localize('schema.languageId', 'The ID of the icon definition for the association.'))
+            }
+        },
+        associations: {
+            type: 'object',
+            properties: {
+                folderExpanded: {
+                    $ref: '#/definitions/folderExpanded'
+                },
+                folder: {
+                    $ref: '#/definitions/folder'
+                },
+                file: {
+                    $ref: '#/definitions/file'
+                },
+                folderNames: {
+                    $ref: '#/definitions/folderNames'
+                },
+                folderNamesExpanded: {
+                    $ref: '#/definitions/folderNamesExpanded'
+                },
+                fileExtensions: {
+                    $ref: '#/definitions/fileExtensions'
+                },
+                fileNames: {
+                    $ref: '#/definitions/fileNames'
+                },
+                languageIds: {
+                    $ref: '#/definitions/languageIds'
+                }
+            }
+        }
+    },
+    properties: {
+        fonts: {
+            type: 'array',
+            description: ( nls.localize('schema.fonts', 'Fonts that are used in the icon definitions.')),
+            items: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'string',
+                        description: ( nls.localize('schema.id', 'The ID of the font.')),
+                        pattern: fontIdRegex,
+                        patternErrorMessage: ( nls.localize(
+                            'schema.id.formatError',
+                            'The ID must only contain letter, numbers, underscore and minus.'
+                        ))
+                    },
+                    src: {
+                        type: 'array',
+                        description: ( nls.localize('schema.src', 'The location of the font.')),
+                        items: {
+                            type: 'object',
+                            properties: {
+                                path: {
+                                    type: 'string',
+                                    description: ( nls.localize(
+                                        'schema.font-path',
+                                        'The font path, relative to the current file icon theme file.'
+                                    )),
+                                },
+                                format: {
+                                    type: 'string',
+                                    description: ( nls.localize('schema.font-format', 'The format of the font.')),
+                                    enum: ['woff', 'woff2', 'truetype', 'opentype', 'embedded-opentype', 'svg']
+                                }
+                            },
+                            required: [
+                                'path',
+                                'format'
+                            ]
+                        }
+                    },
+                    weight: {
+                        type: 'string',
+                        description: ( nls.localize(
+                            'schema.font-weight',
+                            'The weight of the font. See https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight for valid values.'
+                        )),
+                        pattern: fontWeightRegex
+                    },
+                    style: {
+                        type: 'string',
+                        description: ( nls.localize(
+                            'schema.font-style',
+                            'The style of the font. See https://developer.mozilla.org/en-US/docs/Web/CSS/font-style for valid values.'
+                        )),
+                        pattern: fontStyleRegex
+                    },
+                    size: {
+                        type: 'string',
+                        description: ( nls.localize(
+                            'schema.font-size',
+                            'The default size of the font. See https://developer.mozilla.org/en-US/docs/Web/CSS/font-size for valid values.'
+                        )),
+                        pattern: fontSizeRegex
+                    }
+                },
+                required: [
+                    'id',
+                    'src'
+                ]
+            }
+        },
+        iconDefinitions: {
+            type: 'object',
+            description: ( nls.localize(
+                'schema.iconDefinitions',
+                'Description of all icons that can be used when associating files to icons.'
+            )),
+            additionalProperties: {
+                type: 'object',
+                description: ( nls.localize(
+                    'schema.iconDefinition',
+                    'An icon definition. The object key is the ID of the definition.'
+                )),
+                properties: {
+                    iconPath: {
+                        type: 'string',
+                        description: ( nls.localize(
+                            'schema.iconPath',
+                            'When using a SVG or PNG: The path to the image. The path is relative to the icon set file.'
+                        ))
+                    },
+                    fontCharacter: {
+                        type: 'string',
+                        description: ( nls.localize(
+                            'schema.fontCharacter',
+                            'When using a glyph font: The character in the font to use.'
+                        ))
+                    },
+                    fontColor: {
+                        type: 'string',
+                        format: 'color-hex',
+                        description: ( nls.localize('schema.fontColor', 'When using a glyph font: The color to use.'))
+                    },
+                    fontSize: {
+                        type: 'string',
+                        description: ( nls.localize(
+                            'schema.fontSize',
+                            'When using a font: The font size in percentage to the text font. If not set, defaults to the size in the font definition.'
+                        )),
+                        pattern: fontSizeRegex
+                    },
+                    fontId: {
+                        type: 'string',
+                        description: ( nls.localize(
+                            'schema.fontId',
+                            'When using a font: The id of the font. If not set, defaults to the first font definition.'
+                        ))
+                    }
+                }
+            }
+        },
+        folderExpanded: {
+            $ref: '#/definitions/folderExpanded'
+        },
+        folder: {
+            $ref: '#/definitions/folder'
+        },
+        file: {
+            $ref: '#/definitions/file'
+        },
+        folderNames: {
+            $ref: '#/definitions/folderNames'
+        },
+        folderNamesExpanded: {
+            $ref: '#/definitions/folderNamesExpanded'
+        },
+        fileExtensions: {
+            $ref: '#/definitions/fileExtensions'
+        },
+        fileNames: {
+            $ref: '#/definitions/fileNames'
+        },
+        languageIds: {
+            $ref: '#/definitions/languageIds'
+        },
+        light: {
+            $ref: '#/definitions/associations',
+            description: ( nls.localize(
+                'schema.light',
+                'Optional associations for file icons in light color themes.'
+            ))
+        },
+        highContrast: {
+            $ref: '#/definitions/associations',
+            description: ( nls.localize(
+                'schema.highContrast',
+                'Optional associations for file icons in high contrast color themes.'
+            ))
+        },
+        hidesExplorerArrows: {
+            type: 'boolean',
+            description: ( nls.localize(
+                'schema.hidesExplorerArrows',
+                'Configures whether the file explorer\'s arrows should be hidden when this theme is active.'
+            ))
+        },
+        showLanguageModeIcons: {
+            type: 'boolean',
+            description: ( nls.localize(
+                'schema.showLanguageModeIcons',
+                'Configures whether the default language icons should be used if the theme does not define an icon for a language.'
+            ))
+        }
+    }
+};
+function registerFileIconThemeSchemas() {
+    const schemaRegistry = ( Registry.as(Extensions.JSONContribution));
+    schemaRegistry.registerSchema(schemaId, schema);
+}
+export { registerFileIconThemeSchemas };

package/dist/vscode/vs/workbench/services/themes/common/hostColorSchemeService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IHostColorSchemeService = ( createDecorator('hostColorSchemeService'));
+export { IHostColorSchemeService };