react-native-tvos 0.78.0-0rc4 → 0.79.0-0

package/React/Fabric/Utils/RCTLinearGradient.mm

@@ -7,7 +7,10 @@
 
 #import "RCTLinearGradient.h"
 
+#import <React/RCTAnimationUtils.h>
 #import <React/RCTConversions.h>
+#include <react/renderer/graphics/ValueUnit.h>
+#import <react/utils/FloatComparison.h>
 
 using namespace facebook::react;
 
@@ -17,22 +20,7 @@ using namespace facebook::react;
 {
   UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc] initWithSize:size];
   const auto &direction = gradient.direction;
-  const auto &colorStops = gradient.colorStops;
-
   UIImage *gradientImage = [renderer imageWithActions:^(UIGraphicsImageRendererContext *_Nonnull rendererContext) {
-    CGContextRef context = rendererContext.CGContext;
-    NSMutableArray *colors = [NSMutableArray array];
-    CGFloat locations[colorStops.size()];
-
-    for (size_t i = 0; i < colorStops.size(); ++i) {
-      const auto &colorStop = colorStops[i];
-      CGColorRef cgColor = RCTCreateCGColorRefFromSharedColor(colorStop.color);
-      [colors addObject:(__bridge id)cgColor];
-      locations[i] = colorStop.position;
-    }
-
-    CGGradientRef cgGradient = CGGradientCreateWithColors(NULL, (__bridge CFArrayRef)colors, locations);
-
     CGPoint startPoint;
     CGPoint endPoint;
 
@@ -49,6 +37,25 @@ using namespace facebook::react;
       endPoint = CGPointMake(0.0, size.height);
     }
 
+    CGFloat dx = endPoint.x - startPoint.x;
+    CGFloat dy = endPoint.y - startPoint.y;
+    CGFloat gradientLineLength = sqrt(dx * dx + dy * dy);
+    const auto processedStops = getFixedColorStops(gradient.colorStops, gradientLineLength);
+    const auto colorStops = processColorTransitionHints(processedStops);
+
+    CGContextRef context = rendererContext.CGContext;
+    NSMutableArray *colors = [NSMutableArray array];
+    CGFloat locations[colorStops.size()];
+
+    for (size_t i = 0; i < colorStops.size(); ++i) {
+      const auto &colorStop = colorStops[i];
+      CGColorRef cgColor = RCTCreateCGColorRefFromSharedColor(colorStop.color);
+      [colors addObject:(__bridge id)cgColor];
+      locations[i] = std::max(std::min(colorStop.position.value(), 1.0), 0.0);
+    }
+
+    CGGradientRef cgGradient = CGGradientCreateWithColors(NULL, (__bridge CFArrayRef)colors, locations);
+
     CGContextDrawLinearGradient(context, cgGradient, startPoint, endPoint, 0);
 
     for (id color in colors) {
@@ -131,4 +138,194 @@ static CGFloat getAngleForKeyword(GradientKeyword keyword, CGSize size)
   }
 }
 
