@adminide-stack/extension-api 11.0.1-alpha.0 → 11.0.1-alpha.12

package/lib/connections/jsonrpc2/connection.js

@@ -1,569 +1,551 @@
-import*as abortableRx from'../../utils/abortable-rx.js';import {Subject,Observable,isObservable,from}from'rxjs';import {isPromise}from'../../utils/util.js';import'@vscode-alt/monaco-editor/esm/vs/base/common/path.js';import {Emitter}from'./events.js';import {LinkedMap}from'./linkedMap.js';import AbortController from'abort-controller';import {isNotificationMessage,isRequestMessage,ErrorCodes,ResponseError,isResponseMessage}from'./messages.js';import {noopTracer}from'./trace.js';const { toPromise } = abortableRx; // to support vite esm
+import*as abortableRx from'../../utils/abortable-rx.js';import {Subject,Observable,isObservable,from}from'rxjs';import {isPromise}from'../../utils/util.js';import'@vscode-alt/monaco-editor/esm/vs/base/common/path.js';import {Emitter}from'./events.js';import {LinkedMap}from'./linkedMap.js';import AbortController from'abort-controller';import {isNotificationMessage,isRequestMessage,ErrorCodes,ResponseError,isResponseMessage}from'./messages.js';import {noopTracer}from'./trace.js';const {
+  toPromise
+} = abortableRx; // to support vite esm
 const NullLogger = Object.freeze({
-    error: () => {
-        /* noop */
-    },
-    warn: () => {
-        /* noop */
-    },
-    info: () => {
-        /* noop */
-    },
-    log: () => {
-        /* noop */
-    },
+  error: () => {
+    /* noop */
+  },
+  warn: () => {
+    /* noop */
+  },
+  info: () => {
+    /* noop */
+  },
+  log: () => {
+    /* noop */
+  }
 });
 var ConnectionErrors;
 (function (ConnectionErrors) {
-    /**
-     * The connection is closed.
-     */
-    ConnectionErrors[ConnectionErrors["Closed"] = 1] = "Closed";
-    /**
-     * The connection got unsubscribed (i.e., disposed).
-     */
-    ConnectionErrors[ConnectionErrors["Unsubscribed"] = 2] = "Unsubscribed";
-    /**
-     * The connection is already in listening mode.
-     */
-    ConnectionErrors[ConnectionErrors["AlreadyListening"] = 3] = "AlreadyListening";
+  /**
+   * The connection is closed.
+   */
+  ConnectionErrors[ConnectionErrors["Closed"] = 1] = "Closed";
+  /**
+   * The connection got unsubscribed (i.e., disposed).
+   */
+  ConnectionErrors[ConnectionErrors["Unsubscribed"] = 2] = "Unsubscribed";
+  /**
+   * The connection is already in listening mode.
+   */
+  ConnectionErrors[ConnectionErrors["AlreadyListening"] = 3] = "AlreadyListening";
 })(ConnectionErrors || (ConnectionErrors = {}));
 class ConnectionError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        Object.setPrototypeOf(this, ConnectionError.prototype);
