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

   1 "use strict";
   2 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
   3     if (k2 === undefined) k2 = k;
   4     Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
   5 }) : (function(o, m, k, k2) {
   6     if (k2 === undefined) k2 = k;
   7     o[k2] = m[k];
   8 }));
   9 var __exportStar = (this && this.__exportStar) || function(m, exports) {
  10     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
  11 };
  12 Object.defineProperty(exports, "__esModule", { value: true });
  13 exports.createMessageConnection = exports.createServerSocketTransport = exports.createClientSocketTransport = exports.createServerPipeTransport = exports.createClientPipeTransport = exports.generateRandomPipeName = exports.StreamMessageWriter = exports.StreamMessageReader = exports.SocketMessageWriter = exports.SocketMessageReader = exports.IPCMessageWriter = exports.IPCMessageReader = void 0;
  14 /* --------------------------------------------------------------------------------------------
  15  * Copyright (c) Microsoft Corporation. All rights reserved.
  16  * Licensed under the MIT License. See License.txt in the project root for license information.
  17  * ----------------------------------------------------------------------------------------- */
  18 const ril_1 = require("./ril");
  19 // Install the node runtime abstract.
  20 ril_1.default.install();
  21 const api_1 = require("../common/api");
  22 const path = require("path");
  23 const os = require("os");
  24 const crypto_1 = require("crypto");
  25 const net_1 = require("net");
  26 __exportStar(require("../common/api"), exports);
  27 class IPCMessageReader extends api_1.AbstractMessageReader {
  28     constructor(process) {
  29         super();
  30         this.process = process;
  31         let eventEmitter = this.process;
  32         eventEmitter.on('error', (error) => this.fireError(error));
  33         eventEmitter.on('close', () => this.fireClose());
  34     }
  35     listen(callback) {
  36         this.process.on('message', callback);
  37         return api_1.Disposable.create(() => this.process.off('message', callback));
  38     }
  39 }
  40 exports.IPCMessageReader = IPCMessageReader;
  41 class IPCMessageWriter extends api_1.AbstractMessageWriter {
  42     constructor(process) {
  43         super();
  44         this.process = process;
  45         this.errorCount = 0;
  46         let eventEmitter = this.process;
  47         eventEmitter.on('error', (error) => this.fireError(error));
  48         eventEmitter.on('close', () => this.fireClose);
  49     }
  50     write(msg) {
  51         try {
  52             if (typeof this.process.send === 'function') {
  53                 this.process.send(msg, undefined, undefined, (error) => {
  54                     if (error) {
  55                         this.errorCount++;
  56                         this.handleError(error, msg);
  57                     }
  58                     else {
  59                         this.errorCount = 0;
  60                     }
  61                 });
  62             }
  63             return Promise.resolve();
  64         }
  65         catch (error) {
  66             this.handleError(error, msg);
  67             return Promise.reject(error);
  68         }
  69     }
  70     handleError(error, msg) {
  71         this.errorCount++;
  72         this.fireError(error, msg, this.errorCount);
  73     }
  74     end() {
  75     }
  76 }
  77 exports.IPCMessageWriter = IPCMessageWriter;
  78 class SocketMessageReader extends api_1.ReadableStreamMessageReader {
  79     constructor(socket, encoding = 'utf-8') {
  80         super(ril_1.default().stream.asReadableStream(socket), encoding);
  81     }
  82 }
  83 exports.SocketMessageReader = SocketMessageReader;
  84 class SocketMessageWriter extends api_1.WriteableStreamMessageWriter {
  85     constructor(socket, options) {
  86         super(ril_1.default().stream.asWritableStream(socket), options);
  87         this.socket = socket;
  88     }
  89     dispose() {
  90         super.dispose();
  91         this.socket.destroy();
  92     }
  93 }
  94 exports.SocketMessageWriter = SocketMessageWriter;
  95 class StreamMessageReader extends api_1.ReadableStreamMessageReader {
  96     constructor(readble, encoding) {
  97         super(ril_1.default().stream.asReadableStream(readble), encoding);
  98     }
  99 }
 100 exports.StreamMessageReader = StreamMessageReader;
 101 class StreamMessageWriter extends api_1.WriteableStreamMessageWriter {
 102     constructor(writable, options) {
 103         super(ril_1.default().stream.asWritableStream(writable), options);
 104     }
 105 }
 106 exports.StreamMessageWriter = StreamMessageWriter;
 107 const XDG_RUNTIME_DIR = process.env['XDG_RUNTIME_DIR'];
 108 const safeIpcPathLengths = new Map([
 109     ['linux', 107],
 110     ['darwin', 103]
 111 ]);
 112 function generateRandomPipeName() {
 113     const randomSuffix = crypto_1.randomBytes(21).toString('hex');
 114     if (process.platform === 'win32') {
 115         return `\\\\.\\pipe\\vscode-jsonrpc-${randomSuffix}-sock`;
 116     }
 117     let result;
 118     if (XDG_RUNTIME_DIR) {
 119         result = path.join(XDG_RUNTIME_DIR, `vscode-ipc-${randomSuffix}.sock`);
 120     }
 121     else {
 122         result = path.join(os.tmpdir(), `vscode-${randomSuffix}.sock`);
 123     }
 124     const limit = safeIpcPathLengths.get(process.platform);
 125     if (limit !== undefined && result.length >= limit) {
 126         ril_1.default().console.warn(`WARNING: IPC handle "${result}" is longer than ${limit} characters.`);
 127     }
 128     return result;
 129 }
 130 exports.generateRandomPipeName = generateRandomPipeName;
 131 function createClientPipeTransport(pipeName, encoding = 'utf-8') {
 132     let connectResolve;
 133     const connected = new Promise((resolve, _reject) => {
 134         connectResolve = resolve;
 135     });
 136     return new Promise((resolve, reject) => {
 137         let server = net_1.createServer((socket) => {
 138             server.close();
 139             connectResolve([
 140                 new SocketMessageReader(socket, encoding),
 141                 new SocketMessageWriter(socket, encoding)
 142             ]);
 143         });
 144         server.on('error', reject);
 145         server.listen(pipeName, () => {
 146             server.removeListener('error', reject);
 147             resolve({
 148                 onConnected: () => { return connected; }
 149             });
 150         });
 151     });
 152 }
 153 exports.createClientPipeTransport = createClientPipeTransport;
 154 function createServerPipeTransport(pipeName, encoding = 'utf-8') {
 155     const socket = net_1.createConnection(pipeName);
 156     return [
 157         new SocketMessageReader(socket, encoding),
 158         new SocketMessageWriter(socket, encoding)
 159     ];
 160 }
 161 exports.createServerPipeTransport = createServerPipeTransport;
 162 function createClientSocketTransport(port, encoding = 'utf-8') {
 163     let connectResolve;
 164     const connected = new Promise((resolve, _reject) => {
 165         connectResolve = resolve;
 166     });
 167     return new Promise((resolve, reject) => {
 168         const server = net_1.createServer((socket) => {
 169             server.close();
 170             connectResolve([
 171                 new SocketMessageReader(socket, encoding),
 172                 new SocketMessageWriter(socket, encoding)
 173             ]);
 174         });
 175         server.on('error', reject);
 176         server.listen(port, '127.0.0.1', () => {
 177             server.removeListener('error', reject);
 178             resolve({
 179                 onConnected: () => { return connected; }
 180             });
 181         });
 182     });
 183 }
 184 exports.createClientSocketTransport = createClientSocketTransport;
 185 function createServerSocketTransport(port, encoding = 'utf-8') {
 186     const socket = net_1.createConnection(port, '127.0.0.1');
 187     return [
 188         new SocketMessageReader(socket, encoding),
 189         new SocketMessageWriter(socket, encoding)
 190     ];
 191 }
 192 exports.createServerSocketTransport = createServerSocketTransport;
 193 function isReadableStream(value) {
 194     const candidate = value;
 195     return candidate.read !== undefined && candidate.addListener !== undefined;
 196 }
 197 function isWritableStream(value) {
 198     const candidate = value;
 199     return candidate.write !== undefined && candidate.addListener !== undefined;
 200 }
 201 function createMessageConnection(input, output, logger, options) {
 202     if (!logger) {
 203         logger = api_1.NullLogger;
 204     }
 205     const reader = isReadableStream(input) ? new StreamMessageReader(input) : input;
 206     const writer = isWritableStream(output) ? new StreamMessageWriter(output) : output;
 207     if (api_1.ConnectionStrategy.is(options)) {
 208         options = { connectionStrategy: options };
 209     }
 210     return api_1.createMessageConnection(reader, writer, logger, options);
 211 }
 212 exports.createMessageConnection = createMessageConnection;
 213 //# sourceMappingURL=main.js.map