.config/coc/extensions/node_modules/coc-json/node_modules/vscode-jsonrpc/lib/node/ril.js

   1 "use strict";
   2 /* --------------------------------------------------------------------------------------------
   3  * Copyright (c) Microsoft Corporation. All rights reserved.
   4  * Licensed under the MIT License. See License.txt in the project root for license information.
   5  * ------------------------------------------------------------------------------------------ */
   6 Object.defineProperty(exports, "__esModule", { value: true });
   7 const ral_1 = require("../common/ral");
   8 const util_1 = require("util");
   9 const disposable_1 = require("../common/disposable");
  10 const messageBuffer_1 = require("../common/messageBuffer");
  11 class MessageBuffer extends messageBuffer_1.AbstractMessageBuffer {
  12     constructor(encoding = 'utf-8') {
  13         super(encoding);
  14     }
  15     emptyBuffer() {
  16         return MessageBuffer.emptyBuffer;
  17     }
  18     fromString(value, encoding) {
  19         return Buffer.from(value, encoding);
  20     }
  21     toString(value, encoding) {
  22         if (value instanceof Buffer) {
  23             return value.toString(encoding);
  24         }
  25         else {
  26             return new util_1.TextDecoder(encoding).decode(value);
  27         }
  28     }
  29     asNative(buffer, length) {
  30         if (length === undefined) {
  31             return buffer instanceof Buffer ? buffer : Buffer.from(buffer);
  32         }
  33         else {
  34             return buffer instanceof Buffer ? buffer.slice(0, length) : Buffer.from(buffer, 0, length);
  35         }
  36     }
  37     allocNative(length) {
  38         return Buffer.allocUnsafe(length);
  39     }
  40 }
  41 MessageBuffer.emptyBuffer = Buffer.allocUnsafe(0);
  42 class ReadableStreamWrapper {
  43     constructor(stream) {
  44         this.stream = stream;
  45     }
  46     onClose(listener) {
  47         this.stream.on('close', listener);
  48         return disposable_1.Disposable.create(() => this.stream.off('close', listener));
  49     }
  50     onError(listener) {
  51         this.stream.on('error', listener);
  52         return disposable_1.Disposable.create(() => this.stream.off('error', listener));
  53     }
  54     onEnd(listener) {
  55         this.stream.on('end', listener);
  56         return disposable_1.Disposable.create(() => this.stream.off('end', listener));
  57     }
  58     onData(listener) {
  59         this.stream.on('data', listener);
  60         return disposable_1.Disposable.create(() => this.stream.off('data', listener));
  61     }
  62 }
  63 class WritableStreamWrapper {
  64     constructor(stream) {
  65         this.stream = stream;
  66     }
  67     onClose(listener) {
  68         this.stream.on('close', listener);
  69         return disposable_1.Disposable.create(() => this.stream.off('close', listener));
  70     }
  71     onError(listener) {
  72         this.stream.on('error', listener);
  73         return disposable_1.Disposable.create(() => this.stream.off('error', listener));
  74     }
  75     onEnd(listener) {
  76         this.stream.on('end', listener);
  77         return disposable_1.Disposable.create(() => this.stream.off('end', listener));
  78     }
  79     write(data, encoding) {
  80         return new Promise((resolve, reject) => {
  81             const callback = (error) => {
  82                 if (error === undefined || error === null) {
  83                     resolve();
  84                 }
  85                 else {
  86                     reject(error);
  87                 }
  88             };
  89             if (typeof data === 'string') {
  90                 this.stream.write(data, encoding, callback);
  91             }
  92             else {
  93                 this.stream.write(data, callback);
  94             }
  95         });
  96     }
  97     end() {
  98         this.stream.end();
  99     }
 100 }
 101 const _ril = Object.freeze({
 102     messageBuffer: Object.freeze({
 103         create: (encoding) => new MessageBuffer(encoding)
 104     }),
 105     applicationJson: Object.freeze({
 106         encoder: Object.freeze({
 107             name: 'application/json',
 108             encode: (msg, options) => {
 109                 try {
 110                     return Promise.resolve(Buffer.from(JSON.stringify(msg, undefined, 0), options.charset));
 111                 }
 112                 catch (err) {
 113                     return Promise.reject(err);
 114                 }
 115             }
 116         }),
 117         decoder: Object.freeze({
 118             name: 'application/json',
 119             decode: (buffer, options) => {
 120                 try {
 121                     if (buffer instanceof Buffer) {
 122                         return Promise.resolve(JSON.parse(buffer.toString(options.charset)));
 123                     }
 124                     else {
 125                         return Promise.resolve(JSON.parse(new util_1.TextDecoder(options.charset).decode(buffer)));
 126                     }
 127                 }
 128                 catch (err) {
 129                     return Promise.reject(err);
 130                 }
 131             }
 132         })
 133     }),
 134     stream: Object.freeze({
 135         asReadableStream: (stream) => new ReadableStreamWrapper(stream),
 136         asWritableStream: (stream) => new WritableStreamWrapper(stream)
 137     }),
 138     console: console,
 139     timer: Object.freeze({
 140         setTimeout(callback, ms, ...args) {
 141             return setTimeout(callback, ms, ...args);
 142         },
 143         clearTimeout(handle) {
 144             clearTimeout(handle);
 145         },
 146         setImmediate(callback, ...args) {
 147             return setImmediate(callback, ...args);
 148         },
 149         clearImmediate(handle) {
 150             clearImmediate(handle);
 151         }
 152     })
 153 });
 154 function RIL() {
 155     return _ril;
 156 }
 157 (function (RIL) {
 158     function install() {
 159         ral_1.default.install(_ril);
 160     }
 161     RIL.install = install;
 162 })(RIL || (RIL = {}));
 163 exports.default = RIL;
 164 //# sourceMappingURL=ril.js.map