+// Spec: https://drafts.csswg.org/css-images-4/#coloring-gradient-line (Refer transition hint section)
+// Browsers add 9 intermediate color stops when a transition hint is present
+// Algorithm is referred from Blink engine
+// [source](https://github.com/chromium/chromium/blob/a296b1bad6dc1ed9d751b7528f7ca2134227b828/third_party/blink/renderer/core/css/css_gradient_value.cc#L240).
+static std::vector<ProcessedColorStop> processColorTransitionHints(const std::vector<ProcessedColorStop> &originalStops)
+{
+  auto colorStops = std::vector<ProcessedColorStop>(originalStops);
+  int indexOffset = 0;
+
+  for (size_t i = 1; i < originalStops.size() - 1; ++i) {
+    // Skip if not a color hint
+    if (originalStops[i].color) {
+      continue;
+    }
+
+    size_t x = i + indexOffset;
+    if (x < 1) {
+      continue;
+    }
+
+    auto offsetLeft = colorStops[x - 1].position.value();
+    auto offsetRight = colorStops[x + 1].position.value();
+    auto offset = colorStops[x].position.value();
+    auto leftDist = offset - offsetLeft;
+    auto rightDist = offsetRight - offset;
+    auto totalDist = offsetRight - offsetLeft;
+    SharedColor leftSharedColor = colorStops[x - 1].color;
+    SharedColor rightSharedColor = colorStops[x + 1].color;
+
+    if (facebook::react::floatEquality(leftDist, rightDist)) {
+      colorStops.erase(colorStops.begin() + x);
+      --indexOffset;
+      continue;
+    }
+
+    if (facebook::react::floatEquality(leftDist, .0f)) {
+      colorStops[x].color = rightSharedColor;
+      continue;
+    }
+
+    if (facebook::react::floatEquality(rightDist, .0f)) {
+      colorStops[x].color = leftSharedColor;
+      continue;
+    }
+
+    std::vector<ProcessedColorStop> newStops;
+    newStops.reserve(9);
+
+    // Position the new color stops
+    if (leftDist > rightDist) {
+      for (int y = 0; y < 7; ++y) {
+        ProcessedColorStop newStop{SharedColor(), offsetLeft + leftDist * ((7.0f + y) / 13.0f)};
+        newStops.push_back(newStop);
+      }
+      ProcessedColorStop stop1{SharedColor(), offset + rightDist * (1.0f / 3.0f)};
+      ProcessedColorStop stop2{SharedColor(), offset + rightDist * (2.0f / 3.0f)};
+      newStops.push_back(stop1);
+      newStops.push_back(stop2);
+    } else {
+      ProcessedColorStop stop1{SharedColor(), offsetLeft + leftDist * (1.0f / 3.0f)};
+      ProcessedColorStop stop2{SharedColor(), offsetLeft + leftDist * (2.0f / 3.0f)};
+      newStops.push_back(stop1);
+      newStops.push_back(stop2);
+      for (int y = 0; y < 7; ++y) {
+        ProcessedColorStop newStop{SharedColor(), offset + rightDist * (y / 13.0f)};
+        newStops.push_back(newStop);
+      }
+    }
+
+    // calculate colors for the new color hints.
+    // The color weighting for the new color stops will be
+    // pointRelativeOffset^(ln(0.5)/ln(hintRelativeOffset)).
+    auto hintRelativeOffset = leftDist / totalDist;
+    const auto logRatio = log(0.5) / log(hintRelativeOffset);
+    auto leftColor = RCTUIColorFromSharedColor(leftSharedColor);
+    auto rightColor = RCTUIColorFromSharedColor(rightSharedColor);
+    NSArray<NSNumber *> *inputRange = @[ @0.0, @1.0 ];
+    NSArray<UIColor *> *outputRange = @[ leftColor, rightColor ];
+
+    for (auto &newStop : newStops) {
+      auto pointRelativeOffset = (newStop.position.value() - offsetLeft) / totalDist;
+      auto weighting = pow(pointRelativeOffset, logRatio);
+
+      if (!std::isfinite(weighting) || std::isnan(weighting)) {
+        continue;
+      }
+
+      auto interpolatedColor = RCTInterpolateColorInRange(weighting, inputRange, outputRange);
+
+      auto alpha = (interpolatedColor >> 24) & 0xFF;
+      auto red = (interpolatedColor >> 16) & 0xFF;
+      auto green = (interpolatedColor >> 8) & 0xFF;
+      auto blue = interpolatedColor & 0xFF;
+
+      newStop.color = facebook::react::colorFromRGBA(red, green, blue, alpha);
+    }
+
+    // Replace the color hint with new color stops
+    colorStops.erase(colorStops.begin() + x);
+    colorStops.insert(colorStops.begin() + x, newStops.begin(), newStops.end());
+    indexOffset += 8;
+  }
+
+  return colorStops;
+}
+
+// https://drafts.csswg.org/css-images-4/#color-stop-fixup
+static std::vector<ProcessedColorStop> getFixedColorStops(
+    const std::vector<ColorStop> &colorStops,
+    CGFloat gradientLineLength)
+{
+  std::vector<ProcessedColorStop> fixedColorStops(colorStops.size());
+  bool hasNullPositions = false;
+  auto maxPositionSoFar = resolveColorStopPosition(colorStops[0].position, gradientLineLength);
+  if (!maxPositionSoFar.has_value()) {
+    maxPositionSoFar = 0.0f;
+  }
+
+  for (size_t i = 0; i < colorStops.size(); i++) {
+    const auto &colorStop = colorStops[i];
+    auto newPosition = resolveColorStopPosition(colorStop.position, gradientLineLength);
+
+    if (!newPosition.has_value()) {
+      // Step 1:
+      // If the first color stop does not have a position,
+      // set its position to 0%. If the last color stop does not have a position,
+      // set its position to 100%.
+      if (i == 0) {
+        newPosition = 0.0f;
+      } else if (i == colorStops.size() - 1) {
+        newPosition = 1.0f;
+      }
+    }
+
+    // Step 2:
+    // If a color stop or transition hint has a position
+    // that is less than the specified position of any color stop or transition hint
+    // before it in the list, set its position to be equal to the
+    // largest specified position of any color stop or transition hint before it.
+    if (newPosition.has_value()) {
+      newPosition = std::max(newPosition.value(), maxPositionSoFar.value());
+      fixedColorStops[i] = ProcessedColorStop{colorStop.color, newPosition};
+      maxPositionSoFar = newPosition;
+    } else {
+      hasNullPositions = true;
+    }
+  }
+
+  // Step 3:
+  // If any color stop still does not have a position,
+  // then, for each run of adjacent color stops without positions,
+  // set their positions so that they are evenly spaced between the preceding and
+  // following color stops with positions.
+  if (hasNullPositions) {
+    size_t lastDefinedIndex = 0;
+    for (size_t i = 1; i < fixedColorStops.size(); i++) {
+      auto endPosition = fixedColorStops[i].position;
+      if (endPosition.has_value()) {
+        size_t unpositionedStops = i - lastDefinedIndex - 1;
+        if (unpositionedStops > 0) {
+          auto startPosition = fixedColorStops[lastDefinedIndex].position;
+          if (startPosition.has_value()) {
+            auto increment = (endPosition.value() - startPosition.value()) / (unpositionedStops + 1);
+            for (size_t j = 1; j <= unpositionedStops; j++) {
+              fixedColorStops[lastDefinedIndex + j] =
+                  ProcessedColorStop{colorStops[lastDefinedIndex + j].color, startPosition.value() + increment * j};
+            }
+          }
+        }
+        lastDefinedIndex = i;
+      }
+    }
+  }
+
+  return fixedColorStops;
+}
+
+static std::optional<Float> resolveColorStopPosition(ValueUnit position, CGFloat gradientLineLength)
+{
+  if (position.unit == UnitType::Point) {
+    return position.resolve(0.0f) / gradientLineLength;
+  }
+
+  if (position.unit == UnitType::Percent) {
+    return position.resolve(1.0f);
+  }
+
+  return std::nullopt;
+}
+
 @end

