vscode-jsonrpc
Advanced tools
Comparing version 3.7.0-next.1 to 4.0.0-next.1
@@ -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; |
@@ -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; |
@@ -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; |
@@ -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; |
@@ -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; |
@@ -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; |
@@ -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; |
@@ -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), |
@@ -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), |
{ | ||
"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", |
@@ -50,2 +50,6 @@ # VSCode JSON RPC | ||
### 4.0.0 | ||
- move JS target to ES6. | ||
### 3.0.0: | ||
@@ -52,0 +56,0 @@ |
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
64
118514
2896