react-native 0.84.0-nightly-20251216-c16eb23a1 → 0.84.0-nightly-20251218-c7f433a41

package/ReactCommon/react/nativemodule/samples/ReactCommon-Samples.podspec

@@ -53,6 +53,7 @@ Pod::Spec.new do |s|
   s.dependency "React-Core"
   s.dependency "React-cxxreact"
   s.dependency "React-jsi"
+  s.dependency "RCTTypeSafety"
   add_dependency(s, "React-RCTFBReactNativeSpec")
   add_dependency(s, "ReactCommon", :subspec => "turbomodule/core", :additional_framework_paths => ["react/nativemodule/core"])
   add_dependency(s, "React-NativeModulesApple")

package/ReactCommon/react/nativemodule/samples/platform/android/NativeSampleTurboModuleSpec.java

@@ -9,6 +9,7 @@
 
 package com.facebook.fbreact.specs;
 
+import com.facebook.proguard.annotations.DoNotStrip;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
@@ -52,13 +53,14 @@ public abstract class NativeSampleTurboModuleSpec extends ReactContextBaseJavaMo
     mEventEmitterCallback.invoke("onChange", value);
   }
 
-  protected void emitOnSubmit(ReadableArray value) {
+  protected final void emitOnSubmit(ReadableArray value) {
     mEventEmitterCallback.invoke("onSubmit", value);
   }
 
   protected abstract Map<String, Object> getTypedExportedConstants();
 
   @Override
+  @DoNotStrip
   public final @Nullable Map<String, Object> getConstants() {
     Map<String, Object> constants = getTypedExportedConstants();
     if (ReactBuildConfig.DEBUG || ReactBuildConfig.IS_INTERNAL_BUILD) {
@@ -70,78 +72,97 @@ public abstract class NativeSampleTurboModuleSpec extends ReactContextBaseJavaMo
       undeclaredConstants.removeAll(optionalFlowConstants);
       if (!undeclaredConstants.isEmpty()) {
         throw new IllegalStateException(
-            "Native Module Flow doesn't declare constants: " + undeclaredConstants);
+            String.format("Native Module Flow doesn't declare constants: %s", undeclaredConstants));
       }
       undeclaredConstants = obligatoryFlowConstants;
       undeclaredConstants.removeAll(constants.keySet());
       if (!undeclaredConstants.isEmpty()) {
         throw new IllegalStateException(
-            "Native Module doesn't fill in constants: " + undeclaredConstants);
+            String.format("Native Module doesn't fill in constants: %s", undeclaredConstants));
       }
     }
     return constants;
   }
 
   @ReactMethod
+  @DoNotStrip
   public abstract void voidFunc();
 
   @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
   public abstract boolean getBool(boolean arg);
 
   @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
   public double getEnum(double arg) {
     return 0;
   }
 
   @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
   public abstract double getNumber(double arg);
 
   @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
   public abstract String getString(String arg);
 
   @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
   public abstract WritableArray getArray(ReadableArray arg);
 
   @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
   public abstract WritableMap getObject(ReadableMap arg);
 
   @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
   public abstract WritableMap getUnsafeObject(ReadableMap arg);
 
   @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
   public abstract double getRootTag(double arg);
 
   @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
   public abstract WritableMap getValue(double x, String y, ReadableMap z);
 
   @ReactMethod
+  @DoNotStrip
   public abstract void getValueWithCallback(Callback callback);
 
   @ReactMethod
+  @DoNotStrip
   public abstract void getValueWithPromise(boolean error, Promise promise);
 
   @ReactMethod
+  @DoNotStrip
   public void voidFuncThrows() {}
 
   @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
   public WritableMap getObjectThrows(ReadableMap arg) {
     return null;
   }
 
   @ReactMethod
+  @DoNotStrip
   public void promiseThrows(Promise promise) {}
 
   @ReactMethod
+  @DoNotStrip
   public void voidFuncAssert() {}
 
   @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
   public WritableMap getObjectAssert(ReadableMap arg) {
     return null;
   }
 
   @ReactMethod
+  @DoNotStrip
   public void promiseAssert(Promise promise) {}
 
   @ReactMethod