package/React/Fabric/Utils/RCTViewFinder.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTViewFinder : NSObject
+
++ (UIView *)findView:(UIView *)root withNativeId:(NSString *)nativeId;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/React/Fabric/Utils/RCTViewFinder.mm

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTViewFinder.h"
+#include <React/RCTViewComponentView.h>
+
+@implementation RCTViewFinder
+
++ (UIView *)findView:(UIView *)root withNativeId:(NSString *)nativeId
+{
+  if (!nativeId) {
+    return nil;
+  }
+
+  if ([root isKindOfClass:[RCTViewComponentView class]] &&
+      [nativeId isEqualToString:((RCTViewComponentView *)root).nativeId]) {
+    return root;
+  }
+
+  for (UIView *subview in root.subviews) {
+    UIView *result = [RCTViewFinder findView:subview withNativeId:nativeId];
+    if (result) {
+      return result;
+    }
+  }
+
+  return nil;
+}
+
+@end

package/React/I18n/FBXXHashUtils.h

@@ -29,39 +29,49 @@
 NS_ASSUME_NONNULL_BEGIN
 
 /// magic constants :-)
-static const uint64_t PRIME1 = 11400714785074694791ULL;
-static const uint64_t PRIME2 = 14029467366897019727ULL;
-static const uint64_t PRIME3 = 1609587929392839161ULL;
-static const uint64_t PRIME4 = 9650029242287828579ULL;
-static const uint64_t PRIME5 = 2870177450012600261ULL;
-
-NS_INLINE uint64_t rotl(uint64_t x, int r)
+static const uint64_t METAXXHASHUTILS_PRIME_1 = 11400714785074694791ULL;
+static const uint64_t METAXXHASHUTILS_PRIME_2 = 14029467366897019727ULL;
+static const uint64_t METAXXHASHUTILS_PRIME_3 = 1609587929392839161ULL;
+static const uint64_t METAXXHASHUTILS_PRIME_4 = 9650029242287828579ULL;
+static const uint64_t METAXXHASHUTILS_PRIME_5 = 2870177450012600261ULL;
+
+#define METAXXHASHUTILS_INLINE_ATTRS \
+        NS_SWIFT_UNAVAILABLE("You'll need to bridge to C/ObjC to use this API.") \
+        NS_INLINE
+
+METAXXHASHUTILS_INLINE_ATTRS
+uint64_t rotl(uint64_t x, int r)
 {
   return ((x << r) | (x >> (64 - r)));
 }
 
