feat: rework the RCTKeyCommands api

BREAKING CHANGE

Author: aleclarson

React/Base/RCTKeyCommands.h

@@ -1,33 +1,56 @@
-/**
- * Copyright (c) 2015-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
 #import <AppKit/AppKit.h>
 
+#pragma mark - RCTKeyCommand
+
+typedef unsigned short RCTKeyCode;
+
+@interface RCTKeyCommand : NSObject
+
+/// The upper or lower cased characters being pressed.
+@property (nonatomic, readonly) NSString *input;
+
+/// The device-independent key code.
+@property (nonatomic, readonly) RCTKeyCode keyCode;
+
+/// True for keydown events. False for keyup events.
+@property (nonatomic, readonly) BOOL isDown;
+
+/// The modifiers being pressed. (eg: command, control, etc)
+@property (nonatomic, readonly) NSEventModifierFlags flags;
+
+/// The window that received the original NSEvent.
+@property (nonatomic, readonly) NSWindow *window;
+
+/// The original NSEvent that triggered this command.
+@property (nonatomic, readonly) NSEvent *event;
+
+- (BOOL)matchesInput:(NSString *)input;
+- (BOOL)matchesInput:(NSString *)input flags:(NSEventModifierFlags)flags;
+
+- (BOOL)matchesKeyCode:(RCTKeyCode)keyCode;
+- (BOOL)matchesKeyCode:(RCTKeyCode)keyCode flags:(NSEventModifierFlags)flags;
+
+- (void)preventDefault;
+- (BOOL)isDefaultPrevented;
+
+@end
+
+#pragma mark - RCTKeyCommandObserver
+
+@protocol RCTKeyCommandObserver <NSObject>
+
+- (void)observeKeyCommand:(RCTKeyCommand *)command;
+
+@end
+
+#pragma mark - RCTKeyCommands
+
 @interface RCTKeyCommands : NSObject
 
 + (instancetype)sharedInstance;
 
-/**
- * Register a single-press keyboard command.
- */
-- (void)registerKeyCommandWithInput:(NSString *)input
-                      modifierFlags:(NSEventModifierFlags)flags
-                             action:(void (^)(NSEvent *command))block;
-
-/**
- * Unregister a single-press keyboard command.
- */
-- (void)unregisterKeyCommandWithInput:(NSString *)input
-                        modifierFlags:(NSEventModifierFlags)flags;
-
-/**
- * Check if a single-press command is registered.
- */
-- (BOOL)isKeyCommandRegisteredForInput:(NSString *)input
-                         modifierFlags:(NSEventModifierFlags)flags;
+- (void)addObserver:(NSObject<RCTKeyCommandObserver> *)observer;
+
+- (void)removeObserver:(NSObject<RCTKeyCommandObserver> *)observer;
 
 @end

React/Base/RCTKeyCommands.m

