add mappings for 3 characters

src/libraries/System.Console/src/System/IO/KeyMapper.cs

@@ -58,24 +58,90 @@ internal static bool MapBufferToConsoleKey(char[] buffer, ConsolePal.TerminalFor
     internal static void MapNew(char[] buffer, ConsolePal.TerminalFormatStrings terminalFormatStrings, byte posixDisableValue, byte veraseCharacter,
         out ConsoleKey key, out char ch, out bool isShift, out bool isAlt, out bool isCtrl, ref int startIndex, int endIndex)
     {
-        if (endIndex - startIndex == 1)
+        int length = endIndex - startIndex;
+
+        if (length >= 3 && TryDecodeTerminalInputSequence(buffer, terminalFormatStrings, out key, out isShift, out isCtrl, out isAlt, ref startIndex, endIndex))
         {
-            DecodeFromSingleChar(buffer[startIndex], out key, out ch, out isShift, out isCtrl);
-            startIndex++;
-            isAlt = false;
+            // these special keys never produce any char (Home, Arrow, F1 etc)
+            ch = default;
+            return;
         }
-        else if (endIndex - startIndex == 2 && buffer[startIndex] == Escape)
+        else if (length == 2 && buffer[startIndex] == Escape)
         {
             DecodeFromSingleChar(buffer[++startIndex], out key, out ch, out isShift, out isCtrl);
             startIndex++;
             isAlt = key != default; // two char sequences starting with Escape are Alt+$Key
         }
         else
+        {
+            DecodeFromSingleChar(buffer[startIndex], out key, out ch, out isShift, out isCtrl);
+            startIndex++;
+            isAlt = false;
+        }
+    }
+
+    private static bool TryDecodeTerminalInputSequence(char[] buffer, ConsolePal.TerminalFormatStrings terminalFormatStrings,
+        out ConsoleKey key, out bool isShift, out bool isAlt, out bool isCtrl, ref int startIndex, int endIndex)
+    {
+        ReadOnlySpan<char> input = buffer.AsSpan(startIndex, endIndex - startIndex);
+        isShift = isAlt = isCtrl = false;
+        key = default;
+
+        // xterm and VT sequences start with "^[[", some xterm start with "^[O" ("^[" stands for Escape (27))
+        if (input.Length < 3 || input[0] != Escape || (input[1] != '[' && input[1] != 'O'))
         {
             key = default;
-            ch = default;
-            isShift = isAlt = isCtrl = false;
+            return false;
+        }
+
+        if (input[1] == 'O' || char.IsAsciiLetterUpper(input[2])) // xterm "^[[O" or xterm "^[["
+        {
+            if (!TryMapUsingDatabase(buffer.AsMemory(startIndex, 3), terminalFormatStrings, ref key, ref isShift, ref isAlt, ref isCtrl))
+            {
+                key = Map(input[2]);
+                Debug.Assert(key != default, $"Missing '{input.Slice(0, 3)}' mapping");
+            }
+            startIndex += 3;
+            return true;
+        }
+
+        if (char.IsAsciiDigit(input[2]))
+        {
+
+        }
+
+        return false;
+
+        static bool TryMapUsingDatabase(ReadOnlyMemory<char> inputSequence, ConsolePal.TerminalFormatStrings terminalFormatStrings,
+            ref ConsoleKey key, ref bool isShift, ref bool isAlt, ref bool isCtrl)
+        {
+            // Check if the string prefix matches.
+            if (terminalFormatStrings.KeyFormatToConsoleKey.TryGetValue(inputSequence, out ConsoleKeyInfo consoleKeyInfo))
+            {
+                key = consoleKeyInfo.Key;
+                isShift = (consoleKeyInfo.Modifiers & ConsoleModifiers.Shift) != 0;
+                isAlt = (consoleKeyInfo.Modifiers & ConsoleModifiers.Alt) != 0;
+                isCtrl = (consoleKeyInfo.Modifiers & ConsoleModifiers.Control) != 0;
+                return true;
+            }
+            return false;
         }
+
+        static ConsoleKey Map(char single)
+            => single switch
+            {
+                'A' => ConsoleKey.UpArrow,
+                'B' => ConsoleKey.DownArrow,
+                'C' => ConsoleKey.RightArrow,
+                'D' => ConsoleKey.LeftArrow,
+                'F' => ConsoleKey.End,
+                'H' => ConsoleKey.Home,
+                'P' => ConsoleKey.F1,
+                'Q' => ConsoleKey.F2,
+                'R' => ConsoleKey.F3,
+                'S' => ConsoleKey.F4,
+                _ => default
+            };
     }
 
     private static void DecodeFromSingleChar(char single, out ConsoleKey key, out char ch, out bool isShift, out bool isCtrl)

src/libraries/System.Console/tests/KeyMapperTests.Unix.cs

@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Text;
 using Xunit;
 
@@ -61,7 +62,7 @@ private static ConsoleKeyInfo Map(char[] chars, ConsolePal.TerminalFormatStrings
         return new ConsoleKeyInfo(ch, consoleKey, isShift, isAlt, isCtrl);
     }
 
-    private static IEnumerable<(char, ConsoleKey)> AsciiKeys
+    private static IEnumerable<(char ch, ConsoleKey key)> AsciiKeys
     {
         get
         {
@@ -96,18 +97,7 @@ private static ConsoleKeyInfo Map(char[] chars, ConsolePal.TerminalFormatStrings
     }
 
     public static IEnumerable<object[]> AsciiCharactersArguments
-    {
-        get
-        {
-            foreach (TerminalData terminalData in Terminals)
-            {
-                foreach ((char ch, ConsoleKey key) in AsciiKeys)
-                {
-                    yield return new object[] { terminalData, ch, key };
-                }
-            }
-        }
-    }
+        => Terminals.SelectMany(terminal => AsciiKeys.Select(tuple => new object[] { terminal, tuple.ch, tuple.key }));
 
     [Theory]
     [MemberData(nameof(AsciiCharactersArguments))]
@@ -119,6 +109,41 @@ public void AsciiCharacters(TerminalData terminalData, char input, ConsoleKey ex
         Assert.Equal(expectedKey, consoleKeyInfo.Key);
         Assert.Equal(char.IsAsciiLetterUpper(input) ? ConsoleModifiers.Shift : 0, consoleKeyInfo.Modifiers);
     }
+
+    private static IEnumerable<(string chars, ConsoleKey key)> ThreeCharactersKeys
+    {
+        get
+        {
+            // "^[["
+            yield return ("\u001B[H", ConsoleKey.Home);
+            yield return ("\u001B[F", ConsoleKey.End);
+            yield return ("\u001B[A", ConsoleKey.UpArrow);
+            yield return ("\u001B[B", ConsoleKey.DownArrow);
+            yield return ("\u001B[C", ConsoleKey.RightArrow);
+            yield return ("\u001B[D", ConsoleKey.LeftArrow);
+            // "^[O"
+            yield return ("\u001BOP", ConsoleKey.F1);
+            yield return ("\u001BOQ", ConsoleKey.F2);
+            yield return ("\u001BOR", ConsoleKey.F3);
+            yield return ("\u001BOS", ConsoleKey.F4);
+        }
+    }
+
+    public static IEnumerable<object[]> ThreeCharactersKeysArguments
+        => Terminals
+            .Where(t => t is not PuTTYData_putty) // different mappings (handled by KeysAreProperlyMapped test) 
+            .SelectMany(terminal => ThreeCharactersKeys.Select(tuple => new object[] { terminal, tuple.chars, tuple.key }));
+
+    [Theory]
+    [MemberData(nameof(ThreeCharactersKeysArguments))]
+    public void ThreeCharactersKey(TerminalData terminalData, string input, ConsoleKey expectedKey)
+    {
+        ConsoleKeyInfo consoleKeyInfo = Map(input.ToCharArray(), terminalData.TerminalDb, terminalData.Verase);
+
+        Assert.Equal(expectedKey, consoleKeyInfo.Key);
+        Assert.Equal(default, consoleKeyInfo.KeyChar);
+        Assert.Equal(default, consoleKeyInfo.Modifiers);
+    }
 }
 
 public abstract class TerminalData