-NS_INLINE uint64_t mix1(const uint64_t h, const uint64_t prime, int rshift)
+METAXXHASHUTILS_INLINE_ATTRS
+uint64_t mix1(const uint64_t h, const uint64_t prime, int rshift)
 {
   return (h ^ (h >> rshift)) * prime;
 }
 
-NS_INLINE uint64_t mix2(const uint64_t p, const uint64_t v)
+METAXXHASHUTILS_INLINE_ATTRS
+uint64_t mix2(const uint64_t p, const uint64_t v)
 {
-  return rotl(v + p * PRIME2, 31) * PRIME1;
+  return rotl(v + p * METAXXHASHUTILS_PRIME_2, 31) * METAXXHASHUTILS_PRIME_1;
 }
 
-NS_INLINE uint64_t mix3(const uint64_t h, const uint64_t v)
+METAXXHASHUTILS_INLINE_ATTRS
+uint64_t mix3(const uint64_t h, const uint64_t v)
 {
-  return (h ^ mix2(v, 0)) * PRIME1 + PRIME4;
+  return (h ^ mix2(v, 0)) * METAXXHASHUTILS_PRIME_1 + METAXXHASHUTILS_PRIME_4;
 }
 
-NS_INLINE uint32_t endian32(const char *v)
+METAXXHASHUTILS_INLINE_ATTRS
+uint32_t endian32(const char *v)
 {
   return (uint32_t)((uint8_t)(v[0])) | ((uint32_t)((uint8_t)(v[1])) << 8)
   | ((uint32_t)((uint8_t)(v[2])) << 16) | ((uint32_t)((uint8_t)(v[3])) << 24);
 }
 
-NS_INLINE uint64_t endian64(const char *v)
+METAXXHASHUTILS_INLINE_ATTRS
+uint64_t endian64(const char *v)
 {
   return (uint64_t)((uint8_t)(v[0])) | ((uint64_t)((uint8_t)(v[1])) << 8)
   | ((uint64_t)((uint8_t)(v[2])) << 16) | ((uint64_t)((uint8_t)(v[3])) << 24)
@@ -69,50 +79,58 @@ NS_INLINE uint64_t endian64(const char *v)
   | ((uint64_t)((uint8_t)(v[6])) << 48) | ((uint64_t)((uint8_t)(v[7])) << 56);
 }
 
-NS_INLINE uint64_t fetch64(const char *p, const uint64_t v)
+METAXXHASHUTILS_INLINE_ATTRS
+uint64_t fetch64(const char *p, const uint64_t v)
 {
   return mix2(endian64(p), v);
 }
 
-NS_INLINE uint64_t fetch32(const char *p)
+METAXXHASHUTILS_INLINE_ATTRS
+uint64_t fetch32(const char *p)
 {
-  return (uint64_t)(endian32(p)) * PRIME1;
+  return (uint64_t)(endian32(p)) * METAXXHASHUTILS_PRIME_1;
 }
 
-NS_INLINE uint64_t fetch8(const char *p)
+METAXXHASHUTILS_INLINE_ATTRS
+uint64_t fetch8(const char *p)
 {
-  return (uint8_t)(*p) * PRIME5;
+  return (uint8_t)(*p) * METAXXHASHUTILS_PRIME_5;
 }
 