@@ -1,101 +1,89 @@
-/**
- * Copyright (c) 2015-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
 #import "RCTKeyCommands.h"
-
-#import <AppKit/AppKit.h>
-
 #import "RCTDefines.h"
 #import "RCTUtils.h"
 
-@interface RCTKeyCommand : NSObject <NSCopying>
-
-@property (nonatomic, strong) NSString *keyCommand;
-@property (nonatomic) NSEventModifierFlags modifierFlags;
-@property (nonatomic, copy) void (^block)(NSEvent *);
-
-@end
-
 @implementation RCTKeyCommand
+{
+  BOOL _preventDefault;
+}
 
-- (instancetype)initWithKeyCommand:(NSString *)keyCommand
-                     modifierFlags:(NSEventModifierFlags)modifierFlags
-                             block:(void (^)(NSEvent *))block
+- (instancetype)initWithEvent:(NSEvent *)event
 {
   if ((self = [super init])) {
-    _keyCommand = keyCommand;
-    _modifierFlags = modifierFlags;
-    _block = block;
+    _event = event;
   }
   return self;
 }
 
 RCT_NOT_IMPLEMENTED(- (instancetype)init)
 
-- (id)copyWithZone:(__unused NSZone *)zone
+- (NSString *)input
 {
-  return self;
+  return _event.characters;
 }
 
-- (NSUInteger)hash
+- (unsigned short)keyCode
 {
-  return _keyCommand.hash ^ _modifierFlags;
+  return _event.keyCode;
 }
 
-- (BOOL)isEqual:(RCTKeyCommand *)object
+- (BOOL)isDown
 {
-  if (![object isKindOfClass:[RCTKeyCommand class]]) {
-    return NO;
-  }
-  return [self matchesInput:object.keyCommand
-                      flags:object.modifierFlags];
+  return _event.type == NSEventTypeKeyDown;
 }
 
-- (BOOL)matchesInput:(NSString*)keyCommand flags:(int)flags
+- (NSEventModifierFlags)flags
 {
-  return [_keyCommand isEqual:keyCommand] && _modifierFlags == flags;
+  return _event.modifierFlags & NSEventModifierFlagDeviceIndependentFlagsMask;
 }
 
-- (NSString *)description
+- (NSWindow *)window
 {
-  return [NSString stringWithFormat:@"<%@:%p input=\"%@\" flags=%zd hasBlock=%@>",
-          [self class], self, _keyCommand, _modifierFlags,
-          _block ? @"YES" : @"NO"];
+  return _event.window;
 }
 
-@end
-
-@interface RCTKeyCommands ()
+- (NSString *)description
+{
+  return [NSString stringWithFormat:@"<%@:%p input=\"%@\" flags=%zd isDown=%@>",
+          [self class], self, self.input, self.flags, self.isDown ? @"YES" : @"NO"];
+}
 
-@property (nonatomic, strong) NSMutableSet<RCTKeyCommand *> *commands;
+- (BOOL)matchesInput:(NSString *)input
+{
+  return [self matchesInput:input flags:0];
+}
 
-@end
+- (BOOL)matchesInput:(NSString *)input flags:(NSEventModifierFlags)flags
+{
+  return [self.input isEqualToString:input] && self.flags == flags;
+}
 
+- (BOOL)matchesKeyCode:(RCTKeyCode)keyCode
+{
+  return [self matchesKeyCode:keyCode flags:0];
+}
 
-@implementation NSWindow (RCTKeyCommands)
+- (BOOL)matchesKeyCode:(RCTKeyCode)keyCode flags:(NSEventModifierFlags)flags
+{
+  return self.keyCode == keyCode && self.flags == flags;
+}
 
-- (void)keyDown:(NSEvent *)theEvent
+- (void)preventDefault
 {
-  for (RCTKeyCommand *command in [RCTKeyCommands sharedInstance].commands) {
-    if ([command.keyCommand isEqualToString:theEvent.characters] &&
-        command.modifierFlags == (theEvent.modifierFlags & NSDeviceIndependentModifierFlagsMask)) {
-      if (command.block) {
-        command.block(theEvent);
-      }
-      return;
-    }
-  }
+  _preventDefault = YES;
+}
 
-  [super keyDown:theEvent];
+- (BOOL)isDefaultPrevented
+{
+  return _preventDefault;
 }
 
 @end
 
 @implementation RCTKeyCommands
+{
+  NSHashTable<id<RCTKeyCommandObserver>> *_observers;
+}
 
 + (instancetype)sharedInstance
 {
@@ -111,46 +99,52 @@ + (instancetype)sharedInstance
 - (instancetype)init
 {
   if ((self = [super init])) {
-    _commands = [NSMutableSet new];
+    _observers = [NSHashTable weakObjectsHashTable];
   }
   return self;
 }
 
-- (void)registerKeyCommandWithInput:(NSString *)input
-                      modifierFlags:(NSEventModifierFlags)flags
-                             action:(void (^)(NSEvent *))block
+- (void)addObserver:(NSObject<RCTKeyCommandObserver> *)observer
 {
   RCTAssertMainQueue();
-
-  RCTKeyCommand *keyCommand = [[RCTKeyCommand alloc] initWithKeyCommand:input modifierFlags:flags block:block];
-  [_commands removeObject:keyCommand];
-  [_commands addObject:keyCommand];
+  [_observers addObject:observer];
 }
 
-- (void)unregisterKeyCommandWithInput:(NSString *)input
-                        modifierFlags:(NSEventModifierFlags)flags
+- (void)removeObserver:(NSObject<RCTKeyCommandObserver> *)observer
 {
   RCTAssertMainQueue();
+  [_observers removeObject:observer];
+}
 
-  for (RCTKeyCommand *command in _commands.allObjects) {
-    if ([command matchesInput:input flags:flags]) {
-      [_commands removeObject:command];
-      break;
-    }
+- (BOOL)observeEvent:(NSEvent *)event
+{
+  RCTAssertMainQueue();
+  RCTKeyCommand *command = [[RCTKeyCommand alloc] initWithEvent:event];
+  for (id<RCTKeyCommandObserver> observer in _observers) {
+    [observer observeKeyCommand:command];
   }
+  return command.isDefaultPrevented;
 }
 
-- (BOOL)isKeyCommandRegisteredForInput:(NSString *)input
-                         modifierFlags:(NSEventModifierFlags)flags
+@end
+
+@implementation NSWindow (RCTKeyCommands)
+
+- (void)keyDown:(NSEvent *)event
 {
-  RCTAssertMainQueue();
+  BOOL isDefaultPrevented = [[RCTKeyCommands sharedInstance] observeEvent:event];
+  if (!isDefaultPrevented) {
+    [super keyDown:event];
+  }
+}
 
-  for (RCTKeyCommand *command in _commands) {
-    if ([command matchesInput:input flags:flags]) {
-      return YES;
-    }
+- (void)keyUp:(NSEvent *)event
+{
+  BOOL isDefaultPrevented = [[RCTKeyCommands sharedInstance] observeEvent:event];
+  if (!isDefaultPrevented) {
+    [super keyUp:event];
   }
-  return NO;
 }
 
 @end
+

React/Base/RCTReloadCommand.h

@@ -15,6 +15,3 @@
 
 /** Registers a weakly-held observer of the Command+R reload key command. */
 RCT_EXTERN void RCTRegisterReloadCommandListener(id<RCTReloadListener> listener);