-    }
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    Object.setPrototypeOf(this, ConnectionError.prototype);
+  }
 }
 function createConnection(transports, logger) {
-    if (!logger) {
-        logger = NullLogger;
-    }
-    return _createConnection(transports, logger);
+  if (!logger) {
+    logger = NullLogger;
+  }
+  return _createConnection(transports, logger);
 }
 var ConnectionState;
 (function (ConnectionState) {
-    ConnectionState[ConnectionState["New"] = 1] = "New";
-    ConnectionState[ConnectionState["Listening"] = 2] = "Listening";
-    ConnectionState[ConnectionState["Closed"] = 3] = "Closed";
-    ConnectionState[ConnectionState["Unsubscribed"] = 4] = "Unsubscribed";
+  ConnectionState[ConnectionState["New"] = 1] = "New";
+  ConnectionState[ConnectionState["Listening"] = 2] = "Listening";
+  ConnectionState[ConnectionState["Closed"] = 3] = "Closed";
+  ConnectionState[ConnectionState["Unsubscribed"] = 4] = "Unsubscribed";
 })(ConnectionState || (ConnectionState = {}));
 const ABORT_REQUEST_METHOD = '$/abortRequest';
 function _createConnection(transports, logger) {
-    let sequenceNumber = 0;
-    let notificationSquenceNumber = 0;
-    let unknownResponseSquenceNumber = 0;
-    const version = '2.0';
-    let starRequestHandler;
-    const requestHandlers = Object.create(null);
-    let starNotificationHandler;
-    const notificationHandlers = Object.create(null);
-    let timer = false;
-    let messageQueue = new LinkedMap();
-    let responseObservables = Object.create(null);
-    let requestAbortControllers = Object.create(null);
-    let tracer = noopTracer;
-    let state = ConnectionState.New;
-    const errorEmitter = new Emitter();
-    const closeEmitter = new Emitter();
-    const unhandledNotificationEmitter = new Emitter();
-    const unsubscribeEmitter = new Emitter();
-    function createRequestQueueKey(id) {
-        return 'req-' + id.toString();
+  let sequenceNumber = 0;
+  let notificationSquenceNumber = 0;
+  let unknownResponseSquenceNumber = 0;
+  const version = '2.0';
+  let starRequestHandler;
+  const requestHandlers = Object.create(null);
+  let starNotificationHandler;
+  const notificationHandlers = Object.create(null);
+  let timer = false;
+  let messageQueue = new LinkedMap();
+  let responseObservables = Object.create(null);
+  let requestAbortControllers = Object.create(null);
+  let tracer = noopTracer;
+  let state = ConnectionState.New;
+  const errorEmitter = new Emitter();
+  const closeEmitter = new Emitter();
+  const unhandledNotificationEmitter = new Emitter();
+  const unsubscribeEmitter = new Emitter();
+  function createRequestQueueKey(id) {
+    return 'req-' + id.toString();
+  }
+  function createResponseQueueKey(id) {
+    if (id === null) {
+      return 'res-unknown-' + (++unknownResponseSquenceNumber).toString();
+    } else {
+      return 'res-' + id.toString();
     }
-    function createResponseQueueKey(id) {
-        if (id === null) {
-            return 'res-unknown-' + (++unknownResponseSquenceNumber).toString();
-        }
-        else {
-            return 'res-' + id.toString();
-        }
+  }
+  function createNotificationQueueKey() {
+    return 'not-' + (++notificationSquenceNumber).toString();
+  }
+  function addMessageToQueue(queue, message) {
+    if (isRequestMessage(message)) {
+      queue.set(createRequestQueueKey(message.id), message);
+    } else if (isResponseMessage(message)) {
+      const key = createResponseQueueKey(message.id) + Math.random(); // TODO(sqs)
+      queue.set(key, message);
+    } else {
+      queue.set(createNotificationQueueKey(), message);
     }
-    function createNotificationQueueKey() {
-        return 'not-' + (++notificationSquenceNumber).toString();
+  }
+  function isListening() {
+    return state === ConnectionState.Listening;
+  }
+  function isClosed() {
+    return state === ConnectionState.Closed;
+  }
+  function isUnsubscribed() {
+    return state === ConnectionState.Unsubscribed;
+  }
+  function closeHandler() {
+    if (state === ConnectionState.New || state === ConnectionState.Listening) {
+      state = ConnectionState.Closed;
+      closeEmitter.fire(undefined);
     }
-    function addMessageToQueue(queue, message) {
-        if (isRequestMessage(message)) {
-            queue.set(createRequestQueueKey(message.id), message);
-        }
-        else if (isResponseMessage(message)) {
-            const key = createResponseQueueKey(message.id) + Math.random(); // TODO(sqs)
-            queue.set(key, message);
-        }
-        else {
-            queue.set(createNotificationQueueKey(), message);
-        }
+    // If the connection is unsubscribed don't sent close events.
+  }
+  function readErrorHandler(error) {
+    errorEmitter.fire([error, undefined, undefined]);
+  }
+  function writeErrorHandler(data) {
+    errorEmitter.fire(data);
+  }
+  transports.reader.onClose(closeHandler);
+  transports.reader.onError(readErrorHandler);
+  transports.writer.onClose(closeHandler);
+  transports.writer.onError(writeErrorHandler);
+  function triggerMessageQueue() {
+    if (timer || messageQueue.size === 0) {
+      return;
+    }
+    timer = true;
+    setImmediateCompat(() => {
+      timer = false;
+      processMessageQueue();
+    });
+  }
+  function processMessageQueue() {
+    if (messageQueue.size === 0) {
+      return;
     }
-    function isListening() {
-        return state === ConnectionState.Listening;
+    const message = messageQueue.shift();
+    try {
+      if (isRequestMessage(message)) {
+        handleRequest(message);
+      } else if (isNotificationMessage(message)) {
+        handleNotification(message);
+      } else if (isResponseMessage(message)) {
+        handleResponse(message);
+      } else {
+        handleInvalidMessage(message);
+      }
+    } finally {
+      triggerMessageQueue();
     }
-    function isClosed() {
-        return state === ConnectionState.Closed;
+  }
+  const callback = message => {
+    console.log('[callback.ON_MESSAGE]: ', {
+      transports,
+      message
+    });
+    try {
+      // We have received an abort signal. Check if the message is still in the queue and abort it if allowed
+      // to do so.
+      if (isNotificationMessage(message) && message.method === ABORT_REQUEST_METHOD) {
+        const key = createRequestQueueKey(message.params[0]);
+        const toAbort = messageQueue.get(key);
+        if (isRequestMessage(toAbort)) {
+          messageQueue.delete(key);
+          const response = {
+            jsonrpc: '2.0',
+            id: toAbort.id,
+            error: {
+              code: ErrorCodes.RequestAborted,
+              message: 'request aborted'
+            }
+          };
+          tracer.responseAborted(response, toAbort, message);
+          transports.writer.write(response);
+          return;
+        }
+      }
+      addMessageToQueue(messageQueue, message);
+    } finally {
+      triggerMessageQueue();
     }
-    function isUnsubscribed() {
-        return state === ConnectionState.Unsubscribed;
+  };
+  function handleRequest(requestMessage) {
+    if (isUnsubscribed()) {
+      // we return here silently since we fired an event when the
+      // connection got unsubscribed.
+      return;
     }
-    function closeHandler() {
-        if (state === ConnectionState.New || state === ConnectionState.Listening) {
-            state = ConnectionState.Closed;
-            closeEmitter.fire(undefined);
-        }
-        // If the connection is unsubscribed don't sent close events.
+    const startTime = Date.now();
+    function reply(resultOrError, complete) {
+      const message = {
+        jsonrpc: version,
+        id: requestMessage.id,
+        complete
+      };
+      if (resultOrError instanceof ResponseError) {
+        message.error = resultOrError.toJSON();
+      } else {
+        message.result = resultOrError === undefined ? null : resultOrError;
+      }
+      tracer.responseSent(message, requestMessage, startTime);
+      transports.writer.write(message);
     }
-    function readErrorHandler(error) {
-        errorEmitter.fire([error, undefined, undefined]);
+    function replyError(error) {
+      const message = {
+        jsonrpc: version,
+        id: requestMessage.id,
+        error: error.toJSON(),
+        complete: true
+      };
+      tracer.responseSent(message, requestMessage, startTime);
+      transports.writer.write(message);
     }
-    function writeErrorHandler(data) {
-        errorEmitter.fire(data);
+    function replySuccess(result) {
+      // The JSON RPC defines that a response must either have a result or an error
+      // So we can't treat undefined as a valid response result.
+      if (result === undefined) {
+        result = null;
+      }
+      const message = {
+        jsonrpc: version,
+        id: requestMessage.id,
+        result,
+        complete: true
+      };
+      tracer.responseSent(message, requestMessage, startTime);
+      transports.writer.write(message);
     }
-    transports.reader.onClose(closeHandler);
-    transports.reader.onError(readErrorHandler);
-    transports.writer.onClose(closeHandler);
-    transports.writer.onError(writeErrorHandler);
-    function triggerMessageQueue() {
-        if (timer || messageQueue.size === 0) {
-            return;
-        }
-        timer = true;
-        setImmediateCompat(() => {
-            timer = false;
-            processMessageQueue();
-        });
+    function replyComplete() {
+      const message = {
+        jsonrpc: version,
+        id: requestMessage.id,
+        complete: true
+      };
+      tracer.responseSent(message, requestMessage, startTime);
+      transports.writer.write(message);
     }
-    function processMessageQueue() {
-        if (messageQueue.size === 0) {
-            return;
-        }
-        const message = messageQueue.shift();
-        try {
-            if (isRequestMessage(message)) {
-                handleRequest(message);
-            }
-            else if (isNotificationMessage(message)) {
-                handleNotification(message);
-            }
-            else if (isResponseMessage(message)) {
-                handleResponse(message);
+    tracer.requestReceived(requestMessage);
+    const element = requestHandlers[requestMessage.method] || requestHandlers[matchedStartActor(Object.keys(requestHandlers), requestMessage.method)];
+    const requestHandler = element && element.handler;
+    if (requestHandler || starRequestHandler) {
+      const abortController = new AbortController();
+      const signalKey = String(requestMessage.id);
+      requestAbortControllers[signalKey] = abortController;
+      try {
+        const params = requestMessage.params !== undefined ? requestMessage.params : null;
+        const handlerResult = requestHandler ? requestHandler(params, abortController.signal, requestMessage.method) : starRequestHandler(requestMessage.method, params, abortController.signal);
+        if (!handlerResult) {
+          delete requestAbortControllers[signalKey];
+          replySuccess(handlerResult);
+        } else if (isPromise(handlerResult) || isObservable(handlerResult)) {
+          const onComplete = () => {
+            delete requestAbortControllers[signalKey];
+          };
+          from(handlerResult).subscribe(value => reply(value, false), error => {
+            onComplete();
+            if (error instanceof ResponseError) {
+              replyError(error);
+            } else if (error && typeof error.message === 'string') {
+              replyError(new ResponseError(ErrorCodes.InternalError, error.message, {
+                stack: error.stack,
+                ...error
+              }));
+            } else {
+              replyError(new ResponseError(ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`));
             }
-            else {
-                handleInvalidMessage(message);
-            }
-        }
-        finally {
-            triggerMessageQueue();
-        }
+          }, () => {
+            onComplete();
+            replyComplete();
+          });
+        } else {
+          delete requestAbortControllers[signalKey];
+          reply(handlerResult, true);
+        }
+      } catch (error) {
+        console.log('[ERROR]: ', error);
+        delete requestAbortControllers[signalKey];
+        if (error instanceof ResponseError) {
+          reply(error, true);
+        } else if (error && typeof error.message === 'string') {
+          replyError(new ResponseError(ErrorCodes.InternalError, error.message, {
+            stack: error.stack,
+            ...error
+          }));
+        } else {
+          replyError(new ResponseError(ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`));
+        }
+      }
+    } else {
+      replyError(new ResponseError(ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`));
     }
-    const callback = (message) => {
-        console.log('[callback.ON_MESSAGE]: ', { transports, message });
+  }
+  function handleResponse(responseMessage) {
+    if (isUnsubscribed()) {
+      // See handle request.
+      return;
+    }
+    if (responseMessage.id === null) {
+      if (responseMessage.error) {
+        logger.error(`Received response message without id: Error is: \n${JSON.stringify(responseMessage.error, undefined, 4)}`);
+      } else {
+        logger.error(`Received response message without id. No further error information provided.`);
+      }
+    } else {
+      const key = String(responseMessage.id);
+      const responseObservable = responseObservables[key];
+      if (responseObservable) {
+        tracer.responseReceived(responseMessage, responseObservable.request || responseObservable.method, responseObservable.timerStart);
         try {
-            // We have received an abort signal. Check if the message is still in the queue and abort it if allowed
-            // to do so.
-            if (isNotificationMessage(message) && message.method === ABORT_REQUEST_METHOD) {
-                const key = createRequestQueueKey(message.params[0]);
-                const toAbort = messageQueue.get(key);
-                if (isRequestMessage(toAbort)) {
-                    messageQueue.delete(key);
-                    const response = {
-                        jsonrpc: '2.0',
-                        id: toAbort.id,
-                        error: { code: ErrorCodes.RequestAborted, message: 'request aborted' },
-                    };
-                    tracer.responseAborted(response, toAbort, message);
-                    transports.writer.write(response);
-                    return;
-                }
-            }
-            addMessageToQueue(messageQueue, message);
-        }
-        finally {
-            triggerMessageQueue();
-        }
-    };
-    function handleRequest(requestMessage) {
-        if (isUnsubscribed()) {
-            // we return here silently since we fired an event when the
-            // connection got unsubscribed.
-            return;
-        }
-        const startTime = Date.now();
-        function reply(resultOrError, complete) {
-            const message = {
-                jsonrpc: version,
-                id: requestMessage.id,
-                complete,
-            };
-            if (resultOrError instanceof ResponseError) {
-                message.error = resultOrError.toJSON();
-            }
-            else {
-                message.result = resultOrError === undefined ? null : resultOrError;
-            }
-            tracer.responseSent(message, requestMessage, startTime);
-            transports.writer.write(message);
-        }
-        function replyError(error) {
-            const message = {
-                jsonrpc: version,
-                id: requestMessage.id,
-                error: error.toJSON(),
-                complete: true,
-            };
-            tracer.responseSent(message, requestMessage, startTime);
-            transports.writer.write(message);
-        }
-        function replySuccess(result) {
-            // The JSON RPC defines that a response must either have a result or an error
-            // So we can't treat undefined as a valid response result.
-            if (result === undefined) {
-                result = null;
-            }
-            const message = {
-                jsonrpc: version,
-                id: requestMessage.id,
-                result,
-                complete: true,
-            };
-            tracer.responseSent(message, requestMessage, startTime);
-            transports.writer.write(message);
-        }
-        function replyComplete() {
-            const message = {
-                jsonrpc: version,
-                id: requestMessage.id,
-                complete: true,
-            };
-            tracer.responseSent(message, requestMessage, startTime);
-            transports.writer.write(message);
-        }
-        tracer.requestReceived(requestMessage);
-        const element = requestHandlers[requestMessage.method] ||
-            requestHandlers[matchedStartActor(Object.keys(requestHandlers), requestMessage.method)];
-        const requestHandler = element && element.handler;
-        if (requestHandler || starRequestHandler) {
-            const abortController = new AbortController();
-            const signalKey = String(requestMessage.id);
-            requestAbortControllers[signalKey] = abortController;
-            try {
-                const params = requestMessage.params !== undefined ? requestMessage.params : null;
-                const handlerResult = requestHandler
-                    ? requestHandler(params, abortController.signal, requestMessage.method)
-                    : starRequestHandler(requestMessage.method, params, abortController.signal);
-                if (!handlerResult) {
-                    delete requestAbortControllers[signalKey];
-                    replySuccess(handlerResult);
-                }
-                else if (isPromise(handlerResult) || isObservable(handlerResult)) {
-                    const onComplete = () => {
-                        delete requestAbortControllers[signalKey];
-                    };
-                    from(handlerResult).subscribe((value) => reply(value, false), (error) => {
-                        onComplete();
-                        if (error instanceof ResponseError) {
-                            replyError(error);
-                        }
-                        else if (error && typeof error.message === 'string') {
-                            replyError(new ResponseError(ErrorCodes.InternalError, error.message, {
-                                stack: error.stack,
-                                ...error,
-                            }));
-                        }
-                        else {
-                            replyError(new ResponseError(ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`));
-                        }
-                    }, () => {
-                        onComplete();
-                        replyComplete();
-                    });
-                }
-                else {
-                    delete requestAbortControllers[signalKey];
-                    reply(handlerResult, true);
-                }
-            }
-            catch (error) {
-                console.log('[ERROR]: ', error);
-                delete requestAbortControllers[signalKey];
-                if (error instanceof ResponseError) {
-                    reply(error, true);
-                }
-                else if (error && typeof error.message === 'string') {
-                    replyError(new ResponseError(ErrorCodes.InternalError, error.message, {
-                        stack: error.stack,
-                        ...error,
-                    }));
-                }
-                else {
-                    replyError(new ResponseError(ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`));
-                }
+          if (responseMessage.error) {
+            const {
+              code,
+              message,
+              data
+            } = responseMessage.error;
+            const err = new ResponseError(code, message, data);
+            if (data && data.stack) {
+              err.stack = data.stack;
             }
-        }
-        else {
-            replyError(new ResponseError(ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`));
-        }
+            responseObservable.observer.error(err);
+          } else if (responseMessage.result !== undefined) {
+            responseObservable.observer.next(responseMessage.result);
+          }
+          if (responseMessage.complete) {
+            responseObservable.complete = true;
+            responseObservable.observer.complete();
+          }
+        } catch (error) {
+          if (error.message) {
+            logger.error(`Response handler '${responseObservable.method}' failed with message: ${error.message}`);
+          } else {
+            logger.error(`Response handler '${responseObservable.method}' failed unexpectedly.`);
+          }
+        } finally {
+          if (responseMessage.complete) {
+            delete responseObservables[key];
+          }
+        }
+      } else {
+        tracer.unknownResponseReceived(responseMessage);
+      }
     }
-    function handleResponse(responseMessage) {
-        if (isUnsubscribed()) {
-            // See handle request.
-            return;
-        }
-        if (responseMessage.id === null) {
-            if (responseMessage.error) {
-                logger.error(`Received response message without id: Error is: \n${JSON.stringify(responseMessage.error, undefined, 4)}`);
-            }
-            else {
-                logger.error(`Received response message without id. No further error information provided.`);
-            }
-        }
-        else {
-            const key = String(responseMessage.id);
-            const responseObservable = responseObservables[key];
-            if (responseObservable) {
-                tracer.responseReceived(responseMessage, responseObservable.request || responseObservable.method, responseObservable.timerStart);
-                try {
-                    if (responseMessage.error) {
-                        const { code, message, data } = responseMessage.error;
-                        const err = new ResponseError(code, message, data);
-                        if (data && data.stack) {
-                            err.stack = data.stack;
-                        }
-                        responseObservable.observer.error(err);
-                    }
-                    else if (responseMessage.result !== undefined) {
-                        responseObservable.observer.next(responseMessage.result);
-                    }
-                    if (responseMessage.complete) {
-                        responseObservable.complete = true;
-                        responseObservable.observer.complete();
-                    }
-                }
-                catch (error) {
-                    if (error.message) {
-                        logger.error(`Response handler '${responseObservable.method}' failed with message: ${error.message}`);
-                    }
-                    else {
-                        logger.error(`Response handler '${responseObservable.method}' failed unexpectedly.`);
-                    }
-                }
-                finally {
-                    if (responseMessage.complete) {
-                        delete responseObservables[key];
-                    }
-                }
-            }
-            else {
-                tracer.unknownResponseReceived(responseMessage);
-            }
-        }
+  }
+  function handleNotification(message) {
+    if (isUnsubscribed()) {
+      // See handle request.
+      return;
     }
-    function handleNotification(message) {
-        if (isUnsubscribed()) {
-            // See handle request.
-            return;
-        }
-        let notificationHandler;
-        if (message.method === ABORT_REQUEST_METHOD) {
-            notificationHandler = (params) => {
-                const id = params[0];
-                const abortController = requestAbortControllers[String(id)];
-                if (abortController) {
-                    abortController.abort();
-                }
-            };
-        }
-        else {
-            const element = notificationHandlers[message.method];
-            if (element) {
-                notificationHandler = element.handler;
-            }
-        }
-        if (notificationHandler || starNotificationHandler) {
-            try {
-                console.log('handleNotification.notificationHandler');
-                tracer.notificationReceived(message);
-                notificationHandler
-                    ? notificationHandler(message.params)
-                    : starNotificationHandler(message.method, message.params);
-            }
-            catch (error) {
-                if (error.message) {
-                    logger.error(`Notification handler '${message.method}' failed with message: ${error.message}`);
-                }
-                else {
-                    logger.error(`Notification handler '${message.method}' failed unexpectedly.`);
-                }
-            }
-        }
-        else {
-            console.log('handleNotification.notificationHandler.else', { notificationHandlers });
-            unhandledNotificationEmitter.fire(message);
-        }
+    let notificationHandler;
+    if (message.method === ABORT_REQUEST_METHOD) {
+      notificationHandler = params => {
+        const id = params[0];
+        const abortController = requestAbortControllers[String(id)];
+        if (abortController) {
+          abortController.abort();
+        }
+      };
+    } else {
+      const element = notificationHandlers[message.method];
+      if (element) {
+        notificationHandler = element.handler;
+      }
     }
-    function handleInvalidMessage(message) {
-        if (!message) {
-            logger.error('Received empty message.');
-            return;
-        }
-        logger.error(`Received message which is neither a response nor a notification message:\n${JSON.stringify(message, null, 4)}`);
-        // Test whether we find an id to reject the promise
-        const responseMessage = message;
-        if (typeof responseMessage.id === 'string' || typeof responseMessage.id === 'number') {
-            const key = String(responseMessage.id);
-            const responseHandler = responseObservables[key];
-            if (responseHandler) {
-                responseHandler.observer.error(new Error('The received response has neither a result nor an error property.'));
-            }
-        }
+    if (notificationHandler || starNotificationHandler) {
+      try {
+        console.log('handleNotification.notificationHandler');
+        tracer.notificationReceived(message);
+        notificationHandler ? notificationHandler(message.params) : starNotificationHandler(message.method, message.params);
+      } catch (error) {
+        if (error.message) {
+          logger.error(`Notification handler '${message.method}' failed with message: ${error.message}`);
+        } else {
+          logger.error(`Notification handler '${message.method}' failed unexpectedly.`);
+        }
+      }
+    } else {
+      console.log('handleNotification.notificationHandler.else', {
+        notificationHandlers
+      });
+      unhandledNotificationEmitter.fire(message);
     }
-    function throwIfClosedOrUnsubscribed() {
-        if (isClosed()) {
-            throw new ConnectionError(ConnectionErrors.Closed, 'Connection is closed.');
-        }
-        if (isUnsubscribed()) {
-            throw new ConnectionError(ConnectionErrors.Unsubscribed, 'Connection is unsubscribed.');
-        }
+  }
+  function handleInvalidMessage(message) {
+    if (!message) {
+      logger.error('Received empty message.');
+      return;
     }
-    function throwIfListening() {
-        if (isListening()) {
-            throw new ConnectionError(ConnectionErrors.AlreadyListening, 'Connection is already listening');
-        }
+    logger.error(`Received message which is neither a response nor a notification message:\n${JSON.stringify(message, null, 4)}`);
+    // Test whether we find an id to reject the promise
+    const responseMessage = message;
+    if (typeof responseMessage.id === 'string' || typeof responseMessage.id === 'number') {
+      const key = String(responseMessage.id);
+      const responseHandler = responseObservables[key];
+      if (responseHandler) {
+        responseHandler.observer.error(new Error('The received response has neither a result nor an error property.'));
+      }
     }
-    function throwIfNotListening() {
-        if (!isListening()) {
-            throw new Error('Call listen() first.');
-        }
+  }
+  function throwIfClosedOrUnsubscribed() {
+    if (isClosed()) {
+      throw new ConnectionError(ConnectionErrors.Closed, 'Connection is closed.');
     }
-    const sendNotification = (method, params, toSecondary = false) => {
-        throwIfClosedOrUnsubscribed();
-        const notificationMessage = {
-            jsonrpc: version,
-            method,
-            params,
-        };
-        tracer.notificationSent(notificationMessage);
-        transports.writer.write(notificationMessage);
+    if (isUnsubscribed()) {
+      throw new ConnectionError(ConnectionErrors.Unsubscribed, 'Connection is unsubscribed.');
+    }
+  }
+  function throwIfListening() {
+    if (isListening()) {
+      throw new ConnectionError(ConnectionErrors.AlreadyListening, 'Connection is already listening');
+    }
+  }
+  function throwIfNotListening() {
+    if (!isListening()) {
+      throw new Error('Call listen() first.');
+    }
+  }
+  const sendNotification = (method, params, toSecondary = false) => {
+    throwIfClosedOrUnsubscribed();
+    const notificationMessage = {
+      jsonrpc: version,
+      method,
+      params
     };
-    /**
-     * @returns a hot observable with the result of sending the request
-     */
-    const requestHelper = (method, params, toSecondary) => {
-        const id = sequenceNumber++;
-        const requestMessage = {
-            jsonrpc: version,
-            id,
-            method,
-            params,
-            toSecondary,
-        };
-        const subject = new Subject();
-        const responseObserver = {
-            method,
-            request: requestMessage,
-            timerStart: Date.now(),
-            complete: false,
-            observer: subject,
-        };
-        tracer.requestSent(requestMessage);
-        try {
-            transports.writer.write(requestMessage);
-            responseObservables[String(id)] = responseObserver;
-        }
-        catch (e) {
-            responseObserver.observer.error(new ResponseError(ErrorCodes.MessageWriteError, e.message ? e.message : 'Unknown reason'));
-        }
-        return new Observable((observer) => {
-            const subscription = subject.subscribe(observer);
-            subscription.add(() => {
-                if (!isUnsubscribed() && responseObserver && !responseObserver.complete && !subscription.closed) {
-                    sendNotification(ABORT_REQUEST_METHOD, [id]);
-                }
-            });
-            return subscription;
-        });
+    tracer.notificationSent(notificationMessage);
+    transports.writer.write(notificationMessage);
+  };
+  /**
+   * @returns a hot observable with the result of sending the request
+   */
+  const requestHelper = (method, params, toSecondary) => {
+    const id = sequenceNumber++;
+    const requestMessage = {
+      jsonrpc: version,
+      id,
+      method,
+      params,
+      toSecondary
     };
-    const connection = {
-        sendNotification,
-        onNotification: (type, handler) => {
-            throwIfClosedOrUnsubscribed();
-            if (typeof type === 'function') {
-                starNotificationHandler = type;
-            }
-            else if (handler) {
-                notificationHandlers[type] = { type: undefined, handler };
-            }
-        },
-        sendRequest: (method, params, signal, toSecondary = false) => {
-            throwIfClosedOrUnsubscribed();
-            throwIfNotListening();
-            return toPromise(requestHelper(method, params, toSecondary), signal);
-        },
-        observeRequest: (method, params) => {
-            throwIfClosedOrUnsubscribed();
-            throwIfNotListening();
-            return requestHelper(method, params);
-        },
-        onRequest: (type, handler) => {
-            throwIfClosedOrUnsubscribed();
-            if (typeof type === 'function') {
-                starRequestHandler = type;
-            }
-            else if (handler) {
-                requestHandlers[type] = { type: undefined, handler };
-            }
-        },
-        trace: (_tracer) => {
-            if (_tracer) {
-                tracer = _tracer;
-            }
-            else {
-                tracer = noopTracer;
-            }
-        },
-        onError: errorEmitter.event,
-        onClose: closeEmitter.event,
-        onUnhandledNotification: unhandledNotificationEmitter.event,
-        onUnsubscribe: unsubscribeEmitter.event,
-        unsubscribe: () => {
-            if (isUnsubscribed()) {
-                return;
-            }
-            state = ConnectionState.Unsubscribed;
-            unsubscribeEmitter.fire(undefined);
-            for (const key of Object.keys(responseObservables)) {
-                responseObservables[key].observer.error(new ConnectionError(ConnectionErrors.Unsubscribed, `The underlying JSON-RPC connection got unsubscribed while responding to this ${responseObservables[key].method} request.`));
-            }
-            responseObservables = Object.create(null);
-            requestAbortControllers = Object.create(null);
-            messageQueue = new LinkedMap();
-            transports.writer.unsubscribe();
-            transports.reader.unsubscribe();
-        },
-        listen: () => {
-            throwIfClosedOrUnsubscribed();
-            throwIfListening();
-            state = ConnectionState.Listening;
-            transports.reader.listen(callback);
-        },
+    const subject = new Subject();
+    const responseObserver = {
+      method,
+      request: requestMessage,
+      timerStart: Date.now(),
+      complete: false,
+      observer: subject
     };
-    return connection;
+    tracer.requestSent(requestMessage);
+    try {
+      transports.writer.write(requestMessage);
+      responseObservables[String(id)] = responseObserver;
+    } catch (e) {
+      responseObserver.observer.error(new ResponseError(ErrorCodes.MessageWriteError, e.message ? e.message : 'Unknown reason'));
+    }
+    return new Observable(observer => {
+      const subscription = subject.subscribe(observer);
+      subscription.add(() => {
+        if (!isUnsubscribed() && responseObserver && !responseObserver.complete && !subscription.closed) {
+          sendNotification(ABORT_REQUEST_METHOD, [id]);
+        }
+      });
+      return subscription;
+    });
+  };
+  const connection = {
+    sendNotification,
+    onNotification: (type, handler) => {
+      throwIfClosedOrUnsubscribed();
+      if (typeof type === 'function') {
+        starNotificationHandler = type;
+      } else if (handler) {
+        notificationHandlers[type] = {
+          type: undefined,
+          handler
+        };
+      }
+    },
+    sendRequest: (method, params, signal, toSecondary = false) => {
+      throwIfClosedOrUnsubscribed();
+      throwIfNotListening();
+      return toPromise(requestHelper(method, params, toSecondary), signal);
+    },
+    observeRequest: (method, params) => {
+      throwIfClosedOrUnsubscribed();
+      throwIfNotListening();
+      return requestHelper(method, params);
+    },
+    onRequest: (type, handler) => {
+      throwIfClosedOrUnsubscribed();
+      if (typeof type === 'function') {
+        starRequestHandler = type;
+      } else if (handler) {
+        requestHandlers[type] = {
+          type: undefined,
+          handler
+        };
+      }
+    },
+    trace: _tracer => {
+      if (_tracer) {
+        tracer = _tracer;
+      } else {
+        tracer = noopTracer;
+      }
+    },
+    onError: errorEmitter.event,
+    onClose: closeEmitter.event,
+    onUnhandledNotification: unhandledNotificationEmitter.event,
+    onUnsubscribe: unsubscribeEmitter.event,
+    unsubscribe: () => {
+      if (isUnsubscribed()) {
+        return;
+      }
+      state = ConnectionState.Unsubscribed;
+      unsubscribeEmitter.fire(undefined);
+      for (const key of Object.keys(responseObservables)) {
+        responseObservables[key].observer.error(new ConnectionError(ConnectionErrors.Unsubscribed, `The underlying JSON-RPC connection got unsubscribed while responding to this ${responseObservables[key].method} request.`));
+      }
+      responseObservables = Object.create(null);
+      requestAbortControllers = Object.create(null);
+      messageQueue = new LinkedMap();
+      transports.writer.unsubscribe();
+      transports.reader.unsubscribe();
+    },
+    listen: () => {
+      throwIfClosedOrUnsubscribed();
+      throwIfListening();
+      state = ConnectionState.Listening;
+      transports.reader.listen(callback);
+    }
+  };
+  return connection;
 }
 /** Support browser and node environments without needing a transpiler. */
 function setImmediateCompat(f) {
-    if (typeof setImmediate !== 'undefined') {
-        setImmediate(f);
-        return;
-    }
-    setTimeout(f, 0);
+  if (typeof setImmediate !== 'undefined') {
+    setImmediate(f);
+    return;
+  }
+  setTimeout(f, 0);
 }
 function matchedStartActor(requestHandlersKeys, method) {
-    try {
-        return requestHandlersKeys.filter((name) => {
-            let methodName = method.split('/')[0];
-            return `${methodName}/*` === name;
-        })[0];
-    }
-    catch (e) {
-        console.log('no matched value');
-        return null;
-    }
-}export{ConnectionError,ConnectionErrors,createConnection};
+  try {
+    return requestHandlersKeys.filter(name => {
+      let methodName = method.split('/')[0];
+      return `${methodName}/*` === name;
+    })[0];
+  } catch (e) {
+    console.log('no matched value');
+    return null;
+  }
+}export{ConnectionError,ConnectionErrors,createConnection};//# sourceMappingURL=connection.js.map