-NS_INLINE uint64_t finalize(const uint64_t h, const char *p, uint64_t len)
+METAXXHASHUTILS_INLINE_ATTRS
+uint64_t finalize(const uint64_t h, const char *p, uint64_t len)
 {
-  return (len >= 8) ? (finalize(rotl(h ^ fetch64(p, 0), 27) * PRIME1 + PRIME4, p + 8, len - 8))
-  : ((len >= 4) ? (finalize(rotl(h ^ fetch32(p), 23) * PRIME2 + PRIME3, p + 4, len - 4))
-      : ((len > 0) ? (finalize(rotl(h ^ fetch8(p), 11) * PRIME1, p + 1, len - 1))
-          : (mix1(mix1(mix1(h, PRIME2, 33), PRIME3, 29), 1, 32))));
+  return (len >= 8) ? (finalize(rotl(h ^ fetch64(p, 0), 27) * METAXXHASHUTILS_PRIME_1 + METAXXHASHUTILS_PRIME_4, p + 8, len - 8))
+  : ((len >= 4) ? (finalize(rotl(h ^ fetch32(p), 23) * METAXXHASHUTILS_PRIME_2 + METAXXHASHUTILS_PRIME_3, p + 4, len - 4))
+      : ((len > 0) ? (finalize(rotl(h ^ fetch8(p), 11) * METAXXHASHUTILS_PRIME_1, p + 1, len - 1))
+          : (mix1(mix1(mix1(h, METAXXHASHUTILS_PRIME_2, 33), METAXXHASHUTILS_PRIME_3, 29), 1, 32))));
 }
 
-NS_INLINE uint64_t h32bytes_compute(const char *p, uint64_t len, const uint64_t v1, const uint64_t v2, const uint64_t v3, const uint64_t v4)
+METAXXHASHUTILS_INLINE_ATTRS
+uint64_t h32bytes_compute(const char *p, uint64_t len, const uint64_t v1, const uint64_t v2, const uint64_t v3, const uint64_t v4)
 {
   return (len >= 32) ? h32bytes_compute(p + 32, len - 32, fetch64(p, v1), fetch64(p + 8, v2), fetch64(p + 16, v3), fetch64(p + 24, v4))
   : mix3(mix3(mix3(mix3(rotl(v1, 1) + rotl(v2, 7) + rotl(v3, 12) + rotl(v4, 18), v1), v2), v3), v4);
 }
 
-NS_INLINE uint64_t h32bytes(const char *p, uint64_t len, const uint64_t seed)
+METAXXHASHUTILS_INLINE_ATTRS
+uint64_t h32bytes(const char *p, uint64_t len, const uint64_t seed)
 {
-  return h32bytes_compute(p, len, seed + PRIME1 + PRIME2, seed + PRIME2, seed, seed - PRIME1);
+  return h32bytes_compute(p, len, seed + METAXXHASHUTILS_PRIME_1 + METAXXHASHUTILS_PRIME_2, seed + METAXXHASHUTILS_PRIME_2, seed, seed - METAXXHASHUTILS_PRIME_1);
 }
 
 /*
   Primary APIs
  */
 
-NS_INLINE uint64_t meta_xxhash64(const char *p, uint64_t len, uint64_t seed)
+METAXXHASHUTILS_INLINE_ATTRS
+uint64_t meta_xxhash64(const char *p, uint64_t len, uint64_t seed)
 {
-  return finalize((len >= 32 ? h32bytes(p, len, seed) : seed + PRIME5) + len, p + (len & ~0x1FULL), len & 0x1FULL);
+  return finalize((len >= 32 ? h32bytes(p, len, seed) : seed + METAXXHASHUTILS_PRIME_5) + len, p + (len & ~0x1FULL), len & 0x1FULL);
 }
 
-NS_INLINE uint64_t FBxxHash64(const char *p, uint64_t len, uint64_t seed)
+METAXXHASHUTILS_INLINE_ATTRS
+uint64_t FBxxHash64(const char *p, uint64_t len, uint64_t seed)
 {
   return meta_xxhash64(p, len, seed);
 }

package/React/Inspector/RCTCxxInspectorWebSocketAdapter.mm

@@ -19,8 +19,6 @@
 
 using namespace facebook::react::jsinspector_modern;
 
