vscode-jsonrpc
Version:
A json rpc implementation over streams
211 lines (210 loc) • 7.27 kB
JavaScript
;
/* --------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
* ------------------------------------------------------------------------------------------ */
Object.defineProperty(exports, "__esModule", { value: true });
exports.PromiseImpl = exports.QueueMicrotaskImpl = void 0;
const api_1 = require("../common/api");
class MessageBuffer extends api_1.AbstractMessageBuffer {
static emptyBuffer = new Uint8Array(0);
asciiDecoder;
constructor(encoding = 'utf-8') {
super(encoding);
this.asciiDecoder = new TextDecoder('ascii');
}
emptyBuffer() {
return MessageBuffer.emptyBuffer;
}
fromString(value, _encoding) {
return (new TextEncoder()).encode(value);
}
toString(value, encoding) {
if (encoding === 'ascii') {
return this.asciiDecoder.decode(value);
}
else {
return (new TextDecoder(encoding)).decode(value);
}
}
asNative(buffer, length) {
if (length === undefined) {
return buffer;
}
else {
return buffer.slice(0, length);
}
}
allocNative(length) {
return new Uint8Array(length);
}
}
class ReadableStreamWrapper {
socket;
_onData;
_messageListener;
constructor(socket) {
this.socket = socket;
this._onData = new api_1.Emitter();
this._messageListener = (event) => {
const blob = event.data;
blob.arrayBuffer().then((buffer) => {
this._onData.fire(new Uint8Array(buffer));
}, () => {
(0, api_1.RAL)().console.error(`Converting blob to array buffer failed.`);
});
};
this.socket.addEventListener('message', this._messageListener);
}
onClose(listener) {
this.socket.addEventListener('close', listener);
return api_1.Disposable.create(() => this.socket.removeEventListener('close', listener));
}
onError(listener) {
this.socket.addEventListener('error', listener);
return api_1.Disposable.create(() => this.socket.removeEventListener('error', listener));
}
onEnd(listener) {
this.socket.addEventListener('end', listener);
return api_1.Disposable.create(() => this.socket.removeEventListener('end', listener));
}
onData(listener) {
return this._onData.event(listener);
}
}
class WritableStreamWrapper {
socket;
constructor(socket) {
this.socket = socket;
}
onClose(listener) {
this.socket.addEventListener('close', listener);
return api_1.Disposable.create(() => this.socket.removeEventListener('close', listener));
}
onError(listener) {
this.socket.addEventListener('error', listener);
return api_1.Disposable.create(() => this.socket.removeEventListener('error', listener));
}
onEnd(listener) {
this.socket.addEventListener('end', listener);
return api_1.Disposable.create(() => this.socket.removeEventListener('end', listener));
}
write(data, encoding) {
if (typeof data === 'string') {
if (encoding !== undefined && encoding !== 'utf-8') {
throw new Error(`In a Browser environments only utf-8 text encoding is supported. But got encoding: ${encoding}`);
}
this.socket.send(data);
}
else {
if (data.buffer instanceof ArrayBuffer) {
this.socket.send(data.buffer);
}
else {
// We can't send a shared array buffer directly, so we need to
// create a copy of it.
this.socket.send(new Uint8Array(data.buffer).slice().buffer);
}
}
return Promise.resolve();
}
end() {
this.socket.close();
}
}
class QueueMicrotaskImpl {
isDisposed;
constructor(callback, ...args) {
this.isDisposed = false;
queueMicrotask(() => {
if (!this.isDisposed) {
callback(...args);
}
});
}
dispose() {
this.isDisposed = true;
}
}
exports.QueueMicrotaskImpl = QueueMicrotaskImpl;
class PromiseImpl {
isDisposed;
constructor(callback, ...args) {
this.isDisposed = false;
Promise.resolve().then(() => {
if (!this.isDisposed) {
callback(...args);
}
}, () => {
});
}
dispose() {
this.isDisposed = true;
}
}
exports.PromiseImpl = PromiseImpl;
const _textEncoder = new TextEncoder();
const _ril = Object.freeze({
messageBuffer: Object.freeze({
create: (encoding) => new MessageBuffer(encoding)
}),
applicationJson: Object.freeze({
encoder: Object.freeze({
name: 'application/json',
encode: (msg, options) => {
if (options.charset !== 'utf-8') {
throw new Error(`In a Browser environments only utf-8 text encoding is supported. But got encoding: ${options.charset}`);
}
return Promise.resolve(_textEncoder.encode(JSON.stringify(msg, undefined, 0)));
}
}),
decoder: Object.freeze({
name: 'application/json',
decode: (buffer, options) => {
if (!(buffer instanceof Uint8Array)) {
throw new Error(`In a Browser environments only Uint8Arrays are supported.`);
}
return Promise.resolve(JSON.parse(new TextDecoder(options.charset).decode(buffer)));
}
})
}),
stream: Object.freeze({
asReadableStream: (socket) => new ReadableStreamWrapper(socket),
asWritableStream: (socket) => new WritableStreamWrapper(socket)
}),
console: console,
timer: Object.freeze({
setTimeout(callback, ms, ...args) {
const handle = setTimeout(callback, ms, ...args);
return { dispose: () => clearTimeout(handle) };
},
setImmediate(callback, ...args) {
// Browser don't have setImmediate and setTimeout with 0 delay of 0 can cause problems
// in webviews and similar environments due to throttling.
if (typeof globalThis.queueMicrotask === 'function') {
return new QueueMicrotaskImpl(callback, ...args);
}
else if (Promise !== undefined) {
return new PromiseImpl(callback, ...args);
}
else {
const handle = setTimeout(callback, 0, ...args);
return { dispose: () => clearTimeout(handle) };
}
},
setInterval(callback, ms, ...args) {
const handle = setInterval(callback, ms, ...args);
return { dispose: () => clearInterval(handle) };
},
})
});
function RIL() {
return _ril;
}
(function (RIL) {
function install() {
api_1.RAL.install(_ril);
}
RIL.install = install;
})(RIL || (RIL = {}));
exports.default = RIL;