text: "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.KeytipLayerBase = void 0;
  var tslib_1 = require("tslib");
  var React = require("react");
  var KeytipLayer_styles_1 = require("./KeytipLayer.styles");
  var Keytip_1 = require("../../Keytip");
  var Layer_1 = require("../../Layer");
  var Utilities_1 = require("../../Utilities");
  var KeytipManager_1 = require("../../utilities/keytips/KeytipManager");
  var KeytipTree_1 = require("./KeytipTree");
  var KeytipUtils_1 = require("../../utilities/keytips/KeytipUtils");
  var IKeytipTransitionKey_1 = require("../../utilities/keytips/IKeytipTransitionKey");
  var KeytipConstants_1 = require("../../utilities/keytips/KeytipConstants");
  // Default sequence is Alt-Windows (Alt-Meta) in Windows, Option-Control (Alt-Control) in Mac
  var defaultStartSequence = {
      key: Utilities_1.isMac() ? 'Control' : 'Meta',
      modifierKeys: [Utilities_1.KeyCodes.alt],
  };
  // Default exit sequence is the same as the start sequence
  var defaultExitSequence = defaultStartSequence;
  // Default return sequence is Escape
  var defaultReturnSequence = {
      key: 'Escape',
  };
  var getClassNames = Utilities_1.classNamesFunction();
  /**
   * A layer that holds all keytip items
   * {@docCategory Keytips}
   */
  var KeytipLayerBase = /** @class */ (function (_super) {
      tslib_1.__extends(KeytipLayerBase, _super);
      function KeytipLayerBase(props, context) {
          var _this = _super.call(this, props, context) || this;
          _this._keytipManager = KeytipManager_1.KeytipManager.getInstance();
          _this._delayedKeytipQueue = [];
          _this._keyHandled = false;
          _this._onDismiss = function (ev) {
              // if we are in keytip mode, then exit keytip mode
              if (_this.state.inKeytipMode) {
                  _this._exitKeytipMode(ev);
              }
          };
          _this._onKeyDown = function (ev) {
              _this._keyHandled = false;
              // using key since which has been deprecated and key is now widely suporrted.
              // See: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/which
              var key = ev.key;
              switch (key) {
                  case 'Tab':
                  case 'Enter':
                  case 'Spacebar':
                  case ' ':
                  case 'ArrowUp':
                  case 'Up':
                  case 'ArrowDown':
                  case 'Down':
                  case 'ArrowLeft':
                  case 'Left':
                  case 'ArrowRight':
                  case 'Right':
                      if (_this.state.inKeytipMode) {
                          _this._keyHandled = true;
                          _this._exitKeytipMode(ev);
                      }
                      break;
                  default:
                      // Special cases for browser-specific keys that are not at standard
                      // (according to http://www.w3.org/TR/uievents-key/#keys-navigation)
                      if (key === 'Esc') {
                          // Edge: https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/5290772/
                          key = 'Escape';
                      }
                      else if (key === 'OS' || key === 'Win') {
                          // Firefox: https://bugzilla.mozilla.org/show_bug.cgi?id=1232918
                          // Edge: https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/8860571/
                          // and https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/16424492/
                          key = 'Meta';
                      }
                      var transitionKey = { key: key };
                      transitionKey.modifierKeys = _this._getModifierKey(key, ev);
                      _this.processTransitionInput(transitionKey, ev);
                      break;
              }
          };
          _this._onKeyPress = function (ev) {
              if (_this.state.inKeytipMode && !_this._keyHandled) {
                  // Call processInput
                  _this.processInput(ev.key.toLocaleLowerCase(), ev);
                  ev.preventDefault();
                  ev.stopPropagation();
              }
          };
          _this._onKeytipAdded = function (eventArgs) {
              var _a;
              var keytipProps = eventArgs.keytip;
              var uniqueID = eventArgs.uniqueID;
              _this._keytipTree.addNode(keytipProps, uniqueID);
              _this._setKeytips();
              // Add the keytip to the queue to show later
              if (_this._keytipTree.isCurrentKeytipParent(keytipProps)) {
                  // Ensure existing children are still shown.
                  _this._delayedKeytipQueue = _this._delayedKeytipQueue.concat(((_a = _this._keytipTree.currentKeytip) === null || _a === void 0 ? void 0 : _a.children) || []);
                  _this._addKeytipToQueue(KeytipUtils_1.sequencesToID(keytipProps.keySequences));
                  // Ensure the child of currentKeytip is successfully added to currentKeytip's children and update it if not.
                  // Note: Added this condition because KeytipTree.addNode was not always reflecting updates made to a parent node
                  // in currentKeytip when that parent is the currentKeytip.
                  if (_this._keytipTree.currentKeytip &&
                      _this._keytipTree.currentKeytip.hasDynamicChildren &&
                      _this._keytipTree.currentKeytip.children.indexOf(keytipProps.id) < 0) {
                      var currNode = _this._keytipTree.getNode(_this._keytipTree.currentKeytip.id);
                      if (currNode) {
                          _this._keytipTree.currentKeytip = currNode;
                      }
                  }
              }
              _this._persistedKeytipChecks(keytipProps);
          };
          _this._onKeytipUpdated = function (eventArgs) {
              var _a;
              var keytipProps = eventArgs.keytip;
              var uniqueID = eventArgs.uniqueID;
              _this._keytipTree.updateNode(keytipProps, uniqueID);
              _this._setKeytips();
              if (_this._keytipTree.isCurrentKeytipParent(keytipProps)) {
                  // Ensure existing children are still shown.
                  _this._delayedKeytipQueue = _this._delayedKeytipQueue.concat(((_a = _this._keytipTree.currentKeytip) === null || _a === void 0 ? void 0 : _a.children) || []);
                  _this._addKeytipToQueue(KeytipUtils_1.sequencesToID(keytipProps.keySequences));
              }
              _this._persistedKeytipChecks(keytipProps);
          };
          /**
           * Helper function to do checks related to persisted/overflow keytips
           * Done on keytip added and keytip updated
           *
           * @param keytipProps - Keytip props
           */
          _this._persistedKeytipChecks = function (keytipProps) {
              if (_this._newCurrentKeytipSequences && Utilities_1.arraysEqual(keytipProps.keySequences, _this._newCurrentKeytipSequences)) {
                  _this._triggerKeytipImmediately(keytipProps);
              }
              if (_this._isCurrentKeytipAnAlias(keytipProps)) {
                  var keytipSequence = keytipProps.keySequences;
                  if (keytipProps.overflowSetSequence) {
                      keytipSequence = KeytipUtils_1.mergeOverflows(keytipSequence, keytipProps.overflowSetSequence);
                  }
                  _this._keytipTree.currentKeytip = _this._keytipTree.getNode(KeytipUtils_1.sequencesToID(keytipSequence));
              }
          };
          _this._onKeytipRemoved = function (eventArgs) {
              var keytipProps = eventArgs.keytip;
              var uniqueID = eventArgs.uniqueID;
              // Remove keytip from the delayed queue
              _this._removeKeytipFromQueue(KeytipUtils_1.sequencesToID(keytipProps.keySequences));
              // Remove the node from the Tree
              _this._keytipTree.removeNode(keytipProps, uniqueID);
              _this._setKeytips();
          };
          _this._onPersistedKeytipAdded = function (eventArgs) {
              var keytipProps = eventArgs.keytip;
              var uniqueID = eventArgs.uniqueID;
              _this._keytipTree.addNode(keytipProps, uniqueID, true);
          };
          _this._onPersistedKeytipRemoved = function (eventArgs) {
              var keytipProps = eventArgs.keytip;
              var uniqueID = eventArgs.uniqueID;
              _this._keytipTree.removeNode(keytipProps, uniqueID);
          };
          _this._onPersistedKeytipExecute = function (eventArgs) {
              _this._persistedKeytipExecute(eventArgs.overflowButtonSequences, eventArgs.keytipSequences);
          };
          /**
           * Sets if we are in keytip mode.
           * Note, this sets both the state for the layer as well as
           * the value that the manager will expose externally.
           * @param inKeytipMode - Boolean so set whether we are in keytip mode or not
           */
          _this._setInKeytipMode = function (inKeytipMode) {
              _this.setState({ inKeytipMode: inKeytipMode });
              _this._keytipManager.inKeytipMode = inKeytipMode;
          };
          /**
           * Emits a warning if duplicate keytips are found for the children of the current keytip
           */
          _this._warnIfDuplicateKeytips = function () {
              var duplicateKeytips = _this._getDuplicateIds(_this._keytipTree.getChildren());
              if (duplicateKeytips.length) {
                  Utilities_1.warn('Duplicate keytips found for ' + duplicateKeytips.join(', '));
              }
          };
          /**
           * Returns duplicates among keytip IDs.
           * If the returned array is empty, no duplicates were found.
           *
           * @param keytipIds - Array of keytip IDs to find duplicates for
           * @returns - Array of duplicates that were found. Each duplicate will only be added once to this array.
           */
          _this._getDuplicateIds = function (keytipIds) {
              var seenIds = {};
              return keytipIds.filter(function (keytipId) {
                  seenIds[keytipId] = seenIds[keytipId] ? seenIds[keytipId] + 1 : 1;
                  // Only add the first duplicate keytip seen
                  return seenIds[keytipId] === 2;
              });
          };
          Utilities_1.initializeComponentRef(_this);
          _this._events = new Utilities_1.EventGroup(_this);
          _this._async = new Utilities_1.Async(_this);
          var keytips = _this._keytipManager.getKeytips();
          _this.state = {
              inKeytipMode: false,
              keytips: keytips,
              visibleKeytips: _this._getVisibleKeytips(keytips),
          };
          _this._buildTree();
          _this._currentSequence = '';
          // Add keytip listeners
          _this._events.on(_this._keytipManager, KeytipConstants_1.KeytipEvents.KEYTIP_ADDED, _this._onKeytipAdded);
          _this._events.on(_this._keytipManager, KeytipConstants_1.KeytipEvents.KEYTIP_UPDATED, _this._onKeytipUpdated);
          _this._events.on(_this._keytipManager, KeytipConstants_1.KeytipEvents.KEYTIP_REMOVED, _this._onKeytipRemoved);
          _this._events.on(_this._keytipManager, KeytipConstants_1.KeytipEvents.PERSISTED_KEYTIP_ADDED, _this._onPersistedKeytipAdded);
          _this._events.on(_this._keytipManager, KeytipConstants_1.KeytipEvents.PERSISTED_KEYTIP_REMOVED, _this._onPersistedKeytipRemoved);
          _this._events.on(_this._keytipManager, KeytipConstants_1.KeytipEvents.PERSISTED_KEYTIP_EXECUTE, _this._onPersistedKeytipExecute);
          return _this;
      }
      KeytipLayerBase.prototype.render = function () {
          var _this = this;
          var _a = this.props, content = _a.content, styles = _a.styles;
          var _b = this.state, keytips = _b.keytips, visibleKeytips = _b.visibleKeytips;
          this._classNames = getClassNames(styles, {});
          return (React.createElement(Layer_1.Layer, { styles: KeytipLayer_styles_1.getLayerStyles },
              React.createElement("span", { id: KeytipConstants_1.KTP_LAYER_ID, className: this._classNames.innerContent }, "" + content + KeytipConstants_1.KTP_ARIA_SEPARATOR),
              keytips &&
                  keytips.map(function (keytipProps, index) {
                      return (React.createElement("span", { key: index, id: KeytipUtils_1.sequencesToID(keytipProps.keySequences), className: _this._classNames.innerContent }, keytipProps.keySequences.join(KeytipConstants_1.KTP_ARIA_SEPARATOR)));
                  }),
              visibleKeytips &&
                  visibleKeytips.map(function (visibleKeytipProps) {
                      return React.createElement(Keytip_1.Keytip, tslib_1.__assign({ key: KeytipUtils_1.sequencesToID(visibleKeytipProps.keySequences) }, visibleKeytipProps));
                  })));
      };
      KeytipLayerBase.prototype.componentDidMount = function () {
          // Add window listeners
          this._events.on(window, 'mouseup', this._onDismiss, true /* useCapture */);
          this._events.on(window, 'pointerup', this._onDismiss, true /* useCapture */);
          this._events.on(window, 'resize', this._onDismiss);
          this._events.on(window, 'keydown', this._onKeyDown, true /* useCapture */);
          this._events.on(window, 'keypress', this._onKeyPress, true /* useCapture */);
          this._events.on(window, 'scroll', this._onDismiss, true /* useCapture */);
          // Add keytip listeners
          this._events.on(this._keytipManager, KeytipConstants_1.KeytipEvents.ENTER_KEYTIP_MODE, this._enterKeytipMode);
          this._events.on(this._keytipManager, KeytipConstants_1.KeytipEvents.EXIT_KEYTIP_MODE, this._exitKeytipMode);
      };
      KeytipLayerBase.prototype.componentWillUnmount = function () {
          this._async.dispose();
          this._events.dispose();
      };
      // The below public functions are only public for testing purposes
      // They are not intended to be used in app code by using a KeytipLayer reference
      KeytipLayerBase.prototype.getCurrentSequence = function () {
          return this._currentSequence;
      };
      KeytipLayerBase.prototype.getKeytipTree = function () {
          return this._keytipTree;
      };
      /**
       * Processes an IKeytipTransitionKey entered by the user
       *
       * @param transitionKey - IKeytipTransitionKey received by the layer to process
       */
      KeytipLayerBase.prototype.processTransitionInput = function (transitionKey, ev) {
          var currKtp = this._keytipTree.currentKeytip;
          if (IKeytipTransitionKey_1.transitionKeysContain(this.props.keytipExitSequences, transitionKey) && currKtp) {
              // If key sequence is in 'exit sequences', exit keytip mode
              this._keyHandled = true;
              this._exitKeytipMode(ev);
          }
          else if (IKeytipTransitionKey_1.transitionKeysContain(this.props.keytipReturnSequences, transitionKey)) {
              // If key sequence is in return sequences, move currentKeytip to parent (or if currentKeytip is the root, exit)
              if (currKtp) {
                  this._keyHandled = true;
                  if (currKtp.id === this._keytipTree.root.id) {
                      // We are at the root, exit keytip mode
                      this._exitKeytipMode(ev);
                  }
                  else {
                      // If this keytip has a onReturn prop, we execute the func.
                      if (currKtp.onReturn) {
                          currKtp.onReturn(this._getKtpExecuteTarget(currKtp), this._getKtpTarget(currKtp));
                      }
                      // Reset currentSequence
                      this._currentSequence = '';
                      // Return pointer to its parent
                      this._keytipTree.currentKeytip = this._keytipTree.getNode(currKtp.parent);
                      // Show children keytips of the new currentKeytip
                      this.showKeytips(this._keytipTree.getChildren());
                      this._warnIfDuplicateKeytips();
                  }
              }
          }
          else if (IKeytipTransitionKey_1.transitionKeysContain(this.props.keytipStartSequences, transitionKey) && !currKtp) {
              // If key sequence is in 'entry sequences' and currentKeytip is null, we enter keytip mode
              this._keyHandled = true;
              this._enterKeytipMode();
              this._warnIfDuplicateKeytips();
          }
      };
      /**
       * Processes inputs from the document listener and traverse the keytip tree
       *
       * @param key - Key pressed by the user
       */
      KeytipLayerBase.prototype.processInput = function (key, ev) {
          // Concat the input key with the current sequence
          var currSequence = this._currentSequence + key;
          var currKtp = this._keytipTree.currentKeytip;
          // currentKeytip must be defined, otherwise we haven't entered keytip mode yet
          if (currKtp) {
              var node = this._keytipTree.getExactMatchedNode(currSequence, currKtp);
              if (node) {
                  this._keytipTree.currentKeytip = currKtp = node;
                  var currKtpChildren = this._keytipTree.getChildren();
                  // Execute this node's onExecute if defined
                  if (currKtp.onExecute) {
                      currKtp.onExecute(this._getKtpExecuteTarget(currKtp), this._getKtpTarget(currKtp));
                      // Reset currKtp, this might have changed from the onExecute
                      currKtp = this._keytipTree.currentKeytip;
                  }
                  // To exit keytipMode after executing the keytip it must not have a menu or have dynamic children
                  if (currKtpChildren.length === 0 && !(currKtp.hasDynamicChildren || currKtp.hasMenu)) {
                      this._exitKeytipMode(ev);
                  }
                  else {
                      // Show all children keytips
                      this.showKeytips(currKtpChildren);
                      this._warnIfDuplicateKeytips();
                  }
                  // Clear currentSequence
                  this._currentSequence = '';
                  return;
              }
              var partialNodes = this._keytipTree.getPartiallyMatchedNodes(currSequence, currKtp);
              if (partialNodes.length > 0) {
                  // We found nodes that partially match the sequence, so we show only those
                  // Omit showing persisted nodes here
                  var ids = partialNodes
                      .filter(function (partialNode) {
                      return !partialNode.persisted;
                  })
                      .map(function (partialNode) {
                      return partialNode.id;
                  });
                  this.showKeytips(ids);
                  // Save currentSequence
                  this._currentSequence = currSequence;
              }
          }
      };
      /**
       * Show the given keytips and hide all others
       *
       * @param ids - Keytip IDs to show
       */
      KeytipLayerBase.prototype.showKeytips = function (ids) {
          // Update the visible prop in the manager
          for (var _i = 0, _a = this._keytipManager.getKeytips(); _i < _a.length; _i++) {
              var keytip = _a[_i];
              var keytipId = KeytipUtils_1.sequencesToID(keytip.keySequences);
              if (keytip.overflowSetSequence) {
                  // Check if the ID with the overflow is the keytip we're looking for
                  keytipId = KeytipUtils_1.sequencesToID(KeytipUtils_1.mergeOverflows(keytip.keySequences, keytip.overflowSetSequence));
              }
              if (ids.indexOf(keytipId) >= 0) {
                  keytip.visible = true;
              }
              else {
                  keytip.visible = false;
              }
          }
          // Apply the manager changes to the Layer state
          this._setKeytips();
      };
      /**
       * Enters keytip mode for this layer
       */
      KeytipLayerBase.prototype._enterKeytipMode = function () {
          if (this._keytipManager.shouldEnterKeytipMode) {
              if (this._keytipManager.delayUpdatingKeytipChange) {
                  this._buildTree();
                  this._setKeytips();
              }
              this._keytipTree.currentKeytip = this._keytipTree.root;
              // Show children of root
              this.showKeytips(this._keytipTree.getChildren());
              this._setInKeytipMode(true /* inKeytipMode */);
              if (this.props.onEnterKeytipMode) {
                  this.props.onEnterKeytipMode();
              }
          }
      };
      KeytipLayerBase.prototype._buildTree = function () {
          this._keytipTree = new KeytipTree_1.KeytipTree();
          // Add regular and persisted keytips to the tree
          for (var _i = 0, _a = Object.keys(this._keytipManager.keytips); _i < _a.length; _i++) {
              var id = _a[_i];
              var uniqueKeytip = this._keytipManager.keytips[id];
              this._keytipTree.addNode(uniqueKeytip.keytip, uniqueKeytip.uniqueID);
          }
          for (var _b = 0, _c = Object.keys(this._keytipManager.persistedKeytips); _b < _c.length; _b++) {
              var id = _c[_b];
              var uniqueKeytip = this._keytipManager.persistedKeytips[id];
              this._keytipTree.addNode(uniqueKeytip.keytip, uniqueKeytip.uniqueID);
          }
      };
      /**
       * Exits keytip mode for this layer
       */
      KeytipLayerBase.prototype._exitKeytipMode = function (ev) {
          this._keytipTree.currentKeytip = undefined;
          this._currentSequence = '';
          // Hide all keytips
          this.showKeytips([]);
          // Reset the delayed keytips if any
          this._delayedQueueTimeout && this._async.clearTimeout(this._delayedQueueTimeout);
          this._delayedKeytipQueue = [];
          this._setInKeytipMode(false /* inKeytipMode */);
          if (this.props.onExitKeytipMode) {
              this.props.onExitKeytipMode(ev);
          }
      };
      /**
       * Sets the keytips state property
       *
       * @param keytipProps - Keytips to set in this layer
       */
      KeytipLayerBase.prototype._setKeytips = function (keytipProps) {
          if (keytipProps === void 0) { keytipProps = this._keytipManager.getKeytips(); }
          this.setState({ keytips: keytipProps, visibleKeytips: this._getVisibleKeytips(keytipProps) });
      };
      /**
       * Callback function to use for persisted keytips
       *
       * @param overflowButtonSequences - The overflow button sequence to execute
       * @param keytipSequences - The keytip that should become the 'currentKeytip' when it is registered
       */
      KeytipLayerBase.prototype._persistedKeytipExecute = function (overflowButtonSequences, keytipSequences) {
          // Save newCurrentKeytip for later
          this._newCurrentKeytipSequences = keytipSequences;
          // Execute the overflow button's onExecute
          var overflowKeytipNode = this._keytipTree.getNode(KeytipUtils_1.sequencesToID(overflowButtonSequences));
          if (overflowKeytipNode && overflowKeytipNode.onExecute) {
              overflowKeytipNode.onExecute(this._getKtpExecuteTarget(overflowKeytipNode), this._getKtpTarget(overflowKeytipNode));
          }
      };
      KeytipLayerBase.prototype._getVisibleKeytips = function (keytips) {
          // Filter out non-visible keytips and duplicates
          var seenIds = {};
          return keytips.filter(function (keytip) {
              var keytipId = KeytipUtils_1.sequencesToID(keytip.keySequences);
              if (keytip.overflowSetSequence) {
                  // Account for overflow set sequences when checking for duplicates
                  keytipId = KeytipUtils_1.sequencesToID(KeytipUtils_1.mergeOverflows(keytip.keySequences, keytip.overflowSetSequence));
              }
              seenIds[keytipId] = seenIds[keytipId] ? seenIds[keytipId] + 1 : 1;
              return keytip.visible && seenIds[keytipId] === 1;
          });
      };
      /**
       * Gets the ModifierKeyCodes based on the keyboard event
       *
       * @param ev - React.KeyboardEvent
       * @returns List of ModifierKeyCodes that were pressed
       */
      KeytipLayerBase.prototype._getModifierKey = function (key, ev) {
          var modifierKeys = [];
          if (ev.altKey && key !== 'Alt') {
              modifierKeys.push(Utilities_1.KeyCodes.alt);
          }
          if (ev.ctrlKey && key !== 'Control') {
              modifierKeys.push(Utilities_1.KeyCodes.ctrl);
          }
          if (ev.shiftKey && key !== 'Shift') {
              modifierKeys.push(Utilities_1.KeyCodes.shift);
          }
          if (ev.metaKey && key !== 'Meta') {
              modifierKeys.push(Utilities_1.KeyCodes.leftWindow);
          }
          return modifierKeys.length ? modifierKeys : undefined;
      };
      /**
       * Trigger a keytip immediately and set it as the current keytip
       *
       * @param keytipProps - Keytip to trigger immediately
       */
      KeytipLayerBase.prototype._triggerKeytipImmediately = function (keytipProps) {
          // This keytip should become the currentKeytip and should execute right away
          var keytipSequence = tslib_1.__spreadArrays(keytipProps.keySequences);
          if (keytipProps.overflowSetSequence) {
              keytipSequence = KeytipUtils_1.mergeOverflows(keytipSequence, keytipProps.overflowSetSequence);
          }
          // Set currentKeytip
          this._keytipTree.currentKeytip = this._keytipTree.getNode(KeytipUtils_1.sequencesToID(keytipSequence));
          if (this._keytipTree.currentKeytip) {
              // Show all children keytips if any
              var children = this._keytipTree.getChildren();
              if (children.length) {
                  this.showKeytips(children);
              }
              if (this._keytipTree.currentKeytip.onExecute) {
                  this._keytipTree.currentKeytip.onExecute(this._getKtpExecuteTarget(this._keytipTree.currentKeytip), this._getKtpTarget(this._keytipTree.currentKeytip));
              }
          }
          // Unset _newCurrKtpSequences
          this._newCurrentKeytipSequences = undefined;
      };
      KeytipLayerBase.prototype._addKeytipToQueue = function (keytipID) {
          var _this = this;
          // Add keytip
          this._delayedKeytipQueue.push(keytipID);
          // Clear timeout
          this._delayedQueueTimeout && this._async.clearTimeout(this._delayedQueueTimeout);
          // Reset timeout
          this._delayedQueueTimeout = this._async.setTimeout(function () {
              if (_this._delayedKeytipQueue.length) {
                  _this.showKeytips(_this._delayedKeytipQueue);
                  _this._delayedKeytipQueue = [];
              }
          }, 300);
      };
      KeytipLayerBase.prototype._removeKeytipFromQueue = function (keytipID) {
          var _this = this;
          var index = this._delayedKeytipQueue.indexOf(keytipID);
          if (index >= 0) {
              // Remove keytip
              this._delayedKeytipQueue.splice(index, 1);
              // Clear timeout
              this._delayedQueueTimeout && this._async.clearTimeout(this._delayedQueueTimeout);
              // Reset timeout
              this._delayedQueueTimeout = this._async.setTimeout(function () {
                  if (_this._delayedKeytipQueue.length) {
                      _this.showKeytips(_this._delayedKeytipQueue);
                      _this._delayedKeytipQueue = [];
                  }
              }, 300);
          }
      };
      KeytipLayerBase.prototype._getKtpExecuteTarget = function (currKtp) {
          return Utilities_1.getDocument().querySelector(KeytipUtils_1.ktpTargetFromId(currKtp.id));
      };
      KeytipLayerBase.prototype._getKtpTarget = function (currKtp) {
          return Utilities_1.getDocument().querySelector(KeytipUtils_1.ktpTargetFromSequences(currKtp.keySequences));
      };
      /**
       * Returns T/F if the keytipProps keySequences match the currentKeytip, and the currentKeytip is in an overflow well
       * This will make 'keytipProps' the new currentKeytip
       *
       * @param keytipProps - Keytip props to check
       * @returns - T/F if this keytip should become the currentKeytip
       */
      KeytipLayerBase.prototype._isCurrentKeytipAnAlias = function (keytipProps) {
          var currKtp = this._keytipTree.currentKeytip;
          if (currKtp &&
              (currKtp.overflowSetSequence || currKtp.persisted) &&
              Utilities_1.arraysEqual(keytipProps.keySequences, currKtp.keySequences)) {
              return true;
          }
          return false;
      };
      KeytipLayerBase.defaultProps = {
          keytipStartSequences: [defaultStartSequence],
          keytipExitSequences: [defaultExitSequence],
          keytipReturnSequences: [defaultReturnSequence],
          content: '',
      };
      return KeytipLayerBase;
  }(React.Component));
  exports.KeytipLayerBase = KeytipLayerBase;
  //# sourceMappingURL=KeytipLayer.base.js.map