-static const uint64_t MAX_CONNECTING_TIME_NS = 2 * 1000000000L;
-
 namespace {
 NSString *NSStringFromUTF8StringView(std::string_view view)
 {
@@ -41,15 +39,6 @@ NSString *NSStringFromUTF8StringView(std::string_view view)
     _webSocket = [[SRWebSocket alloc] initWithURL:[NSURL URLWithString:NSStringFromUTF8StringView(url)]];
     _webSocket.delegate = self;
     [_webSocket open];
-    uint64_t startTime = clock_gettime_nsec_np(CLOCK_MONOTONIC_RAW);
-    while ([_webSocket readyState] == SR_CONNECTING) {
-      if ((clock_gettime_nsec_np(CLOCK_MONOTONIC_RAW) - startTime) > MAX_CONNECTING_TIME_NS) {
-        break;
-      }
-    }
-    if ([_webSocket readyState] != SR_OPEN) {
-      return nil;
-    }
   }
   return self;
 }
@@ -71,6 +60,14 @@ NSString *NSStringFromUTF8StringView(std::string_view view)
   [_webSocket closeWithCode:1000 reason:@"End of session"];
 }
 
+- (void)webSocketDidOpen:(__unused SRWebSocket *)webSocket
+{
+  // NOTE: We are on the main queue here, per SRWebSocket's defaults.
+  if (auto delegate = _delegate.lock()) {
+    delegate->didOpen();
+  }
+}
+
 - (void)webSocket:(__unused SRWebSocket *)webSocket didFailWithError:(NSError *)error
 {
   // NOTE: We are on the main queue here, per SRWebSocket's defaults.

package/React/React-RCTFBReactNativeSpec.podspec

@@ -62,12 +62,7 @@ Pod::Spec.new do |s|
   add_dependency(s, "ReactCommon", :subspec => "turbomodule/core", :additional_framework_paths => ["react/nativemodule/core"])
   add_dependency(s, "ReactCommon", :subspec => "turbomodule/bridging", :additional_framework_paths => ["react/nativemodule/bridging"])
 
-  if ENV["USE_HERMES"] == nil || ENV["USE_HERMES"] == "1"
-    s.dependency "hermes-engine"
-  else
-    s.dependency "React-jsc"
-  end
-
+  depend_on_js_engine(s)
 
   s.script_phases = [
     {

package/React/React-RCTFabric.podspec

@@ -99,14 +99,12 @@ Pod::Spec.new do |s|
   add_dependency(s, "React-rendererdebug")
   add_dependency(s, "React-rendererconsistency")
   add_dependency(s, "React-runtimescheduler")
+  add_dependency(s, "React-RCTAnimation", :framework_name => 'RCTAnimation')
   add_dependency(s, "React-jsinspector", :framework_name => 'jsinspector_modern')
   add_dependency(s, "React-jsinspectortracing", :framework_name => 'jsinspector_moderntracing')
+  add_dependency(s, "React-renderercss")
 
-  if ENV["USE_HERMES"] == nil || ENV["USE_HERMES"] == "1"
-    s.dependency "hermes-engine"
-  else
-    s.dependency "React-jsc"
-  end
+  depend_on_js_engine(s)
 
   s.test_spec 'Tests' do |test_spec|
     test_spec.source_files = "Tests/**/*.{mm}"

package/React/Runtime/RCTHermesInstanceFactory.h

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <react/runtime/JSRuntimeFactoryCAPI.h>
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+JSRuntimeFactoryRef jsrt_create_hermes_factory(void);
+
+#ifdef __cplusplus
+}
+#endif

package/React/Runtime/RCTHermesInstanceFactory.mm

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTHermesInstanceFactory.h"
+#import <ReactCommon/RCTHermesInstance.h>
+
+using namespace facebook::react;
+
+extern "C" {
+
+JSRuntimeFactoryRef jsrt_create_hermes_factory(void)
+{
+  return reinterpret_cast<JSRuntimeFactoryRef>(new RCTHermesInstance(nullptr, /* allocInOldGenBeforeTTI */ false));
+}
+
+} // extern "C"

package/React/Runtime/RCTJscInstanceFactory.h

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <react/runtime/JSRuntimeFactoryCAPI.h>
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+JSRuntimeFactoryRef jsrt_create_jsc_factory(void);
+
+#ifdef __cplusplus
+}
+#endif

package/React/Runtime/RCTJscInstanceFactory.mm

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTJscInstanceFactory.h"
+#import <ReactCommon/RCTJscInstance.h>
+
+using namespace facebook::react;
+
+extern "C" {
+
+JSRuntimeFactoryRef jsrt_create_jsc_factory(void)
+{
+  return reinterpret_cast<JSRuntimeFactoryRef>(new RCTJscInstance());
+}
+
+} // extern "C"