@codingame/monaco-vscode-api 2.1.4 → 2.2.0-next.1

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

@@ -0,0 +1,296 @@
+import { localizeWithPath } from '../../../../nls.js';
+import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
+import { getTokenClassificationRegistry, typeAndModifierIdPattern } from '../../../../platform/theme/common/tokenClassificationRegistry.js';
+const tokenClassificationRegistry = getTokenClassificationRegistry();
+const tokenTypeExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'semanticTokenTypes',
+    jsonSchema: {
+        description: ( localizeWithPath(
+            'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+            'contributes.semanticTokenTypes',
+            'Contributes semantic token types.'
+        )),
+        type: 'array',
+        items: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: ( localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenTypes.id',
+                        'The identifier of the semantic token type'
+                    )),
+                    pattern: typeAndModifierIdPattern,
+                    patternErrorMessage: ( localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenTypes.id.format',
+                        'Identifiers should be in the form letterOrDigit[_-letterOrDigit]*'
+                    )),
+                },
+                superType: {
+                    type: 'string',
+                    description: ( localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenTypes.superType',
+                        'The super type of the semantic token type'
+                    )),
+                    pattern: typeAndModifierIdPattern,
+                    patternErrorMessage: ( localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenTypes.superType.format',
+                        'Super types should be in the form letterOrDigit[_-letterOrDigit]*'
+                    )),
+                },
+                description: {
+                    type: 'string',
+                    description: ( localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.color.description',
+                        'The description of the semantic token type'
+                    )),
+                }
+            }
+        }
+    }
+}));
+const tokenModifierExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'semanticTokenModifiers',
+    jsonSchema: {
+        description: ( localizeWithPath(
+            'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+            'contributes.semanticTokenModifiers',
+            'Contributes semantic token modifiers.'
+        )),
+        type: 'array',
+        items: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: ( localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenModifiers.id',
+                        'The identifier of the semantic token modifier'
+                    )),
+                    pattern: typeAndModifierIdPattern,
+                    patternErrorMessage: ( localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenModifiers.id.format',
+                        'Identifiers should be in the form letterOrDigit[_-letterOrDigit]*'
+                    ))
+                },
+                description: {
+                    type: 'string',
+                    description: ( localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenModifiers.description',
+                        'The description of the semantic token modifier'
+                    ))
+                }
+            }
+        }
+    }
+}));
+const tokenStyleDefaultsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'semanticTokenScopes',
+    jsonSchema: {
+        description: ( localizeWithPath(
+            'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+            'contributes.semanticTokenScopes',
+            'Contributes semantic token scope maps.'
+        )),
+        type: 'array',
+        items: {
+            type: 'object',
+            properties: {
+                language: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenScopes.languages',
+                        'Lists the languge for which the defaults are.'
+                    )),
+                    type: 'string'
+                },
+                scopes: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenScopes.scopes',
+                        'Maps a semantic token (described by semantic token selector) to one or more textMate scopes used to represent that token.'
+                    )),
+                    type: 'object',
+                    additionalProperties: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    }
+                }
+            }
+        }
+    }
+}));
+class TokenClassificationExtensionPoints {
+    constructor() {
+        function validateTypeOrModifier(contribution, extensionPoint, collector) {
+            if (typeof contribution.id !== 'string' || contribution.id.length === 0) {
+                collector.error(( localizeWithPath(
+                    'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                    'invalid.id',
+                    "'configuration.{0}.id' must be defined and can not be empty",
+                    extensionPoint
+                )));
+                return false;
+            }
+            if (!contribution.id.match(typeAndModifierIdPattern)) {
+                collector.error(( localizeWithPath(
+                    'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                    'invalid.id.format',
+                    "'configuration.{0}.id' must follow the pattern letterOrDigit[-_letterOrDigit]*",
+                    extensionPoint
+                )));
+                return false;
+            }
+            const superType = contribution.superType;
+            if (superType && !superType.match(typeAndModifierIdPattern)) {
+                collector.error(( localizeWithPath(
+                    'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                    'invalid.superType.format',
+                    "'configuration.{0}.superType' must follow the pattern letterOrDigit[-_letterOrDigit]*",
+                    extensionPoint
+                )));
+                return false;
+            }
+            if (typeof contribution.description !== 'string' || contribution.id.length === 0) {
+                collector.error(( localizeWithPath(
+                    'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                    'invalid.description',
+                    "'configuration.{0}.description' must be defined and can not be empty",
+                    extensionPoint
+                )));
+                return false;
+            }
+            return true;
+        }
+        tokenTypeExtPoint.setHandler((extensions, delta) => {
+            for (const extension of delta.added) {
+                const extensionValue = extension.value;
+                const collector = extension.collector;
+                if (!extensionValue || !Array.isArray(extensionValue)) {
+                    collector.error(( localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'invalid.semanticTokenTypeConfiguration',
+                        "'configuration.semanticTokenType' must be an array"
+                    )));
+                    return;
+                }
+                for (const contribution of extensionValue) {
+                    if (validateTypeOrModifier(contribution, 'semanticTokenType', collector)) {
+                        tokenClassificationRegistry.registerTokenType(contribution.id, contribution.description, contribution.superType);
+                    }
+                }
+            }
+            for (const extension of delta.removed) {
+                const extensionValue = extension.value;
+                for (const contribution of extensionValue) {
+                    tokenClassificationRegistry.deregisterTokenType(contribution.id);
+                }
+            }
+        });
+        tokenModifierExtPoint.setHandler((extensions, delta) => {
+            for (const extension of delta.added) {
+                const extensionValue = extension.value;
+                const collector = extension.collector;
+                if (!extensionValue || !Array.isArray(extensionValue)) {
+                    collector.error(( localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'invalid.semanticTokenModifierConfiguration',
+                        "'configuration.semanticTokenModifier' must be an array"
+                    )));
+                    return;
+                }
+                for (const contribution of extensionValue) {
+                    if (validateTypeOrModifier(contribution, 'semanticTokenModifier', collector)) {
+                        tokenClassificationRegistry.registerTokenModifier(contribution.id, contribution.description);
+                    }
+                }
+            }
+            for (const extension of delta.removed) {
+                const extensionValue = extension.value;
+                for (const contribution of extensionValue) {
+                    tokenClassificationRegistry.deregisterTokenModifier(contribution.id);
+                }
+            }
+        });
+        tokenStyleDefaultsExtPoint.setHandler((extensions, delta) => {
+            for (const extension of delta.added) {
+                const extensionValue = extension.value;
+                const collector = extension.collector;
+                if (!extensionValue || !Array.isArray(extensionValue)) {
+                    collector.error(( localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'invalid.semanticTokenScopes.configuration',
+                        "'configuration.semanticTokenScopes' must be an array"
+                    )));
+                    return;
+                }
+                for (const contribution of extensionValue) {
+                    if (contribution.language && typeof contribution.language !== 'string') {
+                        collector.error(( localizeWithPath(
+                            'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                            'invalid.semanticTokenScopes.language',
+                            "'configuration.semanticTokenScopes.language' must be a string"
+                        )));
+                        continue;
+                    }
+                    if (!contribution.scopes || typeof contribution.scopes !== 'object') {
+                        collector.error(( localizeWithPath(
+                            'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                            'invalid.semanticTokenScopes.scopes',
+                            "'configuration.semanticTokenScopes.scopes' must be defined as an object"
+                        )));
+                        continue;
+                    }
+                    for (const selectorString in contribution.scopes) {
+                        const tmScopes = contribution.scopes[selectorString];
+                        if (!Array.isArray(tmScopes) || ( tmScopes.some(l => typeof l !== 'string'))) {
+                            collector.error(( localizeWithPath(
+                                'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                                'invalid.semanticTokenScopes.scopes.value',
+                                "'configuration.semanticTokenScopes.scopes' values must be an array of strings"
+                            )));
+                            continue;
+                        }
+                        try {
+                            const selector = tokenClassificationRegistry.parseTokenSelector(selectorString, contribution.language);
+                            tokenClassificationRegistry.registerTokenStyleDefault(selector, { scopesToProbe: ( tmScopes.map(s => s.split(' '))) });
+                        }
+                        catch (e) {
+                            collector.error(( localizeWithPath(
+                                'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                                'invalid.semanticTokenScopes.scopes.selector',
+                                "configuration.semanticTokenScopes.scopes': Problems parsing selector {0}.",
+                                selectorString
+                            )));
+                        }
+                    }
+                }
+            }
+            for (const extension of delta.removed) {
+                const extensionValue = extension.value;
+                for (const contribution of extensionValue) {
+                    for (const selectorString in contribution.scopes) {
+                        const tmScopes = contribution.scopes[selectorString];
+                        try {
+                            const selector = tokenClassificationRegistry.parseTokenSelector(selectorString, contribution.language);
+                            tokenClassificationRegistry.registerTokenStyleDefault(selector, { scopesToProbe: ( tmScopes.map(s => s.split(' '))) });
+                        }
+                        catch (e) {
+                        }
+                    }
+                }
+            }
+        });
+    }
+}
+export { TokenClassificationExtensionPoints };