+  @DoNotStrip
   public void getImageUrl(Promise promise) {}
 }

package/ReactCommon/react/nativemodule/samples/platform/ios/ReactCommon/RCTNativeSampleTurboModuleSpec.h

@@ -9,17 +9,80 @@
 
 #import <vector>
 
-#import <Foundation/Foundation.h>
+#ifndef __cplusplus
+#error This file must be compiled as Obj-C++. If you are importing it, you must change your file extension to .mm.
+#endif
 
+#import <Foundation/Foundation.h>
+#import <RCTRequired/RCTRequired.h>
+#import <RCTTypeSafety/RCTConvertHelpers.h>
+#import <RCTTypeSafety/RCTTypedModuleConstants.h>
 #import <React/RCTBridgeModule.h>
-
 #import <ReactCommon/RCTTurboModule.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
-/**
- * The ObjC protocol based on the JS Flow type for SampleTurboModule.
- */
+namespace JS::NativeSampleTurboModule {
+struct Constants {
+  struct Builder {
+    using ResultT = Constants;
+
+    struct Input {
+      RCTRequired<bool> const1;
+      RCTRequired<double> const2;
+      RCTRequired<NSString *> const3;
+    };
+
+    /** Initialize with a set of values */
+    Builder(const Input i);
+    /** Initialize with an existing Constants */
+    Builder(Constants i);
+    /** Builds the object. Generally used only by the infrastructure. */
+    NSDictionary *buildUnsafeRawValue() const
+    {
+      return _factory();
+    };
+
+   private:
+    NSDictionary * (^_factory)(void);
+  };
+
+  static Constants fromUnsafeRawValue(NSDictionary *const v)
+  {
+    return {v};
+  }
+  NSDictionary *unsafeRawValue() const
+  {
+    return _v;
+  }
+
+ private:
+  Constants(NSDictionary *const v) : _v(v) {}
+  NSDictionary *_v;
+};
+
+} // namespace JS::NativeSampleTurboModule
+
+inline JS::NativeSampleTurboModule::Constants::Builder::Builder(const Input i)
+    : _factory(^{
+        NSMutableDictionary *d = [NSMutableDictionary new];
+        auto const1 = i.const1.get();
+        d[@"const1"] = @(const1);
+        auto const2 = i.const2.get();
+        d[@"const2"] = @(const2);
+        auto const3 = i.const3.get();
+        d[@"const3"] = const3;
+        return d;
+      })
+{
+}
+inline JS::NativeSampleTurboModule::Constants::Builder::Builder(Constants i)
+    : _factory(^{
+        return i.unsafeRawValue();
+      })
+{
+}
+
 @protocol NativeSampleTurboModuleSpec <RCTBridgeModule, RCTTurboModule>
 
 - (void)voidFunc;
@@ -40,8 +103,9 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)voidFuncAssert;
 - (NSDictionary *)getObjectAssert:(NSDictionary *)arg;
 - (void)promiseAssert:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject;
-- (NSDictionary *)constantsToExport;
-- (NSDictionary *)getConstants;
+- (void)getImageUrl:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject;
+- (facebook::react::ModuleConstants<JS::NativeSampleTurboModule::Constants>)constantsToExport;
+- (facebook::react::ModuleConstants<JS::NativeSampleTurboModule::Constants>)getConstants;
 
 @end
 
@@ -49,23 +113,22 @@ NS_ASSUME_NONNULL_BEGIN
  @protected
   facebook::react::EventEmitterCallback _eventEmitterCallback;
 }
-- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *_Nonnull)eventEmitterCallbackWrapper;
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper;
+
 - (void)emitOnPress;
-- (void)emitOnClick:(NSString *)value;
+- (void)emitOnClick:(NSString *_Nonnull)value;
 - (void)emitOnChange:(NSDictionary *)value;
-- (void)emitOnSubmit:(NSArray *)value;
+- (void)emitOnSubmit:(NSArray<id<NSObject>> *)value;
 @end
 
 namespace facebook::react {
-
 /**
- * The iOS TurboModule impl specific to SampleTurboModule.
+ * ObjC++ class for module 'NativeSampleTurboModule'
  */
 class JSI_EXPORT NativeSampleTurboModuleSpecJSI : public ObjCTurboModule {
  public:
   NativeSampleTurboModuleSpecJSI(const ObjCTurboModule::InitParams &params);
 };
-
 } // namespace facebook::react
 
 NS_ASSUME_NONNULL_END

