fix(v3): name only presses that can actually be bound, on macOS

Addresses both review comments on #6032, each confirmed with a test that
fails against the previous code first.

A press with no name was still named after its modifiers alone, producing
strings like "cmd" that no binding can match and that parseAccelerator
rejects outright - so each one was reported as an error rather than
ignored. The name is now empty in that case, and -keyDown: does not send an
empty name on, which would only have moved the error rather than removed
it. -performKeyEquivalent: already declined to.

F21 to F35 and the keypad's Clear key had no name at all. namedKeys accepts
f21 through f35 and numlock, so bindings can be written for them, but
nothing on macOS ever produced those names: the keys exist only on extended
keyboards, where AppKit reports them through characters rather than through
a key code this build knows. They are named from their characters now -
NSF21FunctionKey and consecutive, and NSClearLineFunctionKey for numlock.

Neither was introduced by this pull request; both were carried over from
the Objective-C the branch replaced.

Also verified against a running application: bindings still fire, and no
accelerator now fails to parse.

Claude-Session: https://claude.ai/code/session_01WP7MWnMpQDT2WB7CPLWbqr

Author: taliesin-ai

v3/pkg/application/accelerator_darwin.go

@@ -65,6 +65,30 @@ var macCharacterNames = map[rune]string{
 	'\x0e': "page up",
 	'\x01': "home",
 	'\x04': "end",
+
+	// F21 to F35 exist only on extended keyboards, and AppKit reports them
+	// through these characters rather than through a key code this build
+	// knows. namedKeys accepts their names, so without this a binding written
+	// for one could never fire. NSF21FunctionKey and consecutive.
+	'\uf718': "f21",
+	'\uf719': "f22",
+	'\uf71a': "f23",
+	'\uf71b': "f24",
+	'\uf71c': "f25",
+	'\uf71d': "f26",
+	'\uf71e': "f27",
+	'\uf71f': "f28",
+	'\uf720': "f29",
+	'\uf721': "f30",
+	'\uf722': "f31",
+	'\uf723': "f32",
+	'\uf724': "f33",
+	'\uf725': "f34",
+	'\uf726': "f35",
+
+	// NSClearLineFunctionKey - the key a Mac keypad labels Clear, and which
+	// namedKeys calls numlock.
+	'\uf739': "numlock",
 }
 
 // macKeyName names the key that was pressed, or returns an empty string for a
@@ -83,6 +107,14 @@ func macKeyName(keyCode uint16, character rune, hasCharacter bool) string {
 // modifiers held, in a fixed order, then the key, joined with "+". Empty if
 // the key has no name, since a binding could not refer to it.
 func macAccelerator(keyCode uint16, modifiers uint, character rune, hasCharacter bool) string {
+	// Without a key there is nothing to bind to, and naming the press after
+	// its modifiers alone produces something like "cmd" that parseAccelerator
+	// rejects - which is what every modifier press used to be reported as.
+	key := macKeyName(keyCode, character, hasCharacter)
+	if key == "" {
+		return ""
+	}
+
 	var parts []string
 	if modifiers&macModifierShift != 0 {
 		parts = append(parts, "shift")
@@ -96,8 +128,6 @@ func macAccelerator(keyCode uint16, modifiers uint, character rune, hasCharacter
 	if modifiers&macModifierCommand != 0 {
 		parts = append(parts, "cmd")
 	}
-	if key := macKeyName(keyCode, character, hasCharacter); key != "" {
-		parts = append(parts, key)
-	}
+	parts = append(parts, key)
 	return strings.Join(parts, "+")
 }

v3/pkg/application/accelerator_darwin_test.go

@@ -2,7 +2,10 @@
 
 package application
 
-import "testing"
+import (
+	"strconv"
+	"testing"
+)
 
 // With Control held, macOS collapses letters to their control codes: Control-A
 // produces U+0001, which is also what an older reading of this took to mean
@@ -81,14 +84,60 @@ func TestModifiersAreNamedInOrder(t *testing.T) {
 	}
 }
 
-// A key with no name cannot be bound, so it is named as nothing rather than as
-// a bare list of modifiers.
+// A key with no name cannot be bound to, so the press is named as nothing at
+// all. Naming it after the modifiers alone produces something like "cmd",
+// which no binding can match and which parseAccelerator rejects - so every
+// press of an unnamed key with a modifier held was reported as an error.
 func TestAnUnknownKeyHasNoName(t *testing.T) {
-	if got := macAccelerator(999, macModifierCommand, 0, false); got != "cmd" {
-		t.Errorf("an unknown key with Command held was named %q, not %q", got, "cmd")
+	for _, modifiers := range []uint{0, macModifierCommand, macModifierShift | macModifierControl} {
+		if got := macAccelerator(999, modifiers, 0, false); got != "" {
+			t.Errorf("an unknown key with modifiers %#x was named %q, not %q", modifiers, got, "")
+		}
+	}
+}
+
+// The names this produces are handed to parseAccelerator, so anything it
+// produces for a real press has to survive that. A bare list of modifiers does
+// not.
+func TestNothingProducedIsRejectedByTheParser(t *testing.T) {
+	presses := []struct {
+		name         string
+		keyCode      uint16
+		modifiers    uint
+		character    rune
+		hasCharacter bool
+	}{
+		{"an unknown key held with Command", 999, macModifierCommand, 0, false},
+		{"a key with no name held with Shift", 56, macModifierShift, 0, false},
+		{"Control-A", 0, macModifierControl, '\x01', true},
+		{"F12", 111, 0, 0, false},
+	}
+	for _, p := range presses {
+		got := macAccelerator(p.keyCode, p.modifiers, p.character, p.hasCharacter)
+		if got == "" {
+			continue // Nothing is dispatched for an unnamed press.
+		}
+		if _, err := parseAccelerator(got); err != nil {
+			t.Errorf("%s was named %q, which the parser rejects: %s", p.name, got, err)
+		}
+	}
+}
+
+// namedKeys accepts these, so a binding can be written for them; they have to
+// be reachable from a real press or the binding can never fire. AppKit reports
+// them only through the characters they produce.
+func TestExtendedFunctionKeysAreNamed(t *testing.T) {
+	// NSF21FunctionKey is 0xF718, and they run consecutively to F35.
+	for i := 0; i <= 35-21; i++ {
+		character := rune(0xF718 + i)
+		want := "f" + strconv.Itoa(21+i)
+		if got := macAccelerator(0xFFFF, 0, character, true); got != want {
+			t.Errorf("the key producing %U was named %q, not %q", character, got, want)
+		}
 	}
-	if got := macAccelerator(999, 0, 0, false); got != "" {
-		t.Errorf("an unknown key was named %q, not %q", got, "")
+	// NSClearLineFunctionKey. Wails calls this key numlock.
+	if got := macAccelerator(0xFFFF, 0, 0xF739, true); got != "numlock" {
+		t.Errorf("the clear key was named %q, not %q", got, "numlock")
 	}
 }
 

v3/pkg/application/webview_window_darwin.m

@@ -90,6 +90,11 @@ - (WebviewWindow*) initWithContentRect:(NSRect)contentRect styleMask:(NSUInteger
 }
 - (void)keyDown:(NSEvent *)event {
     NSString *keyEventString = acceleratorStringFromKeyEvent(event);
+    // A press with no name cannot match a binding, and the parser rejects the
+    // empty string, so sending it on only produces an error for every one.
+    if (keyEventString.length == 0) {
+        return;
+    }
     WebviewWindowDelegate *delegate = (WebviewWindowDelegate*)self.delegate;
     processWindowKeyDownEvent(delegate.windowId, [keyEventString UTF8String]);
 }