package/vscode/src/vs/workbench/services/untitled/common/untitledTextEditorHandler.js

@@ -0,0 +1,99 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { URI } from '../../../../base/common/uri.js';
+import { ITextEditorService } from '../../textfile/common/textEditorService.js';
+import { toLocalResource, isEqual } from '../../../../base/common/resources.js';
+import { PLAINTEXT_LANGUAGE_ID } from '../../../../editor/common/languages/modesRegistry.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { IFilesConfigurationService } from '../../filesConfiguration/common/filesConfigurationService.js';
+import { IPathService } from '../../path/common/pathService.js';
+import { UntitledTextEditorInput } from './untitledTextEditorInput.js';
+import { NO_TYPE_ID } from '../../workingCopy/common/workingCopy.js';
+import { IWorkingCopyEditorService } from '../../workingCopy/common/workingCopyEditorService.js';
+import { IUntitledTextEditorService } from './untitledTextEditorService.js';
+let UntitledTextEditorInputSerializer = class UntitledTextEditorInputSerializer {
+    constructor(filesConfigurationService, environmentService, pathService) {
+        this.filesConfigurationService = filesConfigurationService;
+        this.environmentService = environmentService;
+        this.pathService = pathService;
+    }
+    canSerialize(editorInput) {
+        return this.filesConfigurationService.isHotExitEnabled && !editorInput.isDisposed();
+    }
+    serialize(editorInput) {
+        if (!this.filesConfigurationService.isHotExitEnabled || editorInput.isDisposed()) {
+            return undefined;
+        }
+        const untitledTextEditorInput = editorInput;
+        let resource = untitledTextEditorInput.resource;
+        if (untitledTextEditorInput.hasAssociatedFilePath) {
+            resource = toLocalResource(resource, this.environmentService.remoteAuthority, this.pathService.defaultUriScheme);
+        }
+        let languageId;
+        const languageIdCandidate = untitledTextEditorInput.getLanguageId();
+        if (languageIdCandidate !== PLAINTEXT_LANGUAGE_ID) {
+            languageId = languageIdCandidate;
+        }
+        else if (untitledTextEditorInput.hasLanguageSetExplicitly) {
+            languageId = languageIdCandidate;
+        }
+        const serialized = {
+            resourceJSON: resource.toJSON(),
+            modeId: languageId,
+            encoding: untitledTextEditorInput.getEncoding()
+        };
+        return JSON.stringify(serialized);
+    }
+    deserialize(instantiationService, serializedEditorInput) {
+        return instantiationService.invokeFunction(accessor => {
+            const deserialized = JSON.parse(serializedEditorInput);
+            const resource = URI.revive(deserialized.resourceJSON);
+            const languageId = deserialized.modeId;
+            const encoding = deserialized.encoding;
+            return accessor.get(ITextEditorService).createTextEditor({ resource, languageId, encoding, forceUntitled: true });
+        });
+    }
+};
+UntitledTextEditorInputSerializer = ( __decorate([
+    ( __param(0, IFilesConfigurationService)),
+    ( __param(1, IWorkbenchEnvironmentService)),
+    ( __param(2, IPathService))
+], UntitledTextEditorInputSerializer));
+let UntitledTextEditorWorkingCopyEditorHandler = class UntitledTextEditorWorkingCopyEditorHandler extends Disposable {
+    constructor(workingCopyEditorService, environmentService, pathService, textEditorService, untitledTextEditorService) {
+        super();
+        this.environmentService = environmentService;
+        this.pathService = pathService;
+        this.textEditorService = textEditorService;
+        this.untitledTextEditorService = untitledTextEditorService;
+        this._register(workingCopyEditorService.registerHandler(this));
+    }
+    handles(workingCopy) {
+        return workingCopy.resource.scheme === Schemas.untitled && workingCopy.typeId === NO_TYPE_ID;
+    }
+    isOpen(workingCopy, editor) {
+        if (!this.handles(workingCopy)) {
+            return false;
+        }
+        return editor instanceof UntitledTextEditorInput && isEqual(workingCopy.resource, editor.resource);
+    }
+    createEditor(workingCopy) {
+        let editorInputResource;
+        if (this.untitledTextEditorService.isUntitledWithAssociatedResource(workingCopy.resource)) {
+            editorInputResource = toLocalResource(workingCopy.resource, this.environmentService.remoteAuthority, this.pathService.defaultUriScheme);
+        }
+        else {
+            editorInputResource = workingCopy.resource;
+        }
+        return this.textEditorService.createTextEditor({ resource: editorInputResource, forceUntitled: true });
+    }
+};
+UntitledTextEditorWorkingCopyEditorHandler = ( __decorate([
+    ( __param(0, IWorkingCopyEditorService)),
+    ( __param(1, IWorkbenchEnvironmentService)),
+    ( __param(2, IPathService)),
+    ( __param(3, ITextEditorService)),
+    ( __param(4, IUntitledTextEditorService))
+], UntitledTextEditorWorkingCopyEditorHandler));
+export { UntitledTextEditorInputSerializer, UntitledTextEditorWorkingCopyEditorHandler };