package/ReactCommon/react/nativemodule/samples/platform/ios/ReactCommon/RCTNativeSampleTurboModuleSpec.mm

@@ -7,6 +7,30 @@
 
 #import "RCTNativeSampleTurboModuleSpec.h"
 
+@implementation NativeSampleTurboModuleSpecBase
+- (void)emitOnPress
+{
+  _eventEmitterCallback("onPress", nil);
+}
+- (void)emitOnClick:(NSString *_Nonnull)value
+{
+  _eventEmitterCallback("onClick", value);
+}
+- (void)emitOnChange:(NSDictionary *)value
+{
+  _eventEmitterCallback("onChange", value);
+}
+- (void)emitOnSubmit:(NSArray<id<NSObject>> *)value
+{
+  _eventEmitterCallback("onSubmit", value);
+}
+
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper
+{
+  _eventEmitterCallback = std::move(eventEmitterCallbackWrapper->_eventEmitterCallback);
+}
+@end
+
 namespace facebook::react {
 
 static facebook::jsi::Value __hostFunction_NativeSampleTurboModuleSpecJSI_voidFunc(
@@ -190,6 +214,16 @@ static facebook::jsi::Value __hostFunction_NativeSampleTurboModuleSpecJSI_promis
       .invokeObjCMethod(rt, PromiseKind, "promiseAssert", @selector(promiseAssert:reject:), args, count);
 }
 
+static facebook::jsi::Value __hostFunction_NativeSampleTurboModuleSpecJSI_getImageUrl(
+    facebook::jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const facebook::jsi::Value *args,
+    size_t count)
+{
+  return static_cast<ObjCTurboModule &>(turboModule)
+      .invokeObjCMethod(rt, PromiseKind, "getImageUrl", @selector(getImageUrl:reject:), args, count);
+}
+
 static facebook::jsi::Value __hostFunction_NativeSampleTurboModuleSpecJSI_getConstants(
     facebook::jsi::Runtime &rt,
     TurboModule &turboModule,
@@ -203,44 +237,48 @@ static facebook::jsi::Value __hostFunction_NativeSampleTurboModuleSpecJSI_getCon
 NativeSampleTurboModuleSpecJSI::NativeSampleTurboModuleSpecJSI(const ObjCTurboModule::InitParams &params)
     : ObjCTurboModule(params)
 {
-  methodMap_["voidFunc"] =
-      MethodMetadata{.argCount = 0, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_voidFunc};
-  methodMap_["getBool"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getBool};
-  methodMap_["getEnum"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getEnum};
-  methodMap_["getNumber"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getNumber};
-  methodMap_["getString"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getString};
-  methodMap_["getArray"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getArray};
-  methodMap_["getObject"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getObject};
-  methodMap_["getUnsafeObject"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getUnsafeObject};
-  methodMap_["getRootTag"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getRootTag};
-  methodMap_["getValue"] =
-      MethodMetadata{.argCount = 3, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getValue};
+  methodMap_["voidFunc"] = MethodMetadata{0, __hostFunction_NativeSampleTurboModuleSpecJSI_voidFunc};
+
+  methodMap_["getBool"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getBool};
+
+  methodMap_["getEnum"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getEnum};
+
+  methodMap_["getNumber"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getNumber};
+
+  methodMap_["getString"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getString};
+
+  methodMap_["getArray"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getArray};
+
+  methodMap_["getObject"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getObject};
+
+  methodMap_["getUnsafeObject"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getUnsafeObject};
+
+  methodMap_["getRootTag"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getRootTag};
+
+  methodMap_["getValue"] = MethodMetadata{3, __hostFunction_NativeSampleTurboModuleSpecJSI_getValue};
+
   methodMap_["getValueWithCallback"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getValueWithCallback};
+      MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getValueWithCallback};
+
   methodMap_["getValueWithPromise"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getValueWithPromise};
-  methodMap_["voidFuncThrows"] =
-      MethodMetadata{.argCount = 0, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_voidFuncThrows};
-  methodMap_["getObjectThrows"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getObjectThrows};
-  methodMap_["promiseThrows"] =
-      MethodMetadata{.argCount = 0, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_promiseThrows};
-  methodMap_["voidFuncAssert"] =
-      MethodMetadata{.argCount = 0, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_voidFuncAssert};
-  methodMap_["getObjectAssert"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getObjectAssert};
-  methodMap_["promiseAssert"] =
-      MethodMetadata{.argCount = 0, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_promiseAssert};
-  methodMap_["getConstants"] =
-      MethodMetadata{.argCount = 0, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getConstants};
+      MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getValueWithPromise};
+
+  methodMap_["voidFuncThrows"] = MethodMetadata{0, __hostFunction_NativeSampleTurboModuleSpecJSI_voidFuncThrows};
+
+  methodMap_["getObjectThrows"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getObjectThrows};
+
+  methodMap_["promiseThrows"] = MethodMetadata{0, __hostFunction_NativeSampleTurboModuleSpecJSI_promiseThrows};
+
+  methodMap_["voidFuncAssert"] = MethodMetadata{0, __hostFunction_NativeSampleTurboModuleSpecJSI_voidFuncAssert};
+
+  methodMap_["getObjectAssert"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getObjectAssert};
+
+  methodMap_["promiseAssert"] = MethodMetadata{0, __hostFunction_NativeSampleTurboModuleSpecJSI_promiseAssert};
+
+  methodMap_["getImageUrl"] = MethodMetadata{0, __hostFunction_NativeSampleTurboModuleSpecJSI_getImageUrl};
+
+  methodMap_["getConstants"] = MethodMetadata{0, __hostFunction_NativeSampleTurboModuleSpecJSI_getConstants};
+
   eventEmitterMap_["onPress"] = std::make_shared<AsyncEventEmitter<id>>();
   eventEmitterMap_["onClick"] = std::make_shared<AsyncEventEmitter<id>>();
   eventEmitterMap_["onChange"] = std::make_shared<AsyncEventEmitter<id>>();
@@ -249,32 +287,4 @@ NativeSampleTurboModuleSpecJSI::NativeSampleTurboModuleSpecJSI(const ObjCTurboMo
     static_cast<AsyncEventEmitter<id> &>(*eventEmitterMap_[name]).emit(value);
   });
 }
