monaco-languageclient 2.0.0 → 2.0.1

package/dist/cjs/monaco-converter.js

@@ -0,0 +1,1195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtocolToMonacoConverter = exports.MonacoToProtocolConverter = exports.ProtocolInlayHint = exports.ProtocolCodeAction = exports.ProtocolCompletionItem = exports.ProtocolCodeLens = exports.ProtocolDocumentLink = void 0;
+const tslib_1 = require("tslib");
+const ls = tslib_1.__importStar(require("vscode-languageserver-protocol"));
+const Is = tslib_1.__importStar(require("vscode-languageserver-protocol/lib/common/utils/is"));
+const api_1 = require("vscode-languageserver-protocol/lib/common/api");
+var ProtocolDocumentLink;
+(function (ProtocolDocumentLink) {
+    function is(item) {
+        return !!item && 'data' in item;
+    }
+    ProtocolDocumentLink.is = is;
+})(ProtocolDocumentLink = exports.ProtocolDocumentLink || (exports.ProtocolDocumentLink = {}));
+var ProtocolCodeLens;
+(function (ProtocolCodeLens) {
+    function is(item) {
+        return !!item && 'data' in item;
+    }
+    ProtocolCodeLens.is = is;
+})(ProtocolCodeLens = exports.ProtocolCodeLens || (exports.ProtocolCodeLens = {}));
+var ProtocolCompletionItem;
+(function (ProtocolCompletionItem) {
+    function is(item) {
+        return !!item && 'data' in item;
+    }
+    ProtocolCompletionItem.is = is;
+})(ProtocolCompletionItem = exports.ProtocolCompletionItem || (exports.ProtocolCompletionItem = {}));
+var ProtocolCodeAction;
+(function (ProtocolCodeAction) {
+    function is(item) {
+        return !!item && 'data' in item;
+    }
+    ProtocolCodeAction.is = is;
+})(ProtocolCodeAction = exports.ProtocolCodeAction || (exports.ProtocolCodeAction = {}));
+var ProtocolInlayHint;
+(function (ProtocolInlayHint) {
+    function is(item) {
+        return !!item && 'data' in item;
+    }
+    ProtocolInlayHint.is = is;
+})(ProtocolInlayHint = exports.ProtocolInlayHint || (exports.ProtocolInlayHint = {}));
+function isRangeReplace(v) {
+    return v.insert !== undefined;
+}
+/**
+ * @deprecated use @CodinGame/monaco-vscode-api and vscode-languageclient/lib/common/codeConverter (see browser example)
+ */
+class MonacoToProtocolConverter {
+    constructor(_monaco) {
+        this._monaco = _monaco;
+    }
+    asPosition(lineNumber, column) {
+        const line = lineNumber === undefined || lineNumber === null ? undefined : lineNumber - 1;
+        const character = column === undefined || column === null ? undefined : column - 1;
+        return {
+            line, character
+        };
+    }
+    asRange(range) {
+        if (range === undefined) {
+            return undefined;
+        }
+        if (range === null) {
+            return null;
+        }
+        if (isRangeReplace(range)) {
+            return this.asRange(range.insert);
+        }
+        else {
+            const start = this.asPosition(range.startLineNumber, range.startColumn);
+            const end = this.asPosition(range.endLineNumber, range.endColumn);
+            return {
+                start, end
+            };
+        }
+    }
+    asLocation(item) {
+        if (!item) {
+            return undefined;
+        }
+        const uri = item.uri.toString();
+        const range = this.asRange(item.range);
+        return {
+            uri,
+            range
+        };
+    }
+    asTextDocumentIdentifier(model) {
+        return {
+            uri: model.uri.toString()
+        };
+    }
+    asTextDocumentPositionParams(model, position) {
+        return {
+            textDocument: this.asTextDocumentIdentifier(model),
+            position: this.asPosition(position.lineNumber, position.column)
+        };
+    }
+    asCompletionParams(model, position, context) {
+        return Object.assign(this.asTextDocumentPositionParams(model, position), {
+            context: this.asCompletionContext(context)
+        });
+    }
+    asCompletionContext(context) {
+        return {
+            triggerKind: this.asCompletionTriggerKind(context.triggerKind),
+            triggerCharacter: context.triggerCharacter
+        };
+    }
+    asSignatureHelpContext(context) {
+        return {
+            triggerKind: this.asSignatureHelpTriggerKind(context.triggerKind),
+            triggerCharacter: context.triggerCharacter,
+            isRetrigger: context.isRetrigger,
+            activeSignatureHelp: this.asSignatureHelp(context.activeSignatureHelp)
+        };
+    }
+    asSignatureHelp(signatureHelp) {
+        if (signatureHelp === undefined) {
+            return undefined;
+        }
+        return {
+            signatures: signatureHelp.signatures.map(signatureInfo => this.asSignatureInformation(signatureInfo)),
+            activeParameter: signatureHelp.activeParameter,
+            activeSignature: signatureHelp.activeSignature
+        };
+    }
+    asSignatureInformation(signatureInformation) {
+        return {
+            documentation: this.asMarkupContent(signatureInformation.documentation),
+            label: signatureInformation.label,
+            parameters: signatureInformation.parameters.map(paramInfo => this.asParameterInformation(paramInfo)),
+            activeParameter: signatureInformation.activeParameter
+        };
+    }
+    asParameterInformation(parameterInformation) {
+        return {
+            documentation: this.asMarkupContent(parameterInformation.documentation),
+            label: parameterInformation.label
+        };
+    }
+    asMarkupContent(markupContent) {
+        if (markupContent === undefined) {
+            return undefined;
+        }
+        if (typeof markupContent === 'string') {
+            return markupContent;
+        }
+        return {
+            kind: api_1.MarkupKind.Markdown,
+            value: markupContent.value
+        };
+    }
+    asSignatureHelpTriggerKind(triggerKind) {
+        switch (triggerKind) {
+            case this._monaco.languages.SignatureHelpTriggerKind.ContentChange:
+                return api_1.SignatureHelpTriggerKind.ContentChange;
+            case this._monaco.languages.SignatureHelpTriggerKind.TriggerCharacter:
+                return api_1.SignatureHelpTriggerKind.TriggerCharacter;
+            default:
+                return api_1.SignatureHelpTriggerKind.Invoked;
+        }
+    }
+    asCompletionTriggerKind(triggerKind) {
+        switch (triggerKind) {
+            case this._monaco.languages.CompletionTriggerKind.TriggerCharacter:
+                return api_1.CompletionTriggerKind.TriggerCharacter;
+            case this._monaco.languages.CompletionTriggerKind.TriggerForIncompleteCompletions:
+                return api_1.CompletionTriggerKind.TriggerForIncompleteCompletions;
+            default:
+                return api_1.CompletionTriggerKind.Invoked;
+        }
+    }
+    asCompletionItem(item) {
+        const result = { label: item.label };
+        const protocolItem = ProtocolCompletionItem.is(item) ? item : undefined;
+        if (item.detail) {
+            result.detail = item.detail;
+        }
+        if (item.documentation) {
+            if (typeof item.documentation === 'string') {
+                result.documentation = item.documentation;
+            }
+            else {
+                result.documentation = this.asDocumentation(protocolItem?.documentationFormat ?? api_1.MarkupKind.Markdown, item.documentation);
+            }
+        }
+        if (item.filterText) {
+            result.filterText = item.filterText;
+        }
+        this.fillPrimaryInsertText(result, item);
+        if (Is.number(item.kind)) {
+            result.kind = this.asCompletionItemKind(item.kind, protocolItem && protocolItem.originalItemKind);
+        }
+        if (item.sortText) {
+            result.sortText = item.sortText;
+        }
+        if (item.additionalTextEdits) {
+            result.additionalTextEdits = this.asTextEdits(item.additionalTextEdits);
+        }
+        if (item.command) {
+            result.command = this.asCommand(item.command);
+        }
+        if (item.commitCharacters) {
+            result.commitCharacters = item.commitCharacters.slice();
+        }
+        if (item.command) {
+            result.command = this.asCommand(item.command);
+        }
+        if (item.preselect === true || item.preselect === false) {
+            result.preselect = item.preselect;
+        }
+        if (protocolItem) {
+            if (protocolItem.data !== undefined) {
+                result.data = protocolItem.data;
+            }
+            if (protocolItem.deprecated === true || protocolItem.deprecated === false) {
+                result.deprecated = protocolItem.deprecated;
+            }
+        }
+        if (item.tags) {
+            result.tags = item.tags?.slice();
+        }
+        return result;
+    }
+    asCompletionItemKind(value, original) {
+        if (original !== undefined) {
+            return original;
+        }
+        switch (value) {
+            case this._monaco.languages.CompletionItemKind.Method: return api_1.CompletionItemKind.Method;
+            case this._monaco.languages.CompletionItemKind.Function: return api_1.CompletionItemKind.Function;
+            case this._monaco.languages.CompletionItemKind.Constructor: return api_1.CompletionItemKind.Constructor;
+            case this._monaco.languages.CompletionItemKind.Field: return api_1.CompletionItemKind.Field;
+            case this._monaco.languages.CompletionItemKind.Variable: return api_1.CompletionItemKind.Variable;
+            case this._monaco.languages.CompletionItemKind.Class: return api_1.CompletionItemKind.Class;
+            case this._monaco.languages.CompletionItemKind.Struct: return api_1.CompletionItemKind.Struct;
+            case this._monaco.languages.CompletionItemKind.Interface: return api_1.CompletionItemKind.Interface;
+            case this._monaco.languages.CompletionItemKind.Module: return api_1.CompletionItemKind.Module;
+            case this._monaco.languages.CompletionItemKind.Property: return api_1.CompletionItemKind.Property;
+            case this._monaco.languages.CompletionItemKind.Event: return api_1.CompletionItemKind.Event;
+            case this._monaco.languages.CompletionItemKind.Operator: return api_1.CompletionItemKind.Operator;
+            case this._monaco.languages.CompletionItemKind.Unit: return api_1.CompletionItemKind.Unit;
+            case this._monaco.languages.CompletionItemKind.Value: return api_1.CompletionItemKind.Value;
+            case this._monaco.languages.CompletionItemKind.Constant: return api_1.CompletionItemKind.Constant;
+            case this._monaco.languages.CompletionItemKind.Enum: return api_1.CompletionItemKind.Enum;
+            case this._monaco.languages.CompletionItemKind.EnumMember: return api_1.CompletionItemKind.EnumMember;
+            case this._monaco.languages.CompletionItemKind.Keyword: return api_1.CompletionItemKind.Keyword;
+            case this._monaco.languages.CompletionItemKind.Text: return api_1.CompletionItemKind.Text;
+            case this._monaco.languages.CompletionItemKind.Color: return api_1.CompletionItemKind.Color;
+            case this._monaco.languages.CompletionItemKind.File: return api_1.CompletionItemKind.File;
+            case this._monaco.languages.CompletionItemKind.Reference: return api_1.CompletionItemKind.Reference;
+            case this._monaco.languages.CompletionItemKind.Customcolor: return api_1.CompletionItemKind.Color;
+            case this._monaco.languages.CompletionItemKind.Folder: return api_1.CompletionItemKind.Folder;
+            case this._monaco.languages.CompletionItemKind.TypeParameter: return api_1.CompletionItemKind.TypeParameter;
+            case this._monaco.languages.CompletionItemKind.Snippet: return api_1.CompletionItemKind.Snippet;
+            default: return value + 1;
+        }
+    }
+    asDocumentation(format, documentation) {
+        switch (format) {
+            case api_1.MarkupKind.PlainText:
+                return { kind: format, value: documentation };
+            case api_1.MarkupKind.Markdown:
+                return { kind: format, value: documentation.value };
+            default:
+                return `Unsupported Markup content received. Kind is: ${format}`;
+        }
+    }
+    fillPrimaryInsertText(target, source) {
+        let format = api_1.InsertTextFormat.PlainText;
+        let text;
+        let range;
+        if (source.insertTextRules !== undefined && (source.insertTextRules & this._monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet) === 0) {
+            format = api_1.InsertTextFormat.Snippet;
+            text = source.insertText;
+        }
+        target.insertTextFormat = format;
+        text = source.insertText;
+        if (source.range) {
+            range = this.asRange(source.range);
+        }
+        target.insertTextFormat = format;
+        if (source.fromEdit && text && range) {
+            target.textEdit = { newText: text, range };
+        }
+        else {
+            target.insertText = text;
+        }
+        target.insertTextMode = source.insertTextMode;
+    }
+    asTextEdit(edit) {
+        const range = this.asRange(edit.range);
+        return {
+            range,
+            newText: edit.text || ''
+        };
+    }
+    asTextEdits(items) {
+        if (!items) {
+            return undefined;
+        }
+        return items.map(item => this.asTextEdit(item));
+    }
+    asReferenceParams(model, position, options) {
+        return {
+            textDocument: this.asTextDocumentIdentifier(model),
+            position: this.asPosition(position.lineNumber, position.column),
+            context: { includeDeclaration: options.includeDeclaration }
+        };
+    }
+    asDocumentSymbolParams(model) {
+        return {
+            textDocument: this.asTextDocumentIdentifier(model)
+        };
+    }
+    asCodeLensParams(model) {
+        return {
+            textDocument: this.asTextDocumentIdentifier(model)
+        };
+    }
+    asDiagnosticSeverity(value) {
+        switch (value) {
+            case this._monaco.MarkerSeverity.Error:
+                return api_1.DiagnosticSeverity.Error;
+            case this._monaco.MarkerSeverity.Warning:
+                return api_1.DiagnosticSeverity.Warning;
+            case this._monaco.MarkerSeverity.Info:
+                return api_1.DiagnosticSeverity.Information;
+            case this._monaco.MarkerSeverity.Hint:
+                return api_1.DiagnosticSeverity.Hint;
+        }
+        return undefined;
+    }
+    asDiagnostic(marker) {
+        const range = this.asRange(new this._monaco.Range(marker.startLineNumber, marker.startColumn, marker.endLineNumber, marker.endColumn));
+        const severity = this.asDiagnosticSeverity(marker.severity);
+        const diag = api_1.Diagnostic.create(range, marker.message, severity, marker.code, marker.source);
+        return diag;
+    }
+    asDiagnostics(markers) {
+        if (markers === void 0 || markers === null) {
+            return markers;
+        }
+        return markers.map(marker => this.asDiagnostic(marker));
+    }
+    asCodeActionContext(context, diagnostics) {
+        if (context === void 0 || context === null) {
+            return context;
+        }
+        // FIXME: CodeActionTriggerKind is missing
+        return api_1.CodeActionContext.create(diagnostics, Is.string(context.only) ? [context.only] : undefined, undefined);
+    }
+    asCodeActionParams(model, range, context, diagnostics) {
+        return {
+            textDocument: this.asTextDocumentIdentifier(model),
+            range: this.asRange(range),
+            context: this.asCodeActionContext(context, diagnostics)
+        };
+    }
+    asCommand(item) {
+        if (item) {
+            const args = item.arguments || [];
+            return api_1.Command.create(item.title, item.id, ...args);
+        }
+        return undefined;
+    }
+    asCodeLens(item) {
+        const result = api_1.CodeLens.create(this.asRange(item.range));
+        if (item.command) {
+            result.command = this.asCommand(item.command);
+        }
+        if (ProtocolCodeLens.is(item)) {
+            if (item.data) {
+                result.data = item.data;
+            }
+        }
+        return result;
+    }
+    asFormattingOptions(options) {
+        return { tabSize: options.tabSize, insertSpaces: options.insertSpaces };
+    }
+    asDocumentFormattingParams(model, options) {
+        return {
+            textDocument: this.asTextDocumentIdentifier(model),
+            options: this.asFormattingOptions(options)
+        };
+    }
+    asDocumentRangeFormattingParams(model, range, options) {
+        return {
+            textDocument: this.asTextDocumentIdentifier(model),
+            range: this.asRange(range),
+            options: this.asFormattingOptions(options)
+        };
+    }
+    asDocumentOnTypeFormattingParams(model, position, ch, options) {
+        return {
+            textDocument: this.asTextDocumentIdentifier(model),
+            position: this.asPosition(position.lineNumber, position.column),
+            ch,
+            options: this.asFormattingOptions(options)
+        };
+    }
+    asRenameParams(model, position, newName) {
+        return {
+            textDocument: this.asTextDocumentIdentifier(model),
+            position: this.asPosition(position.lineNumber, position.column),
+            newName
+        };
+    }
+    asDocumentLinkParams(model) {
+        return {
+            textDocument: this.asTextDocumentIdentifier(model)
+        };
+    }
+    asDocumentLink(item) {
+        const result = api_1.DocumentLink.create(this.asRange(item.range));
+        if (item.url) {
+            result.target = typeof item.url === 'string' ? item.url : item.url.toString();
+        }
+        if (ProtocolDocumentLink.is(item) && item.data) {
+            result.data = item.data;
+        }
+        if (item.tooltip) {
+            result.tooltip = item.tooltip;
+        }
+        return result;
+    }
+    asCodeAction(item) {
+        const result = { title: item.title };
+        const protocolCodeAction = ProtocolCodeAction.is(item) ? item : undefined;
+        if (Is.number(item.kind)) {
+            result.kind = item.kind;
+        }
+        if (item.diagnostics) {
+            result.diagnostics = this.asDiagnostics(item.diagnostics);
+        }
+        if (item.edit) {
+            throw new Error('VS Code code actions can only be converted to a protocol code action without an edit.');
+        }
+        if (item.command) {
+            result.command = this.asCommand(item.command);
+        }
+        if (item.isPreferred !== undefined) {
+            result.isPreferred = item.isPreferred;
+        }
+        if (item.disabled) {
+            result.disabled = { reason: item.disabled };
+        }
+        if (protocolCodeAction) {
+            if (protocolCodeAction.data !== undefined) {
+                result.data = protocolCodeAction.data;
+            }
+        }
+        return result;
+    }
+    asInlayHintLabelPart(part) {
+        return {
+            value: part.label,
+            command: this.asCommand(part.command),
+            location: this.asLocation(part.location),
+            tooltip: this.asMarkupContent(part.tooltip)
+        };
+    }
+    asInlayHintLabel(label) {
+        if (Array.isArray(label)) {
+            return label.map(part => this.asInlayHintLabelPart(part));
+        }
+        return label;
+    }
+    asInlayHint(item) {
+        const result = api_1.InlayHint.create(this.asPosition(item.position.lineNumber, item.position.column), this.asInlayHintLabel(item.label), item.kind);
+        if (ProtocolInlayHint.is(item)) {
+            if (item.data) {
+                result.data = item.data;
+            }
+        }
+        return result;
+    }
+}
+exports.MonacoToProtocolConverter = MonacoToProtocolConverter;
+/**
+ * @deprecated use @CodinGame/monaco-vscode-api and vscode-languageclient/lib/common/protocolConverter (see browser example)
+ */
+class ProtocolToMonacoConverter {
+    constructor(_monaco) {
+        this._monaco = _monaco;
+    }
+    asResourceEdits(resource, edits, asMetadata, modelVersionId) {
+        return edits.map(edit => ({
+            resource,
+            edit: this.asTextEdit(edit),
+            modelVersionId,
+            metadata: api_1.AnnotatedTextEdit.is(edit) ? asMetadata(edit.annotationId) : undefined
+        }));
+    }
+    asWorkspaceEditMetadata(changeAnnotation) {
+        return {
+            needsConfirmation: changeAnnotation.needsConfirmation === true,
+            label: changeAnnotation.label,
+            description: changeAnnotation.description
+        };
+    }
+    asWorkspaceEdit(item) {
+        if (!item) {
+            return undefined;
+        }
+        const sharedMetadata = new Map();
+        if (item.changeAnnotations !== undefined) {
+            for (const key of Object.keys(item.changeAnnotations)) {
+                const metaData = this.asWorkspaceEditMetadata(item.changeAnnotations[key]);
+                sharedMetadata.set(key, metaData);
+            }
+        }
+        const asMetadata = (annotation) => {
+            if (annotation === undefined) {
+                return undefined;
+            }
+            else {
+                return sharedMetadata.get(annotation);
+            }
+        };
+        const edits = [];
+        if (item.documentChanges) {
+            item.documentChanges.forEach(change => {
+                if (ls.CreateFile.is(change)) {
+                    edits.push({
+                        newUri: this._monaco.Uri.parse(change.uri),
+                        options: change.options,
+                        metadata: asMetadata(change.annotationId)
+                    });
+                }
+                else if (ls.RenameFile.is(change)) {
+                    edits.push({
+                        oldUri: this._monaco.Uri.parse(change.oldUri),
+                        newUri: this._monaco.Uri.parse(change.newUri),
+                        options: change.options,
+                        metadata: asMetadata(change.annotationId)
+                    });
+                }
+                else if (ls.DeleteFile.is(change)) {
+                    edits.push({
+                        oldUri: this._monaco.Uri.parse(change.uri),
+                        options: change.options,
+                        metadata: asMetadata(change.annotationId)
+                    });
+                }
+                else if (ls.TextDocumentEdit.is(change)) {
+                    const resource = this._monaco.Uri.parse(change.textDocument.uri);
+                    const version = typeof change.textDocument.version === 'number' ? change.textDocument.version : undefined;
+                    edits.push(...this.asResourceEdits(resource, change.edits, asMetadata, version));
+                }
+                else {
+                    console.error(`Unknown workspace edit change received:\n${JSON.stringify(change, undefined, 4)}`);
+                }
+            });
+        }
+        else if (item.changes) {
+            for (const key of Object.keys(item.changes)) {
+                const resource = this._monaco.Uri.parse(key);
+                edits.push(...this.asResourceEdits(resource, item.changes[key], asMetadata));
+            }
+        }
+        return {
+            edits
+        };
+    }
+    asTextEdit(edit) {
+        if (!edit) {
+            return undefined;
+        }
+        const range = this.asRange(edit.range);
+        return {
+            range,
+            text: edit.newText
+        };
+    }
+    asTextEdits(items) {
+        if (!items) {
+            return undefined;
+        }
+        return items.map(item => this.asTextEdit(item));
+    }
+    asCodeLens(item) {
+        if (!item) {
+            return undefined;
+        }
+        const range = this.asRange(item.range);
+        const result = { range };
+        if (item.command) {
+            result.command = this.asCommand(item.command);
+        }
+        if (item.data !== void 0 && item.data !== null) {
+            result.data = item.data;
+        }
+        return result;
+    }
+    asCodeLensList(items) {
+        if (!items) {
+            return undefined;
+        }
+        return {
+            lenses: items.map((codeLens) => this.asCodeLens(codeLens)),
+            dispose: () => { }
+        };
+    }
+    asCodeActionList(actions) {
+        return {
+            actions: actions.map(action => this.asCodeAction(action)),
+            dispose: () => { }
+        };
+    }
+    asCodeAction(item) {
+        if (api_1.Command.is(item)) {
+            return {
+                command: {
+                    id: item.command,
+                    title: item.title,
+                    arguments: item.arguments
+                },
+                title: item.title
+            };
+        }
+        return {
+            title: item.title,
+            command: this.asCommand(item.command),
+            edit: this.asWorkspaceEdit(item.edit),
+            diagnostics: this.asDiagnostics(item.diagnostics),
+            kind: item.kind,
+            disabled: item.disabled ? item.disabled.reason : undefined,
+            isPreferred: item.isPreferred,
+            data: item.data
+        };
+    }
+    asCommand(command) {
+        if (!command) {
+            return undefined;
+        }
+        return {
+            id: command.command,
+            title: command.title,
+            arguments: command.arguments
+        };
+    }
+    asDocumentSymbol(value) {
+        const children = value.children && value.children.map(c => this.asDocumentSymbol(c));
+        return {
+            name: value.name,
+            detail: value.detail || '',
+            kind: this.asSymbolKind(value.kind),
+            tags: value.tags || [],
+            range: this.asRange(value.range),
+            selectionRange: this.asRange(value.selectionRange),
+            children
+        };
+    }
+    asDocumentSymbols(values) {
+        if (api_1.DocumentSymbol.is(values[0])) {
+            return values.map(s => this.asDocumentSymbol(s));
+        }
+        return this.asSymbolInformations(values);
+    }
+    asSymbolInformations(values, uri) {
+        if (!values) {
+            return undefined;
+        }
+        return values.map(information => this.asSymbolInformation(information, uri));
+    }
+    asSymbolInformation(item, uri) {
+        const location = this.asLocation(uri ? { ...item.location, uri: uri.toString() } : item.location);
+        return {
+            name: item.name,
+            detail: '',
+            containerName: item.containerName,
+            kind: this.asSymbolKind(item.kind),
+            tags: item.tags || [],
+            range: location.range,
+            selectionRange: location.range
+        };
+    }
+    asSymbolKind(item) {
+        if (item <= api_1.SymbolKind.TypeParameter) {
+            // Symbol kind is one based in the protocol and zero based in code.
+            return item - 1;
+        }
+        return this._monaco.languages.SymbolKind.Property;
+    }
+    asDocumentHighlights(values) {
+        if (!values) {
+            return undefined;
+        }
+        return values.map(item => this.asDocumentHighlight(item));
+    }
+    asDocumentHighlight(item) {
+        const range = this.asRange(item.range);
+        const kind = Is.number(item.kind) ? this.asDocumentHighlightKind(item.kind) : undefined;
+        return { range, kind };
+    }
+    asDocumentHighlightKind(item) {
+        switch (item) {
+            case api_1.DocumentHighlightKind.Text:
+                return this._monaco.languages.DocumentHighlightKind.Text;
+            case api_1.DocumentHighlightKind.Read:
+                return this._monaco.languages.DocumentHighlightKind.Read;
+            case api_1.DocumentHighlightKind.Write:
+                return this._monaco.languages.DocumentHighlightKind.Write;
+        }
+        return this._monaco.languages.DocumentHighlightKind.Text;
+    }
+    asReferences(values) {
+        if (!values) {
+            return undefined;
+        }
+        return values.map(location => this.asLocation(location));
+    }
+    asDefinitionResult(item) {
+        if (!item) {
+            return undefined;
+        }
+        if (Is.array(item)) {
+            if (item.length === 0) {
+                return undefined;
+            }
+            else if (api_1.LocationLink.is(item[0])) {
+                const links = item;
+                return links.map((location) => this.asLocationLink(location));
+            }
+            else {
+                const locations = item;
+                return locations.map((location) => this.asLocation(location));
+            }
+        }
+        else {
+            return this.asLocation(item);
+        }
+    }
+    asLocation(item) {
+        if (!item) {
+            return undefined;
+        }
+        const uri = this._monaco.Uri.parse(item.uri);
+        const range = this.asRange(item.range);
+        return {
+            uri, range
+        };
+    }
+    asLocationLink(item) {
+        if (!item) {
+            return undefined;
+        }
+        const result = {
+            uri: this._monaco.Uri.parse(item.targetUri),
+            range: this.asRange(item.targetSelectionRange),
+            originSelectionRange: this.asRange(item.originSelectionRange),
+            targetSelectionRange: this.asRange(item.targetSelectionRange)
+        };
+        if (!result.targetSelectionRange) {
+            throw new Error('targetSelectionRange must not be undefined or null');
+        }
+        return result;
+    }
+    asSignatureHelpResult(item) {
+        if (!item) {
+            return undefined;
+        }
+        const result = {};
+        if (Is.number(item.activeSignature)) {
+            result.activeSignature = item.activeSignature;
+        }
+        else {
+            // activeSignature was optional in the past
+            result.activeSignature = 0;
+        }
+        if (Is.number(item.activeParameter)) {
+            result.activeParameter = item.activeParameter;
+        }
+        else {
+            // activeParameter was optional in the past
+            result.activeParameter = 0;
+        }
+        if (item.signatures) {
+            result.signatures = this.asSignatureInformations(item.signatures);
+        }
+        else {
+            result.signatures = [];
+        }
+        return {
+            value: result,
+            dispose: () => { }
+        };
+    }
+    asSignatureInformations(items) {
+        return items.map(item => this.asSignatureInformation(item));
+    }
+    asSignatureInformation(item) {
+        const result = { label: item.label };
+        if (item.documentation) {
+            result.documentation = this.asDocumentation(item.documentation);
+        }
+        if (item.parameters) {
+            result.parameters = this.asParameterInformations(item.parameters);
+        }
+        else {
+            result.parameters = [];
+        }
+        if (item.activeParameter) {
+            result.activeParameter = item.activeParameter;
+        }
+        return result;
+    }
+    asParameterInformations(item) {
+        return item.map(item => this.asParameterInformation(item));
+    }
+    asParameterInformation(item) {
+        const result = { label: item.label };
+        if (item.documentation) {
+            result.documentation = this.asDocumentation(item.documentation);
+        }
+        return result;
+    }
+    asHover(hover) {
+        if (!hover) {
+            return undefined;
+        }
+        return {
+            contents: this.asHoverContent(hover.contents),
+            range: this.asRange(hover.range)
+        };
+    }
+    asHoverContent(contents) {
+        if (Array.isArray(contents)) {
+            return contents.map(content => this.asMarkdownString(content));
+        }
+        return [this.asMarkdownString(contents)];
+    }
+    asDocumentation(value) {
+        if (Is.string(value)) {
+            return value;
+        }
+        if (value.kind === api_1.MarkupKind.PlainText) {
+            return value.value;
+        }
+        return this.asMarkdownString(value);
+    }
+    asMarkdownString(content) {
+        if (api_1.MarkupContent.is(content)) {
+            return {
+                value: content.value
+            };
+        }
+        if (Is.string(content)) {
+            return { value: content };
+        }
+        const { language, value } = content;
+        return {
+            value: '```' + language + '\n' + value + '\n```'
+        };
+    }
+    asSeverity(severity) {
+        if (severity === 1) {
+            return this._monaco.MarkerSeverity.Error;
+        }
+        if (severity === 2) {
+            return this._monaco.MarkerSeverity.Warning;
+        }
+        if (severity === 3) {
+            return this._monaco.MarkerSeverity.Info;
+        }
+        return this._monaco.MarkerSeverity.Hint;
+    }
+    asDiagnostics(diagnostics) {
+        if (!diagnostics) {
+            return undefined;
+        }
+        return diagnostics.map(diagnostic => this.asDiagnostic(diagnostic));
+    }
+    asDiagnostic(diagnostic) {
+        return {
+            code: typeof diagnostic.code === 'number' ? diagnostic.code.toString() : diagnostic.code,
+            severity: this.asSeverity(diagnostic.severity),
+            message: diagnostic.message,
+            source: diagnostic.source,
+            startLineNumber: diagnostic.range.start.line + 1,
+            startColumn: diagnostic.range.start.character + 1,
+            endLineNumber: diagnostic.range.end.line + 1,
+            endColumn: diagnostic.range.end.character + 1,
+            relatedInformation: this.asRelatedInformations(diagnostic.relatedInformation),
+            tags: diagnostic.tags
+        };
+    }
+    asRelatedInformations(relatedInformation) {
+        if (!relatedInformation) {
+            return undefined;
+        }
+        return relatedInformation.map(item => this.asRelatedInformation(item));
+    }
+    asRelatedInformation(relatedInformation) {
+        return {
+            resource: this._monaco.Uri.parse(relatedInformation.location.uri),
+            startLineNumber: relatedInformation.location.range.start.line + 1,
+            startColumn: relatedInformation.location.range.start.character + 1,
+            endLineNumber: relatedInformation.location.range.end.line + 1,
+            endColumn: relatedInformation.location.range.end.character + 1,
+            message: relatedInformation.message
+        };
+    }
+    asCompletionResult(result, defaultMonacoRange) {
+        if (!result) {
+            return {
+                incomplete: false,
+                suggestions: []
+            };
+        }
+        if (Array.isArray(result)) {
+            const suggestions = result.map(item => this.asCompletionItem(item, defaultMonacoRange, defaultRange));
+            return {
+                incomplete: false,
+                suggestions
+            };
+        }
+        const defaultRange = this.getCompletionItemDefaultRange(result);
+        return {
+            incomplete: result.isIncomplete,
+            suggestions: result.items.map(item => this.asCompletionItem(item, defaultMonacoRange, defaultRange, result.itemDefaults))
+        };
+    }
+    asCompletionItem(item, defaultMonacoRange, defaultRange, itemDefaults) {
+        const result = { label: this.asCompletionItemLabel(item) };
+        if (item.detail) {
+            result.detail = item.detail;
+        }
+        if (item.documentation) {
+            result.documentation = this.asDocumentation(item.documentation);
+            result.documentationFormat = Is.string(item.documentation) ? undefined : item.documentation.kind;
+        }
+        if (item.filterText) {
+            result.filterText = item.filterText;
+        }
+        const insertText = this.asCompletionInsertText(item, defaultRange, itemDefaults?.insertTextFormat);
+        result.insertText = insertText.insertText;
+        result.range = insertText.range ?? defaultMonacoRange;
+        result.fromEdit = insertText.fromEdit;
+        if (insertText.isSnippet) {
+            result.insertTextRules = this._monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+        }
+        if (Is.number(item.kind)) {
+            const [itemKind, original] = this.asCompletionItemKind(item.kind);
+            result.kind = itemKind;
+            if (original) {
+                result.originalItemKind = original;
+            }
+        }
+        if (item.sortText) {
+            result.sortText = item.sortText;
+        }
+        if (item.additionalTextEdits) {
+            result.additionalTextEdits = this.asTextEdits(item.additionalTextEdits);
+        }
+        if (Is.stringArray(item.commitCharacters)) {
+            result.commitCharacters = item.commitCharacters.slice();
+        }
+        if (item.command) {
+            result.command = this.asCommand(item.command);
+        }
+        if (item.deprecated === true || item.deprecated === false) {
+            result.deprecated = item.deprecated;
+        }
+        if (item.preselect === true || item.preselect === false) {
+            result.preselect = item.preselect;
+        }
+        const data = item.data ?? itemDefaults?.data;
+        if (data !== undefined) {
+            result.data = data;
+        }
+        if (item.deprecated === true || item.deprecated === false) {
+            result.deprecated = item.deprecated;
+        }
+        const insertTextMode = item.insertTextMode ?? itemDefaults?.insertTextMode;
+        if (insertTextMode) {
+            result.insertTextMode = insertTextMode;
+        }
+        if (item.tags) {
+            result.tags = item.tags;
+        }
+        return result;
+    }
+    getCompletionItemDefaultRange(list) {
+        const rangeDefaults = list.itemDefaults?.editRange;
+        return ls.Range.is(rangeDefaults)
+            ? this.asRange(rangeDefaults)
+            : rangeDefaults !== undefined
+                ? { insert: this.asRange(rangeDefaults.insert), replace: this.asRange(rangeDefaults.replace) }
+                : undefined;
+    }
+    asCompletionItemLabel(item) {
+        if (ls.CompletionItemLabelDetails.is(item.labelDetails)) {
+            return {
+                label: item.label,
+                detail: item.labelDetails.detail,
+                description: item.labelDetails.description
+            };
+        }
+        else {
+            return item.label;
+        }
+    }
+    asCompletionItemKind(value) {
+        if (api_1.CompletionItemKind.Text <= value && value <= api_1.CompletionItemKind.TypeParameter) {
+            switch (value) {
+                case api_1.CompletionItemKind.Text: return [this._monaco.languages.CompletionItemKind.Text, undefined];
+                case api_1.CompletionItemKind.Method: return [this._monaco.languages.CompletionItemKind.Method, undefined];
+                case api_1.CompletionItemKind.Function: return [this._monaco.languages.CompletionItemKind.Function, undefined];
+                case api_1.CompletionItemKind.Constructor: return [this._monaco.languages.CompletionItemKind.Constructor, undefined];
+                case api_1.CompletionItemKind.Field: return [this._monaco.languages.CompletionItemKind.Field, undefined];
+                case api_1.CompletionItemKind.Variable: return [this._monaco.languages.CompletionItemKind.Variable, undefined];
+                case api_1.CompletionItemKind.Class: return [this._monaco.languages.CompletionItemKind.Class, undefined];
+                case api_1.CompletionItemKind.Interface: return [this._monaco.languages.CompletionItemKind.Interface, undefined];
+                case api_1.CompletionItemKind.Module: return [this._monaco.languages.CompletionItemKind.Module, undefined];
+                case api_1.CompletionItemKind.Property: return [this._monaco.languages.CompletionItemKind.Property, undefined];
+                case api_1.CompletionItemKind.Unit: return [this._monaco.languages.CompletionItemKind.Unit, undefined];
+                case api_1.CompletionItemKind.Value: return [this._monaco.languages.CompletionItemKind.Value, undefined];
+                case api_1.CompletionItemKind.Enum: return [this._monaco.languages.CompletionItemKind.Enum, undefined];
+                case api_1.CompletionItemKind.Keyword: return [this._monaco.languages.CompletionItemKind.Keyword, undefined];
+                case api_1.CompletionItemKind.Snippet: return [this._monaco.languages.CompletionItemKind.Snippet, undefined];
+                case api_1.CompletionItemKind.Color: return [this._monaco.languages.CompletionItemKind.Color, undefined];
+                case api_1.CompletionItemKind.File: return [this._monaco.languages.CompletionItemKind.File, undefined];
+                case api_1.CompletionItemKind.Reference: return [this._monaco.languages.CompletionItemKind.Reference, undefined];
+                case api_1.CompletionItemKind.Folder: return [this._monaco.languages.CompletionItemKind.Folder, undefined];
+                case api_1.CompletionItemKind.EnumMember: return [this._monaco.languages.CompletionItemKind.EnumMember, undefined];
+                case api_1.CompletionItemKind.Constant: return [this._monaco.languages.CompletionItemKind.Constant, undefined];
+                case api_1.CompletionItemKind.Struct: return [this._monaco.languages.CompletionItemKind.Struct, undefined];
+                case api_1.CompletionItemKind.Event: return [this._monaco.languages.CompletionItemKind.Event, undefined];
+                case api_1.CompletionItemKind.Operator: return [this._monaco.languages.CompletionItemKind.Operator, undefined];
+                case api_1.CompletionItemKind.TypeParameter: return [this._monaco.languages.CompletionItemKind.TypeParameter, undefined];
+                default: return [value - 1, undefined];
+            }
+        }
+        return [api_1.CompletionItemKind.Text, value];
+    }
+    asCompletionInsertText(item, defaultRange, defaultInsertTextFormat) {
+        const insertTextFormat = item.insertTextFormat ?? defaultInsertTextFormat;
+        const isSnippet = insertTextFormat === api_1.InsertTextFormat.Snippet;
+        if (item.textEdit !== undefined || defaultRange !== undefined) {
+            const [range, newText] = item.textEdit !== undefined
+                ? this.getCompletionRangeAndText(item.textEdit)
+                : [defaultRange, item.textEditText ?? item.label];
+            return { insertText: newText, range, fromEdit: true, isSnippet };
+        }
+        else if (item.insertText) {
+            return { isSnippet, insertText: item.insertText, fromEdit: false, range: defaultRange };
+        }
+        return { insertText: item.label, range: defaultRange, fromEdit: false, isSnippet: false };
+    }
+    getCompletionRangeAndText(value) {
+        if (ls.InsertReplaceEdit.is(value)) {
+            return [{ insert: this.asRange(value.insert), replace: this.asRange(value.replace) }, value.newText];
+        }
+        else {
+            return [this.asRange(value.range), value.newText];
+        }
+    }
+    asDocumentLinks(documentLinks) {
+        const links = documentLinks.map(link => this.asDocumentLink(link));
+        return { links };
+    }
+    asDocumentLink(documentLink) {
+        return {
+            range: this.asRange(documentLink.range),
+            url: documentLink.target,
+            data: documentLink.data,
+            tooltip: documentLink.tooltip
+        };
+    }
+    asRange(range) {
+        if (range === undefined) {
+            return undefined;
+        }
+        if (range === null) {
+            return null;
+        }
+        const start = this.asPosition(range.start);
+        const end = this.asPosition(range.end);
+        if (start instanceof this._monaco.Position && end instanceof this._monaco.Position) {
+            return new this._monaco.Range(start.lineNumber, start.column, end.lineNumber, end.column);
+        }
+        const startLineNumber = !start || start.lineNumber === undefined ? undefined : start.lineNumber;
+        const startColumn = !start || start.column === undefined ? undefined : start.column;
+        const endLineNumber = !end || end.lineNumber === undefined ? undefined : end.lineNumber;
+        const endColumn = !end || end.column === undefined ? undefined : end.column;
+        return { startLineNumber, startColumn, endLineNumber, endColumn };
+    }
+    asPosition(position) {
+        if (position === undefined) {
+            return undefined;
+        }
+        if (position === null) {
+            return null;
+        }
+        const { line, character } = position;
+        const lineNumber = line === undefined ? undefined : line + 1;
+        const column = character === undefined ? undefined : character + 1;
+        if (lineNumber !== undefined && column !== undefined) {
+            return new this._monaco.Position(lineNumber, column);
+        }
+        return { lineNumber, column };
+    }
+    asColorInformations(items) {
+        return items.map(item => this.asColorInformation(item));
+    }
+    asColorInformation(item) {
+        return {
+            range: this.asRange(item.range),
+            color: item.color
+        };
+    }
+    asColorPresentations(items) {
+        return items.map(item => this.asColorPresentation(item));
+    }
+    asColorPresentation(item) {
+        return {
+            label: item.label,
+            textEdit: this.asTextEdit(item.textEdit),
+            additionalTextEdits: this.asTextEdits(item.additionalTextEdits)
+        };
+    }
+    asFoldingRanges(items) {
+        if (!items) {
+            return items;
+        }
+        return items.map(item => this.asFoldingRange(item));
+    }
+    asFoldingRange(item) {
+        return {
+            start: item.startLine + 1,
+            end: item.endLine + 1,
+            kind: this.asFoldingRangeKind(item.kind)
+        };
+    }
+    asFoldingRangeKind(kind) {
+        if (kind) {
+            switch (kind) {
+                case api_1.FoldingRangeKind.Comment:
+                    return this._monaco.languages.FoldingRangeKind.Comment;
+                case api_1.FoldingRangeKind.Imports:
+                    return this._monaco.languages.FoldingRangeKind.Imports;
+                case api_1.FoldingRangeKind.Region:
+                    return this._monaco.languages.FoldingRangeKind.Region;
+            }
+        }
+        return undefined;
+    }
+    asSemanticTokens(semanticTokens) {
+        return {
+            resultId: semanticTokens.resultId,
+            data: Uint32Array.from(semanticTokens.data)
+        };
+    }
+    asInlayHintLabelPart(part) {
+        return {
+            label: part.value,
+            command: this.asCommand(part.command),
+            location: this.asLocation(part.location),
+            tooltip: part.tooltip && this.asMarkdownString(part.tooltip)
+        };
+    }
+    asInlayHintLabel(label) {
+        if (Array.isArray(label)) {
+            return label.map(part => this.asInlayHintLabelPart(part));
+        }
+        return label;
+    }
+    asInlayHint(inlayHint) {
+        return {
+            data: inlayHint.data,
+            label: this.asInlayHintLabel(inlayHint.label),
+            position: this.asPosition(inlayHint.position),
+            kind: inlayHint.kind,
+            paddingLeft: inlayHint.paddingLeft,
+            paddingRight: inlayHint.paddingRight,
+            tooltip: inlayHint.tooltip && this.asMarkdownString(inlayHint.tooltip)
+        };
+    }
+    asInlayHintList(items) {
+        if (!items) {
+            return undefined;
+        }
+        return {
+            hints: items.map((hint) => this.asInlayHint(hint)),
+            dispose: () => { }
+        };
+    }
+}
+exports.ProtocolToMonacoConverter = ProtocolToMonacoConverter;
+//# sourceMappingURL=monaco-converter.js.map