-
-/** Triggers a reload for all current listeners. You shouldn't need to use this directly in most cases. */
-RCT_EXTERN void RCTTriggerReloadCommandListeners(void);

React/Base/RCTReloadCommand.m

@@ -10,32 +10,44 @@
 #import "RCTAssert.h"
 #import "RCTKeyCommands.h"
 
-/** main queue only */
-static NSHashTable<id<RCTReloadListener>> *listeners;
+@interface RCTReloadCommand : NSObject <RCTKeyCommandObserver>
 
-void RCTRegisterReloadCommandListener(id<RCTReloadListener> listener)
+@property (nonatomic, strong) NSHashTable<id<RCTReloadListener>> *listeners;
+
+@end
+
+@implementation RCTReloadCommand
+
+- (instancetype)init
 {
-  RCTAssertMainQueue(); // because registerKeyCommandWithInput: must be called on the main thread
-  static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^{
-    listeners = [NSHashTable weakObjectsHashTable];
-    [[RCTKeyCommands sharedInstance] registerKeyCommandWithInput:@"r"
-                                                   modifierFlags:NSEventModifierFlagCommand
-                                                          action:
-     ^(__unused NSEvent *command) {
-       RCTTriggerReloadCommandListeners();
-     }];
-  });
-  [listeners addObject:listener];
+  if (self = [super init]) {
+    _listeners = [NSHashTable weakObjectsHashTable];
+    
+    [RCTKeyCommands.sharedInstance addObserver:self];
+  }
+  return self;
 }
 
-void RCTTriggerReloadCommandListeners(void)
+- (void)observeKeyCommand:(RCTKeyCommand *)command
 {
-  RCTAssertMainQueue();
-  // Copy to protect against mutation-during-enumeration.
-  // If listeners hasn't been initialized yet we get nil, which works just fine.
-  NSArray<id<RCTReloadListener>> *copiedListeners = [listeners allObjects];
-  for (id<RCTReloadListener> l in copiedListeners) {
-    [l didReceiveReloadCommand];
+  if (command.isDown && [command matchesInput:@"r" flags:NSEventModifierFlagCommand]) {
+    for (id<RCTReloadListener> listener in _listeners.allObjects) {
+      [listener didReceiveReloadCommand];
+    }
   }
 }
+
+@end
+
+void RCTRegisterReloadCommandListener(id<RCTReloadListener> listener)
+{
+  RCTAssertMainQueue();
+  
+  static RCTReloadCommand *command;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    command = [RCTReloadCommand new];
+  });
+  
+  [command.listeners addObject:listener];
+}

React/Base/RCTRootView.m

@@ -15,7 +15,6 @@
 #import "RCTBridge.h"
 #import "RCTBridge+Private.h"
 #import "RCTEventDispatcher.h"
-#import "RCTKeyCommands.h"
 #import "RCTLog.h"
 #import "RCTPerformanceLogger.h"
 #import "RCTProfile.h"