-
 } // namespace facebook::react
-
-@implementation NativeSampleTurboModuleSpecBase
-- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *_Nonnull)eventEmitterCallbackWrapper
-{
-  _eventEmitterCallback = std::move(eventEmitterCallbackWrapper->_eventEmitterCallback);
-}
-
-- (void)emitOnPress
-{
-  _eventEmitterCallback("onPress", nil);
-}
-
-- (void)emitOnClick:(NSString *)value
-{
-  _eventEmitterCallback("onClick", value);
-}
-
-- (void)emitOnChange:(NSDictionary *)value
-{
-  _eventEmitterCallback("onChange", value);
-}
-
-- (void)emitOnSubmit:(NSArray *)value
-{
-  _eventEmitterCallback("onSubmit", value);
-}
-@end

package/ReactCommon/react/nativemodule/samples/platform/ios/ReactCommon/RCTSampleTurboModule.mm

@@ -20,7 +20,7 @@ using namespace facebook::react;
 @end
 
 @implementation RCTSampleTurboModule {
-  NSDictionary *_constants;
+  facebook::react::ModuleConstants<JS::NativeSampleTurboModule::Constants> _constants;
 }
 
 // Backward-compatible export
@@ -37,11 +37,11 @@ RCT_EXPORT_MODULE()
   UIScreen *mainScreen = UIScreen.mainScreen;
   CGSize screenSize = mainScreen.bounds.size;
 
-  _constants = @{
-    @"const1" : @YES,
-    @"const2" : @(screenSize.width),
-    @"const3" : @"something",
-  };
+  _constants = facebook::react::typedConstants<JS::NativeSampleTurboModule::Constants>({
+      .const1 = YES,
+      .const2 = screenSize.width,
+      .const3 = @"something",
+  });
 }
 
 - (dispatch_queue_t)methodQueue
