@inst/vscode-bin-darwin
Version:
BINARY ONLY - VSCode binary deployment for macOS
350 lines (349 loc) • 12 kB
JavaScript
/* --------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
* ------------------------------------------------------------------------------------------ */
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
const code = require("vscode");
const ls = require("vscode-languageserver-protocol");
const is = require("./utils/is");
const protocolCompletionItem_1 = require("./protocolCompletionItem");
const protocolCodeLens_1 = require("./protocolCodeLens");
function createConverter(uriConverter) {
const nullConverter = (value) => code.Uri.parse(value);
const _uriConverter = uriConverter || nullConverter;
function asUri(value) {
return _uriConverter(value);
}
function asDiagnostics(diagnostics) {
return diagnostics.map(asDiagnostic);
}
function asDiagnostic(diagnostic) {
let result = new code.Diagnostic(asRange(diagnostic.range), diagnostic.message, asDiagnosticSeverity(diagnostic.severity));
if (is.number(diagnostic.code) || is.string(diagnostic.code)) {
result.code = diagnostic.code;
}
if (diagnostic.source) {
result.source = diagnostic.source;
}
return result;
}
function asPosition(value) {
if (!value) {
return undefined;
}
return new code.Position(value.line, value.character);
}
function asRange(value) {
if (!value) {
return undefined;
}
return new code.Range(asPosition(value.start), asPosition(value.end));
}
function asDiagnosticSeverity(value) {
if (value === void 0 || value === null) {
return code.DiagnosticSeverity.Error;
}
switch (value) {
case ls.DiagnosticSeverity.Error:
return code.DiagnosticSeverity.Error;
case ls.DiagnosticSeverity.Warning:
return code.DiagnosticSeverity.Warning;
case ls.DiagnosticSeverity.Information:
return code.DiagnosticSeverity.Information;
case ls.DiagnosticSeverity.Hint:
return code.DiagnosticSeverity.Hint;
}
return code.DiagnosticSeverity.Error;
}
function asHover(hover) {
if (!hover) {
return undefined;
}
return new code.Hover(hover.contents, asRange(hover.range));
}
function asCompletionResult(result) {
if (!result) {
return undefined;
}
if (Array.isArray(result)) {
let items = result;
return items.map(asCompletionItem);
}
let list = result;
return new code.CompletionList(list.items.map(asCompletionItem), list.isIncomplete);
}
function asCompletionItem(item) {
let result = new protocolCompletionItem_1.default(item.label);
if (item.detail) {
result.detail = item.detail;
}
if (item.documentation) {
result.documentation = item.documentation;
}
;
if (item.filterText) {
result.filterText = item.filterText;
}
let insertText = asCompletionInsertText(item);
if (insertText) {
result.insertText = insertText.text;
result.range = insertText.range;
result.fromEdit = insertText.fromEdit;
}
// Protocol item kind is 1 based, codes item kind is zero based.
if (is.number(item.kind) && item.kind > 0) {
result.kind = item.kind - 1;
}
if (item.sortText) {
result.sortText = item.sortText;
}
if (item.additionalTextEdits) {
result.additionalTextEdits = asTextEdits(item.additionalTextEdits);
}
if (item.command) {
result.command = asCommand(item.command);
}
if (item.data !== void 0 && item.data !== null) {
result.data = item.data;
}
return result;
}
function asCompletionInsertText(item) {
if (item.textEdit) {
if (item.insertTextFormat === ls.InsertTextFormat.Snippet) {
return { text: new code.SnippetString(item.textEdit.newText), range: asRange(item.textEdit.range), fromEdit: true };
}
else {
return { text: item.textEdit.newText, range: asRange(item.textEdit.range), fromEdit: true };
}
}
else if (item.insertText) {
if (item.insertTextFormat === ls.InsertTextFormat.Snippet) {
return { text: new code.SnippetString(item.insertText), fromEdit: false };
}
else {
return { text: item.insertText, fromEdit: false };
}
}
else {
return undefined;
}
}
function asTextEdit(edit) {
if (!edit) {
return undefined;
}
return new code.TextEdit(asRange(edit.range), edit.newText);
}
function asTextEdits(items) {
if (!items) {
return undefined;
}
return items.map(asTextEdit);
}
function asSignatureHelp(item) {
if (!item) {
return undefined;
}
let result = new code.SignatureHelp();
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 = asSignatureInformations(item.signatures);
}
return result;
}
function asSignatureInformations(items) {
return items.map(asSignatureInformation);
}
function asSignatureInformation(item) {
let result = new code.SignatureInformation(item.label);
if (item.documentation) {
result.documentation = item.documentation;
}
if (item.parameters) {
result.parameters = asParameterInformations(item.parameters);
}
return result;
}
function asParameterInformations(item) {
return item.map(asParameterInformation);
}
function asParameterInformation(item) {
let result = new code.ParameterInformation(item.label);
if (item.documentation) {
result.documentation = item.documentation;
}
;
return result;
}
function asDefinitionResult(item) {
if (!item) {
return undefined;
}
if (is.array(item)) {
return item.map((location) => asLocation(location));
}
else {
return asLocation(item);
}
}
function asLocation(item) {
if (!item) {
return undefined;
}
return new code.Location(_uriConverter(item.uri), asRange(item.range));
}
function asReferences(values) {
if (!values) {
return undefined;
}
return values.map(location => asLocation(location));
}
function asDocumentHighlights(values) {
if (!values) {
return undefined;
}
return values.map(asDocumentHighlight);
}
function asDocumentHighlight(item) {
let result = new code.DocumentHighlight(asRange(item.range));
if (is.number(item.kind)) {
result.kind = asDocumentHighlightKind(item.kind);
}
return result;
}
function asDocumentHighlightKind(item) {
switch (item) {
case ls.DocumentHighlightKind.Text:
return code.DocumentHighlightKind.Text;
case ls.DocumentHighlightKind.Read:
return code.DocumentHighlightKind.Read;
case ls.DocumentHighlightKind.Write:
return code.DocumentHighlightKind.Write;
}
return code.DocumentHighlightKind.Text;
}
function asSymbolInformations(values, uri) {
if (!values) {
return undefined;
}
return values.map(information => asSymbolInformation(information, uri));
}
function asSymbolInformation(item, uri) {
// Symbol kind is one based in the protocol and zero based in code.
let result = new code.SymbolInformation(item.name, item.kind - 1, asRange(item.location.range), item.location.uri ? _uriConverter(item.location.uri) : uri);
if (item.containerName) {
result.containerName = item.containerName;
}
return result;
}
function asCommand(item) {
let result = { title: item.title, command: item.command };
if (item.arguments) {
result.arguments = item.arguments;
}
return result;
}
function asCommands(items) {
if (!items) {
return undefined;
}
return items.map(asCommand);
}
function asCodeLens(item) {
if (!item) {
return undefined;
}
let result = new protocolCodeLens_1.default(asRange(item.range));
if (item.command) {
result.command = asCommand(item.command);
}
if (item.data !== void 0 && item.data !== null) {
result.data = item.data;
}
return result;
}
function asCodeLenses(items) {
if (!items) {
return undefined;
}
return items.map((codeLens) => asCodeLens(codeLens));
}
function asWorkspaceEdit(item) {
if (!item) {
return undefined;
}
let result = new code.WorkspaceEdit();
if (item.documentChanges) {
item.documentChanges.forEach(change => {
result.set(_uriConverter(change.textDocument.uri), asTextEdits(change.edits));
});
}
else if (item.changes) {
Object.keys(item.changes).forEach(key => {
result.set(_uriConverter(key), asTextEdits(item.changes[key]));
});
}
return result;
}
function asDocumentLink(item) {
let range = asRange(item.range);
let target = item.target ? asUri(item.target) : undefined;
// target must be optional in DocumentLink
return new code.DocumentLink(range, target);
}
function asDocumentLinks(items) {
if (!items) {
return undefined;
}
return items.map(asDocumentLink);
}
return {
asUri,
asDiagnostics,
asDiagnostic,
asRange,
asPosition,
asDiagnosticSeverity,
asHover,
asCompletionResult,
asCompletionItem,
asTextEdit,
asTextEdits,
asSignatureHelp,
asSignatureInformations,
asSignatureInformation,
asParameterInformations,
asParameterInformation,
asDefinitionResult,
asLocation,
asReferences,
asDocumentHighlights,
asDocumentHighlight,
asDocumentHighlightKind,
asSymbolInformations,
asSymbolInformation,
asCommand,
asCommands,
asCodeLens,
asCodeLenses,
asWorkspaceEdit,
asDocumentLink,
asDocumentLinks
};
}
exports.createConverter = createConverter;