.config/coc/extensions/node_modules/coc-json/node_modules/vscode-jsonrpc/lib/common/messageWriter.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.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = void 0;
   8 const ral_1 = require("./ral");
   9 const Is = require("./is");
  10 const semaphore_1 = require("./semaphore");
  11 const events_1 = require("./events");
  12 const ContentLength = 'Content-Length: ';
  13 const CRLF = '\r\n';
  14 var MessageWriter;
  15 (function (MessageWriter) {
  16     function is(value) {
  17         let candidate = value;
  18         return candidate && Is.func(candidate.dispose) && Is.func(candidate.onClose) &&
  19             Is.func(candidate.onError) && Is.func(candidate.write);
  20     }
  21     MessageWriter.is = is;
  22 })(MessageWriter = exports.MessageWriter || (exports.MessageWriter = {}));
  23 class AbstractMessageWriter {
  24     constructor() {
  25         this.errorEmitter = new events_1.Emitter();
  26         this.closeEmitter = new events_1.Emitter();
  27     }
  28     dispose() {
  29         this.errorEmitter.dispose();
  30         this.closeEmitter.dispose();
  31     }
  32     get onError() {
  33         return this.errorEmitter.event;
  34     }
  35     fireError(error, message, count) {
  36         this.errorEmitter.fire([this.asError(error), message, count]);
  37     }
  38     get onClose() {
  39         return this.closeEmitter.event;
  40     }
  41     fireClose() {
  42         this.closeEmitter.fire(undefined);
  43     }
  44     asError(error) {
  45         if (error instanceof Error) {
  46             return error;
  47         }
  48         else {
  49             return new Error(`Writer received error. Reason: ${Is.string(error.message) ? error.message : 'unknown'}`);
  50         }
  51     }
  52 }
  53 exports.AbstractMessageWriter = AbstractMessageWriter;
  54 var ResolvedMessageWriterOptions;
  55 (function (ResolvedMessageWriterOptions) {
  56     function fromOptions(options) {
  57         var _a, _b;
  58         if (options === undefined || typeof options === 'string') {
  59             return { charset: options !== null && options !== void 0 ? options : 'utf-8', contentTypeEncoder: ral_1.default().applicationJson.encoder };
  60         }
  61         else {
  62             return { charset: (_a = options.charset) !== null && _a !== void 0 ? _a : 'utf-8', contentEncoder: options.contentEncoder, contentTypeEncoder: (_b = options.contentTypeEncoder) !== null && _b !== void 0 ? _b : ral_1.default().applicationJson.encoder };
  63         }
  64     }
  65     ResolvedMessageWriterOptions.fromOptions = fromOptions;
  66 })(ResolvedMessageWriterOptions || (ResolvedMessageWriterOptions = {}));
  67 class WriteableStreamMessageWriter extends AbstractMessageWriter {
  68     constructor(writable, options) {
  69         super();
  70         this.writable = writable;
  71         this.options = ResolvedMessageWriterOptions.fromOptions(options);
  72         this.errorCount = 0;
  73         this.writeSemaphore = new semaphore_1.Semaphore(1);
  74         this.writable.onError((error) => this.fireError(error));
  75         this.writable.onClose(() => this.fireClose());
  76     }
  77     async write(msg) {
  78         return this.writeSemaphore.lock(async () => {
  79             const payload = this.options.contentTypeEncoder.encode(msg, this.options).then((buffer) => {
  80                 if (this.options.contentEncoder !== undefined) {
  81                     return this.options.contentEncoder.encode(buffer);
  82                 }
  83                 else {
  84                     return buffer;
  85                 }
  86             });
  87             return payload.then((buffer) => {
  88                 const headers = [];
  89                 headers.push(ContentLength, buffer.byteLength.toString(), CRLF);
  90                 headers.push(CRLF);
  91                 return this.doWrite(msg, headers, buffer);
  92             }, (error) => {
  93                 this.fireError(error);
  94                 throw error;
  95             });
  96         });
  97     }
  98     async doWrite(msg, headers, data) {
  99         try {
 100             await this.writable.write(headers.join(''), 'ascii');
 101             return this.writable.write(data);
 102         }
 103         catch (error) {
 104             this.handleError(error, msg);
 105             return Promise.reject(error);
 106         }
 107     }
 108     handleError(error, msg) {
 109         this.errorCount++;
 110         this.fireError(error, msg, this.errorCount);
 111     }
 112     end() {
 113         this.writable.end();
 114     }
 115 }
 116 exports.WriteableStreamMessageWriter = WriteableStreamMessageWriter;
 117 //# sourceMappingURL=messageWriter.js.map