handleKeyUp(event, focusTreeId, componentId, options) {
    const key = getKeyName(event);

    if (this.currentCombination.isKeyUpSimulated(key)) {
      this._ignoreAlreadySimulatedEvent(event, key, KeyEventType.keyup, componentId);

      return false;
    }

    const shouldDiscardFocusId = this.focusTree.isNewerThan(focusTreeId);
    const propagator = this.eventPropagator;

    if (propagator.startNewPropagationStep(componentId, event, key, KeyEventType.keyup)) {

      /**
       * We first decide if the keyup event should be handled (to ensure the correct
       * order of logging statements)
       */
      const responseAction = this._howToHandleKeyEvent(event,
        focusTreeId, componentId, key, options, 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 (propagator.isFirstPropagationStep(componentId) && this.currentCombination.isKeyIncluded(key)) {
        this._recordNewKeyInCombination(key, KeyEventType.keyup, stateFromEvent(event), componentId);
      }

      /**
       * We attempt to find a handler of the event, only if it has not already been
       * handled and should not be ignored
       */
      if (responseAction === EventResponse.handled) {
        this._callHandlerIfActionNotHandled(event, key, KeyEventType.keyup, componentId, focusTreeId);
      }

      /**
       * 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, focusTreeId, componentId, options);

      propagator.finishPropagationStep();
    }

    return shouldDiscardFocusId;
  }
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 many times as a keyboard event bubbles up through the React
render tree. The event is only registered the first time it is seen and results
of some calculations are cached. The event is matched against the handlers registered
at each component level, to ensure the proper handler declaration scoping.
@param {SyntheticKeyboardEvent} event Event containing the key name and state
@param {FocusTreeId} focusTreeId Id of focus tree component thinks it's apart of
@param {ComponentId} componentId The index of the component that is currently handling
       the keyboard event as it bubbles towards the document root.
@param {Object} options Hash of options that configure how the event
       is handled.
@returns {boolean} Whether HotKeys component should discard its current focusTreeId
       because it's stale (part of an old focus tree)