@@ -62,15 +62,19 @@ RCT_EXPORT_MODULE()
   NSLog(@"Invalidating RCTSampleTurboModule...");
 }
 
-- (NSDictionary *)getConstants
+- (facebook::react::ModuleConstants<JS::NativeSampleTurboModule::Constants>)constantsToExport
+{
+  return _constants;
+}
+
+- (facebook::react::ModuleConstants<JS::NativeSampleTurboModule::Constants>)getConstants
 {
   return _constants;
 }
 
-// TODO: Remove once fully migrated to TurboModule.
-- (NSDictionary *)constantsToExport
+- (void)getImageUrl:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
 {
-  return [self getConstants];
+  reject(@"Exception", @"Not implemented", nil);
 }
 
 #pragma mark - RCTTurboModuleWithJSIBindings
@@ -168,7 +172,7 @@ RCT_EXPORT_METHOD(
 
 RCT_EXPORT_METHOD(voidFuncThrows)
 {
-  NSException *myException = [NSException exceptionWithName:@"Excepption"
+  NSException *myException = [NSException exceptionWithName:@"Exception"
                                                      reason:@"Intentional exception from ObjC voidFuncThrows"
                                                    userInfo:nil];
   @throw myException;
@@ -176,7 +180,7 @@ RCT_EXPORT_METHOD(voidFuncThrows)
 
 RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSDictionary *, getObjectThrows : (NSDictionary *)arg)
 {
-  NSException *myException = [NSException exceptionWithName:@"Excepption"
+  NSException *myException = [NSException exceptionWithName:@"Exception"
                                                      reason:@"Intentional exception from ObjC getObjectThrows"
                                                    userInfo:nil];
   @throw myException;
@@ -184,7 +188,7 @@ RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSDictionary *, getObjectThrows : (NSDiction
 
 RCT_EXPORT_METHOD(promiseThrows : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject)
 {
-  NSException *myException = [NSException exceptionWithName:@"Excepption"
+  NSException *myException = [NSException exceptionWithName:@"Exception"
                                                      reason:@"Intentional exception from ObjC promiseThrows"
                                                    userInfo:nil];
   @throw myException;

package/ReactCommon/react/networking/NetworkReporter.cpp

@@ -168,9 +168,16 @@ void NetworkReporter::reportDataReceived(
     int dataLength,
     const std::optional<int>& encodedDataLength) {
 #ifdef REACT_NATIVE_DEBUGGER_ENABLED
+  auto now = HighResTimeStamp::now();
+
   // Debugger enabled: CDP event handling
   jsinspector_modern::NetworkHandler::getInstance().onDataReceived(
       requestId, dataLength, encodedDataLength.value_or(dataLength));
+
+  // Debugger enabled: Add trace event to Performance timeline
+  jsinspector_modern::tracing::PerformanceTracer::getInstance()
+      .reportResourceReceivedData(
+          requestId, now, encodedDataLength.value_or(dataLength));
 #endif
 }
 

package/ReactCommon/react/renderer/animationbackend/AnimatedPropSerializer.cpp

@@ -110,6 +110,94 @@ void packShadowRadius(
   dyn.insert("shadowRadius", get<Float>(animatedProp));
 }
 
+void packBorderColorEdge(
+    folly::dynamic& dyn,
+    const std::string& propName,
+    const std::optional<SharedColor>& colorValue) {
+  if (colorValue.has_value() && colorValue.value()) {
+    dyn.insert(propName, static_cast<int32_t>(*colorValue.value()));
+  }
+}
+
+void packBorderColor(
+    folly::dynamic& dyn,
+    const AnimatedPropBase& animatedProp) {
+  const auto& borderColors = get<CascadedBorderColors>(animatedProp);
+
+  packBorderColorEdge(dyn, "borderLeftColor", borderColors.left);
+  packBorderColorEdge(dyn, "borderTopColor", borderColors.top);
+  packBorderColorEdge(dyn, "borderRightColor", borderColors.right);
+  packBorderColorEdge(dyn, "borderBottomColor", borderColors.bottom);
+  packBorderColorEdge(dyn, "borderStartColor", borderColors.start);
+  packBorderColorEdge(dyn, "borderEndColor", borderColors.end);
+
+  if (borderColors.all.has_value() && borderColors.all.value()) {
+    dyn.insert("borderColor", static_cast<int32_t>(*borderColors.all.value()));
+  }
+}
+
+void packFilter(folly::dynamic& dyn, const AnimatedPropBase& animatedProp) {
+  const auto& filters = get<std::vector<FilterFunction>>(animatedProp);
+  auto filterArray = folly::dynamic::array();
+  for (const auto& f : filters) {
+    folly::dynamic filterObj = folly::dynamic::object();
+    std::string typeKey = toString(f.type);
+    if (std::holds_alternative<Float>(f.parameters)) {
+      filterObj[typeKey] = std::get<Float>(f.parameters);
+    } else if (std::holds_alternative<DropShadowParams>(f.parameters)) {
+      const auto& dropShadowParams = std::get<DropShadowParams>(f.parameters);
+      folly::dynamic shadowObj = folly::dynamic::object();
+      shadowObj["offsetX"] = dropShadowParams.offsetX;
+      shadowObj["offsetY"] = dropShadowParams.offsetY;
+      shadowObj["standardDeviation"] = dropShadowParams.standardDeviation;
+      shadowObj["color"] = static_cast<int32_t>(*dropShadowParams.color);
+      filterObj[typeKey] = shadowObj;
+    }
+    filterArray.push_back(filterObj);
+  }
+  dyn.insert("filter", filterArray);
+}
+
+void packOutlineColor(
+    folly::dynamic& dyn,
+    const AnimatedPropBase& animatedProp) {
+  const auto& outlineColor = get<SharedColor>(animatedProp);
+  dyn.insert("outlineColor", static_cast<int32_t>(*outlineColor));
+}
+
+void packOutlineOffset(
+    folly::dynamic& dyn,
+    const AnimatedPropBase& animatedProp) {
+  dyn.insert("outlineOffset", get<Float>(animatedProp));
+}
+
+void packOutlineStyle(
+    folly::dynamic& dyn,
+    const AnimatedPropBase& animatedProp) {
+  const auto& outlineStyle = get<OutlineStyle>(animatedProp);
+  std::string styleStr;
+  switch (outlineStyle) {
+    case OutlineStyle::Solid:
+      styleStr = "solid";
+      break;
+    case OutlineStyle::Dotted:
+      styleStr = "dotted";
+      break;
+    case OutlineStyle::Dashed:
+      styleStr = "dashed";
+      break;
+    default:
+      throw std::runtime_error("Unknown outline style");
+  }
+  dyn.insert("outlineStyle", styleStr);
+}
+
+void packOutlineWidth(
+    folly::dynamic& dyn,
+    const AnimatedPropBase& animatedProp) {
+  dyn.insert("outlineWidth", get<Float>(animatedProp));
+}
+
 void packAnimatedProp(
     folly::dynamic& dyn,
     const std::unique_ptr<AnimatedPropBase>& animatedProp) {
@@ -146,12 +234,37 @@ void packAnimatedProp(
       packShadowRadius(dyn, *animatedProp);
       break;
 
+    case BORDER_COLOR:
+      packBorderColor(dyn, *animatedProp);
+      break;
+
+    case FILTER:
+      packFilter(dyn, *animatedProp);
+      break;
+
+    case OUTLINE_COLOR:
+      packOutlineColor(dyn, *animatedProp);
+      break;
+
+    case OUTLINE_OFFSET:
+      packOutlineOffset(dyn, *animatedProp);
+      break;
+
+    case OUTLINE_STYLE:
+      packOutlineStyle(dyn, *animatedProp);
+      break;
+
+    case OUTLINE_WIDTH:
+      packOutlineWidth(dyn, *animatedProp);
+      break;
+
     case WIDTH:
     case HEIGHT:
     case FLEX:
     case PADDING:
     case MARGIN:
     case POSITION:
+    case BORDER_WIDTH:
       throw std::runtime_error("Tried to synchronously update layout props");
   }
 }