Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

vscode-jsonrpc

Package Overview
Dependencies
Maintainers
11
Versions
130
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

vscode-jsonrpc - npm Package Compare versions

Comparing version 3.7.0-next.1 to 4.0.0-next.1

88

lib/cancellation.js

@@ -7,4 +7,4 @@ /*---------------------------------------------------------------------------------------------

Object.defineProperty(exports, "__esModule", { value: true });
var events_1 = require("./events");
var Is = require("./is");
const events_1 = require("./events");
const Is = require("./is");
var CancellationToken;

@@ -21,3 +21,3 @@ (function (CancellationToken) {

function is(value) {
var candidate = value;
let candidate = value;
return candidate && (candidate === CancellationToken.None

@@ -29,11 +29,11 @@ || candidate === CancellationToken.Cancelled

})(CancellationToken = exports.CancellationToken || (exports.CancellationToken = {}));
var shortcutEvent = Object.freeze(function (callback, context) {
var handle = setTimeout(callback.bind(context), 0);
return { dispose: function () { clearTimeout(handle); } };
const shortcutEvent = Object.freeze(function (callback, context) {
let handle = setTimeout(callback.bind(context), 0);
return { dispose() { clearTimeout(handle); } };
});
var MutableToken = /** @class */ (function () {
function MutableToken() {
class MutableToken {
constructor() {
this._isCancelled = false;
}
MutableToken.prototype.cancel = function () {
cancel() {
if (!this._isCancelled) {

@@ -46,42 +46,27 @@ this._isCancelled = true;

}
};
Object.defineProperty(MutableToken.prototype, "isCancellationRequested", {
get: function () {
return this._isCancelled;
},
enumerable: true,
configurable: true
});
Object.defineProperty(MutableToken.prototype, "onCancellationRequested", {
get: function () {
if (this._isCancelled) {
return shortcutEvent;
}
if (!this._emitter) {
this._emitter = new events_1.Emitter();
}
return this._emitter.event;
},
enumerable: true,
configurable: true
});
return MutableToken;
}());
var CancellationTokenSource = /** @class */ (function () {
function CancellationTokenSource() {
}
Object.defineProperty(CancellationTokenSource.prototype, "token", {
get: function () {
if (!this._token) {
// be lazy and create the token only when
// actually needed
this._token = new MutableToken();
}
return this._token;
},
enumerable: true,
configurable: true
});
CancellationTokenSource.prototype.cancel = function () {
get isCancellationRequested() {
return this._isCancelled;
}
get onCancellationRequested() {
if (this._isCancelled) {
return shortcutEvent;
}
if (!this._emitter) {
this._emitter = new events_1.Emitter();
}
return this._emitter.event;
}
}
class CancellationTokenSource {
get token() {
if (!this._token) {
// be lazy and create the token only when
// actually needed
this._token = new MutableToken();
}
return this._token;
}
cancel() {
if (!this._token) {
// save an object by returning the default

@@ -95,8 +80,7 @@ // cancelled token when cancellation happens

}
};
CancellationTokenSource.prototype.dispose = function () {
}
dispose() {
this.cancel();
};
return CancellationTokenSource;
}());
}
}
exports.CancellationTokenSource = CancellationTokenSource;

118

lib/events.js

@@ -18,11 +18,7 @@ /* --------------------------------------------------------------------------------------------

(function (Event) {
var _disposable = { dispose: function () { } };
const _disposable = { dispose() { } };
Event.None = function () { return _disposable; };
})(Event = exports.Event || (exports.Event = {}));
var CallbackList = /** @class */ (function () {
function CallbackList() {
}
CallbackList.prototype.add = function (callback, context, bucket) {
var _this = this;
if (context === void 0) { context = null; }
class CallbackList {
add(callback, context = null, bucket) {
if (!this._callbacks) {

@@ -35,7 +31,6 @@ this._callbacks = [];

if (Array.isArray(bucket)) {
bucket.push({ dispose: function () { return _this.remove(callback, context); } });
bucket.push({ dispose: () => this.remove(callback, context) });
}
};
CallbackList.prototype.remove = function (callback, context) {
if (context === void 0) { context = null; }
}
remove(callback, context = null) {
if (!this._callbacks) {

@@ -61,8 +56,4 @@ return;

}
};
CallbackList.prototype.invoke = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
}
invoke(...args) {
if (!this._callbacks) {

@@ -81,53 +72,47 @@ return [];

return ret;
};
CallbackList.prototype.isEmpty = function () {
}
isEmpty() {
return !this._callbacks || this._callbacks.length === 0;
};
CallbackList.prototype.dispose = function () {
}
dispose() {
this._callbacks = undefined;
this._contexts = undefined;
};
return CallbackList;
}());
var Emitter = /** @class */ (function () {
function Emitter(_options) {
}
}
class Emitter {
constructor(_options) {
this._options = _options;
}
Object.defineProperty(Emitter.prototype, "event", {
/**
* For the public to allow to subscribe
* to events from this Emitter
*/
get: function () {
var _this = this;
if (!this._event) {
this._event = function (listener, thisArgs, disposables) {
if (!_this._callbacks) {
_this._callbacks = new CallbackList();
}
if (_this._options && _this._options.onFirstListenerAdd && _this._callbacks.isEmpty()) {
_this._options.onFirstListenerAdd(_this);
}
_this._callbacks.add(listener, thisArgs);
var result;
result = {
dispose: function () {
_this._callbacks.remove(listener, thisArgs);
result.dispose = Emitter._noop;
if (_this._options && _this._options.onLastListenerRemove && _this._callbacks.isEmpty()) {
_this._options.onLastListenerRemove(_this);
}
/**
* For the public to allow to subscribe
* to events from this Emitter
*/
get event() {
if (!this._event) {
this._event = (listener, thisArgs, disposables) => {
if (!this._callbacks) {
this._callbacks = new CallbackList();
}
if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
this._options.onFirstListenerAdd(this);
}
this._callbacks.add(listener, thisArgs);
let result;
result = {
dispose: () => {
this._callbacks.remove(listener, thisArgs);
result.dispose = Emitter._noop;
if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {
this._options.onLastListenerRemove(this);
}
};
if (Array.isArray(disposables)) {
disposables.push(result);
}
return result;
};
}
return this._event;
},
enumerable: true,
configurable: true
});
if (Array.isArray(disposables)) {
disposables.push(result);
}
return result;
};
}
return this._event;
}
/**

@@ -137,8 +122,8 @@ * To be kept private to fire an event to

*/
Emitter.prototype.fire = function (event) {
fire(event) {
if (this._callbacks) {
this._callbacks.invoke.call(this._callbacks, event);
}
};
Emitter.prototype.dispose = function () {
}
dispose() {
if (this._callbacks) {

@@ -148,6 +133,5 @@ this._callbacks.dispose();

}
};
Emitter._noop = function () { };
return Emitter;
}());
}
}
Emitter._noop = function () { };
exports.Emitter = Emitter;

11

lib/is.js

@@ -7,3 +7,2 @@ /* --------------------------------------------------------------------------------------------

Object.defineProperty(exports, "__esModule", { value: true });
var toString = Object.prototype.toString;
function boolean(value) {

@@ -14,15 +13,15 @@ return value === true || value === false;

function string(value) {
return toString.call(value) === '[object String]';
return typeof value === 'string' || value instanceof String;
}
exports.string = string;
function number(value) {
return toString.call(value) === '[object Number]';
return typeof value === 'number' || value instanceof Number;
}
exports.number = number;
function error(value) {
return toString.call(value) === '[object Error]';
return value instanceof Error;
}
exports.error = error;
function func(value) {
return toString.call(value) === '[object Function]';
return typeof value === 'function';
}

@@ -35,4 +34,4 @@ exports.func = func;

function stringArray(value) {
return array(value) && value.every(function (elem) { return string(elem); });
return array(value) && value.every(elem => string(elem));
}
exports.stringArray = stringArray;

112

lib/linkedMap.js

@@ -13,4 +13,4 @@ "use strict";

})(Touch = exports.Touch || (exports.Touch = {}));
var LinkedMap = /** @class */ (function () {
function LinkedMap() {
class LinkedMap {
constructor() {
this._map = new Map();

@@ -21,3 +21,3 @@ this._head = undefined;

}
LinkedMap.prototype.clear = function () {
clear() {
this._map.clear();

@@ -27,18 +27,14 @@ this._head = undefined;

this._size = 0;
};
LinkedMap.prototype.isEmpty = function () {
}
isEmpty() {
return !this._head && !this._tail;
};
Object.defineProperty(LinkedMap.prototype, "size", {
get: function () {
return this._size;
},
enumerable: true,
configurable: true
});
LinkedMap.prototype.has = function (key) {
}
get size() {
return this._size;
}
has(key) {
return this._map.has(key);
};
LinkedMap.prototype.get = function (key) {
var item = this._map.get(key);
}
get(key) {
const item = this._map.get(key);
if (!item) {

@@ -48,6 +44,5 @@ return undefined;

return item.value;
};
LinkedMap.prototype.set = function (key, value, touch) {
if (touch === void 0) { touch = Touch.None; }
var item = this._map.get(key);
}
set(key, value, touch = Touch.None) {
let item = this._map.get(key);
if (item) {

@@ -60,3 +55,3 @@ item.value = value;

else {
item = { key: key, value: value, next: undefined, previous: undefined };
item = { key, value, next: undefined, previous: undefined };
switch (touch) {

@@ -79,5 +74,5 @@ case Touch.None:

}
};
LinkedMap.prototype.delete = function (key) {
var item = this._map.get(key);
}
delete(key) {
const item = this._map.get(key);
if (!item) {

@@ -90,4 +85,4 @@ return false;

return true;
};
LinkedMap.prototype.shift = function () {
}
shift() {
if (!this._head && !this._tail) {

@@ -99,3 +94,3 @@ return undefined;

}
var item = this._head;
const item = this._head;
this._map.delete(item.key);

@@ -105,5 +100,5 @@ this.removeItem(item);

return item.value;
};
LinkedMap.prototype.forEach = function (callbackfn, thisArg) {
var current = this._head;
}
forEach(callbackfn, thisArg) {
let current = this._head;
while (current) {

@@ -118,5 +113,5 @@ if (thisArg) {

}
};
LinkedMap.prototype.forEachReverse = function (callbackfn, thisArg) {
var current = this._tail;
}
forEachReverse(callbackfn, thisArg) {
let current = this._tail;
while (current) {

@@ -131,6 +126,6 @@ if (thisArg) {

}
};
LinkedMap.prototype.values = function () {
var result = [];
var current = this._head;
}
values() {
let result = [];
let current = this._head;
while (current) {

@@ -141,6 +136,6 @@ result.push(current.value);

return result;
};
LinkedMap.prototype.keys = function () {
var result = [];
var current = this._head;
}
keys() {
let result = [];
let current = this._head;
while (current) {

@@ -151,3 +146,3 @@ result.push(current.key);

return result;
};
}
/* JSON RPC run on es5 which has no Symbol.iterator

@@ -192,3 +187,3 @@ public keys(): IterableIterator<K> {

*/
LinkedMap.prototype.addItemFirst = function (item) {
addItemFirst(item) {
// First time Insert

@@ -206,4 +201,4 @@ if (!this._head && !this._tail) {

this._head = item;
};
LinkedMap.prototype.addItemLast = function (item) {
}
addItemLast(item) {
// First time Insert

@@ -221,4 +216,4 @@ if (!this._head && !this._tail) {

this._tail = item;
};
LinkedMap.prototype.removeItem = function (item) {
}
removeItem(item) {
if (item === this._head && item === this._tail) {

@@ -235,4 +230,4 @@ this._head = undefined;

else {
var next = item.next;
var previous = item.previous;
const next = item.next;
const previous = item.previous;
if (!next || !previous) {

@@ -244,4 +239,4 @@ throw new Error('Invalid list');

}
};
LinkedMap.prototype.touch = function (item, touch) {
}
touch(item, touch) {
if (!this._head || !this._tail) {

@@ -257,4 +252,4 @@ throw new Error('Invalid list');

}
var next = item.next;
var previous = item.previous;
const next = item.next;
const previous = item.previous;
// Unlink the item

@@ -282,4 +277,4 @@ if (item === this._tail) {

}
var next = item.next;
var previous = item.previous;
const next = item.next;
const previous = item.previous;
// Unlink the item.

@@ -302,5 +297,4 @@ if (item === this._head) {

}
};
return LinkedMap;
}());
}
}
exports.LinkedMap = LinkedMap;

330

lib/main.js

@@ -7,12 +7,2 @@ /* --------------------------------------------------------------------------------------------

'use strict';
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
function __export(m) {

@@ -22,4 +12,4 @@ for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];

Object.defineProperty(exports, "__esModule", { value: true });
var Is = require("./is");
var messages_1 = require("./messages");
const Is = require("./is");
const messages_1 = require("./messages");
exports.RequestType = messages_1.RequestType;

@@ -49,3 +39,3 @@ exports.RequestType0 = messages_1.RequestType0;

exports.NotificationType9 = messages_1.NotificationType9;
var messageReader_1 = require("./messageReader");
const messageReader_1 = require("./messageReader");
exports.MessageReader = messageReader_1.MessageReader;

@@ -55,3 +45,3 @@ exports.StreamMessageReader = messageReader_1.StreamMessageReader;

exports.SocketMessageReader = messageReader_1.SocketMessageReader;
var messageWriter_1 = require("./messageWriter");
const messageWriter_1 = require("./messageWriter");
exports.MessageWriter = messageWriter_1.MessageWriter;

@@ -61,10 +51,10 @@ exports.StreamMessageWriter = messageWriter_1.StreamMessageWriter;

exports.SocketMessageWriter = messageWriter_1.SocketMessageWriter;
var events_1 = require("./events");
const events_1 = require("./events");
exports.Disposable = events_1.Disposable;
exports.Event = events_1.Event;
exports.Emitter = events_1.Emitter;
var cancellation_1 = require("./cancellation");
const cancellation_1 = require("./cancellation");
exports.CancellationTokenSource = cancellation_1.CancellationTokenSource;
exports.CancellationToken = cancellation_1.CancellationToken;
var linkedMap_1 = require("./linkedMap");
const linkedMap_1 = require("./linkedMap");
__export(require("./pipeSupport"));

@@ -77,6 +67,6 @@ __export(require("./socketSupport"));

exports.NullLogger = Object.freeze({
error: function () { },
warn: function () { },
info: function () { },
log: function () { }
error: () => { },
warn: () => { },
info: () => { },
log: () => { }
});

@@ -158,12 +148,9 @@ var Trace;

})(ConnectionErrors = exports.ConnectionErrors || (exports.ConnectionErrors = {}));
var ConnectionError = /** @class */ (function (_super) {
__extends(ConnectionError, _super);
function ConnectionError(code, message) {
var _this = _super.call(this, message) || this;
_this.code = code;
Object.setPrototypeOf(_this, ConnectionError.prototype);
return _this;
class ConnectionError extends Error {
constructor(code, message) {
super(message);
this.code = code;
Object.setPrototypeOf(this, ConnectionError.prototype);
}
return ConnectionError;
}(Error));
}
exports.ConnectionError = ConnectionError;

@@ -173,3 +160,3 @@ var ConnectionStrategy;

function is(value) {
var candidate = value;
let candidate = value;
return candidate && Is.func(candidate.cancelUndispatched);

@@ -187,22 +174,22 @@ }

function _createMessageConnection(messageReader, messageWriter, logger, strategy) {
var sequenceNumber = 0;
var notificationSquenceNumber = 0;
var unknownResponseSquenceNumber = 0;
var version = '2.0';
var starRequestHandler = undefined;
var requestHandlers = Object.create(null);
var starNotificationHandler = undefined;
var notificationHandlers = Object.create(null);
var timer;
var messageQueue = new linkedMap_1.LinkedMap();
var responsePromises = Object.create(null);
var requestTokens = Object.create(null);
var trace = Trace.Off;
var traceFormat = TraceFormat.Text;
var tracer;
var state = ConnectionState.New;
var errorEmitter = new events_1.Emitter();
var closeEmitter = new events_1.Emitter();
var unhandledNotificationEmitter = new events_1.Emitter();
var disposeEmitter = new events_1.Emitter();
let sequenceNumber = 0;
let notificationSquenceNumber = 0;
let unknownResponseSquenceNumber = 0;
const version = '2.0';
let starRequestHandler = undefined;
let requestHandlers = Object.create(null);
let starNotificationHandler = undefined;
let notificationHandlers = Object.create(null);
let timer;
let messageQueue = new linkedMap_1.LinkedMap();
let responsePromises = Object.create(null);
let requestTokens = Object.create(null);
let trace = Trace.Off;
let traceFormat = TraceFormat.Text;
let tracer;
let state = ConnectionState.New;
let errorEmitter = new events_1.Emitter();
let closeEmitter = new events_1.Emitter();
let unhandledNotificationEmitter = new events_1.Emitter();
let disposeEmitter = new events_1.Emitter();
function createRequestQueueKey(id) {

@@ -267,3 +254,3 @@ return 'req-' + id.toString();

}
timer = setImmediate(function () {
timer = setImmediate(() => {
timer = undefined;

@@ -277,3 +264,3 @@ processMessageQueue();

}
var message = messageQueue.shift();
let message = messageQueue.shift();
try {

@@ -297,3 +284,3 @@ if (messages_1.isRequestMessage(message)) {

}
var callback = function (message) {
let callback = (message) => {
try {

@@ -303,6 +290,6 @@ // We have received a cancellation message. Check if the message is still in the queue

if (messages_1.isNotificationMessage(message) && message.method === CancelNotification.type.method) {
var key = createRequestQueueKey(message.params.id);
var toCancel = messageQueue.get(key);
let key = createRequestQueueKey(message.params.id);
let toCancel = messageQueue.get(key);
if (messages_1.isRequestMessage(toCancel)) {
var response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
let response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
if (response && (response.error !== void 0 || response.result !== void 0)) {

@@ -330,3 +317,3 @@ messageQueue.delete(key);

function reply(resultOrError, method, startTime) {
var message = {
let message = {
jsonrpc: version,

@@ -345,3 +332,3 @@ id: requestMessage.id

function replyError(error, method, startTime) {
var message = {
let message = {
jsonrpc: version,

@@ -360,3 +347,3 @@ id: requestMessage.id,

}
var message = {
let message = {
jsonrpc: version,

@@ -370,5 +357,5 @@ id: requestMessage.id,

traceReceivedRequest(requestMessage);
var element = requestHandlers[requestMessage.method];
var type;
var requestHandler;
let element = requestHandlers[requestMessage.method];
let type;
let requestHandler;
if (element) {

@@ -378,9 +365,9 @@ type = element.type;

}
var startTime = Date.now();
let startTime = Date.now();
if (requestHandler || starRequestHandler) {
var cancellationSource = new cancellation_1.CancellationTokenSource();
var tokenKey_1 = String(requestMessage.id);
requestTokens[tokenKey_1] = cancellationSource;
let cancellationSource = new cancellation_1.CancellationTokenSource();
let tokenKey = String(requestMessage.id);
requestTokens[tokenKey] = cancellationSource;
try {
var handlerResult = void 0;
let handlerResult;
if (requestMessage.params === void 0 || (type !== void 0 && type.numberOfParams === 0)) {

@@ -393,3 +380,4 @@ handlerResult = requestHandler

handlerResult = requestHandler
? requestHandler.apply(void 0, requestMessage.params.concat([cancellationSource.token])) : starRequestHandler.apply(void 0, [requestMessage.method].concat(requestMessage.params, [cancellationSource.token]));
? requestHandler(...requestMessage.params, cancellationSource.token)
: starRequestHandler(requestMessage.method, ...requestMessage.params, cancellationSource.token);
}

@@ -401,13 +389,13 @@ else {

}
var promise = handlerResult;
let promise = handlerResult;
if (!handlerResult) {
delete requestTokens[tokenKey_1];
delete requestTokens[tokenKey];
replySuccess(handlerResult, requestMessage.method, startTime);
}
else if (promise.then) {
promise.then(function (resultOrError) {
delete requestTokens[tokenKey_1];
promise.then((resultOrError) => {
delete requestTokens[tokenKey];
reply(resultOrError, requestMessage.method, startTime);
}, function (error) {
delete requestTokens[tokenKey_1];
}, error => {
delete requestTokens[tokenKey];
if (error instanceof messages_1.ResponseError) {

@@ -417,6 +405,6 @@ replyError(error, requestMessage.method, startTime);

else if (error && Is.string(error.message)) {
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, "Request " + requestMessage.method + " failed with message: " + error.message), requestMessage.method, startTime);
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
}
else {
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, "Request " + requestMessage.method + " failed unexpectedly without providing any details."), requestMessage.method, startTime);
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
}

@@ -426,3 +414,3 @@ });

else {
delete requestTokens[tokenKey_1];
delete requestTokens[tokenKey];
reply(handlerResult, requestMessage.method, startTime);

@@ -432,3 +420,3 @@ }

catch (error) {
delete requestTokens[tokenKey_1];
delete requestTokens[tokenKey];
if (error instanceof messages_1.ResponseError) {

@@ -438,6 +426,6 @@ reply(error, requestMessage.method, startTime);

else if (error && Is.string(error.message)) {
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, "Request " + requestMessage.method + " failed with message: " + error.message), requestMessage.method, startTime);
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
}
else {
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, "Request " + requestMessage.method + " failed unexpectedly without providing any details."), requestMessage.method, startTime);
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
}

@@ -447,3 +435,3 @@ }

else {
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.MethodNotFound, "Unhandled method " + requestMessage.method), requestMessage.method, startTime);
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`), requestMessage.method, startTime);
}

@@ -458,11 +446,11 @@ }

if (responseMessage.error) {
logger.error("Received response message without id: Error is: \n" + JSON.stringify(responseMessage.error, undefined, 4));
logger.error(`Received response message without id: Error is: \n${JSON.stringify(responseMessage.error, undefined, 4)}`);
}
else {
logger.error("Received response message without id. No further error information provided.");
logger.error(`Received response message without id. No further error information provided.`);
}
}
else {
var key = String(responseMessage.id);
var responsePromise = responsePromises[key];
let key = String(responseMessage.id);
let responsePromise = responsePromises[key];
traceReceivedResponse(responseMessage, responsePromise);

@@ -473,3 +461,3 @@ if (responsePromise) {

if (responseMessage.error) {
var error = responseMessage.error;
let error = responseMessage.error;
responsePromise.reject(new messages_1.ResponseError(error.code, error.message, error.data));

@@ -486,6 +474,6 @@ }

if (error.message) {
logger.error("Response handler '" + responsePromise.method + "' failed with message: " + error.message);
logger.error(`Response handler '${responsePromise.method}' failed with message: ${error.message}`);
}
else {
logger.error("Response handler '" + responsePromise.method + "' failed unexpectedly.");
logger.error(`Response handler '${responsePromise.method}' failed unexpectedly.`);
}

@@ -501,8 +489,8 @@ }

}
var type = undefined;
var notificationHandler;
let type = undefined;
let notificationHandler;
if (message.method === CancelNotification.type.method) {
notificationHandler = function (params) {
var id = params.id;
var source = requestTokens[String(id)];
notificationHandler = (params) => {
let id = params.id;
let source = requestTokens[String(id)];
if (source) {

@@ -514,3 +502,3 @@ source.cancel();

else {
var element = notificationHandlers[message.method];
let element = notificationHandlers[message.method];
if (element) {

@@ -528,3 +516,3 @@ notificationHandler = element.handler;

else if (Is.array(message.params) && (type === void 0 || type.numberOfParams > 1)) {
notificationHandler ? notificationHandler.apply(void 0, message.params) : starNotificationHandler.apply(void 0, [message.method].concat(message.params));
notificationHandler ? notificationHandler(...message.params) : starNotificationHandler(message.method, ...message.params);
}

@@ -537,6 +525,6 @@ else {

if (error.message) {
logger.error("Notification handler '" + message.method + "' failed with message: " + error.message);
logger.error(`Notification handler '${message.method}' failed with message: ${error.message}`);
}
else {
logger.error("Notification handler '" + message.method + "' failed unexpectedly.");
logger.error(`Notification handler '${message.method}' failed unexpectedly.`);
}

@@ -554,8 +542,8 @@ }

}
logger.error("Received message which is neither a response nor a notification message:\n" + JSON.stringify(message, null, 4));
logger.error(`Received message which is neither a response nor a notification message:\n${JSON.stringify(message, null, 4)}`);
// Test whether we find an id to reject the promise
var responseMessage = message;
let responseMessage = message;
if (Is.string(responseMessage.id) || Is.number(responseMessage.id)) {
var key = String(responseMessage.id);
var responseHandler = responsePromises[key];
let key = String(responseMessage.id);
let responseHandler = responsePromises[key];
if (responseHandler) {

@@ -571,7 +559,7 @@ responseHandler.reject(new Error('The received response has neither a result nor an error property.'));

if (traceFormat === TraceFormat.Text) {
var data = undefined;
let data = undefined;
if (trace === Trace.Verbose && message.params) {
data = "Params: " + JSON.stringify(message.params, null, 4) + "\n\n";
data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`;
}
tracer.log("Sending request '" + message.method + " - (" + message.id + ")'.", data);
tracer.log(`Sending request '${message.method} - (${message.id})'.`, data);
}

@@ -587,6 +575,6 @@ else {

if (traceFormat === TraceFormat.Text) {
var data = undefined;
let data = undefined;
if (trace === Trace.Verbose) {
if (message.params) {
data = "Params: " + JSON.stringify(message.params, null, 4) + "\n\n";
data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`;
}

@@ -597,3 +585,3 @@ else {

}
tracer.log("Sending notification '" + message.method + "'.", data);
tracer.log(`Sending notification '${message.method}'.`, data);
}

@@ -609,10 +597,10 @@ else {

if (traceFormat === TraceFormat.Text) {
var data = undefined;
let data = undefined;
if (trace === Trace.Verbose) {
if (message.error && message.error.data) {
data = "Error data: " + JSON.stringify(message.error.data, null, 4) + "\n\n";
data = `Error data: ${JSON.stringify(message.error.data, null, 4)}\n\n`;
}
else {
if (message.result) {
data = "Result: " + JSON.stringify(message.result, null, 4) + "\n\n";
data = `Result: ${JSON.stringify(message.result, null, 4)}\n\n`;
}

@@ -624,3 +612,3 @@ else if (message.error === void 0) {

}
tracer.log("Sending response '" + method + " - (" + message.id + ")'. Processing request took " + (Date.now() - startTime) + "ms", data);
tracer.log(`Sending response '${method} - (${message.id})'. Processing request took ${Date.now() - startTime}ms`, data);
}

@@ -636,7 +624,7 @@ else {

if (traceFormat === TraceFormat.Text) {
var data = undefined;
let data = undefined;
if (trace === Trace.Verbose && message.params) {
data = "Params: " + JSON.stringify(message.params, null, 4) + "\n\n";
data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`;
}
tracer.log("Received request '" + message.method + " - (" + message.id + ")'.", data);
tracer.log(`Received request '${message.method} - (${message.id})'.`, data);
}

@@ -652,6 +640,6 @@ else {

if (traceFormat === TraceFormat.Text) {
var data = undefined;
let data = undefined;
if (trace === Trace.Verbose) {
if (message.params) {
data = "Params: " + JSON.stringify(message.params, null, 4) + "\n\n";
data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`;
}

@@ -662,3 +650,3 @@ else {

}
tracer.log("Received notification '" + message.method + "'.", data);
tracer.log(`Received notification '${message.method}'.`, data);
}

@@ -674,10 +662,10 @@ else {

if (traceFormat === TraceFormat.Text) {
var data = undefined;
let data = undefined;
if (trace === Trace.Verbose) {
if (message.error && message.error.data) {
data = "Error data: " + JSON.stringify(message.error.data, null, 4) + "\n\n";
data = `Error data: ${JSON.stringify(message.error.data, null, 4)}\n\n`;
}
else {
if (message.result) {
data = "Result: " + JSON.stringify(message.result, null, 4) + "\n\n";
data = `Result: ${JSON.stringify(message.result, null, 4)}\n\n`;
}

@@ -690,7 +678,7 @@ else if (message.error === void 0) {

if (responsePromise) {
var error = message.error ? " Request failed: " + message.error.message + " (" + message.error.code + ")." : '';
tracer.log("Received response '" + responsePromise.method + " - (" + message.id + ")' in " + (Date.now() - responsePromise.timerStart) + "ms." + error, data);
let error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : '';
tracer.log(`Received response '${responsePromise.method} - (${message.id})' in ${Date.now() - responsePromise.timerStart}ms.${error}`, data);
}
else {
tracer.log("Received response " + message.id + " without active response promise.", data);
tracer.log(`Received response ${message.id} without active response promise.`, data);
}

@@ -706,6 +694,6 @@ }

}
var lspMessage = {
const lspMessage = {
isLSPMessage: true,
type: type,
message: message,
type,
message,
timestamp: Date.now()

@@ -742,4 +730,4 @@ };

function computeMessageParams(type, params) {
var result;
var numberOfParams = type.numberOfParams;
let result;
let numberOfParams = type.numberOfParams;
switch (numberOfParams) {

@@ -754,7 +742,7 @@ case 0:

result = [];
for (var i = 0; i < params.length && i < numberOfParams; i++) {
for (let i = 0; i < params.length && i < numberOfParams; i++) {
result.push(undefinedToNull(params[i]));
}
if (params.length < numberOfParams) {
for (var i = params.length; i < numberOfParams; i++) {
for (let i = params.length; i < numberOfParams; i++) {
result.push(null);

@@ -767,11 +755,7 @@ }

}
var connection = {
sendNotification: function (type) {
var params = [];
for (var _i = 1; _i < arguments.length; _i++) {
params[_i - 1] = arguments[_i];
}
let connection = {
sendNotification: (type, ...params) => {
throwIfClosedOrDisposed();
var method;
var messageParams;
let method;
let messageParams;
if (Is.string(type)) {

@@ -795,3 +779,3 @@ method = type;

}
var notificationMessage = {
let notificationMessage = {
jsonrpc: version,

@@ -804,3 +788,3 @@ method: method,

},
onNotification: function (type, handler) {
onNotification: (type, handler) => {
throwIfClosedOrDisposed();

@@ -812,19 +796,15 @@ if (Is.func(type)) {

if (Is.string(type)) {
notificationHandlers[type] = { type: undefined, handler: handler };
notificationHandlers[type] = { type: undefined, handler };
}
else {
notificationHandlers[type.method] = { type: type, handler: handler };
notificationHandlers[type.method] = { type, handler };
}
}
},
sendRequest: function (type) {
var params = [];
for (var _i = 1; _i < arguments.length; _i++) {
params[_i - 1] = arguments[_i];
}
sendRequest: (type, ...params) => {
throwIfClosedOrDisposed();
throwIfNotListening();
var method;
var messageParams;
var token = undefined;
let method;
let messageParams;
let token = undefined;
if (Is.string(type)) {

@@ -847,3 +827,3 @@ method = type;

default:
var last = params.length - 1;
const last = params.length - 1;
if (cancellation_1.CancellationToken.is(params[last])) {

@@ -855,7 +835,7 @@ token = params[last];

else {
messageParams = params.slice(0, last).map(function (value) { return undefinedToNull(value); });
messageParams = params.slice(0, last).map(value => undefinedToNull(value));
}
}
else {
messageParams = params.map(function (value) { return undefinedToNull(value); });
messageParams = params.map(value => undefinedToNull(value));
}

@@ -868,8 +848,8 @@ break;

messageParams = computeMessageParams(type, params);
var numberOfParams = type.numberOfParams;
let numberOfParams = type.numberOfParams;
token = cancellation_1.CancellationToken.is(params[numberOfParams]) ? params[numberOfParams] : undefined;
}
var id = sequenceNumber++;
var result = new Promise(function (resolve, reject) {
var requestMessage = {
let id = sequenceNumber++;
let result = new Promise((resolve, reject) => {
let requestMessage = {
jsonrpc: version,

@@ -880,3 +860,3 @@ id: id,

};
var responsePromise = { method: method, timerStart: Date.now(), resolve: resolve, reject: reject };
let responsePromise = { method: method, timerStart: Date.now(), resolve, reject };
traceSendingRequest(requestMessage);

@@ -896,4 +876,4 @@ try {

if (token) {
token.onCancellationRequested(function () {
connection.sendNotification(CancelNotification.type, { id: id });
token.onCancellationRequested(() => {
connection.sendNotification(CancelNotification.type, { id });
});

@@ -903,3 +883,3 @@ }

},
onRequest: function (type, handler) {
onRequest: (type, handler) => {
throwIfClosedOrDisposed();

@@ -911,12 +891,12 @@ if (Is.func(type)) {

if (Is.string(type)) {
requestHandlers[type] = { type: undefined, handler: handler };
requestHandlers[type] = { type: undefined, handler };
}
else {
requestHandlers[type.method] = { type: type, handler: handler };
requestHandlers[type.method] = { type, handler };
}
}
},
trace: function (_value, _tracer, sendNotificationOrTraceOptions) {
var _sendNotification = false;
var _traceFormat = TraceFormat.Text;
trace: (_value, _tracer, sendNotificationOrTraceOptions) => {
let _sendNotification = false;
let _traceFormat = TraceFormat.Text;
if (sendNotificationOrTraceOptions !== void 0) {

@@ -947,3 +927,3 @@ if (Is.boolean(sendNotificationOrTraceOptions)) {

onDispose: disposeEmitter.event,
dispose: function () {
dispose: () => {
if (isDisposed()) {

@@ -954,4 +934,4 @@ return;

disposeEmitter.fire(undefined);
var error = new Error('Connection got disposed.');
Object.keys(responsePromises).forEach(function (key) {
let error = new Error('Connection got disposed.');
Object.keys(responsePromises).forEach((key) => {
responsePromises[key].reject(error);

@@ -970,3 +950,3 @@ });

},
listen: function () {
listen: () => {
throwIfClosedOrDisposed();

@@ -977,7 +957,7 @@ throwIfListening();

},
inspect: function () {
inspect: () => {
console.log("inspect");
}
};
connection.onNotification(LogTraceNotification.type, function (params) {
connection.onNotification(LogTraceNotification.type, (params) => {
if (trace === Trace.Off || !tracer) {

@@ -1000,6 +980,6 @@ return;

}
var reader = isMessageReader(input) ? input : new messageReader_1.StreamMessageReader(input);
var writer = isMessageWriter(output) ? output : new messageWriter_1.StreamMessageWriter(output);
let reader = isMessageReader(input) ? input : new messageReader_1.StreamMessageReader(input);
let writer = isMessageWriter(output) ? output : new messageWriter_1.StreamMessageWriter(output);
return _createMessageConnection(reader, writer, logger, strategy);
}
exports.createMessageConnection = createMessageConnection;

249

lib/messageReader.js

@@ -6,27 +6,16 @@ /* --------------------------------------------------------------------------------------------

'use strict';
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var events_1 = require("./events");
var Is = require("./is");
var DefaultSize = 8192;
var CR = new Buffer('\r', 'ascii')[0];
var LF = new Buffer('\n', 'ascii')[0];
var CRLF = '\r\n';
var MessageBuffer = /** @class */ (function () {
function MessageBuffer(encoding) {
if (encoding === void 0) { encoding = 'utf8'; }
const events_1 = require("./events");
const Is = require("./is");
let DefaultSize = 8192;
let CR = Buffer.from('\r', 'ascii')[0];
let LF = Buffer.from('\n', 'ascii')[0];
let CRLF = '\r\n';
class MessageBuffer {
constructor(encoding = 'utf8') {
this.encoding = encoding;
this.index = 0;
this.buffer = new Buffer(DefaultSize);
this.buffer = Buffer.allocUnsafe(DefaultSize);
}
MessageBuffer.prototype.append = function (chunk) {
append(chunk) {
var toAppend = chunk;

@@ -36,3 +25,3 @@ if (typeof (chunk) === 'string') {

var bufferLen = Buffer.byteLength(str, this.encoding);
toAppend = new Buffer(bufferLen);
toAppend = Buffer.allocUnsafe(bufferLen);
toAppend.write(str, 0, bufferLen, this.encoding);

@@ -46,3 +35,3 @@ }

if (this.index === 0) {
this.buffer = new Buffer(newSize);
this.buffer = Buffer.allocUnsafe(newSize);
toAppend.copy(this.buffer, 0, 0, toAppend.length);

@@ -55,6 +44,6 @@ }

this.index += toAppend.length;
};
MessageBuffer.prototype.tryReadHeaders = function () {
var result = undefined;
var current = 0;
}
tryReadHeaders() {
let result = undefined;
let current = 0;
while (current + 3 < this.index && (this.buffer[current] !== CR || this.buffer[current + 1] !== LF || this.buffer[current + 2] !== CR || this.buffer[current + 3] !== LF)) {

@@ -68,40 +57,35 @@ current++;

result = Object.create(null);
var headers = this.buffer.toString('ascii', 0, current).split(CRLF);
headers.forEach(function (header) {
var index = header.indexOf(':');
let headers = this.buffer.toString('ascii', 0, current).split(CRLF);
headers.forEach((header) => {
let index = header.indexOf(':');
if (index === -1) {
throw new Error('Message header must separate key and value using :');
}
var key = header.substr(0, index);
var value = header.substr(index + 1).trim();
let key = header.substr(0, index);
let value = header.substr(index + 1).trim();
result[key] = value;
});
var nextStart = current + 4;
let nextStart = current + 4;
this.buffer = this.buffer.slice(nextStart);
this.index = this.index - nextStart;
return result;
};
MessageBuffer.prototype.tryReadContent = function (length) {
}
tryReadContent(length) {
if (this.index < length) {
return null;
}
var result = this.buffer.toString(this.encoding, 0, length);
var nextStart = length;
let result = this.buffer.toString(this.encoding, 0, length);
let nextStart = length;
this.buffer.copy(this.buffer, 0, nextStart);
this.index = this.index - nextStart;
return result;
};
Object.defineProperty(MessageBuffer.prototype, "numberOfBytes", {
get: function () {
return this.index;
},
enumerable: true,
configurable: true
});
return MessageBuffer;
}());
}
get numberOfBytes() {
return this.index;
}
}
var MessageReader;
(function (MessageReader) {
function is(value) {
var candidate = value;
let candidate = value;
return candidate && Is.func(candidate.listen) && Is.func(candidate.dispose) &&

@@ -112,4 +96,4 @@ Is.func(candidate.onError) && Is.func(candidate.onClose) && Is.func(candidate.onPartialMessage);

})(MessageReader = exports.MessageReader || (exports.MessageReader = {}));
var AbstractMessageReader = /** @class */ (function () {
function AbstractMessageReader() {
class AbstractMessageReader {
constructor() {
this.errorEmitter = new events_1.Emitter();

@@ -119,37 +103,25 @@ this.closeEmitter = new events_1.Emitter();

}
AbstractMessageReader.prototype.dispose = function () {
dispose() {
this.errorEmitter.dispose();
this.closeEmitter.dispose();
};
Object.defineProperty(AbstractMessageReader.prototype, "onError", {
get: function () {
return this.errorEmitter.event;
},
enumerable: true,
configurable: true
});
AbstractMessageReader.prototype.fireError = function (error) {
}
get onError() {
return this.errorEmitter.event;
}
fireError(error) {
this.errorEmitter.fire(this.asError(error));
};
Object.defineProperty(AbstractMessageReader.prototype, "onClose", {
get: function () {
return this.closeEmitter.event;
},
enumerable: true,
configurable: true
});
AbstractMessageReader.prototype.fireClose = function () {
}
get onClose() {
return this.closeEmitter.event;
}
fireClose() {
this.closeEmitter.fire(undefined);
};
Object.defineProperty(AbstractMessageReader.prototype, "onPartialMessage", {
get: function () {
return this.partialMessageEmitter.event;
},
enumerable: true,
configurable: true
});
AbstractMessageReader.prototype.firePartialMessage = function (info) {
}
get onPartialMessage() {
return this.partialMessageEmitter.event;
}
firePartialMessage(info) {
this.partialMessageEmitter.fire(info);
};
AbstractMessageReader.prototype.asError = function (error) {
}
asError(error) {
if (error instanceof Error) {

@@ -159,30 +131,21 @@ return error;

else {
return new Error("Reader recevied error. Reason: " + (Is.string(error.message) ? error.message : 'unknown'));
return new Error(`Reader recevied error. Reason: ${Is.string(error.message) ? error.message : 'unknown'}`);
}
};
return AbstractMessageReader;
}());
}
}
exports.AbstractMessageReader = AbstractMessageReader;
var StreamMessageReader = /** @class */ (function (_super) {
__extends(StreamMessageReader, _super);
function StreamMessageReader(readable, encoding) {
if (encoding === void 0) { encoding = 'utf8'; }
var _this = _super.call(this) || this;
_this.readable = readable;
_this.buffer = new MessageBuffer(encoding);
_this._partialMessageTimeout = 10000;
return _this;
class StreamMessageReader extends AbstractMessageReader {
constructor(readable, encoding = 'utf8') {
super();
this.readable = readable;
this.buffer = new MessageBuffer(encoding);
this._partialMessageTimeout = 10000;
}
Object.defineProperty(StreamMessageReader.prototype, "partialMessageTimeout", {
get: function () {
return this._partialMessageTimeout;
},
set: function (timeout) {
this._partialMessageTimeout = timeout;
},
enumerable: true,
configurable: true
});
StreamMessageReader.prototype.listen = function (callback) {
var _this = this;
set partialMessageTimeout(timeout) {
this._partialMessageTimeout = timeout;
}
get partialMessageTimeout() {
return this._partialMessageTimeout;
}
listen(callback) {
this.nextMessageLength = -1;

@@ -192,21 +155,21 @@ this.messageToken = 0;

this.callback = callback;
this.readable.on('data', function (data) {
_this.onData(data);
this.readable.on('data', (data) => {
this.onData(data);
});
this.readable.on('error', function (error) { return _this.fireError(error); });
this.readable.on('close', function () { return _this.fireClose(); });
};
StreamMessageReader.prototype.onData = function (data) {
this.readable.on('error', (error) => this.fireError(error));
this.readable.on('close', () => this.fireClose());
}
onData(data) {
this.buffer.append(data);
while (true) {
if (this.nextMessageLength === -1) {
var headers = this.buffer.tryReadHeaders();
let headers = this.buffer.tryReadHeaders();
if (!headers) {
return;
}
var contentLength = headers['Content-Length'];
let contentLength = headers['Content-Length'];
if (!contentLength) {
throw new Error('Header must provide a Content-Length property.');
}
var length = parseInt(contentLength);
let length = parseInt(contentLength);
if (isNaN(length)) {

@@ -231,4 +194,4 @@ throw new Error('Content-Length value must be a number.');

}
};
StreamMessageReader.prototype.clearPartialMessageTimer = function () {
}
clearPartialMessageTimer() {
if (this.partialMessageTimer) {

@@ -238,5 +201,4 @@ clearTimeout(this.partialMessageTimer);

}
};
StreamMessageReader.prototype.setPartialMessageTimer = function () {
var _this = this;
}
setPartialMessageTimer() {
this.clearPartialMessageTimer();

@@ -246,37 +208,30 @@ if (this._partialMessageTimeout <= 0) {

}
this.partialMessageTimer = setTimeout(function (token, timeout) {
_this.partialMessageTimer = undefined;
if (token === _this.messageToken) {
_this.firePartialMessage({ messageToken: token, waitingTime: timeout });
_this.setPartialMessageTimer();
this.partialMessageTimer = setTimeout((token, timeout) => {
this.partialMessageTimer = undefined;
if (token === this.messageToken) {
this.firePartialMessage({ messageToken: token, waitingTime: timeout });
this.setPartialMessageTimer();
}
}, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout);
};
return StreamMessageReader;
}(AbstractMessageReader));
}
}
exports.StreamMessageReader = StreamMessageReader;
var IPCMessageReader = /** @class */ (function (_super) {
__extends(IPCMessageReader, _super);
function IPCMessageReader(process) {
var _this = _super.call(this) || this;
_this.process = process;
var eventEmitter = _this.process;
eventEmitter.on('error', function (error) { return _this.fireError(error); });
eventEmitter.on('close', function () { return _this.fireClose(); });
return _this;
class IPCMessageReader extends AbstractMessageReader {
constructor(process) {
super();
this.process = process;
let eventEmitter = this.process;
eventEmitter.on('error', (error) => this.fireError(error));
eventEmitter.on('close', () => this.fireClose());
}
IPCMessageReader.prototype.listen = function (callback) {
listen(callback) {
this.process.on('message', callback);
};
return IPCMessageReader;
}(AbstractMessageReader));
}
}
exports.IPCMessageReader = IPCMessageReader;
var SocketMessageReader = /** @class */ (function (_super) {
__extends(SocketMessageReader, _super);
function SocketMessageReader(socket, encoding) {
if (encoding === void 0) { encoding = 'utf-8'; }
return _super.call(this, socket, encoding) || this;
class SocketMessageReader extends StreamMessageReader {
constructor(socket, encoding = 'utf-8') {
super(socket, encoding);
}
return SocketMessageReader;
}(StreamMessageReader));
}
exports.SocketMessageReader = SocketMessageReader;

352

lib/messages.js

@@ -6,14 +6,4 @@ /* --------------------------------------------------------------------------------------------

'use strict';
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var is = require("./is");
const is = require("./is");
/**

@@ -44,12 +34,10 @@ * Predefined error codes.

*/
var ResponseError = /** @class */ (function (_super) {
__extends(ResponseError, _super);
function ResponseError(code, message, data) {
var _this = _super.call(this, message) || this;
_this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode;
_this.data = data;
Object.setPrototypeOf(_this, ResponseError.prototype);
return _this;
class ResponseError extends Error {
constructor(code, message, data) {
super(message);
this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode;
this.data = data;
Object.setPrototypeOf(this, ResponseError.prototype);
}
ResponseError.prototype.toJson = function () {
toJson() {
return {

@@ -60,5 +48,4 @@ code: this.code,

};
};
return ResponseError;
}(Error));
}
}
exports.ResponseError = ResponseError;

@@ -68,23 +55,14 @@ /**

*/
var AbstractMessageType = /** @class */ (function () {
function AbstractMessageType(_method, _numberOfParams) {
class AbstractMessageType {
constructor(_method, _numberOfParams) {
this._method = _method;
this._numberOfParams = _numberOfParams;
}
Object.defineProperty(AbstractMessageType.prototype, "method", {
get: function () {
return this._method;
},
enumerable: true,
configurable: true
});
Object.defineProperty(AbstractMessageType.prototype, "numberOfParams", {
get: function () {
return this._numberOfParams;
},
enumerable: true,
configurable: true
});
return AbstractMessageType;
}());
get method() {
return this._method;
}
get numberOfParams() {
return this._numberOfParams;
}
}
exports.AbstractMessageType = AbstractMessageType;

@@ -94,221 +72,155 @@ /**

*/
var RequestType0 = /** @class */ (function (_super) {
__extends(RequestType0, _super);
function RequestType0(method) {
var _this = _super.call(this, method, 0) || this;
_this._ = undefined;
return _this;
class RequestType0 extends AbstractMessageType {
constructor(method) {
super(method, 0);
this._ = undefined;
}
return RequestType0;
}(AbstractMessageType));
}
exports.RequestType0 = RequestType0;
var RequestType = /** @class */ (function (_super) {
__extends(RequestType, _super);
function RequestType(method) {
var _this = _super.call(this, method, 1) || this;
_this._ = undefined;
return _this;
class RequestType extends AbstractMessageType {
constructor(method) {
super(method, 1);
this._ = undefined;
}
return RequestType;
}(AbstractMessageType));
}
exports.RequestType = RequestType;
var RequestType1 = /** @class */ (function (_super) {
__extends(RequestType1, _super);
function RequestType1(method) {
var _this = _super.call(this, method, 1) || this;
_this._ = undefined;
return _this;
class RequestType1 extends AbstractMessageType {
constructor(method) {
super(method, 1);
this._ = undefined;
}
return RequestType1;
}(AbstractMessageType));
}
exports.RequestType1 = RequestType1;
var RequestType2 = /** @class */ (function (_super) {
__extends(RequestType2, _super);
function RequestType2(method) {
var _this = _super.call(this, method, 2) || this;
_this._ = undefined;
return _this;
class RequestType2 extends AbstractMessageType {
constructor(method) {
super(method, 2);
this._ = undefined;
}
return RequestType2;
}(AbstractMessageType));
}
exports.RequestType2 = RequestType2;
var RequestType3 = /** @class */ (function (_super) {
__extends(RequestType3, _super);
function RequestType3(method) {
var _this = _super.call(this, method, 3) || this;
_this._ = undefined;
return _this;
class RequestType3 extends AbstractMessageType {
constructor(method) {
super(method, 3);
this._ = undefined;
}
return RequestType3;
}(AbstractMessageType));
}
exports.RequestType3 = RequestType3;
var RequestType4 = /** @class */ (function (_super) {
__extends(RequestType4, _super);
function RequestType4(method) {
var _this = _super.call(this, method, 4) || this;
_this._ = undefined;
return _this;
class RequestType4 extends AbstractMessageType {
constructor(method) {
super(method, 4);
this._ = undefined;
}
return RequestType4;
}(AbstractMessageType));
}
exports.RequestType4 = RequestType4;
var RequestType5 = /** @class */ (function (_super) {
__extends(RequestType5, _super);
function RequestType5(method) {
var _this = _super.call(this, method, 5) || this;
_this._ = undefined;
return _this;
class RequestType5 extends AbstractMessageType {
constructor(method) {
super(method, 5);
this._ = undefined;
}
return RequestType5;
}(AbstractMessageType));
}
exports.RequestType5 = RequestType5;
var RequestType6 = /** @class */ (function (_super) {
__extends(RequestType6, _super);
function RequestType6(method) {
var _this = _super.call(this, method, 6) || this;
_this._ = undefined;
return _this;
class RequestType6 extends AbstractMessageType {
constructor(method) {
super(method, 6);
this._ = undefined;
}
return RequestType6;
}(AbstractMessageType));
}
exports.RequestType6 = RequestType6;
var RequestType7 = /** @class */ (function (_super) {
__extends(RequestType7, _super);
function RequestType7(method) {
var _this = _super.call(this, method, 7) || this;
_this._ = undefined;
return _this;
class RequestType7 extends AbstractMessageType {
constructor(method) {
super(method, 7);
this._ = undefined;
}
return RequestType7;
}(AbstractMessageType));
}
exports.RequestType7 = RequestType7;
var RequestType8 = /** @class */ (function (_super) {
__extends(RequestType8, _super);
function RequestType8(method) {
var _this = _super.call(this, method, 8) || this;
_this._ = undefined;
return _this;
class RequestType8 extends AbstractMessageType {
constructor(method) {
super(method, 8);
this._ = undefined;
}
return RequestType8;
}(AbstractMessageType));
}
exports.RequestType8 = RequestType8;
var RequestType9 = /** @class */ (function (_super) {
__extends(RequestType9, _super);
function RequestType9(method) {
var _this = _super.call(this, method, 9) || this;
_this._ = undefined;
return _this;
class RequestType9 extends AbstractMessageType {
constructor(method) {
super(method, 9);
this._ = undefined;
}
return RequestType9;
}(AbstractMessageType));
}
exports.RequestType9 = RequestType9;
var NotificationType = /** @class */ (function (_super) {
__extends(NotificationType, _super);
function NotificationType(method) {
var _this = _super.call(this, method, 1) || this;
_this._ = undefined;
return _this;
class NotificationType extends AbstractMessageType {
constructor(method) {
super(method, 1);
this._ = undefined;
}
return NotificationType;
}(AbstractMessageType));
}
exports.NotificationType = NotificationType;
var NotificationType0 = /** @class */ (function (_super) {
__extends(NotificationType0, _super);
function NotificationType0(method) {
var _this = _super.call(this, method, 0) || this;
_this._ = undefined;
return _this;
class NotificationType0 extends AbstractMessageType {
constructor(method) {
super(method, 0);
this._ = undefined;
}
return NotificationType0;
}(AbstractMessageType));
}
exports.NotificationType0 = NotificationType0;
var NotificationType1 = /** @class */ (function (_super) {
__extends(NotificationType1, _super);
function NotificationType1(method) {
var _this = _super.call(this, method, 1) || this;
_this._ = undefined;
return _this;
class NotificationType1 extends AbstractMessageType {
constructor(method) {
super(method, 1);
this._ = undefined;
}
return NotificationType1;
}(AbstractMessageType));
}
exports.NotificationType1 = NotificationType1;
var NotificationType2 = /** @class */ (function (_super) {
__extends(NotificationType2, _super);
function NotificationType2(method) {
var _this = _super.call(this, method, 2) || this;
_this._ = undefined;
return _this;
class NotificationType2 extends AbstractMessageType {
constructor(method) {
super(method, 2);
this._ = undefined;
}
return NotificationType2;
}(AbstractMessageType));
}
exports.NotificationType2 = NotificationType2;
var NotificationType3 = /** @class */ (function (_super) {
__extends(NotificationType3, _super);
function NotificationType3(method) {
var _this = _super.call(this, method, 3) || this;
_this._ = undefined;
return _this;
class NotificationType3 extends AbstractMessageType {
constructor(method) {
super(method, 3);
this._ = undefined;
}
return NotificationType3;
}(AbstractMessageType));
}
exports.NotificationType3 = NotificationType3;
var NotificationType4 = /** @class */ (function (_super) {
__extends(NotificationType4, _super);
function NotificationType4(method) {
var _this = _super.call(this, method, 4) || this;
_this._ = undefined;
return _this;
class NotificationType4 extends AbstractMessageType {
constructor(method) {
super(method, 4);
this._ = undefined;
}
return NotificationType4;
}(AbstractMessageType));
}
exports.NotificationType4 = NotificationType4;
var NotificationType5 = /** @class */ (function (_super) {
__extends(NotificationType5, _super);
function NotificationType5(method) {
var _this = _super.call(this, method, 5) || this;
_this._ = undefined;
return _this;
class NotificationType5 extends AbstractMessageType {
constructor(method) {
super(method, 5);
this._ = undefined;
}
return NotificationType5;
}(AbstractMessageType));
}
exports.NotificationType5 = NotificationType5;
var NotificationType6 = /** @class */ (function (_super) {
__extends(NotificationType6, _super);
function NotificationType6(method) {
var _this = _super.call(this, method, 6) || this;
_this._ = undefined;
return _this;
class NotificationType6 extends AbstractMessageType {
constructor(method) {
super(method, 6);
this._ = undefined;
}
return NotificationType6;
}(AbstractMessageType));
}
exports.NotificationType6 = NotificationType6;
var NotificationType7 = /** @class */ (function (_super) {
__extends(NotificationType7, _super);
function NotificationType7(method) {
var _this = _super.call(this, method, 7) || this;
_this._ = undefined;
return _this;
class NotificationType7 extends AbstractMessageType {
constructor(method) {
super(method, 7);
this._ = undefined;
}
return NotificationType7;
}(AbstractMessageType));
}
exports.NotificationType7 = NotificationType7;
var NotificationType8 = /** @class */ (function (_super) {
__extends(NotificationType8, _super);
function NotificationType8(method) {
var _this = _super.call(this, method, 8) || this;
_this._ = undefined;
return _this;
class NotificationType8 extends AbstractMessageType {
constructor(method) {
super(method, 8);
this._ = undefined;
}
return NotificationType8;
}(AbstractMessageType));
}
exports.NotificationType8 = NotificationType8;
var NotificationType9 = /** @class */ (function (_super) {
__extends(NotificationType9, _super);
function NotificationType9(method) {
var _this = _super.call(this, method, 9) || this;
_this._ = undefined;
return _this;
class NotificationType9 extends AbstractMessageType {
constructor(method) {
super(method, 9);
this._ = undefined;
}
return NotificationType9;
}(AbstractMessageType));
}
exports.NotificationType9 = NotificationType9;

@@ -319,3 +231,3 @@ /**

function isRequestMessage(message) {
var candidate = message;
let candidate = message;
return candidate && is.string(candidate.method) && (is.string(candidate.id) || is.number(candidate.id));

@@ -328,3 +240,3 @@ }

function isNotificationMessage(message) {
var candidate = message;
let candidate = message;
return candidate && is.string(candidate.method) && message.id === void 0;

@@ -337,5 +249,5 @@ }

function isResponseMessage(message) {
var candidate = message;
let candidate = message;
return candidate && (candidate.result !== void 0 || !!candidate.error) && (is.string(candidate.id) || is.number(candidate.id) || candidate.id === null);
}
exports.isResponseMessage = isResponseMessage;

208

lib/messageWriter.js

@@ -6,21 +6,11 @@ /* --------------------------------------------------------------------------------------------

'use strict';
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var events_1 = require("./events");
var Is = require("./is");
var ContentLength = 'Content-Length: ';
var CRLF = '\r\n';
const events_1 = require("./events");
const Is = require("./is");
let ContentLength = 'Content-Length: ';
let CRLF = '\r\n';
var MessageWriter;
(function (MessageWriter) {
function is(value) {
var candidate = value;
let candidate = value;
return candidate && Is.func(candidate.dispose) && Is.func(candidate.onClose) &&

@@ -31,32 +21,24 @@ Is.func(candidate.onError) && Is.func(candidate.write);

})(MessageWriter = exports.MessageWriter || (exports.MessageWriter = {}));
var AbstractMessageWriter = /** @class */ (function () {
function AbstractMessageWriter() {
class AbstractMessageWriter {
constructor() {
this.errorEmitter = new events_1.Emitter();
this.closeEmitter = new events_1.Emitter();
}
AbstractMessageWriter.prototype.dispose = function () {
dispose() {
this.errorEmitter.dispose();
this.closeEmitter.dispose();
};
Object.defineProperty(AbstractMessageWriter.prototype, "onError", {
get: function () {
return this.errorEmitter.event;
},
enumerable: true,
configurable: true
});
AbstractMessageWriter.prototype.fireError = function (error, message, count) {
}
get onError() {
return this.errorEmitter.event;
}
fireError(error, message, count) {
this.errorEmitter.fire([this.asError(error), message, count]);
};
Object.defineProperty(AbstractMessageWriter.prototype, "onClose", {
get: function () {
return this.closeEmitter.event;
},
enumerable: true,
configurable: true
});
AbstractMessageWriter.prototype.fireClose = function () {
}
get onClose() {
return this.closeEmitter.event;
}
fireClose() {
this.closeEmitter.fire(undefined);
};
AbstractMessageWriter.prototype.asError = function (error) {
}
asError(error) {
if (error instanceof Error) {

@@ -66,24 +48,20 @@ return error;

else {
return new Error("Writer recevied error. Reason: " + (Is.string(error.message) ? error.message : 'unknown'));
return new Error(`Writer recevied error. Reason: ${Is.string(error.message) ? error.message : 'unknown'}`);
}
};
return AbstractMessageWriter;
}());
}
}
exports.AbstractMessageWriter = AbstractMessageWriter;
var StreamMessageWriter = /** @class */ (function (_super) {
__extends(StreamMessageWriter, _super);
function StreamMessageWriter(writable, encoding) {
if (encoding === void 0) { encoding = 'utf8'; }
var _this = _super.call(this) || this;
_this.writable = writable;
_this.encoding = encoding;
_this.errorCount = 0;
_this.writable.on('error', function (error) { return _this.fireError(error); });
_this.writable.on('close', function () { return _this.fireClose(); });
return _this;
class StreamMessageWriter extends AbstractMessageWriter {
constructor(writable, encoding = 'utf8') {
super();
this.writable = writable;
this.encoding = encoding;
this.errorCount = 0;
this.writable.on('error', (error) => this.fireError(error));
this.writable.on('close', () => this.fireClose());
}
StreamMessageWriter.prototype.write = function (msg) {
var json = JSON.stringify(msg);
var contentLength = Buffer.byteLength(json, this.encoding);
var headers = [
write(msg) {
let json = JSON.stringify(msg);
let contentLength = Buffer.byteLength(json, this.encoding);
let headers = [
ContentLength, contentLength.toString(), CRLF,

@@ -103,20 +81,17 @@ CRLF

}
};
return StreamMessageWriter;
}(AbstractMessageWriter));
}
}
exports.StreamMessageWriter = StreamMessageWriter;
var IPCMessageWriter = /** @class */ (function (_super) {
__extends(IPCMessageWriter, _super);
function IPCMessageWriter(process) {
var _this = _super.call(this) || this;
_this.process = process;
_this.errorCount = 0;
_this.queue = [];
_this.sending = false;
var eventEmitter = _this.process;
eventEmitter.on('error', function (error) { return _this.fireError(error); });
eventEmitter.on('close', function () { return _this.fireClose; });
return _this;
class IPCMessageWriter extends AbstractMessageWriter {
constructor(process) {
super();
this.process = process;
this.errorCount = 0;
this.queue = [];
this.sending = false;
let eventEmitter = this.process;
eventEmitter.on('error', (error) => this.fireError(error));
eventEmitter.on('close', () => this.fireClose);
}
IPCMessageWriter.prototype.write = function (msg) {
write(msg) {
if (!this.sending && this.queue.length === 0) {

@@ -129,19 +104,18 @@ // See https://github.com/nodejs/node/issues/7657

}
};
IPCMessageWriter.prototype.doWriteMessage = function (msg) {
var _this = this;
}
doWriteMessage(msg) {
try {
if (this.process.send) {
this.sending = true;
this.process.send(msg, undefined, undefined, function (error) {
_this.sending = false;
this.process.send(msg, undefined, undefined, (error) => {
this.sending = false;
if (error) {
_this.errorCount++;
_this.fireError(error, msg, _this.errorCount);
this.errorCount++;
this.fireError(error, msg, this.errorCount);
}
else {
_this.errorCount = 0;
this.errorCount = 0;
}
if (_this.queue.length > 0) {
_this.doWriteMessage(_this.queue.shift());
if (this.queue.length > 0) {
this.doWriteMessage(this.queue.shift());
}

@@ -155,21 +129,17 @@ });

}
};
return IPCMessageWriter;
}(AbstractMessageWriter));
}
}
exports.IPCMessageWriter = IPCMessageWriter;
var SocketMessageWriter = /** @class */ (function (_super) {
__extends(SocketMessageWriter, _super);
function SocketMessageWriter(socket, encoding) {
if (encoding === void 0) { encoding = 'utf8'; }
var _this = _super.call(this) || this;
_this.socket = socket;
_this.queue = [];
_this.sending = false;
_this.encoding = encoding;
_this.errorCount = 0;
_this.socket.on('error', function (error) { return _this.fireError(error); });
_this.socket.on('close', function () { return _this.fireClose(); });
return _this;
class SocketMessageWriter extends AbstractMessageWriter {
constructor(socket, encoding = 'utf8') {
super();
this.socket = socket;
this.queue = [];
this.sending = false;
this.encoding = encoding;
this.errorCount = 0;
this.socket.on('error', (error) => this.fireError(error));
this.socket.on('close', () => this.fireClose());
}
SocketMessageWriter.prototype.write = function (msg) {
write(msg) {
if (!this.sending && this.queue.length === 0) {

@@ -182,8 +152,7 @@ // See https://github.com/nodejs/node/issues/7657

}
};
SocketMessageWriter.prototype.doWriteMessage = function (msg) {
var _this = this;
var json = JSON.stringify(msg);
var contentLength = Buffer.byteLength(json, this.encoding);
var headers = [
}
doWriteMessage(msg) {
let json = JSON.stringify(msg);
let contentLength = Buffer.byteLength(json, this.encoding);
let headers = [
ContentLength, contentLength.toString(), CRLF,

@@ -195,18 +164,18 @@ CRLF

this.sending = true;
this.socket.write(headers.join(''), 'ascii', function (error) {
this.socket.write(headers.join(''), 'ascii', (error) => {
if (error) {
_this.handleError(error, msg);
this.handleError(error, msg);
}
try {
// Now write the content. This can be written in any encoding
_this.socket.write(json, _this.encoding, function (error) {
_this.sending = false;
this.socket.write(json, this.encoding, (error) => {
this.sending = false;
if (error) {
_this.handleError(error, msg);
this.handleError(error, msg);
}
else {
_this.errorCount = 0;
this.errorCount = 0;
}
if (_this.queue.length > 0) {
_this.doWriteMessage(_this.queue.shift());
if (this.queue.length > 0) {
this.doWriteMessage(this.queue.shift());
}

@@ -216,3 +185,3 @@ });

catch (error) {
_this.handleError(error, msg);
this.handleError(error, msg);
}

@@ -224,9 +193,8 @@ });

}
};
SocketMessageWriter.prototype.handleError = function (error, msg) {
}
handleError(error, msg) {
this.errorCount++;
this.fireError(error, msg, this.errorCount);
};
return SocketMessageWriter;
}(AbstractMessageWriter));
}
}
exports.SocketMessageWriter = SocketMessageWriter;

38

lib/pipeSupport.js

@@ -7,27 +7,26 @@ /* --------------------------------------------------------------------------------------------

Object.defineProperty(exports, "__esModule", { value: true });
var path_1 = require("path");
var os_1 = require("os");
var crypto_1 = require("crypto");
var net_1 = require("net");
var messageReader_1 = require("./messageReader");
var messageWriter_1 = require("./messageWriter");
const path_1 = require("path");
const os_1 = require("os");
const crypto_1 = require("crypto");
const net_1 = require("net");
const messageReader_1 = require("./messageReader");
const messageWriter_1 = require("./messageWriter");
function generateRandomPipeName() {
var randomSuffix = crypto_1.randomBytes(21).toString('hex');
const randomSuffix = crypto_1.randomBytes(21).toString('hex');
if (process.platform === 'win32') {
return "\\\\.\\pipe\\vscode-jsonrpc-" + randomSuffix + "-sock";
return `\\\\.\\pipe\\vscode-jsonrpc-${randomSuffix}-sock`;
}
else {
// Mac/Unix: use socket file
return path_1.join(os_1.tmpdir(), "vscode-" + randomSuffix + ".sock");
return path_1.join(os_1.tmpdir(), `vscode-${randomSuffix}.sock`);
}
}
exports.generateRandomPipeName = generateRandomPipeName;
function createClientPipeTransport(pipeName, encoding) {
if (encoding === void 0) { encoding = 'utf-8'; }
var connectResolve;
var connected = new Promise(function (resolve, _reject) {
function createClientPipeTransport(pipeName, encoding = 'utf-8') {
let connectResolve;
let connected = new Promise((resolve, _reject) => {
connectResolve = resolve;
});
return new Promise(function (resolve, reject) {
var server = net_1.createServer(function (socket) {
return new Promise((resolve, reject) => {
let server = net_1.createServer((socket) => {
server.close();

@@ -40,6 +39,6 @@ connectResolve([

server.on('error', reject);
server.listen(pipeName, function () {
server.listen(pipeName, () => {
server.removeListener('error', reject);
resolve({
onConnected: function () { return connected; }
onConnected: () => { return connected; }
});

@@ -50,5 +49,4 @@ });

exports.createClientPipeTransport = createClientPipeTransport;
function createServerPipeTransport(pipeName, encoding) {
if (encoding === void 0) { encoding = 'utf-8'; }
var socket = net_1.createConnection(pipeName);
function createServerPipeTransport(pipeName, encoding = 'utf-8') {
const socket = net_1.createConnection(pipeName);
return [

@@ -55,0 +53,0 @@ new messageReader_1.SocketMessageReader(socket, encoding),

26

lib/socketSupport.js

@@ -7,13 +7,12 @@ /* --------------------------------------------------------------------------------------------

Object.defineProperty(exports, "__esModule", { value: true });
var net_1 = require("net");
var messageReader_1 = require("./messageReader");
var messageWriter_1 = require("./messageWriter");
function createClientSocketTransport(port, encoding) {
if (encoding === void 0) { encoding = 'utf-8'; }
var connectResolve;
var connected = new Promise(function (resolve, _reject) {
const net_1 = require("net");
const messageReader_1 = require("./messageReader");
const messageWriter_1 = require("./messageWriter");
function createClientSocketTransport(port, encoding = 'utf-8') {
let connectResolve;
let connected = new Promise((resolve, _reject) => {
connectResolve = resolve;
});
return new Promise(function (resolve, reject) {
var server = net_1.createServer(function (socket) {
return new Promise((resolve, reject) => {
let server = net_1.createServer((socket) => {
server.close();

@@ -26,6 +25,6 @@ connectResolve([

server.on('error', reject);
server.listen(port, '127.0.0.1', function () {
server.listen(port, '127.0.0.1', () => {
server.removeListener('error', reject);
resolve({
onConnected: function () { return connected; }
onConnected: () => { return connected; }
});

@@ -36,5 +35,4 @@ });

exports.createClientSocketTransport = createClientSocketTransport;
function createServerSocketTransport(port, encoding) {
if (encoding === void 0) { encoding = 'utf-8'; }
var socket = net_1.createConnection(port, '127.0.0.1');
function createServerSocketTransport(port, encoding = 'utf-8') {
const socket = net_1.createConnection(port, '127.0.0.1');
return [

@@ -41,0 +39,0 @@ new messageReader_1.SocketMessageReader(socket, encoding),

4

package.json
{
"name": "vscode-jsonrpc",
"description": "A json rpc implementation over streams",
"version": "3.7.0-next.1",
"version": "4.0.0-next.1",
"author": "Microsoft Corporation",

@@ -15,3 +15,3 @@ "license": "MIT",

"engines": {
"node": ">=4.0.0 || >=6.0.0"
"node": ">=8.0.0 || >=10.0.0"
},

@@ -18,0 +18,0 @@ "main": "./lib/main.js",

4

README.md

@@ -50,2 +50,6 @@ # VSCode JSON RPC

### 4.0.0
- move JS target to ES6.
### 3.0.0:

@@ -52,0 +56,0 @@

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc