Method sendKey

src/configuration/remapper.ts:95–465

(keys: string[], modeHandler: ModeHandler)

  }

  public async sendKey(keys: string[], modeHandler: ModeHandler): Promise<boolean> {
    const { vimState, remapState } = modeHandler;

    this._isPotentialRemap = false;
    const allowPotentialRemapOnFirstKey = vimState.recordedState.allowPotentialRemapOnFirstKey;
    let remainingKeys: string[] = [];

    /**
     * Means that the timeout finished so we now can't allow the keys to be buffered again
     * because the user already waited for timeout.
     */
    let allowBufferingKeys = true;

    if (!this.remappedModes.includes(vimState.currentModeIncludingPseudoModes)) {
      return false;
    }

    const userDefinedRemappings = configuration[this.configKey] as Map<string, IKeyRemapping>;

    if (keys.at(-1) === SpecialKeys.TimeoutFinished) {
      // Timeout finished. Don't let an ambiguous or potential remap start another timeout again
      keys = keys.slice(0, keys.length - 1);
      allowBufferingKeys = false;
    }

    if (keys.length === 0) {
      return true;
    }

    Logger.trace(
      `trying to find matching remap. keys=${keys}. mode=${
        Mode[vimState.currentMode]
      }. keybindings=${this.configKey}.`,
    );

    let remapping: IKeyRemapping | undefined = this.findMatchingRemap(userDefinedRemappings, keys);

    // Check to see if a remapping could potentially be applied when more keys are received
    let isPotentialRemap = Remapper.hasPotentialRemap(keys, userDefinedRemappings);

    this._isPotentialRemap =
      isPotentialRemap && allowBufferingKeys && allowPotentialRemapOnFirstKey;

    /**
     * Handle a broken potential or ambiguous remap
     * 1. If this Remapper doesn't have a remapping AND
     * 2. (It previously had an AmbiguousRemap OR a PotentialRemap) AND
     * 3. (It doesn't have a potential remap anymore OR timeout finished) AND
     * 4. keys length is more than 1
     *
     * Points 1-3: If we no longer have a remapping but previously had one or a potential one
     * and there is no longer potential remappings because of another pressed key or because the
     * timeout has passed we need to handle those situations by resending the keys or handling the
     * ambiguous remap and resending any remaining keys.
     * Point 4: if there is only one key there is no point in resending it without allowing remaps
     * on first key, we can let the remapper go to the end because since either there was no potential
     * remap anymore or the timeout finished so this means that the next two checks (the 'Buffer keys
     * and create timeout' and 'Handle remapping and remaining keys') will never be hit, so it reaches