[react-packager][streamline oss] Move open sourced JS source to react-native-github

2026-04-23 20:01:01 +08:00 · 2015-02-19 20:10:52 -08:00
commit efae175a8e
434 changed files with 44658 additions and 0 deletions
--- a/ReactKit/Base/RCTAnimationType.h
+++ b/ReactKit/Base/RCTAnimationType.h
@@ -0,0 +1,11 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, RCTAnimationType) {
+  RCTAnimationTypeSpring = 0,
+  RCTAnimationTypeLinear,
+  RCTAnimationTypeEaseIn,
+  RCTAnimationTypeEaseOut,
+  RCTAnimationTypeEaseInEaseOut,
+};
--- a/ReactKit/Base/RCTAssert.h
+++ b/ReactKit/Base/RCTAssert.h
@@ -0,0 +1,36 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <Foundation/Foundation.h>
+
+#define RCTErrorDomain @"RCTErrorDomain"
+
+#define RCTAssert(condition, message, ...) _RCTAssert(condition, message, ##__VA_ARGS__)
+#define RCTCAssert(condition, message, ...) _RCTCAssert(condition, message, ##__VA_ARGS__)
+
+typedef void (^RCTAssertFunction)(BOOL condition, NSString *message, ...);
+
+extern RCTAssertFunction RCTInjectedAssertFunction;
+extern RCTAssertFunction RCTInjectedCAssertFunction;
+
+void RCTInjectAssertFunctions(RCTAssertFunction assertFunction, RCTAssertFunction cAssertFunction);
+
+#define _RCTAssert(condition, message, ...) \
+do { \
+  if (RCTInjectedAssertFunction) { \
+    RCTInjectedAssertFunction(condition, message, ##__VA_ARGS__); \
+  } else { \
+    NSAssert(condition, message, ##__VA_ARGS__); \
+  } \
+} while (false)
+
+#define _RCTCAssert(condition, message, ...) \
+do { \
+  if (RCTInjectedCAssertFunction) { \
+    RCTInjectedCAssertFunction(condition, message, ##__VA_ARGS__); \
+  } else { \
+    NSCAssert(condition, message, ##__VA_ARGS__); \
+  } \
+} while (false)
+
+#define RCTAssertMainThread() RCTAssert([NSThread isMainThread], @"This method must be called on the main thread");
+#define RCTCAssertMainThread() RCTCAssert([NSThread isMainThread], @"This function must be called on the main thread");
--- a/ReactKit/Base/RCTAssert.m
+++ b/ReactKit/Base/RCTAssert.m
@@ -0,0 +1,12 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import "RCTAssert.h"
+
+RCTAssertFunction RCTInjectedAssertFunction = nil;
+RCTAssertFunction RCTInjectedCAssertFunction = nil;
+
+void RCTInjectAssertFunctions(RCTAssertFunction assertFunction, RCTAssertFunction cAssertFunction)
+{
+  RCTInjectedAssertFunction = assertFunction;
+  RCTInjectedCAssertFunction = cAssertFunction;
+}
--- a/ReactKit/Base/RCTAutoInsetsProtocol.h
+++ b/ReactKit/Base/RCTAutoInsetsProtocol.h
@@ -0,0 +1,13 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <UIKit/UIKit.h>
+
+/**
+ * Defines a View that wants to support auto insets adjustment
+ */
+@protocol RCTAutoInsetsProtocol
+
+@property (nonatomic, assign, readwrite) UIEdgeInsets contentInset;
+@property (nonatomic, assign, readwrite) BOOL automaticallyAdjustContentInsets;
+
+@end
--- a/ReactKit/Base/RCTBridge.h
+++ b/ReactKit/Base/RCTBridge.h
@@ -0,0 +1,93 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import "RCTBridgeModule.h"
+#import "RCTInvalidating.h"
+#import "RCTJavaScriptExecutor.h"
+
+@class RCTEventDispatcher;
+@class RCTRootView;
+
+/**
+ * Utilities for constructing common response objects. When sending a
+ * systemError back to JS, it's important to describe whether or not it was a
+ * system error, or API usage error. System errors should never happen and are
+ * therefore logged using `RCTLogError()`. API usage errors are expected if the
+ * API is misused and will therefore not be logged using `RCTLogError()`. The JS
+ * application code is expected to handle them. Regardless of type, each error
+ * should be logged at most once.
+ */
+static inline NSDictionary *RCTSystemErrorObject(NSString *msg)
+{
+  return @{@"systemError": msg ?: @""};
+}
+
+static inline NSDictionary *RCTAPIErrorObject(NSString *msg)
+{
+  return @{@"apiError": msg ?: @""};
+}
+
+/**
+ * Async batched bridge used to communicate with the JavaScript application.
+ */
+@interface RCTBridge : NSObject <RCTInvalidating>
+
+/**
+ * The designated initializer. This creates a new bridge on top of the specified
+ * executor. The bridge should then be used for all subsequent communication
+ * with the JavaScript code running in the executor. You can optionally pass in
+ * a list of module instances to be used instead of the auto-instantiated versions.
+ */
+- (instancetype)initWithJavaScriptExecutor:(id<RCTJavaScriptExecutor>)javaScriptExecutor
+                           moduleInstances:(NSArray *)moduleInstances NS_DESIGNATED_INITIALIZER;
+
+/**
+ * This method is used to call functions in the JavaScript application context.
+ * It is primarily intended for use by modules that require two-way communication
+ * with the JavaScript code.
+ */
+- (void)enqueueJSCall:(NSString *)moduleDotMethod args:(NSArray *)args;
+
+/**
+ * This method is used to execute a new application script. It is called
+ * internally whenever a JS application bundle is loaded/reloaded, but should
+ * probably not be used at any other time.
+ */
+- (void)enqueueApplicationScript:(NSString *)script url:(NSURL *)url onComplete:(RCTJavaScriptCompleteBlock)onComplete;
+
+/**
+ * The event dispatcher is a wrapper around -enqueueJSCall:args: that provides a
+ * higher-level interface for sending UI events such as touches and text input.
+ */
+@property (nonatomic, readonly) RCTEventDispatcher *eventDispatcher;
+
+/**
+ * The shadow queue is used to execute callbacks from the JavaScript code. All
+ * native hooks (e.g. exported module methods) will be executed on the shadow
+ * queue.
+ */
+@property (nonatomic, readonly) dispatch_queue_t shadowQueue;
+
+// For use in implementing delegates, which may need to queue responses.
+- (RCTResponseSenderBlock)createResponseSenderBlock:(NSInteger)callbackID;
+
+/**
+ * Register a root view with the bridge. Theorectically, a single bridge can
+ * support multiple root views, however this feature is not currently exposed
+ * and may eventually be removed.
+ */
+- (void)registerRootView:(RCTRootView *)rootView;
+
+/**
+ * Global logging function that will print to both xcode and JS debugger consoles.
+ *
+ * NOTE: Use via RCTLog* macros defined in RCTLog.h
+ * TODO (#5906496): should log function be exposed here, or could it be a module?
+ */
+ (void)log:(NSArray *)objects level:(NSString *)level;
+
+/**
+ * Method to check that a valid executor exists with which to log
+ */
+ (BOOL)hasValidJSExecutor;
+
+@end
--- a/ReactKit/Base/RCTBridge.m
+++ b/ReactKit/Base/RCTBridge.m
@@ -0,0 +1,836 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import "RCTBridge.h"
+
+#import <dlfcn.h>
+#import <mach-o/getsect.h>
+#import <mach-o/dyld.h>
+#import <objc/message.h>
+#import <objc/runtime.h>
+
+#import "RCTConvert.h"
+#import "RCTInvalidating.h"
+#import "RCTEventDispatcher.h"
+#import "RCTLog.h"
+#import "RCTSparseArray.h"
+#import "RCTUtils.h"
+
+/**
+ * Must be kept in sync with `MessageQueue.js`.
+ */
+typedef NS_ENUM(NSUInteger, RCTBridgeFields) {
+  RCTBridgeFieldRequestModuleIDs = 0,
+  RCTBridgeFieldMethodIDs,
+  RCTBridgeFieldParamss,
+  RCTBridgeFieldResponseCBIDs,
+  RCTBridgeFieldResponseReturnValues,
+  RCTBridgeFieldFlushDateMillis
+};
+
+/**
+ * This private class is used as a container for exported method info
+ */
+@interface RCTModuleMethod : NSObject
+
+@property (readonly, nonatomic, assign) SEL selector;
+@property (readonly, nonatomic, copy) NSString *JSMethodName;
+@property (readonly, nonatomic, assign) NSUInteger arity;
+@property (readonly, nonatomic, copy) NSIndexSet *blockArgumentIndexes;
+
+@end
+
+@implementation RCTModuleMethod
+
+- (instancetype)initWithSelector:(SEL)selector
+                    JSMethodName:(NSString *)JSMethodName
+                           arity:(NSUInteger)arity
+            blockArgumentIndexes:(NSIndexSet *)blockArgumentIndexes
+{
+  if ((self = [super init])) {
+    _selector = selector;
+    _JSMethodName = [JSMethodName copy];
+    _arity = arity;
+    _blockArgumentIndexes = [blockArgumentIndexes copy];
+  }
+  return self;
+}
+
+- (NSString *)description
+{
+  NSString *blocks = @"no block args";
+  if (self.blockArgumentIndexes.count > 0) {
+    NSMutableString *indexString = [NSMutableString string];
+    [self.blockArgumentIndexes enumerateIndexesUsingBlock:^(NSUInteger idx, BOOL *stop) {
+      [indexString appendFormat:@", %tu", idx];
+    }];
+    blocks = [NSString stringWithFormat:@"block args at %@", [indexString substringFromIndex:2]];
+  }
+  
+  return [NSString stringWithFormat:@"<%@: %p; exports -%@ as %@; %@>", NSStringFromClass(self.class), self, NSStringFromSelector(self.selector), self.JSMethodName, blocks];
+}
+
+@end
+
+#ifdef __LP64__
+typedef uint64_t RCTExportValue;
+typedef struct section_64 RCTExportSection;
+#define RCTGetSectByNameFromHeader getsectbynamefromheader_64
+#else
+typedef uint32_t RCTExportValue;
+typedef struct section RCTExportSection;
+#define RCTGetSectByNameFromHeader getsectbynamefromheader
+#endif
+
+/**
+ * This function returns the module name for a given class.
+ */
+static NSString *RCTModuleNameForClass(Class cls)
+{
+  return [cls respondsToSelector:@selector(moduleName)] ? [cls moduleName] : NSStringFromClass(cls);
+}
+
+/**
+ * This function instantiates a new module instance.
+ */
+static id<RCTBridgeModule> RCTCreateModuleInstance(Class cls, RCTBridge *bridge)
+{
+  if ([cls instancesRespondToSelector:@selector(initWithBridge:)]) {
+    return [[cls alloc] initWithBridge:bridge];
+  } else {
+    return [[cls alloc] init];
+  }
+}
+
+/**
+ * This function scans all classes available at runtime and returns an array
+ * of all classes that implement the RTCBridgeModule protocol.
+ */
+static NSArray *RCTModuleNamesByID;
+static NSArray *RCTBridgeModuleClassesByModuleID(void)
+{
+  static NSArray *modules;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    modules = [NSMutableArray array];
+    RCTModuleNamesByID = [NSMutableArray array];
+
+    unsigned int classCount;
+    Class *classes = objc_copyClassList(&classCount);
+    for (unsigned int i = 0; i < classCount; i++) {
+
+      Class cls = classes[i];
+
+      if (!class_getSuperclass(cls)) {
+        // Class has no superclass - it's probably something weird
+        continue;
+      }
+
+      if (![cls conformsToProtocol:@protocol(RCTBridgeModule)]) {
+        // Not an RCTBridgeModule
+        continue;
+      }
+
+      // Add module
+      [(NSMutableArray *)modules addObject:cls];
+
+      // Add module name
+      NSString *moduleName = RCTModuleNameForClass(cls);
+      [(NSMutableArray *)RCTModuleNamesByID addObject:moduleName];
+    }
+    free(classes);
+
+    modules = [modules copy];
+    RCTModuleNamesByID = [RCTModuleNamesByID copy];
+  });
+  
+  return modules;
+}
+
+/**
+ * This function parses the exported methods inside RCTBridgeModules and
+ * generates an array of arrays of RCTModuleMethod objects, keyed
+ * by module index.
+ */
+static RCTSparseArray *RCTExportedMethodsByModuleID(void)
+{
+  static RCTSparseArray *methodsByModuleID;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+
+    Dl_info info;
+    dladdr(&RCTExportedMethodsByModuleID, &info);
+
+    const RCTExportValue mach_header = (RCTExportValue)info.dli_fbase;
+    const RCTExportSection *section = RCTGetSectByNameFromHeader((void *)mach_header, "__DATA", "RCTExport");
+
+    if (section == NULL) {
+      return;
+    }
+
+    NSArray *classes = RCTBridgeModuleClassesByModuleID();
+    NSMutableDictionary *methodsByModuleClassName = [NSMutableDictionary dictionaryWithCapacity:[classes count]];
+    NSCharacterSet *plusMinusCharacterSet = [NSCharacterSet characterSetWithCharactersInString:@"+-"];
+
+    for (RCTExportValue addr = section->offset;
+         addr < section->offset + section->size;
+         addr += sizeof(id) * 2) {
+
+      const char **entry = (const char **)(mach_header + addr);
+      NSScanner *scanner = [NSScanner scannerWithString:@(entry[0])];
+
+      NSString *plusMinus;
+      if (![scanner scanCharactersFromSet:plusMinusCharacterSet intoString:&plusMinus]) continue;
+      if (![scanner scanString:@"[" intoString:NULL]) continue;
+
+      NSString *className;
+      if (![scanner scanUpToString:@" " intoString:&className]) continue;
+      [scanner scanString:@" " intoString:NULL];
+
+      NSString *selectorName;
+      if (![scanner scanUpToString:@"]" intoString:&selectorName]) continue;
+
+      Class moduleClass = NSClassFromString(className);
+      if (moduleClass == Nil) continue;
+
+      SEL selector = NSSelectorFromString(selectorName);
+      Method method = ([plusMinus characterAtIndex:0] == '+' ? class_getClassMethod : class_getInstanceMethod)(moduleClass, selector);
+      if (method == nil) continue;
+
+      unsigned int argumentCount = method_getNumberOfArguments(method);
+      NSMutableIndexSet *blockArgumentIndexes = [NSMutableIndexSet indexSet];
+      static const char *blockType = @encode(typeof(^{}));
+      for (unsigned int i = 2; i < argumentCount; i++) {
+        char *type = method_copyArgumentType(method, i);
+        if (!strcmp(type, blockType)) {
+          [blockArgumentIndexes addIndex:i - 2];
+        }
+        free(type);
+      }
+
+      NSString *JSMethodName = strlen(entry[1]) ? @(entry[1]) : [NSStringFromSelector(selector) componentsSeparatedByString:@":"][0];
+      RCTModuleMethod *moduleMethod =
+      [[RCTModuleMethod alloc] initWithSelector:selector
+                                   JSMethodName:JSMethodName
+                                          arity:method_getNumberOfArguments(method) - 2
+                           blockArgumentIndexes:blockArgumentIndexes];
+
+      NSArray *methods = methodsByModuleClassName[className];
+      methodsByModuleClassName[className] = methods ? [methods arrayByAddingObject:moduleMethod] : @[moduleMethod];
+    }
+
+    methodsByModuleID = [[RCTSparseArray alloc] initWithCapacity:[classes count]];
+    [classes enumerateObjectsUsingBlock:^(Class moduleClass, NSUInteger moduleID, BOOL *stop) {
+      methodsByModuleID[moduleID] = methodsByModuleClassName[NSStringFromClass(moduleClass)];
+    }];
+  });
+  
+  return methodsByModuleID;
+}
+
+/**
+ * This constructs the remote modules configuration data structure,
+ * which represents the native modules and methods that will be called
+ * by JS. A numeric ID is assigned to each module and method, which will
+ * be used to communicate via the bridge. The structure of each
+ * module is as follows:
+ *
+ * "ModuleName1": {
+ *   "moduleID": 0,
+ *   "methods": {
+ *     "methodName1": {
+ *       "methodID": 0,
+ *       "type": "remote"
+ *     },
+ *     "methodName2": {
+ *       "methodID": 1,
+ *       "type": "remote"
+ *     },
+ *     etc...
+ *   },
+ *   "constants": {
+ *     ...
+ *   }
+ * },
+ * etc...
+ */
+static NSDictionary *RCTRemoteModulesConfig(NSDictionary *modulesByName)
+{
+  static NSMutableDictionary *remoteModuleConfigByClassName;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+
+    remoteModuleConfigByClassName = [[NSMutableDictionary alloc] init];
+    [RCTBridgeModuleClassesByModuleID() enumerateObjectsUsingBlock:^(Class moduleClass, NSUInteger moduleID, BOOL *stop) {
+
+      NSArray *methods = RCTExportedMethodsByModuleID()[moduleID];
+      NSMutableDictionary *methodsByName = [NSMutableDictionary dictionaryWithCapacity:methods.count];
+      [methods enumerateObjectsUsingBlock:^(RCTModuleMethod *method, NSUInteger methodID, BOOL *stop) {
+        methodsByName[method.JSMethodName] = @{
+          @"methodID": @(methodID),
+          @"type": @"remote",
+        };
+      }];
+      
+      NSDictionary *module = @{
+        @"moduleID": @(moduleID),
+        @"methods": methodsByName
+      };
+
+      // Add static constants
+      if (RCTClassOverridesClassMethod(moduleClass, @selector(constantsToExport))) {
+        NSMutableDictionary *mutableModule = [module mutableCopy];
+        mutableModule[@"constants"] = [moduleClass constantsToExport] ?: @{};
+        module = [mutableModule copy];
+      }
+
+      remoteModuleConfigByClassName[NSStringFromClass(moduleClass)] = module;
+    }];
+  });
+
+  // Create config
+  NSMutableDictionary *moduleConfig = [[NSMutableDictionary alloc] init];
+  [modulesByName enumerateKeysAndObjectsUsingBlock:^(NSString *moduleName, id<RCTBridgeModule> module, BOOL *stop) {
+
+    // Add "psuedo-constants"
+    NSMutableDictionary *config = remoteModuleConfigByClassName[NSStringFromClass([module class])];
+    if (RCTClassOverridesInstanceMethod([module class], @selector(constantsToExport))) {
+      NSMutableDictionary *mutableConfig = [NSMutableDictionary dictionaryWithDictionary:config];
+      NSMutableDictionary *mutableConstants = [NSMutableDictionary dictionaryWithDictionary:config[@"constants"]];
+      [mutableConstants addEntriesFromDictionary:[module constantsToExport]];
+      mutableConfig[@"constants"] = mutableConstants; // There's no real need to copy this
+      config = mutableConfig; // Nor this - receiver is unlikely to mutate it
+    }
+
+    moduleConfig[moduleName] = config;
+  }];
+
+  return moduleConfig;
+}
+
+/**
+ * As above, but for local modules/methods, which represent JS classes
+ * and methods that will be called by the native code via the bridge.
+ * Structure is essentially the same as for remote modules:
+ *
+ * "ModuleName1": {
+ *   "moduleID": 0,
+ *   "methods": {
+ *     "methodName1": {
+ *       "methodID": 0,
+ *       "type": "local"
+ *     },
+ *     "methodName2": {
+ *       "methodID": 1,
+ *       "type": "local"
+ *     },
+ *     etc...
+ *   }
+ * },
+ * etc...
+ */
+static NSMutableDictionary *RCTLocalModuleIDs;
+static NSMutableDictionary *RCTLocalMethodIDs;
+static NSDictionary *RCTLocalModulesConfig()
+{
+  static NSMutableDictionary *localModules;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    
+    RCTLocalModuleIDs = [[NSMutableDictionary alloc] init];
+    RCTLocalMethodIDs = [[NSMutableDictionary alloc] init];
+    
+    NSMutableArray *JSMethods = [[NSMutableArray alloc] init];
+    
+    // Add globally used methods
+    [JSMethods addObjectsFromArray:@[
+      @"AppRegistry.runApplication",
+      @"RCTDeviceEventEmitter.emit",
+      @"RCTEventEmitter.receiveEvent",
+      @"RCTEventEmitter.receiveTouches",
+    ]];
+    
+    //  NOTE: these methods are currently unused in the OSS project
+    //  @"Dimensions.set",
+    //  @"RCTNativeAppEventEmitter.emit",
+    //  @"ReactIOS.unmountComponentAtNodeAndRemoveContainer",
+    
+    // Register individual methods from modules
+    for (Class cls in RCTBridgeModuleClassesByModuleID()) {
+      if (RCTClassOverridesClassMethod(cls, @selector(JSMethods))) {
+        [JSMethods addObjectsFromArray:[cls JSMethods]];
+      }
+    }
+    
+    localModules = [[NSMutableDictionary alloc] init];
+    for (NSString *moduleDotMethod in JSMethods) {
+      
+      NSArray *parts = [moduleDotMethod componentsSeparatedByString:@"."];
+      RCTCAssert(parts.count == 2, @"'%@' is not a valid JS method definition - expected 'Module.method' format.", moduleDotMethod);
+      
+      // Add module if it doesn't already exist
+      NSString *moduleName = parts[0];
+      NSDictionary *module = localModules[moduleName];
+      if (!module) {
+        module = @{
+          @"moduleID": @(localModules.count),
+          @"methods": [[NSMutableDictionary alloc] init]
+        };
+        localModules[moduleName] = module;
+      }
+      
+      // Add method if it doesn't already exist
+      NSString *methodName = parts[1];
+      NSMutableDictionary *methods = module[@"methods"];
+      if (!methods[methodName]) {
+        methods[methodName] = @{
+          @"methodID": @(methods.count),
+          @"type": @"local"
+        };
+      }
+      
+      // Add module and method lookup
+      RCTLocalModuleIDs[moduleDotMethod] = module[@"moduleID"];
+      RCTLocalMethodIDs[moduleDotMethod] = methods[methodName][@"methodID"];
+    }
+  });
+  
+  return localModules;
+}
+
+@implementation RCTBridge
+{
+  RCTSparseArray *_modulesByID;
+  NSMutableDictionary *_modulesByName;
+  id<RCTJavaScriptExecutor> _javaScriptExecutor;
+}
+
+static id<RCTJavaScriptExecutor> _latestJSExecutor;
+
+- (instancetype)initWithJavaScriptExecutor:(id<RCTJavaScriptExecutor>)javaScriptExecutor
+                           moduleInstances:(NSArray *)moduleInstances
+{
+  if ((self = [super init])) {
+    _javaScriptExecutor = javaScriptExecutor;
+    _latestJSExecutor = _javaScriptExecutor;
+    _eventDispatcher = [[RCTEventDispatcher alloc] initWithBridge:self];
+    _shadowQueue = dispatch_queue_create("com.facebook.ReactKit.ShadowQueue", DISPATCH_QUEUE_SERIAL);
+
+    // Register passed-in module instances
+    NSMutableDictionary *preregisteredModules = [[NSMutableDictionary alloc] init];
+    for (id<RCTBridgeModule> module in moduleInstances) {
+      preregisteredModules[RCTModuleNameForClass([module class])] = module;
+    }
+
+    // Instantiate modules
+    _modulesByID = [[RCTSparseArray alloc] init];
+    _modulesByName = [[NSMutableDictionary alloc] initWithDictionary:preregisteredModules];
+    [RCTBridgeModuleClassesByModuleID() enumerateObjectsUsingBlock:^(Class moduleClass, NSUInteger moduleID, BOOL *stop) {
+      NSString *moduleName = RCTModuleNamesByID[moduleID];
+      // Check if module instance has already been registered for this name
+      if (_modulesByName[moduleName] != nil) {
+        // Preregistered instances takes precedence, no questions asked
+        if (!preregisteredModules[moduleName]) {
+          // It's OK to have a name collision as long as the second instance is nil
+          RCTAssert(RCTCreateModuleInstance(moduleClass, self) == nil,
+                    @"Attempted to register RCTBridgeModule class %@ for the name '%@', \
+                    but name was already registered by class %@", moduleClass,
+                    moduleName, [_modulesByName[moduleName] class]);
+        }
+      } else {
+        // Module name hasn't been used before, so go ahead and instantiate
+        _modulesByID[moduleID] = _modulesByName[moduleName] = RCTCreateModuleInstance(moduleClass, self);
+      }
+    }];
+    
+    // Inject module data into JS context
+    NSString *configJSON = RCTJSONStringify(@{
+      @"remoteModuleConfig": RCTRemoteModulesConfig(_modulesByName),
+      @"localModulesConfig": RCTLocalModulesConfig()
+    }, NULL);
+    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+    [_javaScriptExecutor injectJSONText:configJSON asGlobalObjectNamed:@"__fbBatchedBridgeConfig" callback:^(id err) {
+      dispatch_semaphore_signal(semaphore);
+    }];
+    
+    if (dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC)) != 0) {
+      RCTLogMustFix(@"JavaScriptExecutor took too long to inject JSON object");
+    }
+  }
+  
+  return self;
+}
+
+- (void)dealloc
+{
+  RCTAssert(!self.valid, @"must call -invalidate before -dealloc");
+}
+
+#pragma mark - RCTInvalidating
+
+- (BOOL)isValid
+{
+  return _javaScriptExecutor != nil;
+}
+
+- (void)invalidate
+{
+  if (_latestJSExecutor == _javaScriptExecutor) {
+    _latestJSExecutor = nil;
+  }
+  [_javaScriptExecutor invalidate];
+  _javaScriptExecutor = nil;
+  
+  dispatch_sync(_shadowQueue, ^{
+    // Make sure all dispatchers have been executed before continuing
+    // TODO: is this still needed?
+  });
+  
+  for (id target in _modulesByID.allObjects) {
+    if ([target respondsToSelector:@selector(invalidate)]) {
+      [(id<RCTInvalidating>)target invalidate];
+    }
+  }
+  [_modulesByID removeAllObjects];
+}
+
+/**
+ * - TODO (#5906496): When we build a `MessageQueue.m`, handling all the requests could
+ * cause both a queue of "responses". We would flush them here. However, we
+ * currently just expect each objc block to handle its own response sending
+ * using a `RCTResponseSenderBlock`.
+ */
+
+#pragma mark - RCTBridge methods
+
+/**
+ * Like JS::call, for objective-c.
+ */
+- (void)enqueueJSCall:(NSString *)moduleDotMethod args:(NSArray *)args
+{
+  NSNumber *moduleID = RCTLocalModuleIDs[moduleDotMethod];
+  RCTAssert(moduleID != nil, @"Module '%@' not registered.",
+            [[moduleDotMethod componentsSeparatedByString:@"."] firstObject]);
+  
+  NSNumber *methodID = RCTLocalMethodIDs[moduleDotMethod];
+  RCTAssert(methodID != nil, @"Method '%@' not registered.", moduleDotMethod);
+  
+  [self _invokeAndProcessModule:@"BatchedBridge"
+                         method:@"callFunctionReturnFlushedQueue"
+                      arguments:@[moduleID, methodID, args]];
+}
+
+- (void)enqueueApplicationScript:(NSString *)script url:(NSURL *)url onComplete:(RCTJavaScriptCompleteBlock)onComplete
+{
+  RCTAssert(onComplete != nil, @"onComplete block passed in should be non-nil");
+  [_javaScriptExecutor executeApplicationScript:script sourceURL:url onComplete:^(NSError *scriptLoadError) {
+    if (scriptLoadError) {
+      onComplete(scriptLoadError);
+      return;
+    }
+    
+    [_javaScriptExecutor executeJSCall:@"BatchedBridge"
+                                method:@"flushedQueue"
+                             arguments:@[]
+                              callback:^(id objcValue, NSError *error) {
+                                [self _handleBuffer:objcValue];
+                                onComplete(error);
+                              }];
+  }];
+}
+
+#pragma mark - Payload Generation
+
+- (void)_invokeAndProcessModule:(NSString *)module method:(NSString *)method arguments:(NSArray *)args
+{
+  NSTimeInterval startJS = RCTTGetAbsoluteTime();
+  
+  RCTJavaScriptCallback processResponse = ^(id objcValue, NSError *error) {
+    NSTimeInterval startNative = RCTTGetAbsoluteTime();
+    [self _handleBuffer:objcValue];
+    
+    NSTimeInterval end = RCTTGetAbsoluteTime();
+    NSTimeInterval timeJS = startNative - startJS;
+    NSTimeInterval timeNative = end - startNative;
+    
+    // TODO: surface this performance information somewhere
+    [[NSNotificationCenter defaultCenter] postNotificationName:@"PERF" object:nil userInfo:@{@"JS": @(timeJS * 1000000), @"Native": @(timeNative * 1000000)}];
+  };
+  
+  [_javaScriptExecutor executeJSCall:module
+                              method:method
+                           arguments:args
+                            callback:processResponse];
+}
+
+/**
+ * TODO (#5906496): Have responses piggy backed on a round trip with ObjC->JS requests.
+ */
+- (void)_sendResponseToJavaScriptCallbackID:(NSInteger)cbID args:(NSArray *)args
+{
+  [self _invokeAndProcessModule:@"BatchedBridge"
+                         method:@"invokeCallbackAndReturnFlushedQueue"
+                      arguments:@[@(cbID), args]];
+}
+
+#pragma mark - Payload Processing
+
+- (void)_handleBuffer:(id)buffer
+{
+  if (buffer == nil || buffer == (id)kCFNull) {
+    return;
+  }
+  
+  if (![buffer isKindOfClass:[NSArray class]]) {
+    RCTLogError(@"Buffer must be an instance of NSArray, got %@", NSStringFromClass([buffer class]));
+    return;
+  }
+  
+  NSArray *requestsArray = (NSArray *)buffer;
+  NSUInteger bufferRowCount = [requestsArray count];
+  NSUInteger expectedFieldsCount = RCTBridgeFieldResponseReturnValues + 1;
+  if (bufferRowCount != expectedFieldsCount) {
+    RCTLogError(@"Must pass all fields to buffer - expected %zd, saw %zd", expectedFieldsCount, bufferRowCount);
+    return;
+  }
+  
+  for (NSUInteger fieldIndex = RCTBridgeFieldRequestModuleIDs; fieldIndex <= RCTBridgeFieldParamss; fieldIndex++) {
+    id field = [requestsArray objectAtIndex:fieldIndex];
+    if (![field isKindOfClass:[NSArray class]]) {
+      RCTLogError(@"Field at index %zd in buffer must be an instance of NSArray, got %@", fieldIndex, NSStringFromClass([field class]));
+      return;
+    }
+  }
+  
+  NSArray *moduleIDs = requestsArray[RCTBridgeFieldRequestModuleIDs];
+  NSArray *methodIDs = requestsArray[RCTBridgeFieldMethodIDs];
+  NSArray *paramsArrays = requestsArray[RCTBridgeFieldParamss];
+  
+  NSUInteger numRequests = [moduleIDs count];
+  BOOL allSame = numRequests == [methodIDs count] && numRequests == [paramsArrays count];
+  if (!allSame) {
+    RCTLogError(@"Invalid data message - all must be length: %zd", numRequests);
+    return;
+  }
+  
+  for (NSUInteger i = 0; i < numRequests; i++) {
+    @autoreleasepool {
+      [self _handleRequestNumber:i
+                        moduleID:[moduleIDs[i] integerValue]
+                        methodID:[methodIDs[i] integerValue]
+                          params:paramsArrays[i]];
+    }
+  }
+  
+  // TODO: only used by RCTUIManager - can we eliminate this special case?
+  dispatch_async(_shadowQueue, ^{
+    for (id module in _modulesByID.allObjects) {
+      if ([module respondsToSelector:@selector(batchDidComplete)]) {
+        [module batchDidComplete];
+      }
+    }
+  });
+}
+
+- (BOOL)_handleRequestNumber:(NSUInteger)i
+                    moduleID:(NSUInteger)moduleID
+                    methodID:(NSUInteger)methodID
+                      params:(NSArray *)params
+{
+  if (![params isKindOfClass:[NSArray class]]) {
+    RCTLogError(@"Invalid module/method/params tuple for request #%zd", i);
+    return NO;
+  }
+
+  NSArray *methods = RCTExportedMethodsByModuleID()[moduleID];
+  if (methodID >= methods.count) {
+    RCTLogError(@"Unknown methodID: %zd for module: %zd (%@)", methodID, moduleID, RCTModuleNamesByID[moduleID]);
+    return NO;
+  }
+  
+  RCTModuleMethod *method = methods[methodID];
+  NSUInteger methodArity = method.arity;
+  if (params.count != methodArity) {
+    RCTLogError(@"Expected %tu arguments but got %tu invoking %@.%@",
+                methodArity,
+                params.count,
+                RCTModuleNamesByID[moduleID],
+                method.JSMethodName);
+    return NO;
+  }
+  
+  __weak RCTBridge *weakSelf = self;
+  dispatch_async(_shadowQueue, ^{
+    __strong RCTBridge *strongSelf = weakSelf;
+    
+    if (!strongSelf.isValid) {
+      // strongSelf has been invalidated since the dispatch_async call and this
+      // invocation should not continue.
+      return;
+    }
+    
+    // TODO: we should just store module instances by index, since that's how we look them up anyway
+    id target = strongSelf->_modulesByID[moduleID];
+    RCTAssert(target != nil, @"No module found for name '%@'", RCTModuleNamesByID[moduleID]);
+    
+    SEL selector = method.selector;
+    NSMethodSignature *methodSignature = [target methodSignatureForSelector:selector];
+    NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:methodSignature];
+    [invocation setArgument:&target atIndex:0];
+    [invocation setArgument:&selector atIndex:1];
+    
+    // Retain used blocks until after invocation completes.
+    NS_VALID_UNTIL_END_OF_SCOPE NSMutableArray *blocks = [NSMutableArray array];
+    
+    [params enumerateObjectsUsingBlock:^(id param, NSUInteger idx, BOOL *stop) {
+      if ([param isEqual:[NSNull null]]) {
+        param = nil;
+      } else if ([method.blockArgumentIndexes containsIndex:idx]) {
+        id block = [strongSelf createResponseSenderBlock:[param integerValue]];
+        [blocks addObject:block];
+        param = block;
+      }
+      
+      NSUInteger argIdx = idx + 2;
+      
+      // TODO: can we do this lookup in advance and cache the logic instead of
+      // recalculating it every time for every parameter?
+      BOOL shouldSet = YES;
+      const char *argumentType = [methodSignature getArgumentTypeAtIndex:argIdx];
+      switch (argumentType[0]) {
+        case ':':
+          if ([param isKindOfClass:[NSString class]]) {
+            SEL selector = NSSelectorFromString(param);
+            [invocation setArgument:&selector atIndex:argIdx];
+            shouldSet = NO;
+          }
+          break;
+          
+        case '*':
+          if ([param isKindOfClass:[NSString class]]) {
+            const char *string = [param UTF8String];
+            [invocation setArgument:&string atIndex:argIdx];
+            shouldSet = NO;
+          }
+          break;
+          
+          // TODO: it seems like an error if the param doesn't respond
+          // so we should probably surface that error rather than failing silently
+#define CASE(_value, _type, _selector)                           \
+        case _value:                                             \
+          if ([param respondsToSelector:@selector(_selector)]) { \
+            _type value = [param _selector];                     \
+            [invocation setArgument:&value atIndex:argIdx];      \
+            shouldSet = NO;                                      \
+          }                                                      \
+          break;
+          
+          CASE('c', char, charValue)
+          CASE('C', unsigned char, unsignedCharValue)
+          CASE('s', short, shortValue)
+          CASE('S', unsigned short, unsignedShortValue)
+          CASE('i', int, intValue)
+          CASE('I', unsigned int, unsignedIntValue)
+          CASE('l', long, longValue)
+          CASE('L', unsigned long, unsignedLongValue)
+          CASE('q', long long, longLongValue)
+          CASE('Q', unsigned long long, unsignedLongLongValue)
+          CASE('f', float, floatValue)
+          CASE('d', double, doubleValue)
+          CASE('B', BOOL, boolValue)
+          
+        default:
+          break;
+      }
+      
+      if (shouldSet) {
+        [invocation setArgument:&param atIndex:argIdx];
+      }
+    }];
+    
+    @try {
+      [invocation invoke];
+    }
+    @catch (NSException *exception) {
+      RCTLogError(@"Exception thrown while invoking %@ on target %@ with params %@: %@", method.JSMethodName, target, params, exception);
+    }
+  });
+  
+  return YES;
+}
+
+/**
+ * Returns a callback that reports values back to the JS thread.
+ * TODO (#5906496): These responses should go into their own queue `MessageQueue.m` that
+ * mirrors the JS queue and protocol. For now, we speak the "language" of the JS
+ * queue by packing it into an array that matches the wire protocol.
+ */
+- (RCTResponseSenderBlock)createResponseSenderBlock:(NSInteger)cbID
+{
+  if (!cbID) {
+    return nil;
+  }
+  
+  return ^(NSArray *args) {
+    [self _sendResponseToJavaScriptCallbackID:cbID args:args];
+  };
+}
+
+ (NSInvocation *)invocationForAdditionalArguments:(NSUInteger)argCount
+{
+  static NSMutableDictionary *invocations;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    invocations = [NSMutableDictionary dictionary];
+  });
+  
+  id key = @(argCount);
+  NSInvocation *invocation = invocations[key];
+  if (invocation == nil) {
+    NSString *objCTypes = [@"v@:" stringByPaddingToLength:3 + argCount withString:@"@" startingAtIndex:0];
+    NSMethodSignature *methodSignature = [NSMethodSignature signatureWithObjCTypes:objCTypes.UTF8String];
+    invocation = [NSInvocation invocationWithMethodSignature:methodSignature];
+    invocations[key] = invocation;
+  }
+  
+  return invocation;
+}
+
+- (void)registerRootView:(RCTRootView *)rootView
+{
+  // TODO: only used by RCTUIManager - can we eliminate this special case?
+  for (id module in _modulesByID.allObjects) {
+    if ([module respondsToSelector:@selector(registerRootView:)]) {
+      [module registerRootView:rootView];
+    }
+  }
+}
+
+ (BOOL)hasValidJSExecutor
+{
+  return (_latestJSExecutor != nil && [_latestJSExecutor isValid]);
+}
+
+ (void)log:(NSArray *)objects level:(NSString *)level
+{
+  if (!_latestJSExecutor || ![_latestJSExecutor isValid]) {
+    RCTLogError(@"%@", RCTLogFormatString(@"ERROR: No valid JS executor to log %@.", objects));
+    return;
+  }
+  NSMutableArray *args = [NSMutableArray arrayWithObject:level];
+  
+  // TODO (#5906496): Find out and document why we skip the first object
+  for (id ob in [objects subarrayWithRange:(NSRange){1, [objects count] - 1}]) {
+    if ([NSJSONSerialization isValidJSONObject:@[ob]]) {
+      [args addObject:ob];
+    } else {
+      [args addObject:[ob description]];
+    }
+  }
+  // Note the js executor could get invalidated while we're trying to call this...need to watch out for that.
+  [_latestJSExecutor executeJSCall:@"RCTLog"
+                            method:@"logIfNoNativeHook"
+                         arguments:args
+                          callback:^(id objcValue, NSError *error) {}];
+}
+
+@end
--- a/ReactKit/Base/RCTBridgeModule.h
+++ b/ReactKit/Base/RCTBridgeModule.h
@@ -0,0 +1,65 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <Foundation/Foundation.h>
+
+@class RCTBridge;
+
+/**
+ * The type of a block that is capable of sending a response to a bridged
+ * operation. Use this for returning callback methods to JS.
+ */
+typedef void (^RCTResponseSenderBlock)(NSArray *response);
+
+/**
+ * Provides minimal interface needed to register a bridge module
+ */
+@protocol RCTBridgeModule <NSObject>
+@optional
+
+/**
+ * Optional initializer for modules that require access
+ * to bridge features, such as sending events or making JS calls
+ */
+- (instancetype)initWithBridge:(RCTBridge *)bridge;
+
+/**
+ * The module name exposed to JS. If omitted, this will be inferred
+ * automatically by using the native module's class name.
+ */
+ (NSString *)moduleName;
+
+/**
+ * Place this macro inside the method body of any method you want to expose
+ * to JS. The optional js_name argument will be used as the JS method name
+ * (the method will be namespaced to the module name, as specified above).
+ * If omitted, the JS method name will match the first part of the Objective-C
+ * method selector name (up to the first colon).
+ */
+#define RCT_EXPORT(js_name) __attribute__((used, section("__DATA,RCTExport" \
+))) static const char *__rct_export_entry__[] = { __func__, #js_name }
+
+/**
+ * Injects constants into JS. These constants are made accessible via
+ * NativeModules.moduleName.X. Note that this method is not inherited when you
+ * subclass a module, and you should not call [super constantsToExport] when
+ * implementing it.
+ */
+ (NSDictionary *)constantsToExport;
+
+/**
+ * An array of JavaScript methods that the module will call via the
+ * -[RCTBridge enqueueJSCall:args:] method. Each method should be specified
+ * as a string of the form "JSModuleName.jsMethodName". Attempting to call a
+ * method that has not been registered will result in an error. If a method
+ * has already been regsistered by another module, it is not necessary to
+ * register it again, but it is good pratice. Registering the same method
+ * more than once is silently ignored and will not result in an error.
+ */
+ (NSArray *)JSMethods;
+
+/**
+ * Notifies the module that a batch of JS method invocations has just completed.
+ */
+- (void)batchDidComplete;
+
+@end
--- a/ReactKit/Base/RCTCache.h
+++ b/ReactKit/Base/RCTCache.h
@@ -0,0 +1,22 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <Foundation/Foundation.h>
+
+@interface RCTCache : NSObject
+
+- (instancetype)init; // name = @"default"
+- (instancetype)initWithName:(NSString *)name;
+
+@property (nonatomic, assign) NSUInteger maximumDiskSize; // in bytes
+
+#pragma mark - Retrieval
+
+- (BOOL)hasDataForKey:(NSString *)key;
+- (void)fetchDataForKey:(NSString *)key completionHandler:(void (^)(NSData *data))completionHandler;
+
+#pragma mark - Insertion
+
+- (void)setData:(NSData *)data forKey:(NSString *)key;
+- (void)removeAllData;
+
+@end
--- a/ReactKit/Base/RCTCache.m
+++ b/ReactKit/Base/RCTCache.m
@@ -0,0 +1,224 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import "RCTCache.h"
+
+#import <UIKit/UIKit.h>
+#import <sys/xattr.h>
+
+static NSString *const RCTCacheSubdirectoryName = @"ReactKit";
+static NSString *const RCTKeyExtendedAttributeName = @"com.facebook.ReactKit.RCTCacheManager.Key";
+static NSMapTable *RCTLivingCachesByName;
+
+static NSError *RCTPOSIXError(int errorNumber)
+{
+  NSDictionary *userInfo = @{
+    NSLocalizedDescriptionKey: @(strerror(errorNumber))
+  };
+  return [NSError errorWithDomain:NSPOSIXErrorDomain code:errorNumber userInfo:userInfo];
+}
+
+static NSString *RCTGetExtendedAttribute(NSURL *fileURL, NSString *key, NSError **error)
+{
+  const char *path = fileURL.fileSystemRepresentation;
+  ssize_t length = getxattr(path, key.UTF8String, NULL, 0, 0, 0);
+  if (length <= 0) {
+    if (error) *error = RCTPOSIXError(errno);
+    return nil;
+  }
+
+  char *buffer = malloc(length);
+  length = getxattr(path, key.UTF8String, buffer, length, 0, 0);
+  if (length > 0) {
+    return [[NSString alloc] initWithBytesNoCopy:buffer length:length encoding:NSUTF8StringEncoding freeWhenDone:YES];
+  }
+
+  free(buffer);
+  if (error) *error = RCTPOSIXError(errno);
+  return nil;
+}
+
+static BOOL RCTSetExtendedAttribute(NSURL *fileURL, NSString *key, NSString *value, NSError **error)
+{
+  const char *path = fileURL.fileSystemRepresentation;
+
+  int result;
+  if (value) {
+    const char *valueUTF8String = value.UTF8String;
+    result = setxattr(path, key.UTF8String, valueUTF8String, strlen(valueUTF8String), 0, 0);
+  } else {
+    result = removexattr(path, key.UTF8String, 0);
+  }
+
+  if (result) {
+    if (error) *error = RCTPOSIXError(errno);
+    return NO;
+  }
+
+  return YES;
+}
+
+#pragma mark - Cache Record -
+
+@interface RCTCacheRecord : NSObject
+
+@property (readonly) NSUUID *UUID;
+@property (readonly, weak) dispatch_queue_t queue;
+@property (nonatomic, copy) NSData *data;
+
+@end
+
+@implementation RCTCacheRecord
+
+- (instancetype)initWithUUID:(NSUUID *)UUID
+{
+  if ((self = [super init])) {
+    _UUID = [UUID copy];
+  }
+  return self;
+}
+
+- (void)enqueueBlock:(dispatch_block_t)block
+{
+  dispatch_queue_t queue = _queue;
+  if (!queue) {
+    NSString *queueName = [NSString stringWithFormat:@"com.facebook.ReactKit.RCTCache.%@", _UUID.UUIDString];
+    queue = dispatch_queue_create(queueName.UTF8String, DISPATCH_QUEUE_SERIAL);
+    _queue = queue;
+  }
+
+  dispatch_async(queue, block);
+}
+
+@end
+
+#pragma mark - Cache
+
+@implementation RCTCache
+{
+  NSString *_name;
+  NSFileManager *_fileManager;
+  NSMutableDictionary *_storage;
+  NSURL *_cacheDirectoryURL;
+}
+
+ (void)initialize
+{
+  if (self == [RCTCache class]) {
+    RCTLivingCachesByName = [NSMapTable strongToWeakObjectsMapTable];
+  }
+}
+
+- (instancetype)init
+{
+  return [self initWithName:@"default"];
+}
+
+- (instancetype)initWithName:(NSString *)name
+{
+  NSParameterAssert(name.length < NAME_MAX);
+  RCTCache *cachedCache = [RCTLivingCachesByName objectForKey:name];
+  if (cachedCache) {
+    self = cachedCache;
+    return self;
+  }
+
+  if ((self = [super init])) {
+    _name = [name copy];
+    _fileManager = [[NSFileManager alloc] init];
+    _storage = [NSMutableDictionary dictionary];
+
+    NSURL *cacheDirectoryURL = [[_fileManager URLsForDirectory:NSCachesDirectory inDomains:NSUserDomainMask] lastObject];
+    cacheDirectoryURL = [cacheDirectoryURL URLByAppendingPathComponent:RCTCacheSubdirectoryName isDirectory:YES];
+    _cacheDirectoryURL = [cacheDirectoryURL URLByAppendingPathComponent:name isDirectory:YES];
+    [_fileManager createDirectoryAtURL:_cacheDirectoryURL withIntermediateDirectories:YES attributes:nil error:NULL];
+
+    NSArray *fileURLs = [_fileManager contentsOfDirectoryAtURL:_cacheDirectoryURL includingPropertiesForKeys:nil options:NSDirectoryEnumerationSkipsHiddenFiles error:NULL];
+    for (NSURL *fileURL in fileURLs) {
+      NSUUID *UUID = [[NSUUID alloc] initWithUUIDString:fileURL.lastPathComponent];
+      if (!UUID) continue;
+
+      NSString *key = RCTGetExtendedAttribute(fileURL, RCTKeyExtendedAttributeName, NULL);
+      if (!key) {
+        [_fileManager removeItemAtURL:fileURL error:NULL];
+        continue;
+      }
+
+      _storage[key] = [[RCTCacheRecord alloc] initWithUUID:UUID];
+    }
+  }
+  return self;
+}
+
+- (BOOL)hasDataForKey:(NSString *)key
+{
+  return _storage[key] != nil;
+}
+
+- (void)fetchDataForKey:(NSString *)key completionHandler:(void (^)(NSData *))completionHandler
+{
+  NSParameterAssert(key.length > 0);
+  NSParameterAssert(completionHandler != nil);
+  RCTCacheRecord *record = _storage[key];
+  if (!record) {
+    completionHandler(nil);
+    return;
+  }
+
+  [record enqueueBlock:^{
+    if (!record.data) {
+      record.data = [NSData dataWithContentsOfURL:[_cacheDirectoryURL URLByAppendingPathComponent:record.UUID.UUIDString]];
+    }
+    completionHandler(record.data);
+  }];
+}
+
+- (void)setData:(NSData *)data forKey:(NSString *)key
+{
+  NSParameterAssert(key.length > 0);
+  RCTCacheRecord *record = _storage[key];
+  if (!record) {
+    if (!data) return;
+
+    record = [[RCTCacheRecord alloc] initWithUUID:[NSUUID UUID]];
+    _storage[key] = record;
+  }
+
+  NSURL *fileURL = [_cacheDirectoryURL URLByAppendingPathComponent:record.UUID.UUIDString];
+
+  UIBackgroundTaskIdentifier identifier = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler:nil];
+  [record enqueueBlock:^{
+    if (data) {
+      [data writeToURL:fileURL options:NSDataWritingAtomic error:NULL];
+      RCTSetExtendedAttribute(fileURL, RCTKeyExtendedAttributeName, key, NULL);
+    } else {
+      [_fileManager removeItemAtURL:fileURL error:NULL];
+    }
+
+    if (identifier != UIBackgroundTaskInvalid) {
+      [[UIApplication sharedApplication] endBackgroundTask:identifier];
+    }
+  }];
+}
+
+- (void)removeAllData
+{
+  UIBackgroundTaskIdentifier identifier = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler:nil];
+  dispatch_group_t group = dispatch_group_create();
+
+  [_storage enumerateKeysAndObjectsUsingBlock:^(NSString *key, RCTCacheRecord *record, BOOL *stop) {
+    NSURL *fileURL = [_cacheDirectoryURL URLByAppendingPathComponent:record.UUID.UUIDString];
+    dispatch_group_async(group, record.queue, ^{
+      [_fileManager removeItemAtURL:fileURL error:NULL];
+    });
+  }];
+
+  if (identifier != UIBackgroundTaskInvalid) {
+    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
+      [[UIApplication sharedApplication] endBackgroundTask:identifier];
+    });
+  }
+
+  [_storage removeAllObjects];
+}
+
+@end
--- a/ReactKit/Base/RCTConvert.h
+++ b/ReactKit/Base/RCTConvert.h
@@ -0,0 +1,85 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <QuartzCore/QuartzCore.h>
+#import <UIKit/UIKit.h>
+
+#import "Layout.h"
+#import "RCTPointerEvents.h"
+#import "RCTAnimationType.h"
+
+/**
+ * This class provides a collection of conversion functions for mapping
+ * JSON objects to native types and classes. These are useful when writing
+ * custom RCTViewManager setter methods.
+ */
+@interface RCTConvert : NSObject
+
+ (BOOL)BOOL:(id)json;
+ (double)double:(id)json;
+ (float)float:(id)json;
+ (int)int:(id)json;
+
+ (NSString *)NSString:(id)json;
+ (NSNumber *)NSNumber:(id)json;
+ (NSInteger)NSInteger:(id)json;
+ (NSUInteger)NSUInteger:(id)json;
+
+ (NSURL *)NSURL:(id)json;
+ (NSURLRequest *)NSURLRequest:(id)json;
+
+ (NSDate *)NSDate:(id)json;
+ (NSTimeZone *)NSTimeZone:(id)json;
+ (NSTimeInterval)NSTimeInterval:(id)json;
+
+ (NSTextAlignment)NSTextAlignment:(id)json;
+ (NSWritingDirection)NSWritingDirection:(id)json;
+ (UITextAutocapitalizationType)UITextAutocapitalizationType:(id)json;
+ (UIKeyboardType)UIKeyboardType:(id)json;
+
+ (CGFloat)CGFloat:(id)json;
+ (CGPoint)CGPoint:(id)json;
+ (CGSize)CGSize:(id)json;
+ (CGRect)CGRect:(id)json;
+ (UIEdgeInsets)UIEdgeInsets:(id)json;
+
+ (CATransform3D)CATransform3D:(id)json;
+ (CGAffineTransform)CGAffineTransform:(id)json;
+
+ (UIColor *)UIColor:(id)json;
+ (CGColorRef)CGColor:(id)json;
+
+ (CAKeyframeAnimation *)GIF:(id)json;
+ (UIImage *)UIImage:(id)json;
+ (CGImageRef)CGImage:(id)json;
+
+ (UIFont *)UIFont:(UIFont *)font withSize:(id)json;
+ (UIFont *)UIFont:(UIFont *)font withWeight:(id)json;
+ (UIFont *)UIFont:(UIFont *)font withFamily:(id)json;
+ (UIFont *)UIFont:(UIFont *)font withFamily:(id)json size:(id)json weight:(id)json;
+
+ (BOOL)css_overflow:(id)json;
+ (css_flex_direction_t)css_flex_direction_t:(id)json;
+ (css_justify_t)css_justify_t:(id)json;
+ (css_align_t)css_align_t:(id)json;
+ (css_position_type_t)css_position_type_t:(id)json;
+ (css_wrap_type_t)css_wrap_type_t:(id)json;
+
+ (RCTPointerEvents)RCTPointerEvents:(id)json;
+ (RCTAnimationType)RCTAnimationType:(id)json;
+
+@end
+
+/**
+ * This function will attempt to set a property using a json value by first
+ * inferring the correct type from all available information, and then
+ * applying an appropriate conversion method. If the property does not
+ * exist, or the type cannot be inferred, the function will return NO.
+ */
+BOOL RCTSetProperty(id target, NSString *keypath, id json);
+
+/**
+ * This function attempts to copy a property from the source object to the
+ * destination object using KVC. If the property does not exist, or cannot
+ * be set, it will do nothing and return NO.
+ */
+BOOL RCTCopyProperty(id target, id source, NSString *keypath);
--- a/ReactKit/Base/RCTConvert.m
+++ b/ReactKit/Base/RCTConvert.m
@@ -0,0 +1,913 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import "RCTConvert.h"
+
+#import <objc/message.h>
+
+#import <ImageIO/ImageIO.h>
+#import <MobileCoreServices/MobileCoreServices.h>
+
+#import "RCTLog.h"
+
+CGFloat const RCTDefaultFontSize = 14;
+NSString *const RCTDefaultFontName = @"HelveticaNeue";
+NSString *const RCTDefaultFontWeight = @"normal";
+NSString *const RCTBoldFontWeight = @"bold";
+
+#define RCT_CONVERTER_CUSTOM(type, name, code) \
+ (type)name:(id)json                          \
+{                                              \
+  @try {                                       \
+    return code;                               \
+  }                                            \
+  @catch (__unused NSException *e) {           \
+    RCTLogError(@"JSON value '%@' of type '%@' cannot be converted to '%s'", \
+    json, [json class], #type); \
+    json = nil; \
+    return code; \
+  } \
+}
+
+#define RCT_CONVERTER(type, name, getter) \
+RCT_CONVERTER_CUSTOM(type, name, [json getter])
+
+#define RCT_ENUM_CONVERTER(type, values, default, getter) \
+ (type)type:(id)json                                     \
+{                                                         \
+  static NSDictionary *mapping;                           \
+  static dispatch_once_t onceToken;                       \
+  dispatch_once(&onceToken, ^{                            \
+    mapping = values;                                     \
+  });                                                     \
+  if (!json) {                                            \
+    return default;                                       \
+  }                                                       \
+  if ([json isKindOfClass:[NSNumber class]]) {            \
+    if ([[mapping allValues] containsObject:json] || [json getter] == default) { \
+      return [json getter];                               \
+    }                                                     \
+    RCTLogError(@"Invalid %s '%@'. should be one of: %@", #type, json, [mapping allValues]); \
+    return default;                                       \
+  }                                                       \
+  if (![json isKindOfClass:[NSString class]]) {           \
+    RCTLogError(@"Expected NSNumber or NSString for %s, received %@: %@", #type, [json class], json); \
+  }                                                       \
+  id value = mapping[json];                               \
+  if(!value && [json description].length > 0) {           \
+    RCTLogError(@"Invalid %s '%@'. should be one of: %@", #type, json, [mapping allKeys]); \
+  }                                                       \
+  return value ? [value getter] : default;                \
+}
+
+#define RCT_STRUCT_CONVERTER(type, values)               \
+ (type)type:(id)json                                    \
+{                                                        \
+  @try {                                                 \
+    static NSArray *fields;                              \
+    static NSUInteger count;                             \
+    static dispatch_once_t onceToken;                    \
+    dispatch_once(&onceToken, ^{                         \
+      fields = values;                                   \
+      count = [fields count];                            \
+    });                                                  \
+    type result;                                         \
+    if ([json isKindOfClass:[NSArray class]]) {          \
+      if ([json count] != count) {                       \
+        RCTLogError(@"Expected array with count %zd, but count is %zd: %@", count, [json count], json); \
+      } else {                                           \
+        for (NSUInteger i = 0; i < count; i++) {         \
+          ((CGFloat *)&result)[i] = [json[i] doubleValue]; \
+        }                                                \
+      }                                                  \
+    } else if ([json isKindOfClass:[NSDictionary class]]) { \
+      for (NSUInteger i = 0; i < count; i++) {           \
+        ((CGFloat *)&result)[i] = [json[fields[i]] doubleValue]; \
+      }                                                  \
+    } else if (json) {                                   \
+      RCTLogError(@"Expected NSArray or NSDictionary for %s, received %@: %@", #type, [json class], json); \
+    }                                                    \
+    return result;                                       \
+  }                                                      \
+  @catch (__unused NSException *e) {                     \
+    RCTLogError(@"JSON value '%@' cannot be converted to '%s'", json, #type); \
+    type result; \
+    return result; \
+  } \
+}
+
+@implementation RCTConvert
+
+RCT_CONVERTER(BOOL, BOOL, boolValue)
+RCT_CONVERTER(double, double, doubleValue)
+RCT_CONVERTER(float, float, floatValue)
+RCT_CONVERTER(int, int, intValue)
+
+RCT_CONVERTER(NSString *, NSString, description)
+RCT_CONVERTER_CUSTOM(NSNumber *, NSNumber, @([json doubleValue]))
+RCT_CONVERTER(NSInteger, NSInteger, integerValue)
+RCT_CONVERTER_CUSTOM(NSUInteger, NSUInteger, [json unsignedIntegerValue])
+
+ (NSURL *)NSURL:(id)json
+{
+  if (![json isKindOfClass:[NSString class]]) {
+    RCTLogError(@"Expected NSString for NSURL, received %@: %@", [json class], json);
+    return nil;
+  }
+
+  NSString *path = json;
+  if ([path isAbsolutePath])
+  {
+    return [NSURL fileURLWithPath:path];
+  }
+  else if ([path length])
+  {
+    return [NSURL URLWithString:path relativeToURL:[[NSBundle mainBundle] resourceURL]];
+  }
+  return nil;
+}
+
+ (NSURLRequest *)NSURLRequest:(id)json
+{
+  return [NSURLRequest requestWithURL:[self NSURL:json]];
+}
+
+RCT_CONVERTER_CUSTOM(NSDate *, NSDate, [NSDate dateWithTimeIntervalSince1970:[json doubleValue]])
+RCT_CONVERTER_CUSTOM(NSTimeZone *, NSTimeZone, [NSTimeZone timeZoneForSecondsFromGMT:[json doubleValue]])
+RCT_CONVERTER(NSTimeInterval, NSTimeInterval, doubleValue)
+
+/**
+ * NOTE: We don't deliberately don't support NSTextAlignmentJustified in the
+ * X-platform RCTText implementation because it isn't available on Android.
+ * We may wish to support this for iOS-specific controls such as UILabel.
+ */
+RCT_ENUM_CONVERTER(NSTextAlignment, (@{
+  @"auto": @(NSTextAlignmentNatural),
+  @"left": @(NSTextAlignmentLeft),
+  @"center": @(NSTextAlignmentCenter),
+  @"right": @(NSTextAlignmentRight),
+  /* @"justify": @(NSTextAlignmentJustify), */
+}), NSTextAlignmentNatural, integerValue)
+
+RCT_ENUM_CONVERTER(NSWritingDirection, (@{
+  @"auto": @(NSWritingDirectionNatural),
+  @"ltr": @(NSWritingDirectionLeftToRight),
+  @"rtl": @(NSWritingDirectionRightToLeft),
+}), NSWritingDirectionNatural, integerValue)
+
+RCT_ENUM_CONVERTER(UITextAutocapitalizationType, (@{
+  @"none": @(UITextAutocapitalizationTypeNone),
+  @"words": @(UITextAutocapitalizationTypeWords),
+  @"sentences": @(UITextAutocapitalizationTypeSentences),
+  @"all": @(UITextAutocapitalizationTypeAllCharacters)
+}), UITextAutocapitalizationTypeSentences, integerValue)
+
+RCT_ENUM_CONVERTER(UIKeyboardType, (@{
+  @"numeric": @(UIKeyboardTypeDecimalPad),
+  @"default": @(UIKeyboardTypeDefault),
+}), UIKeyboardTypeDefault, integerValue)
+
+RCT_CONVERTER(CGFloat, CGFloat, doubleValue)
+RCT_STRUCT_CONVERTER(CGPoint, (@[@"x", @"y"]))
+RCT_STRUCT_CONVERTER(CGSize, (@[@"w", @"h"]))
+RCT_STRUCT_CONVERTER(CGRect, (@[@"x", @"y", @"w", @"h"]))
+RCT_STRUCT_CONVERTER(UIEdgeInsets, (@[@"top", @"left", @"bottom", @"right"]))
+
+RCT_STRUCT_CONVERTER(CATransform3D, (@[
+  @"m11", @"m12", @"m13", @"m14",
+  @"m21", @"m22", @"m23", @"m24",
+  @"m31", @"m32", @"m33", @"m34",
+  @"m41", @"m42", @"m43", @"m44"
+]))
+
+RCT_STRUCT_CONVERTER(CGAffineTransform, (@[@"a", @"b", @"c", @"d", @"tx", @"ty"]))
+
+ (UIColor *)UIColor:(id)json
+{
+  // Check color cache
+  static NSMutableDictionary *colorCache = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    colorCache = [[NSMutableDictionary alloc] init];
+  });
+  UIColor *color = colorCache[json];
+  if (color) {
+    return color;
+  }
+
+  if ([json isKindOfClass:[NSString class]]) {
+
+    // Check named colors
+    static NSDictionary *namedColors = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+      namedColors = @{
+
+        // CSS colors
+        @"aliceblue": @"#f0f8ff",
+        @"antiquewhite": @"#faebd7",
+        @"aqua": @"#00ffff",
+        @"aquamarine": @"#7fffd4",
+        @"azure": @"#f0ffff",
+        @"beige": @"#f5f5dc",
+        @"bisque": @"#ffe4c4",
+        @"black": @"#000000",
+        @"blanchedalmond": @"#ffebcd",
+        @"blue": @"#0000ff",
+        @"blueviolet": @"#8a2be2",
+        @"brown": @"#a52a2a",
+        @"burlywood": @"#deb887",
+        @"cadetblue": @"#5f9ea0",
+        @"chartreuse": @"#7fff00",
+        @"chocolate": @"#d2691e",
+        @"coral": @"#ff7f50",
+        @"cornflowerblue": @"#6495ed",
+        @"cornsilk": @"#fff8dc",
+        @"crimson": @"#dc143c",
+        @"cyan": @"#00ffff",
+        @"darkblue": @"#00008b",
+        @"darkcyan": @"#008b8b",
+        @"darkgoldenrod": @"#b8860b",
+        @"darkgray": @"#a9a9a9",
+        @"darkgrey": @"#a9a9a9",
+        @"darkgreen": @"#006400",
+        @"darkkhaki": @"#bdb76b",
+        @"darkmagenta": @"#8b008b",
+        @"darkolivegreen": @"#556b2f",
+        @"darkorange": @"#ff8c00",
+        @"darkorchid": @"#9932cc",
+        @"darkred": @"#8b0000",
+        @"darksalmon": @"#e9967a",
+        @"darkseagreen": @"#8fbc8f",
+        @"darkslateblue": @"#483d8b",
+        @"darkslategray": @"#2f4f4f",
+        @"darkslategrey": @"#2f4f4f",
+        @"darkturquoise": @"#00ced1",
+        @"darkviolet": @"#9400d3",
+        @"deeppink": @"#ff1493",
+        @"deepskyblue": @"#00bfff",
+        @"dimgray": @"#696969",
+        @"dimgrey": @"#696969",
+        @"dodgerblue": @"#1e90ff",
+        @"firebrick": @"#b22222",
+        @"floralwhite": @"#fffaf0",
+        @"forestgreen": @"#228b22",
+        @"fuchsia": @"#ff00ff",
+        @"gainsboro": @"#dcdcdc",
+        @"ghostwhite": @"#f8f8ff",
+        @"gold": @"#ffd700",
+        @"goldenrod": @"#daa520",
+        @"gray": @"#808080",
+        @"grey": @"#808080",
+        @"green": @"#008000",
+        @"greenyellow": @"#adff2f",
+        @"honeydew": @"#f0fff0",
+        @"hotpink": @"#ff69b4",
+        @"indianred": @"#cd5c5c",
+        @"indigo": @"#4b0082",
+        @"ivory": @"#fffff0",
+        @"khaki": @"#f0e68c",
+        @"lavender": @"#e6e6fa",
+        @"lavenderblush": @"#fff0f5",
+        @"lawngreen": @"#7cfc00",
+        @"lemonchiffon": @"#fffacd",
+        @"lightblue": @"#add8e6",
+        @"lightcoral": @"#f08080",
+        @"lightcyan": @"#e0ffff",
+        @"lightgoldenrodyellow": @"#fafad2",
+        @"lightgray": @"#d3d3d3",
+        @"lightgrey": @"#d3d3d3",
+        @"lightgreen": @"#90ee90",
+        @"lightpink": @"#ffb6c1",
+        @"lightsalmon": @"#ffa07a",
+        @"lightseagreen": @"#20b2aa",
+        @"lightskyblue": @"#87cefa",
+        @"lightslategray": @"#778899",
+        @"lightslategrey": @"#778899",
+        @"lightsteelblue": @"#b0c4de",
+        @"lightyellow": @"#ffffe0",
+        @"lime": @"#00ff00",
+        @"limegreen": @"#32cd32",
+        @"linen": @"#faf0e6",
+        @"magenta": @"#ff00ff",
+        @"maroon": @"#800000",
+        @"mediumaquamarine": @"#66cdaa",
+        @"mediumblue": @"#0000cd",
+        @"mediumorchid": @"#ba55d3",
+        @"mediumpurple": @"#9370db",
+        @"mediumseagreen": @"#3cb371",
+        @"mediumslateblue": @"#7b68ee",
+        @"mediumspringgreen": @"#00fa9a",
+        @"mediumturquoise": @"#48d1cc",
+        @"mediumvioletred": @"#c71585",
+        @"midnightblue": @"#191970",
+        @"mintcream": @"#f5fffa",
+        @"mistyrose": @"#ffe4e1",
+        @"moccasin": @"#ffe4b5",
+        @"navajowhite": @"#ffdead",
+        @"navy": @"#000080",
+        @"oldlace": @"#fdf5e6",
+        @"olive": @"#808000",
+        @"olivedrab": @"#6b8e23",
+        @"orange": @"#ffa500",
+        @"orangered": @"#ff4500",
+        @"orchid": @"#da70d6",
+        @"palegoldenrod": @"#eee8aa",
+        @"palegreen": @"#98fb98",
+        @"paleturquoise": @"#afeeee",
+        @"palevioletred": @"#db7093",
+        @"papayawhip": @"#ffefd5",
+        @"peachpuff": @"#ffdab9",
+        @"peru": @"#cd853f",
+        @"pink": @"#ffc0cb",
+        @"plum": @"#dda0dd",
+        @"powderblue": @"#b0e0e6",
+        @"purple": @"#800080",
+        @"rebeccapurple": @"#663399",
+        @"red": @"#ff0000",
+        @"rosybrown": @"#bc8f8f",
+        @"royalblue": @"#4169e1",
+        @"saddlebrown": @"#8b4513",
+        @"salmon": @"#fa8072",
+        @"sandybrown": @"#f4a460",
+        @"seagreen": @"#2e8b57",
+        @"seashell": @"#fff5ee",
+        @"sienna": @"#a0522d",
+        @"silver": @"#c0c0c0",
+        @"skyblue": @"#87ceeb",
+        @"slateblue": @"#6a5acd",
+        @"slategray": @"#708090",
+        @"slategrey": @"#708090",
+        @"snow": @"#fffafa",
+        @"springgreen": @"#00ff7f",
+        @"steelblue": @"#4682b4",
+        @"tan": @"#d2b48c",
+        @"teal": @"#008080",
+        @"thistle": @"#d8bfd8",
+        @"tomato": @"#ff6347",
+        @"turquoise": @"#40e0d0",
+        @"violet": @"#ee82ee",
+        @"wheat": @"#f5deb3",
+        @"white": @"#ffffff",
+        @"whitesmoke": @"#f5f5f5",
+        @"yellow": @"#ffff00",
+        @"yellowgreen": @"#9acd32",
+
+        // Nonstandard color extensions
+        @"transparent": @"rgba(0,0,0,0)",
+      };
+    });
+    NSString *colorString = namedColors[json];
+    if (!colorString) {
+      colorString = json;
+    }
+
+    // Parse color
+    NSUInteger red = -1;
+    NSUInteger green = -1;
+    NSUInteger blue = -1;
+    CGFloat alpha = 1.0;
+    if ([colorString hasPrefix:@"#"]) {
+      sscanf([colorString UTF8String], "#%02tX%02tX%02tX", &red, &green, &blue);
+    } else if ([colorString hasPrefix:@"rgba("]) {
+      double tmpAlpha;
+      sscanf([colorString UTF8String], "rgba(%zd,%zd,%zd,%lf)", &red, &green, &blue, &tmpAlpha);
+      alpha = tmpAlpha > 0.99 ? 1.0 : tmpAlpha;
+    } else if ([colorString hasPrefix:@"rgb("]) {
+      sscanf([colorString UTF8String], "rgb(%zd,%zd,%zd)", &red, &green, &blue);
+    } else {
+      RCTLogError(@"Unrecognized color format '%@', must be one of #hex|rgba|rgb", colorString);
+    }
+    if (red == -1 || green == -1 || blue == -1 || alpha > 1.0 || alpha < 0.0) {
+      RCTLogError(@"Invalid color string '%@'", colorString);
+    } else {
+      color = [UIColor colorWithRed:red / 255.0 green:green / 255.0 blue:blue / 255.0 alpha:alpha];
+    }
+
+  } else if ([json isKindOfClass:[NSArray class]]) {
+
+    if ([json count] < 3 || [json count] > 4) {
+
+      RCTLogError(@"Expected array with count 3 or 4, but count is %zd: %@", [json count], json);
+
+    } else {
+
+      // Color array
+      color = [UIColor colorWithRed:[json[0] doubleValue]
+                              green:[json[1] doubleValue]
+                               blue:[json[2] doubleValue]
+                              alpha:[json count] > 3 ? [json[3] doubleValue] : 1];
+    }
+
+  } else if ([json isKindOfClass:[NSDictionary class]]) {
+
+    // Color dictionary
+    color = [UIColor colorWithRed:[json[@"r"] doubleValue]
+                            green:[json[@"g"] doubleValue]
+                             blue:[json[@"b"] doubleValue]
+                            alpha:[json[@"a"] ?: @1 doubleValue]];
+
+  } else if (json && ![json isKindOfClass:[NSNull class]]) {
+
+    RCTLogError(@"Expected NSArray, NSDictionary or NSString for UIColor, received %@: %@", [json class], json);
+  }
+
+  // Default color
+  if (!color) {
+    color = [UIColor whiteColor];
+  }
+
+  // Cache and return
+  if (json) {
+    colorCache[json] = color;
+  }
+  return color;
+}
+
+ (CGColorRef)CGColor:(id)json
+{
+  return [self UIColor:json].CGColor;
+}
+
+ (CAKeyframeAnimation *)GIF:(id)json
+{
+  CGImageSourceRef imageSource = NULL;
+  if ([json isKindOfClass:[NSString class]]) {
+    NSString *path = json;
+    if (path.length == 0) {
+      return nil;
+    }
+
+    NSURL *fileURL = [path isAbsolutePath] ? [NSURL fileURLWithPath:path] : [[NSBundle mainBundle] URLForResource:path withExtension:nil];
+    imageSource = CGImageSourceCreateWithURL((CFURLRef)fileURL, NULL);
+  } else if ([json isKindOfClass:[NSData class]]) {
+    NSData *data = json;
+    if (data.length == 0) {
+      return nil;
+    }
+
+    imageSource = CGImageSourceCreateWithData((CFDataRef)data, NULL);
+  }
+
+  if (!UTTypeConformsTo(CGImageSourceGetType(imageSource), kUTTypeGIF)) {
+    CFRelease(imageSource);
+    return nil;
+  }
+
+  NSDictionary *properties = (__bridge_transfer NSDictionary *)CGImageSourceCopyProperties(imageSource, NULL);
+  NSUInteger loopCount = [properties[(id)kCGImagePropertyGIFDictionary][(id)kCGImagePropertyGIFLoopCount] unsignedIntegerValue];
+
+  size_t imageCount = CGImageSourceGetCount(imageSource);
+  NSTimeInterval duration = 0;
+  NSMutableArray *delays = [NSMutableArray arrayWithCapacity:imageCount];
+  NSMutableArray *images = [NSMutableArray arrayWithCapacity:imageCount];
+  for (size_t i = 0; i < imageCount; i++) {
+    CGImageRef image = CGImageSourceCreateImageAtIndex(imageSource, i, NULL);
+    NSDictionary *frameProperties = (__bridge_transfer NSDictionary *)CGImageSourceCopyPropertiesAtIndex(imageSource, i, NULL);
+    NSDictionary *frameGIFProperties = frameProperties[(id)kCGImagePropertyGIFDictionary];
+
+    const NSTimeInterval kDelayTimeIntervalDefault = 0.1;
+    NSNumber *delayTime = frameGIFProperties[(id)kCGImagePropertyGIFUnclampedDelayTime] ?: frameGIFProperties[(id)kCGImagePropertyGIFDelayTime];
+    if (delayTime == nil) {
+      if (i == 0) {
+        delayTime = @(kDelayTimeIntervalDefault);
+      } else {
+        delayTime = delays[i - 1];
+      }
+    }
+
+    const NSTimeInterval kDelayTimeIntervalMinimum = 0.02;
+    if (delayTime.floatValue < (float)kDelayTimeIntervalMinimum - FLT_EPSILON) {
+      delayTime = @(kDelayTimeIntervalDefault);
+    }
+
+    duration += delayTime.doubleValue;
+    delays[i] = delayTime;
+    images[i] = (__bridge_transfer id)image;
+  }
+
+  CFRelease(imageSource);
+
+  NSMutableArray *keyTimes = [NSMutableArray arrayWithCapacity:delays.count];
+  NSTimeInterval runningDuration = 0;
+  for (NSNumber *delayNumber in delays) {
+    [keyTimes addObject:@(runningDuration / duration)];
+    runningDuration += delayNumber.doubleValue;
+  }
+
+  [keyTimes addObject:@1.0];
+
+  CAKeyframeAnimation *animation = [CAKeyframeAnimation animationWithKeyPath:@"contents"];
+  animation.calculationMode = kCAAnimationDiscrete;
+  animation.repeatCount = loopCount == 0 ? HUGE_VALF : loopCount;
+  animation.keyTimes = keyTimes;
+  animation.values = images;
+  animation.duration = duration;
+  return animation;
+}
+
+ (UIImage *)UIImage:(id)json
+{
+  if (![json isKindOfClass:[NSString class]]) {
+    RCTLogError(@"Expected NSString for UIImage, received %@: %@", [json class], json);
+    return nil;
+  }
+
+  if ([json length] == 0) {
+    return nil;
+  }
+
+  UIImage *image = nil;
+  NSString *path = json;
+  if ([path isAbsolutePath]) {
+    image = [UIImage imageWithContentsOfFile:path];
+  } else {
+    image = [UIImage imageNamed:path];
+    if (!image) {
+      image = [UIImage imageWithContentsOfFile:[[NSBundle mainBundle] pathForResource:path ofType:nil]];
+    }
+  }
+  if (!image) {
+    RCTLogWarn(@"No image was found at path %@", json);
+  }
+  return image;
+}
+
+ (CGImageRef)CGImage:(id)json
+{
+  return [self UIImage:json].CGImage;
+}
+
+ (UIFont *)UIFont:(UIFont *)font withSize:(id)json
+{
+  return [self UIFont:font withFamily:nil size:json weight:nil];
+}
+
+ (UIFont *)UIFont:(UIFont *)font withWeight:(id)json
+{
+  return [self UIFont:font withFamily:nil size:nil weight:json];
+}
+
+ (UIFont *)UIFont:(UIFont *)font withFamily:(id)json
+{
+  return [self UIFont:font withFamily:json size:nil weight:nil];
+}
+
+ (UIFont *)UIFont:(UIFont *)font withFamily:(id)family size:(id)size weight:(id)weight
+{
+  // Create descriptor
+  UIFontDescriptor *fontDescriptor = font.fontDescriptor ?: [UIFontDescriptor fontDescriptorWithName:RCTDefaultFontName size:RCTDefaultFontSize];
+
+  // Get font size
+  CGFloat fontSize = [self CGFloat:size];
+  if (fontSize && !isnan(fontSize)) {
+    fontDescriptor = [fontDescriptor fontDescriptorWithSize:fontSize];
+  }
+
+  // Get font family
+  NSString *familyName = [RCTConvert NSString:family];
+  if (familyName) {
+      if ([UIFont fontNamesForFamilyName:familyName].count == 0) {
+      font = [UIFont fontWithName:familyName size:fontDescriptor.pointSize];
+      if (font) {
+        // It's actually a font name, not a font family name,
+        // but we'll do what was meant, not what was said.
+        familyName = font.familyName;
+        fontDescriptor = font.fontDescriptor;
+      } else {
+        // Not a valid font or family
+        RCTLogError(@"Unrecognized font family '%@'", familyName);
+      }
+    } else {
+      // Set font family
+      fontDescriptor = [fontDescriptor fontDescriptorWithFamily:familyName];
+    }
+  }
+
+  // Get font weight
+  NSString *fontWeight = [RCTConvert NSString:weight];
+  if (fontWeight) {
+
+    static NSSet *values;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+      values = [NSSet setWithObjects:@"bold", @"normal", nil];
+    });
+
+    if (fontWeight && ![values containsObject:fontWeight]) {
+      RCTLogError(@"Unrecognized font weight '%@', must be one of %@", fontWeight, values);
+    }
+
+    UIFontDescriptorSymbolicTraits symbolicTraits = fontDescriptor.symbolicTraits;
+    if ([fontWeight isEqualToString:RCTBoldFontWeight]) {
+      symbolicTraits |= UIFontDescriptorTraitBold;
+    } else {
+      symbolicTraits &= ~UIFontDescriptorTraitBold;
+    }
+    fontDescriptor = [fontDescriptor fontDescriptorWithSymbolicTraits:symbolicTraits];
+  }
+
+  // TODO: font style
+
+  // Create font
+  return [UIFont fontWithDescriptor:fontDescriptor size:fontDescriptor.pointSize];
+}
+
+typedef BOOL css_overflow;
+
+RCT_ENUM_CONVERTER(css_overflow, (@{
+  @"hidden": @NO,
+  @"visible": @YES
+}), YES, boolValue)
+
+RCT_ENUM_CONVERTER(css_flex_direction_t, (@{
+  @"row": @(CSS_FLEX_DIRECTION_ROW),
+  @"column": @(CSS_FLEX_DIRECTION_COLUMN)
+}), CSS_FLEX_DIRECTION_COLUMN, intValue)
+
+RCT_ENUM_CONVERTER(css_justify_t, (@{
+  @"flex-start": @(CSS_JUSTIFY_FLEX_START),
+  @"flex-end": @(CSS_JUSTIFY_FLEX_END),
+  @"center": @(CSS_JUSTIFY_CENTER),
+  @"space-between": @(CSS_JUSTIFY_SPACE_BETWEEN),
+  @"space-around": @(CSS_JUSTIFY_SPACE_AROUND)
+}), CSS_JUSTIFY_FLEX_START, intValue)
+
+RCT_ENUM_CONVERTER(css_align_t, (@{
+  @"flex-start": @(CSS_ALIGN_FLEX_START),
+  @"flex-end": @(CSS_ALIGN_FLEX_END),
+  @"center": @(CSS_ALIGN_CENTER),
+  @"auto": @(CSS_ALIGN_AUTO),
+  @"stretch": @(CSS_ALIGN_STRETCH)
+}), CSS_ALIGN_FLEX_START, intValue)
+
+RCT_ENUM_CONVERTER(css_position_type_t, (@{
+  @"absolute": @(CSS_POSITION_ABSOLUTE),
+  @"relative": @(CSS_POSITION_RELATIVE)
+}), CSS_POSITION_RELATIVE, intValue)
+
+RCT_ENUM_CONVERTER(css_wrap_type_t, (@{
+  @"wrap": @(CSS_WRAP),
+  @"nowrap": @(CSS_NOWRAP)
+}), CSS_NOWRAP, intValue)
+
+RCT_ENUM_CONVERTER(RCTPointerEvents, (@{
+  @"none": @(RCTPointerEventsNone),
+  @"boxonly": @(RCTPointerEventsBoxOnly),
+  @"boxnone": @(RCTPointerEventsBoxNone)
+}), RCTPointerEventsUnspecified, integerValue)
+
+RCT_ENUM_CONVERTER(RCTAnimationType, (@{
+  @"spring": @(RCTAnimationTypeSpring),
+  @"linear": @(RCTAnimationTypeLinear),
+  @"easeIn": @(RCTAnimationTypeEaseIn),
+  @"easeOut": @(RCTAnimationTypeEaseOut),
+  @"easeInEaseOut": @(RCTAnimationTypeEaseInEaseOut),
+}), RCTAnimationTypeEaseInEaseOut, integerValue)
+
+@end
+
+static NSString *RCTGuessTypeEncoding(id target, NSString *key, id value, NSString *encoding)
+{
+  // TODO (#5906496): handle more cases
+  if ([key rangeOfString:@"color" options:NSCaseInsensitiveSearch].location != NSNotFound) {
+    if ([target isKindOfClass:[CALayer class]]) {
+      return @(@encode(CGColorRef));
+    } else {
+      return @"@\"UIColor\"";
+    }
+  }
+
+  return nil;
+}
+
+static NSDictionary *RCTConvertValue(id value, NSString *encoding)
+{
+  static NSDictionary *converters = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+
+    id (^numberConvert)(id) = ^(id val){
+      return [RCTConvert NSNumber:val];
+    };
+
+    id (^boolConvert)(id) = ^(id val){
+      return @([RCTConvert BOOL:val]);
+    };
+
+    // TODO (#5906496): add the rest of RCTConvert here
+    converters =
+    @{
+      @(@encode(char)): boolConvert,
+      @(@encode(int)): numberConvert,
+      @(@encode(short)): numberConvert,
+      @(@encode(long)): numberConvert,
+      @(@encode(long long)): numberConvert,
+      @(@encode(unsigned char)): numberConvert,
+      @(@encode(unsigned int)): numberConvert,
+      @(@encode(unsigned short)): numberConvert,
+      @(@encode(unsigned long)): numberConvert,
+      @(@encode(unsigned long long)): numberConvert,
+      @(@encode(float)): numberConvert,
+      @(@encode(double)): numberConvert,
+      @(@encode(bool)): boolConvert,
+      @(@encode(UIEdgeInsets)): ^(id val) {
+        return [NSValue valueWithUIEdgeInsets:[RCTConvert UIEdgeInsets:val]];
+      },
+      @(@encode(CGPoint)): ^(id val) {
+        return [NSValue valueWithCGPoint:[RCTConvert CGPoint:val]];
+      },
+      @(@encode(CGSize)): ^(id val) {
+        return [NSValue valueWithCGSize:[RCTConvert CGSize:val]];
+      },
+      @(@encode(CGRect)): ^(id val) {
+        return [NSValue valueWithCGRect:[RCTConvert CGRect:val]];
+      },
+      @(@encode(CGColorRef)): ^(id val) {
+        return (id)[RCTConvert CGColor:val];
+      },
+      @(@encode(CGAffineTransform)): ^(id val) {
+        return [NSValue valueWithCGAffineTransform:[RCTConvert CGAffineTransform:val]];
+      },
+      @(@encode(CATransform3D)): ^(id val) {
+        return [NSValue valueWithCATransform3D:[RCTConvert CATransform3D:val]];
+      },
+      @"@\"NSString\"": ^(id val) {
+        return [RCTConvert NSString:val];
+      },
+      @"@\"NSURL\"": ^(id val) {
+        return [RCTConvert NSURL:val];
+      },
+      @"@\"UIColor\"": ^(id val) {
+        return [RCTConvert UIColor:val];
+      },
+      @"@\"UIImage\"": ^(id val) {
+        return [RCTConvert UIImage:val];
+      },
+      @"@\"NSDate\"": ^(id val) {
+        return [RCTConvert NSDate:val];
+      },
+      @"@\"NSTimeZone\"": ^(id val) {
+        return [RCTConvert NSTimeZone:val];
+      },
+    };
+  });
+
+  // Handle null values
+  if (value == [NSNull null] && ![encoding isEqualToString:@"@\"NSNull\""]) {
+    return nil;
+  }
+
+  // Convert value
+  id (^converter)(id) = converters[encoding];
+  return converter ? converter(value) : value;
+}
+
+BOOL RCTSetProperty(id target, NSString *keypath, id value)
+{
+  // Split keypath
+  NSArray *parts = [keypath componentsSeparatedByString:@"."];
+  NSString *key = [parts lastObject];
+  for (NSUInteger i = 0; i < parts.count - 1; i++) {
+    target = [target valueForKey:parts[i]];
+    if (!target) {
+      return NO;
+    }
+  }
+
+  // Check target class for property definition
+  NSString *encoding = nil;
+  objc_property_t property = class_getProperty([target class], [key UTF8String]);
+  if (property) {
+
+    // Get type info
+    char *typeEncoding = property_copyAttributeValue(property, "T");
+    encoding = @(typeEncoding);
+    free(typeEncoding);
+
+  } else {
+
+    // Check if setter exists
+    SEL setter = NSSelectorFromString([NSString stringWithFormat:@"set%@%@:",
+                                       [[key substringToIndex:1] uppercaseString],
+                                       [key substringFromIndex:1]]);
+
+    if (![target respondsToSelector:setter]) {
+      return NO;
+    }
+
+    // Get type of first method argument
+    Method method = class_getInstanceMethod([target class], setter);
+    char *typeEncoding = method_copyArgumentType(method, 2);
+    if (typeEncoding) {
+      encoding = @(typeEncoding);
+      free(typeEncoding);
+    }
+  }
+
+  if (encoding.length == 0 || [encoding isEqualToString:@(@encode(id))]) {
+    // Not enough info about the type encoding to be useful, so
+    // try to guess the type from the value and property name
+    encoding = RCTGuessTypeEncoding(target, key, value, encoding);
+  }
+
+  // Special case for numeric encodings, which may be enums
+  if ([value isKindOfClass:[NSString class]] &&
+      [@"iIsSlLqQ" rangeOfString:[encoding substringToIndex:1]].length) {
+
+    /**
+     * NOTE: the property names below may seem weird, but it's
+     * because they are tested as case-sensitive suffixes, so
+     * "apitalizationType" will match any of the following
+     *
+     * - capitalizationType
+     * - autocapitalizationType
+     * - autoCapitalizationType
+     * - titleCapitalizationType
+     * - etc.
+     */
+    static NSDictionary *converters = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+      converters =
+      @{
+        @"apitalizationType": ^(id val) {
+          return [RCTConvert UITextAutocapitalizationType:val];
+        },
+        @"eyboardType": ^(id val) {
+          return [RCTConvert UIKeyboardType:val];
+        },
+        @"extAlignment": ^(id val) {
+          return [RCTConvert NSTextAlignment:val];
+        },
+        @"ointerEvents": ^(id val) {
+          return [RCTConvert RCTPointerEvents:val];
+        },
+      };
+    });
+    for (NSString *subkey in converters) {
+      if ([key hasSuffix:subkey]) {
+        NSInteger (^converter)(NSString *) = converters[subkey];
+        value = @(converter(value));
+        break;
+      }
+    }
+  }
+
+  // Another nasty special case
+  if ([target isKindOfClass:[UITextField class]]) {
+    static NSDictionary *specialCases = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+      specialCases = @{
+        @"autocapitalizationType": ^(UITextField *f, NSInteger v){ f.autocapitalizationType = v; },
+        @"autocorrectionType": ^(UITextField *f, NSInteger v){ f.autocorrectionType = v; },
+        @"spellCheckingType": ^(UITextField *f, NSInteger v){ f.spellCheckingType = v; },
+        @"keyboardType": ^(UITextField *f, NSInteger v){ f.keyboardType = v; },
+        @"keyboardAppearance": ^(UITextField *f, NSInteger v){ f.keyboardAppearance = v; },
+        @"returnKeyType": ^(UITextField *f, NSInteger v){ f.returnKeyType = v; },
+        @"enablesReturnKeyAutomatically": ^(UITextField *f, NSInteger v){ f.enablesReturnKeyAutomatically = !!v; },
+        @"secureTextEntry": ^(UITextField *f, NSInteger v){ f.secureTextEntry = !!v; }};
+    });
+
+    void (^block)(UITextField *f, NSInteger v) = specialCases[key];
+    if (block)
+    {
+      block(target, [value integerValue]);
+      return YES;
+    }
+  }
+
+  // Set converted value
+  [target setValue:RCTConvertValue(value, encoding) forKey:key];
+  return YES;
+}
+
+BOOL RCTCopyProperty(id target, id source, NSString *keypath)
+{
+  // Split keypath
+  NSArray *parts = [keypath componentsSeparatedByString:@"."];
+  NSString *key = [parts lastObject];
+  for (NSUInteger i = 0; i < parts.count - 1; i++) {
+    source = [source valueForKey:parts[i]];
+    target = [target valueForKey:parts[i]];
+    if (!source || !target) {
+      return NO;
+    }
+  }
+
+  // Check class for property definition
+  if (!class_getProperty([source class], [key UTF8String])) {
+    // Check if setter exists
+    SEL setter = NSSelectorFromString([NSString stringWithFormat:@"set%@%@:",
+                                       [[key substringToIndex:1] uppercaseString],
+                                       [key substringFromIndex:1]]);
+
+    if (![source respondsToSelector:setter]
+        || ![target respondsToSelector:setter]) {
+      return NO;
+    }
+  }
+
+  [target setValue:[source valueForKey:key] forKey:key];
+  return YES;
+}
--- a/ReactKit/Base/RCTEventDispatcher.h
+++ b/ReactKit/Base/RCTEventDispatcher.h
@@ -0,0 +1,60 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <UIKit/UIKit.h>
+
+@class RCTBridge;
+
+typedef NS_ENUM(NSInteger, RCTTextEventType) {
+  RCTTextEventTypeFocus,
+  RCTTextEventTypeBlur,
+  RCTTextEventTypeChange,
+  RCTTextEventTypeSubmit,
+  RCTTextEventTypeEnd
+};
+
+typedef NS_ENUM(NSInteger, RCTScrollEventType) {
+  RCTScrollEventTypeStart,
+  RCTScrollEventTypeMove,
+  RCTScrollEventTypeEnd,
+  RCTScrollEventTypeStartDeceleration,
+  RCTScrollEventTypeEndDeceleration,
+  RCTScrollEventTypeEndAnimation,
+};
+
+/**
+ * This class wraps the -[RCTBridge enqueueJSCall:args:] method, and
+ * provides some convenience methods for generating event calls.
+ */
+@interface RCTEventDispatcher : NSObject
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge;
+
+/**
+ * Send a device or application event that does not relate to a specific
+ * view, e.g. rotation, location, keyboard show/hide, background/awake, etc.
+ */
+- (void)sendDeviceEventWithName:(NSString *)name body:(NSDictionary *)body;
+
+/**
+ * Send a user input event. The body dictionary must contain a "target"
+ * parameter, representing the react tag of the view sending the event
+ */
+- (void)sendInputEventWithName:(NSString *)name body:(NSDictionary *)body;
+
+/**
+ * Send a text input/focus event.
+ */
+- (void)sendTextEventWithType:(RCTTextEventType)type
+                     reactTag:(NSNumber *)reactTag
+                         text:(NSString *)text;
+
+/**
+ * Send a scroll event.
+ * (You can send a fake scroll event by passing nil for scrollView).
+ */
+- (void)sendScrollEventWithType:(RCTScrollEventType)type
+                       reactTag:(NSNumber *)reactTag
+                     scrollView:(UIScrollView *)scrollView
+                       userData:(NSDictionary *)userData;
+
+@end
--- a/ReactKit/Base/RCTEventDispatcher.m
+++ b/ReactKit/Base/RCTEventDispatcher.m
@@ -0,0 +1,103 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import "RCTEventDispatcher.h"
+
+#import "RCTAssert.h"
+#import "RCTBridge.h"
+
+@implementation RCTEventDispatcher
+{
+  RCTBridge *_bridge;
+}
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+{
+  if ((self = [super init])) {
+    _bridge = bridge;
+  }
+  return self;
+}
+
+- (void)sendDeviceEventWithName:(NSString *)name body:(NSDictionary *)body
+{
+  [_bridge enqueueJSCall:@"RCTDeviceEventEmitter.emit"
+                    args:body ? @[name, body] : @[name]];
+}
+
+
+- (void)sendInputEventWithName:(NSString *)name body:(NSDictionary *)body
+{
+  RCTAssert([body[@"target"] isKindOfClass:[NSNumber class]],
+            @"Event body dictionary must include a 'target' property containing a react tag");
+  
+  [_bridge enqueueJSCall:@"RCTEventEmitter.receiveEvent"
+                    args:@[body[@"target"], name, body]];
+}
+
+- (void)sendTextEventWithType:(RCTTextEventType)type
+                     reactTag:(NSNumber *)reactTag
+                         text:(NSString *)text
+{
+  static NSString *events[] = {
+    @"topFocus",
+    @"topBlur",
+    @"topChange",
+    @"topSubmitEditing",
+    @"topEndEditing",
+  };
+  
+  [self sendInputEventWithName:events[type] body:@{
+    @"text": text,
+    @"target": reactTag
+  }];
+}
+
+/**
+ * TODO: throttling
+ * NOTE: the old system used a per-scrollview throttling
+ * which would be fairly easy to re-implement if needed,
+ * but this is non-optimal as it leads to degradation in
+ * scroll responsiveness. A better solution would be to
+ * coalesce multiple scroll events into a single batch.
+ */
+- (void)sendScrollEventWithType:(RCTScrollEventType)type
+                       reactTag:(NSNumber *)reactTag
+                     scrollView:(UIScrollView *)scrollView
+                       userData:(NSDictionary *)userData
+{
+  static NSString *events[] = {
+    @"topScrollBeginDrag",
+    @"topScroll",
+    @"topScrollEndDrag",
+    @"topMomentumScrollBegin",
+    @"topMomentumScrollEnd",
+    @"topScrollAnimationEnd",
+  };
+  
+  NSDictionary *body = @{
+    @"contentOffset": @{
+      @"x": @(scrollView.contentOffset.x),
+      @"y": @(scrollView.contentOffset.y)
+    },
+    @"contentSize": @{
+      @"width": @(scrollView.contentSize.width),
+      @"height": @(scrollView.contentSize.height)
+    },
+    @"layoutMeasurement": @{
+      @"width": @(scrollView.frame.size.width),
+      @"height": @(scrollView.frame.size.height)
+    },
+    @"zoomScale": @(scrollView.zoomScale ?: 1),
+    @"target": reactTag
+  };
+  
+  if (userData) {
+    NSMutableDictionary *mutableBody = [body mutableCopy];
+    [mutableBody addEntriesFromDictionary:userData];
+    body = mutableBody;
+  }
+  
+  [self sendInputEventWithName:events[type] body:body];
+}
+
+@end
--- a/ReactKit/Base/RCTImageDownloader.h
+++ b/ReactKit/Base/RCTImageDownloader.h
@@ -0,0 +1,22 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <UIKit/UIKit.h>
+
+typedef void (^RCTDataDownloadBlock)(NSData *data, NSError *error);
+typedef void (^RCTImageDownloadBlock)(UIImage *image, NSError *error);
+
+@interface RCTImageDownloader : NSObject
+
+ (instancetype)sharedInstance;
+
+- (id)downloadDataForURL:(NSURL *)url
+                   block:(RCTDataDownloadBlock)block;
+
+- (id)downloadImageForURL:(NSURL *)url
+                     size:(CGSize)size
+                    scale:(CGFloat)scale
+                    block:(RCTImageDownloadBlock)block;
+
+- (void)cancelDownload:(id)downloadToken;
+
+@end
--- a/ReactKit/Base/RCTImageDownloader.m
+++ b/ReactKit/Base/RCTImageDownloader.m
@@ -0,0 +1,159 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import "RCTImageDownloader.h"
+
+#import "RCTCache.h"
+#import "RCTUtils.h"
+
+// TODO: something a bit more sophisticated
+
+typedef void (^RCTCachedDataDownloadBlock)(BOOL cached, NSData *data, NSError *error);
+
+@implementation RCTImageDownloader
+{
+  RCTCache *_cache;
+  NSMutableDictionary *_pendingBlocks;
+}
+
+ (instancetype)sharedInstance
+{
+  RCTAssertMainThread();
+  static RCTImageDownloader *sharedInstance;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    sharedInstance = [[self alloc] init];
+  });
+  return sharedInstance;
+}
+
+- (instancetype)init
+{
+  if ((self = [super init])) {
+    _cache = [[RCTCache alloc] initWithName:@"RCTImageDownloader"];
+    _pendingBlocks = [NSMutableDictionary dictionary];
+  }
+  return self;
+}
+
+- (NSString *)cacheKeyForURL:(NSURL *)url
+{
+  return url.absoluteString;
+}
+
+- (id)_downloadDataForURL:(NSURL *)url block:(RCTCachedDataDownloadBlock)block
+{
+  NSString *cacheKey = [self cacheKeyForURL:url];
+
+  __block BOOL cancelled = NO;
+  __block NSURLSessionDataTask *task = nil;
+  dispatch_block_t cancel = ^{
+    cancelled = YES;
+
+    NSMutableArray *pendingBlocks = _pendingBlocks[cacheKey];
+    [pendingBlocks removeObject:block];
+
+    if (task) {
+      [task cancel];
+      task = nil;
+    }
+  };
+
+  NSMutableArray *pendingBlocks = _pendingBlocks[cacheKey];
+  if (pendingBlocks) {
+    [pendingBlocks addObject:block];
+  } else {
+    _pendingBlocks[cacheKey] = [NSMutableArray arrayWithObject:block];
+
+    __weak RCTImageDownloader *weakSelf = self;
+    RCTCachedDataDownloadBlock runBlocks = ^(BOOL cached, NSData *data, NSError *error) {
+      RCTImageDownloader *strongSelf = weakSelf;
+      NSArray *blocks = strongSelf->_pendingBlocks[cacheKey];
+      [strongSelf->_pendingBlocks removeObjectForKey:cacheKey];
+
+      for (RCTCachedDataDownloadBlock block in blocks) {
+        block(cached, data, error);
+      }
+    };
+
+    if ([_cache hasDataForKey:cacheKey]) {
+      [_cache fetchDataForKey:cacheKey completionHandler:^(NSData *data) {
+        if (!cancelled) runBlocks(YES, data, nil);
+      }];
+    } else {
+      task = [[NSURLSession sharedSession] dataTaskWithURL:url completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
+        if (!cancelled) runBlocks(NO, data, error);
+      }];
+
+      [task resume];
+    }
+  }
+
+  return [cancel copy];
+}
+
+- (id)downloadDataForURL:(NSURL *)url block:(RCTDataDownloadBlock)block
+{
+  NSString *cacheKey = [self cacheKeyForURL:url];
+  __weak RCTImageDownloader *weakSelf = self;
+  return [self _downloadDataForURL:url block:^(BOOL cached, NSData *data, NSError *error) {
+    if (!cached) {
+      RCTImageDownloader *strongSelf = weakSelf;
+      [strongSelf->_cache setData:data forKey:cacheKey];
+    }
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+      block(data, error);
+    });
+  }];
+}
+
+- (id)downloadImageForURL:(NSURL *)url size:(CGSize)size scale:(CGFloat)scale block:(RCTImageDownloadBlock)block
+{
+  NSString *cacheKey = [self cacheKeyForURL:url];
+  __weak RCTImageDownloader *weakSelf = self;
+  return [self _downloadDataForURL:url block:^(BOOL cached, NSData *data, NSError *error) {
+    if (!data) {
+      return dispatch_async(dispatch_get_main_queue(), ^{
+        block(nil, error);
+      });
+    }
+
+    UIImage *image = [UIImage imageWithData:data scale:scale];
+
+    if (image) {
+      CGSize imageSize = size;
+      if (CGSizeEqualToSize(imageSize, CGSizeZero)) {
+        imageSize = image.size;
+      }
+
+      CGFloat imageScale = scale;
+      if (imageScale == 0 || imageScale > image.scale) {
+        imageScale = image.scale;
+      }
+
+      UIGraphicsBeginImageContextWithOptions(imageSize, NO, imageScale);
+      [image drawInRect:(CGRect){{0, 0}, imageSize}];
+      image = UIGraphicsGetImageFromCurrentImageContext();
+      UIGraphicsEndImageContext();
+
+      if (!cached) {
+        RCTImageDownloader *strongSelf = weakSelf;
+        [strongSelf->_cache setData:UIImagePNGRepresentation(image) forKey:cacheKey];
+      }
+    }
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+      block(image, nil);
+    });
+  }];
+}
+
+- (void)cancelDownload:(id)downloadToken
+{
+  if (downloadToken) {
+    dispatch_block_t block = (id)downloadToken;
+    block();
+  }
+}
+
+@end
--- a/ReactKit/Base/RCTInvalidating.h
+++ b/ReactKit/Base/RCTInvalidating.h
@@ -0,0 +1,16 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <Foundation/Foundation.h>
+
+// TODO (#5906496): is there a reason for this protocol? It seems to be
+// used in a number of places where it isn't really required - only the
+// RCTBridge actually ever calls casts to it - in all other
+// cases it is simply a way of adding some method definitions to classes
+
+@protocol RCTInvalidating <NSObject>
+
+@property (nonatomic, assign, readonly, getter = isValid) BOOL valid;
+
+- (void)invalidate;
+
+@end
--- a/ReactKit/Base/RCTJavaScriptExecutor.h
+++ b/ReactKit/Base/RCTJavaScriptExecutor.h
@@ -0,0 +1,35 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <JavaScriptCore/JavaScriptCore.h>
+
+#import "RCTInvalidating.h"
+
+typedef void (^RCTJavaScriptCompleteBlock)(NSError *error);
+typedef void (^RCTJavaScriptCallback)(id objcValue, NSError *error);
+
+/**
+ * Abstracts away a JavaScript execution context - we may be running code in a
+ * web view (for debugging purposes), or may be running code in a `JSContext`.
+ */
+@protocol RCTJavaScriptExecutor <RCTInvalidating>
+
+/**
+ * Executes given method with arguments on JS thread and calls the given callback
+ * with JSValue and JSContext as a result of the JS module call.
+ */
+- (void)executeJSCall:(NSString *)name
+               method:(NSString *)method
+            arguments:(NSArray *)arguments
+             callback:(RCTJavaScriptCallback)onComplete;
+
+/**
+ * Runs an application script, and notifies of the script load being complete via `onComplete`.
+ */
+- (void)executeApplicationScript:(NSString *)script
+                       sourceURL:(NSURL *)url
+                      onComplete:(RCTJavaScriptCompleteBlock)onComplete;
+
+- (void)injectJSONText:(NSString *)script
+   asGlobalObjectNamed:(NSString *)objectName
+              callback:(RCTJavaScriptCompleteBlock)onComplete;
+@end
--- a/ReactKit/Base/RCTKeyCommands.h
+++ b/ReactKit/Base/RCTKeyCommands.h
@@ -0,0 +1,28 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <UIKit/UIKit.h>
+
+@interface RCTKeyCommands : NSObject
+
+ (instancetype)sharedInstance;
+
+/**
+ * Register a keyboard command.
+ */
+- (void)registerKeyCommandWithInput:(NSString *)input
+                      modifierFlags:(UIKeyModifierFlags)flags
+                             action:(void (^)(UIKeyCommand *command))block;
+
+/**
+ * Unregister a keyboard command.
+ */
+- (void)unregisterKeyCommandWithInput:(NSString *)input
+                        modifierFlags:(UIKeyModifierFlags)flags;
+
+/**
+ * Check if a command is registered.
+ */
+- (BOOL)isKeyCommandRegisteredForInput:(NSString *)input
+                         modifierFlags:(UIKeyModifierFlags)flags;
+
+@end
--- a/ReactKit/Base/RCTKeyCommands.m
+++ b/ReactKit/Base/RCTKeyCommands.m
@@ -0,0 +1,116 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import "RCTKeyCommands.h"
+
+#import <UIKit/UIKit.h>
+
+#import "RCTUtils.h"
+
+@interface RCTKeyCommands ()
+
+@property (nonatomic, strong) NSMutableDictionary *commandBindings;
+
+- (void)RCT_handleKeyCommand:(UIKeyCommand *)key;
+
+@end
+
+@implementation UIApplication (RCTKeyCommands)
+
+- (NSArray *)RCT_keyCommands
+{
+  NSDictionary *commandBindings = [RCTKeyCommands sharedInstance].commandBindings;
+  return [[self RCT_keyCommands] arrayByAddingObjectsFromArray:[commandBindings allKeys]];
+}
+
+- (BOOL)RCT_sendAction:(SEL)action to:(id)target from:(id)sender forEvent:(UIEvent *)event
+{
+  if (action == @selector(RCT_handleKeyCommand:)) {
+    [[RCTKeyCommands sharedInstance] RCT_handleKeyCommand:sender];
+    return YES;
+  }
+  return [self RCT_sendAction:action to:target from:sender forEvent:event];
+}
+
+@end
+
+@implementation RCTKeyCommands
+
+ (void)initialize
+{  
+  //swizzle UIApplication
+  RCTSwapInstanceMethods([UIApplication class], @selector(keyCommands), @selector(RCT_keyCommands));
+  RCTSwapInstanceMethods([UIApplication class], @selector(sendAction:to:from:forEvent:), @selector(RCT_sendAction:to:from:forEvent:));
+}
+
+static RCTKeyCommands *RKKeyCommandsSharedInstance = nil;
+
+ (instancetype)sharedInstance
+{
+  static RCTKeyCommands *sharedInstance;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    sharedInstance = [[self alloc] init];
+  });
+  
+  return sharedInstance;
+}
+
+- (instancetype)init
+{
+  if ((self = [super init])) {
+    _commandBindings = [[NSMutableDictionary alloc] init];
+  }
+  return self;
+}
+
+- (void)RCT_handleKeyCommand:(UIKeyCommand *)key
+{
+  // NOTE: We should just be able to do commandBindings[key] here, but curiously, the
+  // lookup seems to return nil sometimes, even if the key is found in the dictionary.
+  // To fix this, we use a linear search, since there won't be many keys anyway
+  
+  [_commandBindings enumerateKeysAndObjectsUsingBlock:^(UIKeyCommand *k, void (^block)(UIKeyCommand *), BOOL *stop) {
+    if ([key.input isEqualToString:k.input] && key.modifierFlags == k.modifierFlags) {
+      block(key);
+    }
+  }];
+}
+
+- (void)registerKeyCommandWithInput:(NSString *)input
+                      modifierFlags:(UIKeyModifierFlags)flags
+                             action:(void (^)(UIKeyCommand *))block
+{
+  RCTAssertMainThread();
+  
+  UIKeyCommand *command = [UIKeyCommand keyCommandWithInput:input
+                                              modifierFlags:flags
+                                                     action:@selector(RCT_handleKeyCommand:)];
+  _commandBindings[command] = block;
+}
+
+- (void)unregisterKeyCommandWithInput:(NSString *)input modifierFlags:(UIKeyModifierFlags)flags
+{
+  RCTAssertMainThread();
+  
+  for (UIKeyCommand *key in [_commandBindings allKeys]) {
+    if ([key.input isEqualToString:input] && key.modifierFlags == flags) {
+      [_commandBindings removeObjectForKey:key];
+      break;
+    }
+  }
+}
+
+- (BOOL)isKeyCommandRegisteredForInput:(NSString *)input
+                         modifierFlags:(UIKeyModifierFlags)flags
+{
+  RCTAssertMainThread();
+  
+  for (UIKeyCommand *key in [_commandBindings allKeys]) {
+    if ([key.input isEqualToString:input] && key.modifierFlags == flags) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+@end
--- a/ReactKit/Base/RCTLog.h
+++ b/ReactKit/Base/RCTLog.h
@@ -0,0 +1,69 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import "RCTAssert.h"
+#import "RCTRedBox.h"
+
+#define RCTLOG_INFO 1
+#define RCTLOG_WARN 2
+#define RCTLOG_ERROR 3
+#define RCTLOG_MUSTFIX 4
+
+// If set to e.g. `RCTLOG_ERROR`, will assert after logging the first error.
+#if DEBUG
+#define RCTLOG_FATAL_LEVEL RCTLOG_MUSTFIX
+#define RCTLOG_REDBOX_LEVEL RCTLOG_ERROR
+#else
+#define RCTLOG_FATAL_LEVEL (RCTLOG_MUSTFIX + 1)
+#define RCTLOG_REDBOX_LEVEL (RCTLOG_MUSTFIX + 1)
+#endif
+
+// If defined, only log messages that match this regex will fatal
+#define RCTLOG_FATAL_REGEX nil
+
+#define _RCTLog(__RCTLog__level, ...) do {                                                                                                       \
+  NSString *__RCTLog__levelStr;                                                                                                                  \
+  switch(__RCTLog__level) {                                                                                                                      \
+    case RCTLOG_INFO: __RCTLog__levelStr = @"info"; break;                                                                                       \
+    case RCTLOG_WARN: __RCTLog__levelStr = @"warn"; break;                                                                                       \
+    case RCTLOG_ERROR: __RCTLog__levelStr = @"error"; break;                                                                                     \
+    case RCTLOG_MUSTFIX: __RCTLog__levelStr = @"mustfix"; break;                                                                                 \
+  }                                                                                                                                              \
+  NSString *__RCTLog__msg = _RCTLogObjects(RCTLogFormat(__VA_ARGS__), __RCTLog__levelStr);                                                       \
+  if (__RCTLog__level >= RCTLOG_FATAL_LEVEL) {                                                                                                   \
+    BOOL __RCTLog__fail = YES;                                                                                                                   \
+    if (RCTLOG_FATAL_REGEX) {                                                                                                                    \
+      NSError *__RCTLog__e;                                                                                                                      \
+      NSRegularExpression *__RCTLog__regex = [NSRegularExpression regularExpressionWithPattern:RCTLOG_FATAL_REGEX options:0 error:&__RCTLog__e]; \
+      __RCTLog__fail = [__RCTLog__regex numberOfMatchesInString:__RCTLog__msg options:0 range:NSMakeRange(0, [__RCTLog__msg length])] > 0;       \
+    }                                                                                                                                            \
+    RCTCAssert(!__RCTLog__fail, @"RCTLOG_FATAL_LEVEL %@: %@", __RCTLog__levelStr, __RCTLog__msg);                                                \
+  }                                                                                                                                              \
+  if (__RCTLog__level >= RCTLOG_REDBOX_LEVEL) {                                                                                                  \
+    RCTRedBox *__RCTLog__redBox = [RCTRedBox sharedInstance];                                                                                    \
+    [__RCTLog__redBox showErrorMessage:__RCTLog__msg];                                                                                           \
+  }                                                                                                                                              \
+} while (0)
+
+#define RCTLog(...) _RCTLog(RCTLOG_INFO, __VA_ARGS__)
+#define RCTLogInfo(...) _RCTLog(RCTLOG_INFO, __VA_ARGS__)
+#define RCTLogWarn(...) _RCTLog(RCTLOG_WARN, __VA_ARGS__)
+#define RCTLogError(...) _RCTLog(RCTLOG_ERROR, __VA_ARGS__)
+#define RCTLogMustFix(...) _RCTLog(RCTLOG_MUSTFIX, __VA_ARGS__)
+
+#define RCTLogFormat(...) _RCTLogFormat(__FILE__, __LINE__, __PRETTY_FUNCTION__, __VA_ARGS__)
+#define RCTLogFormatString(...) _RCTLogFormatString(__FILE__, __LINE__, __PRETTY_FUNCTION__, __VA_ARGS__)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NSString *_RCTLogObjects(NSArray *objects, NSString *level);
+NSArray *_RCTLogFormat(const char *file, int lineNumber, const char *funcName, NSString *format, ...) NS_FORMAT_FUNCTION(4,5);
+NSString *_RCTLogFormatString(const char *file, int lineNumber, const char *funcName, NSString *format, ...) NS_FORMAT_FUNCTION(4,5);
+
+#ifdef __cplusplus
+}
+#endif
+
+typedef void (^RCTLogFunction)(NSString *format, NSString *str);
+void RCTInjectLogFunction(RCTLogFunction func);
--- a/ReactKit/Base/RCTLog.m
+++ b/ReactKit/Base/RCTLog.m
@@ -0,0 +1,88 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import "RCTLog.h"
+
+#import "RCTBridge.h"
+
+static RCTLogFunction injectedLogFunction;
+
+void RCTInjectLogFunction(RCTLogFunction func) {
+  injectedLogFunction = func;
+}
+
+static inline NSString *_RCTLogPreamble(const char *file, int lineNumber, const char *funcName)
+{
+  NSString *threadName = [[NSThread currentThread] name];
+  NSString *fileName=[[NSString stringWithUTF8String:file] lastPathComponent];
+  if (!threadName || threadName.length <= 0) {
+    threadName = [NSString stringWithFormat:@"%p", [NSThread currentThread]];
+  }
+  return [NSString stringWithFormat:@"[RCTLog][tid:%@][%@:%d]>", threadName, fileName, lineNumber];
+}
+
+// TODO (#5906496): // kinda ugly that this is tied to RCTBridge
+NSString *_RCTLogObjects(NSArray *objects, NSString *level)
+{
+  NSString *str = objects[0];
+#if TARGET_IPHONE_SIMULATOR
+  if ([RCTBridge hasValidJSExecutor]) {
+    fprintf(stderr, "%s\n", [str UTF8String]); // don't print timestamps and other junk
+    [RCTBridge log:objects level:level];
+  } else
+#endif
+  {
+    // Print normal errors with timestamps when not in simulator.
+    // Non errors are already compiled out above, so log as error here.
+    if (injectedLogFunction) {
+      injectedLogFunction(@">\n  %@", str);
+    } else {
+      NSLog(@">\n  %@", str);
+    }
+  }
+  return str;
+}
+
+// Returns array of objects.  First arg is a simple string to print, remaining args are objects to pass through to the debugger so they are
+// inspectable in the console.
+NSArray *_RCTLogFormat(const char *file, int lineNumber, const char *funcName, NSString *format, ...)
+{
+  va_list args;
+  va_start(args, format);
+  NSString *preamble = _RCTLogPreamble(file, lineNumber, funcName);
+  
+  // Pull out NSObjects so we can pass them through as inspectable objects to the js debugger
+  NSArray *formatParts = [format componentsSeparatedByString:@"%"];
+  NSMutableArray *objects = [NSMutableArray arrayWithObject:preamble];
+  BOOL valid = YES;
+  for (int i = 0; i < formatParts.count; i++) {
+    if (i == 0) { // first part is always a string
+      [objects addObject:formatParts[i]];
+    } else {
+      if (valid && [formatParts[i] length] && [formatParts[i] characterAtIndex:0] == '@') {
+        id obj = va_arg(args, id);
+        [objects addObject:obj ?: @"null"];
+        [objects addObject:[formatParts[i] substringFromIndex:1]]; // remove formatting char
+      } else {
+        // We could determine the type (double, int?) of the va_arg by parsing the formatPart, but for now we just bail.
+        valid = NO;
+        [objects addObject:[NSString stringWithFormat:@"unknown object for %%%@", formatParts[i]]];
+      }
+    }
+  }
+  va_end(args);
+  va_start(args, format);
+  NSString *strOut = [preamble stringByAppendingString:[[NSString alloc] initWithFormat:format arguments:args]];
+  va_end(args);
+  NSMutableArray *objectsOut = [NSMutableArray arrayWithObject:strOut];
+  [objectsOut addObjectsFromArray:objects];
+  return objectsOut;
+}
+
+NSString *_RCTLogFormatString(const char *file, int lineNumber, const char *funcName, NSString *format, ...)
+{
+  va_list args;
+  va_start (args, format);
+  NSString *body =  [[NSString alloc] initWithFormat:format arguments:args];
+  va_end (args);
+  return [NSString stringWithFormat:@"%@ %@", _RCTLogPreamble(file, lineNumber, funcName), body];
+}
--- a/ReactKit/Base/RCTPointerEvents.h
+++ b/ReactKit/Base/RCTPointerEvents.h
@@ -0,0 +1,10 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, RCTPointerEvents) {
+  RCTPointerEventsUnspecified = 0, // Default
+  RCTPointerEventsNone,
+  RCTPointerEventsBoxNone,
+  RCTPointerEventsBoxOnly,
+};
--- a/ReactKit/Base/RCTRedBox.h
+++ b/ReactKit/Base/RCTRedBox.h
@@ -0,0 +1,16 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <UIKit/UIKit.h>
+
+@interface RCTRedBox : NSObject
+
+ (instancetype)sharedInstance;
+
+- (void)showErrorMessage:(NSString *)message;
+- (void)showErrorMessage:(NSString *)message withDetails:(NSString *)details;
+- (void)showErrorMessage:(NSString *)message withStack:(NSArray *)stack;
+- (void)updateErrorMessage:(NSString *)message withStack:(NSArray *)stack;
+
+- (void)dismiss;
+
+@end
--- a/ReactKit/Base/RCTRedBox.m
+++ b/ReactKit/Base/RCTRedBox.m
@@ -0,0 +1,294 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import "RCTRedBox.h"
+
+#import "RCTRootView.h"
+#import "RCTUtils.h"
+
+@interface RCTRedBoxWindow : UIWindow <UITableViewDelegate, UITableViewDataSource>
+
+@end
+
+@implementation RCTRedBoxWindow
+{
+  UIView *_rootView;
+  UITableView *_stackTraceTableView;
+  
+  NSString *_lastErrorMessage;
+  NSArray *_lastStackTrace;
+  
+  UITableViewCell *_cachedMessageCell;
+}
+
+- (id)initWithFrame:(CGRect)frame
+{
+  if ((self = [super initWithFrame:frame])) {
+    
+    self.windowLevel = UIWindowLevelStatusBar + 5;
+    self.backgroundColor = [UIColor colorWithRed:0.8 green:0 blue:0 alpha:1];
+    self.hidden = YES;
+    
+    UIViewController *rootController = [[UIViewController alloc] init];
+    self.rootViewController = rootController;
+    _rootView = rootController.view;
+    _rootView.backgroundColor = [UIColor clearColor];
+    
+    const CGFloat buttonHeight = 60;
+
+    CGRect detailsFrame = _rootView.bounds;
+    detailsFrame.size.height -= buttonHeight;
+    
+    _stackTraceTableView = [[UITableView alloc] initWithFrame:detailsFrame style:UITableViewStylePlain];
+    _stackTraceTableView.delegate = self;
+    _stackTraceTableView.dataSource = self;
+    _stackTraceTableView.backgroundColor = [UIColor clearColor];
+    _stackTraceTableView.separatorColor = [[UIColor whiteColor] colorWithAlphaComponent:0.3];
+    _stackTraceTableView.separatorStyle = UITableViewCellSeparatorStyleNone;
+    [_rootView addSubview:_stackTraceTableView];
+    
+    UIButton *dismissButton = [UIButton buttonWithType:UIButtonTypeCustom];
+    dismissButton.titleLabel.font = [UIFont systemFontOfSize:14];
+    [dismissButton setTitle:@"Dismiss (ESC)" forState:UIControlStateNormal];
+    [dismissButton setTitleColor:[[UIColor whiteColor] colorWithAlphaComponent:0.5] forState:UIControlStateNormal];
+    [dismissButton setTitleColor:[UIColor whiteColor] forState:UIControlStateHighlighted];
+    [dismissButton addTarget:self action:@selector(dismiss) forControlEvents:UIControlEventTouchUpInside];
+    
+    UIButton *reloadButton = [UIButton buttonWithType:UIButtonTypeCustom];
+    reloadButton.titleLabel.font = [UIFont systemFontOfSize:14];
+    [reloadButton setTitle:@"Reload JS (\u2318R)" forState:UIControlStateNormal];
+    [reloadButton setTitleColor:[[UIColor whiteColor] colorWithAlphaComponent:0.5] forState:UIControlStateNormal];
+    [reloadButton setTitleColor:[UIColor whiteColor] forState:UIControlStateHighlighted];
+    [reloadButton addTarget:self action:@selector(reload) forControlEvents:UIControlEventTouchUpInside];
+    
+    CGFloat buttonWidth = self.bounds.size.width / 2;
+    dismissButton.frame = CGRectMake(0, self.bounds.size.height - buttonHeight, buttonWidth, buttonHeight);
+    reloadButton.frame = CGRectMake(buttonWidth, self.bounds.size.height - buttonHeight, buttonWidth, buttonHeight);
+    [_rootView addSubview:dismissButton];
+    [_rootView addSubview:reloadButton];
+  }
+  return self;
+}
+
+- (void)openStackFrameInEditor:(NSDictionary *)stackFrame
+{
+  NSData *stackFrameJSON = [RCTJSONStringify(stackFrame, nil) dataUsingEncoding:NSUTF8StringEncoding];
+  NSString *postLength = [NSString stringWithFormat:@"%lu", (unsigned long)[stackFrameJSON length]];
+  NSMutableURLRequest *request = [[NSMutableURLRequest alloc] init];
+  request.URL = [NSURL URLWithString:@"http://localhost:8081/open-stack-frame"];
+  request.HTTPMethod = @"POST";
+  request.HTTPBody = stackFrameJSON;
+  [request setValue:postLength forHTTPHeaderField:@"Content-Length"];
+  [request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
+
+  [NSURLConnection sendAsynchronousRequest:request queue:[[NSOperationQueue alloc] init] completionHandler:nil];
+}
+
+- (void)showErrorMessage:(NSString *)message withStack:(NSArray *)stack showIfHidden:(BOOL)shouldShow
+{
+  _lastStackTrace = stack;
+  _lastErrorMessage = message;
+  _cachedMessageCell = [self reuseCell:nil forErrorMessage:message];
+  [_stackTraceTableView reloadData];
+  [_stackTraceTableView setNeedsLayout];
+  
+  if (self.hidden && shouldShow) {
+    [_stackTraceTableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]
+                                atScrollPosition:UITableViewScrollPositionTop
+                                        animated:NO];
+    [self makeKeyAndVisible];
+    [self becomeFirstResponder];
+  }
+}
+
+- (void)dismiss
+{
+  self.hidden = YES;
+}
+
+- (void)reload
+{
+  [RCTRootView reloadAll];
+  [self dismiss];
+}
+
+#pragma mark - TableView
+
+- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
+{
+  return 2;
+}
+
+- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
+{
+  return section == 0 ? 1 : [_lastStackTrace count];
+}
+
+- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
+{
+  if ([indexPath section] == 0) {
+    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"msg-cell"];
+    return [self reuseCell:cell forErrorMessage:_lastErrorMessage];
+  }
+  UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"cell"];
+  NSUInteger index = [indexPath row];
+  NSDictionary *stackFrame = _lastStackTrace[index];
+  return [self reuseCell:cell forStackFrame:stackFrame];
+}
+
+- (UITableViewCell *)reuseCell:(UITableViewCell *)cell forErrorMessage:(NSString *)message
+{
+  if (!cell) {
+    cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:@"msg-cell"];
+    cell.textLabel.textColor = [UIColor whiteColor];
+    cell.textLabel.font = [UIFont boldSystemFontOfSize:16];
+    cell.textLabel.lineBreakMode = NSLineBreakByWordWrapping;
+    cell.textLabel.numberOfLines = 0;
+    cell.detailTextLabel.textColor = [UIColor whiteColor];
+    cell.backgroundColor = [UIColor clearColor];
+    cell.selectionStyle = UITableViewCellSelectionStyleNone;
+  }
+  
+  cell.textLabel.text = message;
+  
+  return cell;
+}
+
+- (UITableViewCell *)reuseCell:(UITableViewCell *)cell forStackFrame:(NSDictionary *)stackFrame
+{
+  if (!cell) {
+    cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:@"cell"];
+    cell.textLabel.textColor = [[UIColor whiteColor] colorWithAlphaComponent:0.9];
+    cell.textLabel.font = [UIFont fontWithName:@"Menlo-Regular" size:14];
+    cell.detailTextLabel.textColor = [[UIColor whiteColor] colorWithAlphaComponent:0.7];
+    cell.detailTextLabel.font = [UIFont fontWithName:@"Menlo-Regular" size:11];
+    cell.detailTextLabel.lineBreakMode = NSLineBreakByTruncatingMiddle;
+    cell.backgroundColor = [UIColor clearColor];
+    cell.selectedBackgroundView = [[UIView alloc] init];
+    cell.selectedBackgroundView.backgroundColor = [[UIColor blackColor] colorWithAlphaComponent:0.2];
+  }
+  
+  cell.textLabel.text = stackFrame[@"methodName"];
+  cell.detailTextLabel.text = cell.detailTextLabel.text = [NSString stringWithFormat:@"%@:%@", [stackFrame[@"file"] lastPathComponent], stackFrame[@"lineNumber"]];
+  return cell;
+}
+
+- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
+{
+  if ([indexPath section] == 0) {
+    NSMutableParagraphStyle *paragraphStyle = [[NSParagraphStyle defaultParagraphStyle] mutableCopy];
+    paragraphStyle.lineBreakMode = NSLineBreakByWordWrapping;
+    
+    NSDictionary *attributes = @{NSFontAttributeName: [UIFont boldSystemFontOfSize:16],
+                                 NSParagraphStyleAttributeName: paragraphStyle};
+    CGRect boundingRect = [_lastErrorMessage boundingRectWithSize:CGSizeMake(tableView.frame.size.width - 30, CGFLOAT_MAX) options:NSStringDrawingUsesLineFragmentOrigin attributes:attributes context:nil];
+    return ceil(boundingRect.size.height) + 40;
+  } else {
+    return 44;
+  }
+}
+
+- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath
+{
+  if ([indexPath section] == 1) {
+    NSUInteger row = [indexPath row];
+    NSDictionary *stackFrame = _lastStackTrace[row];
+    [self openStackFrameInEditor:stackFrame];
+  }
+  [tableView deselectRowAtIndexPath:indexPath animated:YES];
+}
+
+#pragma mark - Key commands
+
+- (NSArray *)keyCommands
+{
+  // NOTE: We could use RCTKeyCommands for this, but since
+  // we control this window, we can use the standard, non-hacky
+  // mechanism instead
+  
+  return @[
+          
+    // Dismiss red box
+    [UIKeyCommand keyCommandWithInput:UIKeyInputEscape
+                        modifierFlags:0
+                               action:@selector(dismiss)],
+    
+    // Reload
+    [UIKeyCommand keyCommandWithInput:@"r"
+                        modifierFlags:UIKeyModifierCommand
+                               action:@selector(reload)]
+  ];
+}
+
+- (BOOL)canBecomeFirstResponder
+{
+  return YES;
+}
+
+@end
+
+@implementation RCTRedBox
+{
+  RCTRedBoxWindow *_window;
+}
+
+ (instancetype)sharedInstance
+{
+  static RCTRedBox *_sharedInstance;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    _sharedInstance = [[RCTRedBox alloc] init];
+  });
+  return _sharedInstance;
+}
+
+- (void)showErrorMessage:(NSString *)message
+{
+  [self showErrorMessage:message withStack:nil showIfHidden:YES];
+}
+
+- (void)showErrorMessage:(NSString *)message withDetails:(NSString *)details
+{
+  NSString *combinedMessage = message;
+  if (details) {
+    combinedMessage = [NSString stringWithFormat:@"%@\n\n%@", message, details];
+  }
+  [self showErrorMessage:combinedMessage];
+}
+
+- (void)showErrorMessage:(NSString *)message withStack:(NSArray *)stack
+{
+  [self showErrorMessage:message withStack:stack showIfHidden:YES];
+}
+
+- (void)updateErrorMessage:(NSString *)message withStack:(NSArray *)stack
+{
+  [self showErrorMessage:message withStack:stack showIfHidden:NO];
+}
+
+- (void)showErrorMessage:(NSString *)message withStack:(NSArray *)stack showIfHidden:(BOOL)shouldShow
+{
+  
+#if DEBUG
+  
+  dispatch_block_t block = ^{
+    if (!_window) {
+       _window = [[RCTRedBoxWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
+    }
+    [_window showErrorMessage:message withStack:stack showIfHidden:shouldShow];
+  };
+  if ([NSThread isMainThread]) {
+    block();
+  } else {
+    dispatch_async(dispatch_get_main_queue(), block);
+  }
+  
+#endif
+  
+}
+
+- (void)dismiss
+{
+  [_window dismiss];
+}
+
+@end
--- a/ReactKit/Base/RCTRootView.h
+++ b/ReactKit/Base/RCTRootView.h
@@ -0,0 +1,41 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <UIKit/UIKit.h>
+
+@interface RCTRootView : UIView
+
+/**
+ * The URL of the bundled application script (required).
+ * Setting this will clear the view contents, and trigger
+ * an asynchronous load/download and execution of the script.
+ */
+@property (nonatomic, strong) NSURL *scriptURL;
+
+/**
+ * The name of the JavaScript module to execute within the
+ * specified scriptURL (required). Setting this will not have
+ * any immediate effect, but it must be done prior to loading
+ * the script.
+ */
+@property (nonatomic, copy) NSString *moduleName;
+
+/**
+ * The default properties to apply to the view when the script bundle
+ * is first loaded. Defaults to nil/empty.
+ */
+@property (nonatomic, copy) NSDictionary *initialProperties;
+
+/** 
+ * The class of the RCTJavaScriptExecutor to use with this view.
+ * If not specified, it will default to using RCTContextExecutor.
+ * Changes will take effect next time the bundle is reloaded.
+ */
+@property (nonatomic, strong) Class executorClass;
+
+/**
+ * Reload this root view, or all root views, respectively.
+ */
+- (void)reload;
+ (void)reloadAll;
+
+@end
--- a/ReactKit/Base/RCTRootView.m
+++ b/ReactKit/Base/RCTRootView.m
@@ -0,0 +1,223 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import "RCTRootView.h"
+
+#import "RCTBridge.h"
+#import "RCTContextExecutor.h"
+#import "RCTEventDispatcher.h"
+#import "RCTKeyCommands.h"
+#import "RCTLog.h"
+#import "RCTRedBox.h"
+#import "RCTTouchHandler.h"
+#import "RCTUIManager.h"
+#import "RCTUtils.h"
+#import "RCTWebViewExecutor.h"
+#import "UIView+ReactKit.h"
+
+NSString *const RCTRootViewReloadNotification = @"RCTRootViewReloadNotification";
+
+@implementation RCTRootView
+{
+  RCTBridge *_bridge;
+  RCTTouchHandler *_touchHandler;
+  id <RCTJavaScriptExecutor> _executor;
+}
+
+static Class _globalExecutorClass;
+
+ (void)initialize
+{
+
+#if DEBUG
+
+  // Register Cmd-R as a global refresh key
+  [[RCTKeyCommands sharedInstance] registerKeyCommandWithInput:@"r"
+                                                 modifierFlags:UIKeyModifierCommand
+                                                        action:^(UIKeyCommand *command) {
+                                                          [self reloadAll];
+                                                        }];
+
+  // Cmd-D reloads using the web view executor, allows attaching from Safari dev tools.
+  [[RCTKeyCommands sharedInstance] registerKeyCommandWithInput:@"d"
+                                                 modifierFlags:UIKeyModifierCommand
+                                                        action:^(UIKeyCommand *command) {
+                                                          _globalExecutorClass = [RCTWebViewExecutor class];
+                                                          [self reloadAll];
+                                                        }];
+
+#endif
+
+}
+
+- (id)initWithCoder:(NSCoder *)aDecoder
+{
+  if ((self = [super initWithCoder:aDecoder])) {
+    [self setUp];
+  }
+  return self;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if ((self = [super initWithFrame:frame])) {
+    self.backgroundColor = [UIColor whiteColor];
+    [self setUp];
+  }
+  return self;
+}
+
+- (void)setUp
+{
+  // Every root view that is created must have a unique react tag.
+  // Numbering of these tags goes from 1, 11, 21, 31, etc
+  static NSInteger rootViewTag = 1;
+  self.reactTag = @(rootViewTag);
+  rootViewTag += 10;
+
+  // Add reload observer
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(reload)
+                                               name:RCTRootViewReloadNotification
+                                             object:nil];
+}
+
+- (void)dealloc
+{
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (void)bundleFinishedLoading:(NSError *)error
+{
+  if (error != nil) {
+    NSArray *stack = [[error userInfo] objectForKey:@"stack"];
+    if (stack) {
+      [[RCTRedBox sharedInstance] showErrorMessage:[error localizedDescription] withStack:stack];
+    } else {
+      [[RCTRedBox sharedInstance] showErrorMessage:[error localizedDescription] withDetails:[error localizedFailureReason]];
+    }
+  } else {
+
+    [_bridge registerRootView:self];
+
+    NSString *moduleName = _moduleName ?: @"";
+    NSDictionary *appParameters = @{
+      @"rootTag": self.reactTag,
+      @"initialProps": self.initialProperties ?: @{},
+    };
+    [_bridge enqueueJSCall:@"AppRegistry.runApplication"
+                      args:@[moduleName, appParameters]];
+  }
+}
+
+- (void)loadBundle
+{
+  // Clear view
+  [self.subviews makeObjectsPerformSelector:@selector(removeFromSuperview)];
+
+  if (!_scriptURL) {
+    return;
+  }
+
+  // Clean up
+  [self removeGestureRecognizer:_touchHandler];
+  [_executor invalidate];
+  [_bridge invalidate];
+
+  // Choose local executor if specified, followed by global, followed by default
+  _executor = [[_executorClass ?: _globalExecutorClass ?: [RCTContextExecutor class] alloc] init];
+  _bridge = [[RCTBridge alloc] initWithJavaScriptExecutor:_executor moduleInstances:nil];
+  _touchHandler = [[RCTTouchHandler alloc] initWithBridge:_bridge];
+  [self addGestureRecognizer:_touchHandler];
+
+  // Load the bundle
+  NSURLSessionDataTask *task = [[NSURLSession sharedSession] dataTaskWithURL:_scriptURL completionHandler:
+                                ^(NSData *data, NSURLResponse *response, NSError *error) {
+
+    // Handle general request errors
+    if (error) {
+      if ([[error domain] isEqualToString:NSURLErrorDomain]) {
+        NSDictionary *userInfo = @{
+          NSLocalizedDescriptionKey: @"Could not connect to development server. Ensure node server is running - run 'npm start' from ReactKit root",
+          NSLocalizedFailureReasonErrorKey: [error localizedDescription],
+          NSUnderlyingErrorKey: error,
+        };
+        error = [NSError errorWithDomain:@"JSServer"
+                                    code:error.code
+                                userInfo:userInfo];
+      }
+      [self bundleFinishedLoading:error];
+      return;
+    }
+
+    // Parse response as text
+    NSStringEncoding encoding = NSUTF8StringEncoding;
+    if (response.textEncodingName != nil) {
+      CFStringEncoding cfEncoding = CFStringConvertIANACharSetNameToEncoding((CFStringRef)response.textEncodingName);
+      if (cfEncoding != kCFStringEncodingInvalidId) {
+        encoding = CFStringConvertEncodingToNSStringEncoding(cfEncoding);
+      }
+    }
+    NSString *rawText = [[NSString alloc] initWithData:data encoding:encoding];
+
+    // Handle HTTP errors
+    if ([response isKindOfClass:[NSHTTPURLResponse class]] && [(NSHTTPURLResponse *)response statusCode] != 200) {
+      NSDictionary *userInfo;
+      NSDictionary *errorDetails = RCTJSONParse(rawText, nil);
+      if ([errorDetails isKindOfClass:[NSDictionary class]]) {
+        userInfo = @{
+          NSLocalizedDescriptionKey: errorDetails[@"message"] ?: @"No message provided",
+          @"stack": @[@{
+            @"methodName": errorDetails[@"description"] ?: @"",
+            @"file": errorDetails[@"filename"] ?: @"",
+            @"lineNumber": errorDetails[@"lineNumber"] ?: @0
+          }]
+        };
+      } else {
+        userInfo = @{NSLocalizedDescriptionKey: rawText};
+      }
+      error = [NSError errorWithDomain:@"JSServer"
+                                  code:[(NSHTTPURLResponse *)response statusCode]
+                              userInfo:userInfo];
+
+      [self bundleFinishedLoading:error];
+      return;
+    }
+
+    // Success!
+    [_bridge enqueueApplicationScript:rawText url:_scriptURL onComplete:^(NSError *error) {
+      dispatch_async(dispatch_get_main_queue(), ^{
+        [self bundleFinishedLoading:error];
+      });
+    }];
+
+  }];
+
+  [task resume];
+}
+
+- (void)setScriptURL:(NSURL *)scriptURL
+{
+  if ([_scriptURL isEqual:scriptURL]) {
+    return;
+  }
+
+  _scriptURL = scriptURL;
+  [self loadBundle];
+}
+
+- (BOOL)isReactRootView
+{
+  return YES;
+}
+
+- (void)reload
+{
+  [self loadBundle];
+}
+
+ (void)reloadAll
+{
+  [[NSNotificationCenter defaultCenter] postNotificationName:RCTRootViewReloadNotification object:nil];
+}
+
+@end
--- a/ReactKit/Base/RCTScrollableProtocol.h
+++ b/ReactKit/Base/RCTScrollableProtocol.h
@@ -0,0 +1,18 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <UIKit/UIKit.h>
+
+/**
+ * Contains any methods related to scrolling. Any `RCTView` that has scrolling
+ * features should implement these methods.
+ */
+@protocol RCTScrollableProtocol
+
+@property (nonatomic, readwrite, weak) NSObject<UIScrollViewDelegate> *nativeMainScrollDelegate;
+@property (nonatomic, readonly) CGSize contentSize;
+
+- (void)scrollToOffset:(CGPoint)offset;
+- (void)scrollToOffset:(CGPoint)offset animated:(BOOL)animated;
+- (void)zoomToRect:(CGRect)rect animated:(BOOL)animated;
+
+@end
--- a/ReactKit/Base/RCTSparseArray.h
+++ b/ReactKit/Base/RCTSparseArray.h
@@ -0,0 +1,31 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <Foundation/Foundation.h>
+
+@interface RCTSparseArray : NSObject <NSCopying>
+
+- (instancetype)initWithCapacity:(NSUInteger)capacity NS_DESIGNATED_INITIALIZER;
+- (instancetype)initWithSparseArray:(RCTSparseArray *)sparseArray NS_DESIGNATED_INITIALIZER;
+
+ (instancetype)sparseArray;
+ (instancetype)sparseArrayWithCapacity:(NSUInteger)capacity;
+ (instancetype)sparseArrayWithSparseArray:(RCTSparseArray *)sparseArray;
+
+// Use nil object to remove at idx.
+- (void)setObject:(id)obj atIndexedSubscript:(NSUInteger)idx;
+- (id)objectAtIndexedSubscript:(NSUInteger)idx;
+
+// Use nil obj to remove at key.
+- (void)setObject:(id)obj forKeyedSubscript:(NSNumber *)key;
+- (id)objectForKeyedSubscript:(NSNumber *)key;
+
+@property (readonly, nonatomic) NSUInteger count;
+@property (readonly, nonatomic, copy) NSArray *allIndexes;
+@property (readonly, nonatomic, copy) NSArray *allObjects;
+
+- (void)enumerateObjectsUsingBlock:(void (^)(id obj, NSNumber *idx, BOOL *stop))block;
+- (void)enumerateObjectsWithOptions:(NSEnumerationOptions)opts usingBlock:(void (^)(id obj, NSNumber *idx, BOOL *stop))block;
+
+- (void)removeAllObjects;
+
+@end
--- a/ReactKit/Base/RCTSparseArray.m
+++ b/ReactKit/Base/RCTSparseArray.m
@@ -0,0 +1,111 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import "RCTSparseArray.h"
+
+@implementation RCTSparseArray
+{
+  NSMutableDictionary *_storage;
+}
+
+- (instancetype)init
+{
+  return [self initWithCapacity:0];
+}
+
+- (instancetype)initWithCapacity:(NSUInteger)capacity
+{
+  if ((self = [super init])) {
+    _storage = [NSMutableDictionary dictionaryWithCapacity:capacity];
+  }
+  return self;
+}
+
+- (instancetype)initWithSparseArray:(RCTSparseArray *)sparseArray
+{
+  if ((self = [super init])) {
+    _storage = [sparseArray->_storage copy];
+  }
+  return self;
+}
+
+ (instancetype)sparseArray
+{
+  return [[self alloc] init];
+}
+
+ (instancetype)sparseArrayWithCapacity:(NSUInteger)capacity
+{
+  return [[self alloc] initWithCapacity:capacity];
+}
+
+ (instancetype)sparseArrayWithSparseArray:(RCTSparseArray *)sparseArray
+{
+  return [[self alloc] initWithSparseArray:sparseArray];
+}
+
+- (id)objectAtIndexedSubscript:(NSUInteger)idx
+{
+  return _storage[@(idx)];
+}
+
+- (void)setObject:(id)obj atIndexedSubscript:(NSUInteger)idx
+{
+  self[@(idx)] = obj;
+}
+
+- (id)objectForKeyedSubscript:(NSNumber *)key
+{
+  return _storage[key];
+}
+
+- (void)setObject:(id)obj forKeyedSubscript:(NSNumber *)key
+{
+  if (obj) {
+    _storage[key] = obj;
+  } else {
+    [_storage removeObjectForKey:key];
+  }
+}
+
+- (NSUInteger)count
+{
+  return _storage.count;
+}
+
+- (NSArray *)allIndexes
+{
+  return _storage.allKeys;
+}
+
+- (NSArray *)allObjects
+{
+  return _storage.allValues;
+}
+
+- (void)enumerateObjectsUsingBlock:(void (^)(id obj, NSNumber *idx, BOOL *stop))block
+{
+  NSParameterAssert(block != nil);
+  [_storage enumerateKeysAndObjectsUsingBlock:^(NSNumber *key, id obj, BOOL *stop) {
+    block(obj, key, stop);
+  }];
+}
+
+- (void)enumerateObjectsWithOptions:(NSEnumerationOptions)opts usingBlock:(void (^)(id obj, NSNumber *idx, BOOL *stop))block
+{
+  NSParameterAssert(block != nil);
+  [_storage enumerateKeysAndObjectsWithOptions:opts usingBlock:^(NSNumber *key, id obj, BOOL *stop) {
+    block(obj, key, stop);
+  }];
+}
+
+- (void)removeAllObjects
+{
+  [_storage removeAllObjects];
+}
+
+- (id)copyWithZone:(NSZone *)zone
+{
+  return [[[self class] allocWithZone:zone] initWithSparseArray:self];
+}
+
+@end
--- a/ReactKit/Base/RCTTouchHandler.h
+++ b/ReactKit/Base/RCTTouchHandler.h
@@ -0,0 +1,11 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <UIKit/UIKit.h>
+
+@class RCTBridge;
+
+@interface RCTTouchHandler : UIGestureRecognizer
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge;
+
+@end
--- a/ReactKit/Base/RCTTouchHandler.m
+++ b/ReactKit/Base/RCTTouchHandler.m
@@ -0,0 +1,220 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import "RCTTouchHandler.h"
+
+#import <UIKit/UIGestureRecognizerSubclass.h>
+
+#import "RCTAssert.h"
+#import "RCTBridge.h"
+#import "RCTLog.h"
+#import "RCTUIManager.h"
+#import "RCTUtils.h"
+#import "UIView+ReactKit.h"
+
+// TODO: this class behaves a lot like a module, and could be implemented as a
+// module if we were to assume that modules and RootViews had a 1:1 relationship
+
+@implementation RCTTouchHandler
+{
+  __weak RCTBridge *_bridge;
+  
+  /**
+   * Arrays managed in parallel tracking native touch object along with the
+   * native view that was touched, and the react touch data dictionary.
+   * This must be kept track of because `UIKit` destroys the touch targets
+   * if touches are canceled and we have no other way to recover this information.
+   */
+  NSMutableOrderedSet *_nativeTouches;
+  NSMutableArray *_reactTouches;
+  NSMutableArray *_touchViews;
+}
+
+- (instancetype)initWithTarget:(id)target action:(SEL)action
+{
+  RCT_NOT_DESIGNATED_INITIALIZER();
+}
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+{
+  if ((self = [super initWithTarget:nil action:NULL])) {
+    
+    RCTAssert(bridge != nil, @"Expect an event dispatcher");
+    
+    _bridge = bridge;
+    
+    _nativeTouches = [[NSMutableOrderedSet alloc] init];
+    _reactTouches = [[NSMutableArray alloc] init];
+    _touchViews = [[NSMutableArray alloc] init];
+    
+    // `cancelsTouchesInView` is needed in order to be used as a top level event delegated recognizer. Otherwise, lower
+    // level components not build using RCT, will fail to recognize gestures.
+    self.cancelsTouchesInView = NO;
+  }
+  return self;
+}
+
+typedef NS_ENUM(NSInteger, RCTTouchEventType) {
+  RCTTouchEventTypeStart,
+  RCTTouchEventTypeMove,
+  RCTTouchEventTypeEnd,
+  RCTTouchEventTypeCancel
+};
+
+#pragma mark - Bookkeeping for touch indices
+
+- (void)_recordNewTouches:(NSSet *)touches
+{
+  for (UITouch *touch in touches) {
+    
+    RCTAssert(![_nativeTouches containsObject:touch],
+              @"Touch is already recorded. This is a critical bug.");
+    
+    // Find closest React-managed touchable view
+    UIView *targetView = touch.view;
+    while (targetView) {
+      if (targetView.reactTag && targetView.userInteractionEnabled) { // TODO: implement respondsToTouch: mechanism
+        break;
+      }
+      targetView = targetView.superview;
+    }
+    
+    RCTAssert(targetView.reactTag && targetView.userInteractionEnabled,
+              @"No react view found for touch - something went wrong.");
+
+    // Get new, unique touch id
+    const NSUInteger RCTMaxTouches = 11; // This is the maximum supported by iDevices
+    NSInteger touchID = ([_reactTouches.lastObject[@"target"] integerValue] + 1) % RCTMaxTouches;
+    for (NSDictionary *reactTouch in _reactTouches) {
+      NSInteger usedID = [reactTouch[@"target"] integerValue];
+      if (usedID == touchID) {
+        // ID has already been used, try next value
+        touchID ++;
+      } else if (usedID > touchID) {
+        // If usedID > touchID, touchID must be unique, so we can stop looking
+        break;
+      }
+    }
+    
+    // Create touch
+    NSMutableDictionary *reactTouch = [[NSMutableDictionary alloc] initWithCapacity:9];
+    reactTouch[@"target"] = [targetView reactTagAtPoint:[touch locationInView:targetView]];
+    reactTouch[@"identifier"] = @(touchID);
+    reactTouch[@"touches"] = [NSNull null];        // We hijack this touchObj to serve both as an event
+    reactTouch[@"changedTouches"] = [NSNull null]; // and as a Touch object, so making this JIT friendly.
+    
+    // Add to arrays
+    [_touchViews addObject:targetView];
+    [_nativeTouches addObject:touch];
+    [_reactTouches addObject:reactTouch];
+  }
+}
+
+- (void)_recordRemovedTouches:(NSSet *)touches
+{
+  for (UITouch *touch in touches) {
+    NSUInteger index = [_nativeTouches indexOfObject:touch];
+    RCTAssert(index != NSNotFound, @"Touch is already removed. This is a critical bug.");
+    [_touchViews removeObjectAtIndex:index];
+    [_nativeTouches removeObjectAtIndex:index];
+    [_reactTouches removeObjectAtIndex:index];
+  }
+}
+
+- (void)_updateReactTouchAtIndex:(NSInteger)touchIndex
+{
+  UITouch *nativeTouch = _nativeTouches[touchIndex];
+  CGPoint windowLocation = [nativeTouch locationInView:nativeTouch.window];
+  CGPoint rootViewLocation = [nativeTouch.window convertPoint:windowLocation toView:self.view];
+  
+  UIView *touchView = _touchViews[touchIndex];
+  CGPoint touchViewLocation = [nativeTouch.window convertPoint:windowLocation toView:touchView];
+  
+  NSMutableDictionary *reactTouch = _reactTouches[touchIndex];
+  reactTouch[@"pageX"] = @(rootViewLocation.x);
+  reactTouch[@"pageY"] = @(rootViewLocation.y);
+  reactTouch[@"locationX"] = @(touchViewLocation.x);
+  reactTouch[@"locationY"] = @(touchViewLocation.y);
+  reactTouch[@"timestamp"] =  @(nativeTouch.timestamp * 1000); // in ms, for JS
+}
+
+/**
+ * Constructs information about touch events to send across the serialized
+ * boundary. This data should be compliant with W3C `Touch` objects. This data
+ * alone isn't sufficient to construct W3C `Event` objects. To construct that,
+ * there must be a simple receiver on the other side of the bridge that
+ * organizes the touch objects into `Event`s.
+ *
+ * We send the data as an array of `Touch`es, the type of action
+ * (start/end/move/cancel) and the indices that represent "changed" `Touch`es
+ * from that array.
+ */
+- (void)_updateAndDispatchTouches:(NSSet *)touches eventName:(NSString *)eventName
+{
+  // Update touches
+  NSMutableArray *changedIndexes = [[NSMutableArray alloc] init];
+  for (UITouch *touch in touches) {
+    NSInteger index = [_nativeTouches indexOfObject:touch];
+    RCTAssert(index != NSNotFound, @"Touch not found. This is a critical bug.");
+    [self _updateReactTouchAtIndex:index];
+    [changedIndexes addObject:@(index)];
+  }
+  
+  // Deep copy the touches because they will be accessed from another thread
+  // TODO: would it be safer to do this in the bridge or executor, rather than trusting caller?
+  NSMutableArray *reactTouches = [[NSMutableArray alloc] initWithCapacity:_reactTouches.count];
+  for (NSDictionary *touch in _reactTouches) {
+    [reactTouches addObject:[touch copy]];
+  }
+  
+  // Dispatch touch event
+  [_bridge enqueueJSCall:@"RCTEventEmitter.receiveTouches"
+                    args:@[eventName, reactTouches, changedIndexes]];
+}
+
+#pragma mark - Gesture Recognizer Delegate Callbacks
+
+- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
+{
+  [super touchesBegan:touches withEvent:event];
+  self.state = UIGestureRecognizerStateBegan;
+  
+  // "start" has to record new touches before extracting the event.
+  // "end"/"cancel" needs to remove the touch *after* extracting the event.
+  [self _recordNewTouches:touches];
+  [self _updateAndDispatchTouches:touches eventName:@"topTouchStart"];
+}
+
+- (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event
+{
+  [super touchesMoved:touches withEvent:event];
+  if (self.state == UIGestureRecognizerStateFailed) {
+    return;
+  }
+  [self _updateAndDispatchTouches:touches eventName:@"topTouchMove"];
+}
+
+- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event
+{
+  [super touchesEnded:touches withEvent:event];
+  [self _updateAndDispatchTouches:touches eventName:@"topTouchEnd"];
+  [self _recordRemovedTouches:touches];
+}
+
+- (void)touchesCancelled:(NSSet *)touches withEvent:(UIEvent *)event
+{
+  [super touchesCancelled:touches withEvent:event];
+  [self _updateAndDispatchTouches:touches eventName:@"topTouchCancel"];
+  [self _recordRemovedTouches:touches];
+}
+
+- (BOOL)canPreventGestureRecognizer:(UIGestureRecognizer *)preventedGestureRecognizer
+{
+  return NO;
+}
+
+- (BOOL)canBePreventedByGestureRecognizer:(UIGestureRecognizer *)preventingGestureRecognizer
+{
+  return NO;
+}
+
+@end
--- a/ReactKit/Base/RCTUtils.h
+++ b/ReactKit/Base/RCTUtils.h
@@ -0,0 +1,41 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import <CoreGraphics/CoreGraphics.h>
+#import <Foundation/Foundation.h>
+#import <tgmath.h>
+
+#import "RCTAssert.h"
+
+// Macro to indicate when inherited initializer is not to be used
+#define RCT_NOT_DESIGNATED_INITIALIZER() \
+do { \
+  RCTAssert(NO, @"%@ is not the designated initializer for instances of %@.", NSStringFromSelector(_cmd), [self class]); \
+  return nil; \
+} while (0)
+
+// Utility functions for JSON object <-> string serialization/deserialization
+NSString *RCTJSONStringify(id jsonObject, NSError **error);
+id RCTJSONParse(NSString *jsonString, NSError **error);
+
+// Get MD5 hash of a string (TODO: currently unused. Remove?)
+NSString *RCTMD5Hash(NSString *string);
+
+// Get screen metrics in a thread-safe way
+CGFloat RCTScreenScale(void);
+CGSize RCTScreenSize(void);
+
+// Round float coordinates to nearest whole screen pixel (not point)
+CGFloat RCTRoundPixelValue(CGFloat value);
+CGFloat RCTCeilPixelValue(CGFloat value);
+CGFloat RCTFloorPixelValue(CGFloat value);
+
+// Get current time, for precise performance metrics
+NSTimeInterval RCTTGetAbsoluteTime(void);
+
+// Method swizzling
+void RCTSwapClassMethods(Class cls, SEL original, SEL replacement);
+void RCTSwapInstanceMethods(Class cls, SEL original, SEL replacement);
+
+// Module subclass support
+BOOL RCTClassOverridesClassMethod(Class cls, SEL selector);
+BOOL RCTClassOverridesInstanceMethod(Class cls, SEL selector);
--- a/ReactKit/Base/RCTUtils.m
+++ b/ReactKit/Base/RCTUtils.m
@@ -0,0 +1,160 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+#import "RCTUtils.h"
+
+#import <CommonCrypto/CommonCrypto.h>
+#import <mach/mach_time.h>
+#import <objc/runtime.h>
+#import <UIKit/UIKit.h>
+
+NSString *RCTJSONStringify(id jsonObject, NSError **error)
+{
+  NSData *jsonData = [NSJSONSerialization dataWithJSONObject:jsonObject options:0 error:error];
+  return jsonData ? [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding] : nil;
+}
+
+id RCTJSONParse(NSString *jsonString, NSError **error)
+{
+  NSData *jsonData = [jsonString dataUsingEncoding:NSUTF8StringEncoding];
+  return [NSJSONSerialization JSONObjectWithData:jsonData options:NSJSONReadingAllowFragments error:error];
+}
+
+NSString *RCTMD5Hash(NSString *string)
+{
+  const char *str = [string UTF8String];
+  unsigned char result[CC_MD5_DIGEST_LENGTH];
+  CC_MD5(str, (CC_LONG)strlen(str), result);
+
+  return [NSString stringWithFormat:@"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
+          result[0], result[1], result[2], result[3],
+          result[4], result[5], result[6], result[7],
+          result[8], result[9], result[10], result[11],
+          result[12], result[13], result[14], result[15]
+          ];
+}
+
+CGFloat RCTScreenScale()
+{
+  static CGFloat scale;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    if (![NSThread isMainThread]) {
+      dispatch_sync(dispatch_get_main_queue(), ^{
+        scale = [UIScreen mainScreen].scale;
+      });
+    } else {
+      scale = [UIScreen mainScreen].scale;
+    }
+  });
+
+  return scale;
+}
+
+CGSize RCTScreenSize()
+{
+  static CGSize size;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    if (![NSThread isMainThread]) {
+      dispatch_sync(dispatch_get_main_queue(), ^{
+        size = [UIScreen mainScreen].bounds.size;
+      });
+    } else {
+      size = [UIScreen mainScreen].bounds.size;
+    }
+  });
+  
+  return size;
+}
+
+CGFloat RCTRoundPixelValue(CGFloat value)
+{
+  CGFloat scale = RCTScreenScale();
+  return round(value * scale) / scale;
+}
+
+CGFloat RCTCeilPixelValue(CGFloat value)
+{
+  CGFloat scale = RCTScreenScale();
+  return ceil(value * scale) / scale;
+}
+
+CGFloat RCTFloorPixelValue(CGFloat value)
+{
+  CGFloat scale = RCTScreenScale();
+  return floor(value * scale) / scale;
+}
+
+NSTimeInterval RCTTGetAbsoluteTime(void)
+{
+  static struct mach_timebase_info tb_info = {0};
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    int ret = mach_timebase_info(&tb_info);
+    assert(0 == ret);
+  });
+  
+  uint64_t timeInNanoseconds = (mach_absolute_time() * tb_info.numer) / tb_info.denom;
+  return ((NSTimeInterval)timeInNanoseconds) / 1000000;
+}
+
+void RCTSwapClassMethods(Class cls, SEL original, SEL replacement)
+{
+  Method originalMethod = class_getClassMethod(cls, original);
+  IMP originalImplementation = method_getImplementation(originalMethod);
+  const char *originalArgTypes = method_getTypeEncoding(originalMethod);
+  
+  Method replacementMethod = class_getClassMethod(cls, replacement);
+  IMP replacementImplementation = method_getImplementation(replacementMethod);
+  const char *replacementArgTypes = method_getTypeEncoding(replacementMethod);
+  
+  if (class_addMethod(cls, original, replacementImplementation, replacementArgTypes))
+  {
+    class_replaceMethod(cls, replacement, originalImplementation, originalArgTypes);
+  }
+  else
+  {
+    method_exchangeImplementations(originalMethod, replacementMethod);
+  }
+}
+
+void RCTSwapInstanceMethods(Class cls, SEL original, SEL replacement)
+{
+  Method originalMethod = class_getInstanceMethod(cls, original);
+  IMP originalImplementation = method_getImplementation(originalMethod);
+  const char *originalArgTypes = method_getTypeEncoding(originalMethod);
+  
+  Method replacementMethod = class_getInstanceMethod(cls, replacement);
+  IMP replacementImplementation = method_getImplementation(replacementMethod);
+  const char *replacementArgTypes = method_getTypeEncoding(replacementMethod);
+  
+  if (class_addMethod(cls, original, replacementImplementation, replacementArgTypes))
+  {
+    class_replaceMethod(cls, replacement, originalImplementation, originalArgTypes);
+  }
+  else
+  {
+    method_exchangeImplementations(originalMethod, replacementMethod);
+  }
+}
+
+BOOL RCTClassOverridesClassMethod(Class cls, SEL selector)
+{
+  return RCTClassOverridesInstanceMethod(object_getClass(cls), selector);
+}
+
+BOOL RCTClassOverridesInstanceMethod(Class cls, SEL selector)
+{
+  unsigned int numberOfMethods;
+  Method *methods = class_copyMethodList(cls, &numberOfMethods);
+  for (unsigned int i = 0; i < numberOfMethods; i++)
+  {
+    if (method_getName(methods[i]) == selector)
+    {
+      free(methods);
+      return YES;
+    }
+  }
+  return NO;
+}
+
--- a/ReactKit/Base/RCTViewNodeProtocol.h
+++ b/ReactKit/Base/RCTViewNodeProtocol.h
@@ -0,0 +1,26 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+/**
+
+ * Logical node in a tree of application components. Both `ShadowView`s and
+ * `UIView+ReactKit`s conform to this. Allows us to write utilities that
+ * reason about trees generally.
+ */
+@protocol RCTViewNodeProtocol <NSObject>
+
+@property (nonatomic, strong) NSNumber *reactTag;
+
+- (void)insertReactSubview:(id<RCTViewNodeProtocol>)subview atIndex:(NSInteger)atIndex;
+- (void)removeReactSubview:(id<RCTViewNodeProtocol>)subview;
+- (NSMutableArray *)reactSubviews;
+- (NSNumber *)reactTagAtPoint:(CGPoint)point;
+
+// View is an RCTRootView
+- (BOOL)isReactRootView;
+
+@optional
+
+// TODO: Deprecate this
+- (void)reactBridgeDidFinishTransaction;
+
+@end