handleKeyUp(event) {
    const key = getKeyName(event);

    if (this.currentCombination.isKeyUpSimulated(key)){
      this.logger.logEventAlreadySimulated(event, key, KeyEventType.keyup);

      return;
    }

    /**
     * We first decide if the keyup event should be handled (to ensure the correct
     * order of logging statements)
     */
    const reactAppResponse = this._howReactAppRespondedTo(event, key, KeyEventType.keyup);

    /**
     * We then add the keyup to our current combination - regardless of whether
     * it's to be handled or not. We need to do this to ensure that if a handler
     * function changes focus to a context that ignored events, the keyup event
     * is not lost (leaving react hotkeys thinking the key is still pressed).
     */
    if (this.currentCombination.isKeyIncluded(key)) {
      this._recordNewKeyInCombination(
        key, KeyEventType.keyup, stateFromEvent(event)
      );
    }

    if (reactAppResponse === EventResponse.unseen){
      /**
       * If the key event has not been seen by the React application, we ensure that
       * it's not still waiting for it. This occurs when action handlers bound to keydown
       * or keypress move the focus outside of the react app before it can record the keyup
       */
      this.keyEventManager.closeHangingKeyCombination(key, KeyEventType.keyup);

      if(this.eventOptions.ignoreEventsCondition(event)) {
        this.logger.logIgnoredKeyEvent(
          event, key, KeyEventType.keyup, 'ignoreEventsFilter rejected it'
        );
      } else {
        this._callHandlerIfNeeded(reactAppResponse, event, key, KeyEventType.keyup);
      }
    } else {
      this._callHandlerIfNeeded(reactAppResponse, event, key, KeyEventType.keyup);
    }

    /**
     * We simulate any hidden keyup events hidden by the command key, regardless
     * of whether the event should be ignored or not
     */
    this._simulateKeyUpEventsHiddenByCmd(event, key);

    this._callKeyCombinationCallbackIfDefined();
  }
Records a keyup keyboard event and matches it against the list of pre-registered
event handlers, calling the first matching handler with the highest priority if
one exists.

This method is called once when a keyboard event bubbles up to document, and checks
the keymaps for all of the mounted global HotKey components.
@param {SyntheticKeyboardEvent} event - Event containing the key name and state