.config/coc/extensions/node_modules/coc-json/node_modules/vscode-jsonrpc/lib/common/messageReader.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 exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = void 0;
   8 const ral_1 = require("./ral");
   9 const Is = require("./is");
  10 const events_1 = require("./events");
  11 var MessageReader;
  12 (function (MessageReader) {
  13     function is(value) {
  14         let candidate = value;
  15         return candidate && Is.func(candidate.listen) && Is.func(candidate.dispose) &&
  16             Is.func(candidate.onError) && Is.func(candidate.onClose) && Is.func(candidate.onPartialMessage);
  17     }
  18     MessageReader.is = is;
  19 })(MessageReader = exports.MessageReader || (exports.MessageReader = {}));
  20 class AbstractMessageReader {
  21     constructor() {
  22         this.errorEmitter = new events_1.Emitter();
  23         this.closeEmitter = new events_1.Emitter();
  24         this.partialMessageEmitter = new events_1.Emitter();
  25     }
  26     dispose() {
  27         this.errorEmitter.dispose();
  28         this.closeEmitter.dispose();
  29     }
  30     get onError() {
  31         return this.errorEmitter.event;
  32     }
  33     fireError(error) {
  34         this.errorEmitter.fire(this.asError(error));
  35     }
  36     get onClose() {
  37         return this.closeEmitter.event;
  38     }
  39     fireClose() {
  40         this.closeEmitter.fire(undefined);
  41     }
  42     get onPartialMessage() {
  43         return this.partialMessageEmitter.event;
  44     }
  45     firePartialMessage(info) {
  46         this.partialMessageEmitter.fire(info);
  47     }
  48     asError(error) {
  49         if (error instanceof Error) {
  50             return error;
  51         }
  52         else {
  53             return new Error(`Reader received error. Reason: ${Is.string(error.message) ? error.message : 'unknown'}`);
  54         }
  55     }
  56 }
  57 exports.AbstractMessageReader = AbstractMessageReader;
  58 var ResolvedMessageReaderOptions;
  59 (function (ResolvedMessageReaderOptions) {
  60     function fromOptions(options) {
  61         var _a;
  62         let charset;
  63         let result;
  64         let contentDecoder;
  65         const contentDecoders = new Map();
  66         let contentTypeDecoder;
  67         const contentTypeDecoders = new Map();
  68         if (options === undefined || typeof options === 'string') {
  69             charset = options !== null && options !== void 0 ? options : 'utf-8';
  70         }
  71         else {
  72             charset = (_a = options.charset) !== null && _a !== void 0 ? _a : 'utf-8';
  73             if (options.contentDecoder !== undefined) {
  74                 contentDecoder = options.contentDecoder;
  75                 contentDecoders.set(contentDecoder.name, contentDecoder);
  76             }
  77             if (options.contentDecoders !== undefined) {
  78                 for (const decoder of options.contentDecoders) {
  79                     contentDecoders.set(decoder.name, decoder);
  80                 }
  81             }
  82             if (options.contentTypeDecoder !== undefined) {
  83                 contentTypeDecoder = options.contentTypeDecoder;
  84                 contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
  85             }
  86             if (options.contentTypeDecoders !== undefined) {
  87                 for (const decoder of options.contentTypeDecoders) {
  88                     contentTypeDecoders.set(decoder.name, decoder);
  89                 }
  90             }
  91         }
  92         if (contentTypeDecoder === undefined) {
  93             contentTypeDecoder = ral_1.default().applicationJson.decoder;
  94             contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
  95         }
  96         return { charset, contentDecoder, contentDecoders, contentTypeDecoder, contentTypeDecoders };
  97     }
  98     ResolvedMessageReaderOptions.fromOptions = fromOptions;
  99 })(ResolvedMessageReaderOptions || (ResolvedMessageReaderOptions = {}));
 100 class ReadableStreamMessageReader extends AbstractMessageReader {
 101     constructor(readable, options) {
 102         super();
 103         this.readable = readable;
 104         this.options = ResolvedMessageReaderOptions.fromOptions(options);
 105         this.buffer = ral_1.default().messageBuffer.create(this.options.charset);
 106         this._partialMessageTimeout = 10000;
 107         this.nextMessageLength = -1;
 108         this.messageToken = 0;
 109     }
 110     set partialMessageTimeout(timeout) {
 111         this._partialMessageTimeout = timeout;
 112     }
 113     get partialMessageTimeout() {
 114         return this._partialMessageTimeout;
 115     }
 116     listen(callback) {
 117         this.nextMessageLength = -1;
 118         this.messageToken = 0;
 119         this.partialMessageTimer = undefined;
 120         this.callback = callback;
 121         const result = this.readable.onData((data) => {
 122             this.onData(data);
 123         });
 124         this.readable.onError((error) => this.fireError(error));
 125         this.readable.onClose(() => this.fireClose());
 126         return result;
 127     }
 128     onData(data) {
 129         this.buffer.append(data);
 130         while (true) {
 131             if (this.nextMessageLength === -1) {
 132                 const headers = this.buffer.tryReadHeaders();
 133                 if (!headers) {
 134                     return;
 135                 }
 136                 const contentLength = headers.get('Content-Length');
 137                 if (!contentLength) {
 138                     throw new Error('Header must provide a Content-Length property.');
 139                 }
 140                 const length = parseInt(contentLength);
 141                 if (isNaN(length)) {
 142                     throw new Error('Content-Length value must be a number.');
 143                 }
 144                 this.nextMessageLength = length;
 145             }
 146             const body = this.buffer.tryReadBody(this.nextMessageLength);
 147             if (body === undefined) {
 148                 /** We haven't received the full message yet. */
 149                 this.setPartialMessageTimer();
 150                 return;
 151             }
 152             this.clearPartialMessageTimer();
 153             this.nextMessageLength = -1;
 154             let p;
 155             if (this.options.contentDecoder !== undefined) {
 156                 p = this.options.contentDecoder.decode(body);
 157             }
 158             else {
 159                 p = Promise.resolve(body);
 160             }
 161             p.then((value) => {
 162                 this.options.contentTypeDecoder.decode(value, this.options).then((msg) => {
 163                     this.callback(msg);
 164                 }, (error) => {
 165                     this.fireError(error);
 166                 });
 167             }, (error) => {
 168                 this.fireError(error);
 169             });
 170         }
 171     }
 172     clearPartialMessageTimer() {
 173         if (this.partialMessageTimer) {
 174             ral_1.default().timer.clearTimeout(this.partialMessageTimer);
 175             this.partialMessageTimer = undefined;
 176         }
 177     }
 178     setPartialMessageTimer() {
 179         this.clearPartialMessageTimer();
 180         if (this._partialMessageTimeout <= 0) {
 181             return;
 182         }
 183         this.partialMessageTimer = ral_1.default().timer.setTimeout((token, timeout) => {
 184             this.partialMessageTimer = undefined;
 185             if (token === this.messageToken) {
 186                 this.firePartialMessage({ messageToken: token, waitingTime: timeout });
 187                 this.setPartialMessageTimer();
 188             }
 189         }, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout);
 190     }
 191 }
 192 exports.ReadableStreamMessageReader = ReadableStreamMessageReader;
 193 //# sourceMappingURL=messageReader.js.map