react-native 0.71.6 → 0.72.0-rc.1

package/Libraries/LogBox/UI/LogBoxMessage.js

@@ -11,6 +11,8 @@
 import type {TextStyleProp} from '../../StyleSheet/StyleSheet';
 import type {Message} from '../Data/parseLogBoxLog';
 
+import Linking from '../../Linking/Linking';
+import StyleSheet from '../../StyleSheet/StyleSheet';
 import Text from '../../Text/Text';
 import * as React from 'react';
 
@@ -22,6 +24,82 @@ type Props = {
   ...
 };
 
+type Range = {
+  lowerBound: number,
+  upperBound: number,
+};
+
+function getLinkRanges(string: string): $ReadOnlyArray<Range> {
+  const regex = /https?:\/\/[^\s$.?#].[^\s]*/gi;
+  const matches = [];
+
+  let regexResult: RegExp$matchResult | null;
+  while ((regexResult = regex.exec(string)) !== null) {
+    if (regexResult != null) {
+      matches.push({
+        lowerBound: regexResult.index,
+        upperBound: regex.lastIndex,
+      });
+    }
+  }
+
+  return matches;
+}
+
+function TappableLinks(props: {
+  content: string,
+  style: void | TextStyleProp,
+}): React.Node {
+  const matches = getLinkRanges(props.content);
+
+  if (matches.length === 0) {
+    // No URLs detected. Just return the content.
+    return <Text style={props.style}>{props.content}</Text>;
+  }
+
+  // URLs were detected. Construct array of Text nodes.
+
+  let fragments: Array<React.Node> = [];
+  let indexCounter = 0;
+  let startIndex = 0;
+
+  for (const linkRange of matches) {
+    if (startIndex < linkRange.lowerBound) {
+      const text = props.content.substring(startIndex, linkRange.lowerBound);
+      fragments.push(<Text key={++indexCounter}>{text}</Text>);
+    }
+
+    const link = props.content.substring(
+      linkRange.lowerBound,
+      linkRange.upperBound,
+    );
+    fragments.push(
+      <Text
+        onPress={() => {
+          // $FlowFixMe[unused-promise]
+          Linking.openURL(link);
+        }}
+        key={++indexCounter}
+        style={styles.linkText}>
+        {link}
+      </Text>,
+    );
+
+    startIndex = linkRange.upperBound;
+  }
+
+  if (startIndex < props.content.length) {
+    const text = props.content.substring(startIndex);
+    fragments.push(
+      <Text key={++indexCounter} style={props.style}>
+        {text}
+      </Text>,
+    );
+  }
+
+  return <Text style={props.style}>{fragments}</Text>;
+}
+
 const cleanContent = (content: string) =>
   content.replace(/^(TransformError |Warning: (Warning: )?|Error: )/g, '');
 
@@ -49,9 +127,7 @@ function LogBoxMessage(props: Props): React.Node {
 
     if (length < maxLength) {
       elements.push(
-        <Text key={key} style={style}>
-          {cleanMessage}
-        </Text>,
+        <TappableLinks content={cleanMessage} key={key} style={style} />,
       );
     }
 
@@ -70,12 +146,12 @@ function LogBoxMessage(props: Props): React.Node {
       createUnderLength(key, prevPart);
     }
 
-    const substititionPart = content.substr(
+    const substitutionPart = content.substr(
       substitution.offset,
       substitution.length,
     );
 
-    createUnderLength(key + '.5', substititionPart, substitutionStyle);
+    createUnderLength(key + '.5', substitutionPart, substitutionStyle);
     return substitution.offset + substitution.length;
   }, 0);
 
@@ -87,4 +163,10 @@ function LogBoxMessage(props: Props): React.Node {
   return <>{elements}</>;
 }
 
+const styles = StyleSheet.create({
+  linkText: {
+    textDecorationLine: 'underline',
+  },
+});
+
 export default LogBoxMessage;

package/Libraries/LogBox/UI/LogBoxNotification.js

@@ -21,13 +21,13 @@ import LogBoxMessage from './LogBoxMessage';
 import * as LogBoxStyle from './LogBoxStyle';
 import * as React from 'react';
 
-type Props = $ReadOnly<{|
+type Props = $ReadOnly<{
   log: LogBoxLog,
   totalLogCount: number,
   level: 'warn' | 'error',
   onPressOpen: () => void,
   onPressDismiss: () => void,
-|}>;
+}>;
 
 function LogBoxLogNotification(props: Props): React.Node {
   const {totalLogCount, level, log} = props;
@@ -56,9 +56,7 @@ function LogBoxLogNotification(props: Props): React.Node {
   );
 }
 
-function CountBadge(
-  props: $TEMPORARY$object<{count: number, level: 'error' | 'warn'}>,
-) {
+function CountBadge(props: {count: number, level: 'error' | 'warn'}) {
   return (
     <View style={countStyles.outside}>
       {/* $FlowFixMe[incompatible-type] (>=0.114.0) This suppression was added
@@ -73,7 +71,7 @@ function CountBadge(
   );
 }
 
-function Message(props: $TEMPORARY$object<{message: MessageType}>) {
+function Message(props: {message: MessageType}) {
   return (
     <View style={messageStyles.container}>
       <Text numberOfLines={1} style={messageStyles.text}>
@@ -89,7 +87,7 @@ function Message(props: $TEMPORARY$object<{message: MessageType}>) {
   );
 }
 
-function DismissButton(props: $TEMPORARY$object<{onPress: () => void}>) {
+function DismissButton(props: {onPress: () => void}) {
   return (
     <View style={dismissStyles.container}>
       <LogBoxButton

package/Libraries/Modal/Modal.js

@@ -13,11 +13,11 @@ import type {RootTag} from '../ReactNative/RootTag';
 import type {DirectEventHandler} from '../Types/CodegenTypes';
 
 import NativeEventEmitter from '../EventEmitter/NativeEventEmitter';
-import {VirtualizedListContextResetter} from '../Lists/VirtualizedListContext.js';
 import {type EventSubscription} from '../vendor/emitter/EventEmitter';
 import ModalInjection from './ModalInjection';
 import NativeModalManager from './NativeModalManager';
 import RCTModalHostView from './RCTModalHostViewNativeComponent';
+import {VirtualizedListContextResetter} from '@react-native/virtualized-lists';
 
 const ScrollView = require('../Components/ScrollView/ScrollView');
 const View = require('../Components/View/View');
@@ -91,7 +91,7 @@ export type Props = $ReadOnly<{|
    * The `statusBarTranslucent` prop determines whether your modal should go under
    * the system statusbar.
    *
-   * See https://reactnative.dev/docs/modal#transparent
+   * See https://reactnative.dev/docs/modal.html#statusbartranslucent-android
    */
   statusBarTranslucent?: ?boolean,
 

package/Libraries/NativeAnimation/Nodes/RCTColorAnimatedNode.m

@@ -8,6 +8,8 @@
 #import <React/RCTColorAnimatedNode.h>
 #import <React/RCTValueAnimatedNode.h>
 
+#import <React/RCTAnimationUtils.h>
+
 @implementation RCTColorAnimatedNode
 
 - (void)performUpdate
@@ -19,8 +21,7 @@
   RCTValueAnimatedNode *bNode = (RCTValueAnimatedNode *)[self.parentNodes objectForKey:self.config[@"b"]];
   RCTValueAnimatedNode *aNode = (RCTValueAnimatedNode *)[self.parentNodes objectForKey:self.config[@"a"]];
 
-  _color = ((int)round(aNode.value * 255) & 0xff) << 24 | ((int)round(rNode.value) & 0xff) << 16 |
-      ((int)round(gNode.value) & 0xff) << 8 | ((int)round(bNode.value) & 0xff);
+  _color = RCTColorFromComponents(rNode.value, gNode.value, bNode.value, aNode.value);
 
   // TODO (T111179606): Support platform colors for color animations
 }

package/Libraries/NativeAnimation/Nodes/RCTInterpolationAnimatedNode.h

@@ -7,6 +7,20 @@
 
 #import "RCTValueAnimatedNode.h"
 
+#import <React/RCTDefines.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+RCT_EXTERN NSString *RCTInterpolateString(
+    NSString *pattern,
+    CGFloat inputValue,
+    NSArray *inputRange,
+    NSArray<NSArray<NSNumber *> *> *outputRange,
+    NSString *extrapolateLeft,
+    NSString *extrapolateRight);
+
 @interface RCTInterpolationAnimatedNode : RCTValueAnimatedNode
 
 @end
+
+NS_ASSUME_NONNULL_END

package/Libraries/NativeAnimation/Nodes/RCTInterpolationAnimatedNode.m

@@ -8,91 +8,116 @@
 #import <React/RCTInterpolationAnimatedNode.h>
 
 #import <React/RCTAnimationUtils.h>
+#import <React/RCTConvert.h>
 
 static NSRegularExpression *regex;
 
+typedef NS_ENUM(NSInteger, RCTInterpolationOutputType) {
+  RCTInterpolationOutputNumber,
+  RCTInterpolationOutputColor,
+  RCTInterpolationOutputString,
+};
+
+static NSRegularExpression *getNumericComponentRegex()
+{
+  static NSRegularExpression *regex;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    NSString *fpRegex = @"[+-]?(\\d+\\.?\\d*|\\.\\d+)([eE][+-]?\\d+)?";
+    regex = [NSRegularExpression regularExpressionWithPattern:fpRegex
+                                                      options:NSRegularExpressionCaseInsensitive
+                                                        error:nil];
+  });
+  return regex;
+}
+
+static NSArray<NSArray<NSNumber *> *> *outputFromStringPattern(NSString *input)
+{
+  NSMutableArray *output = [NSMutableArray array];
+  [getNumericComponentRegex()
+      enumerateMatchesInString:input
+                       options:0
+                         range:NSMakeRange(0, input.length)
+                    usingBlock:^(NSTextCheckingResult *_Nullable result, NSMatchingFlags flags, BOOL *_Nonnull stop) {
+                      [output addObject:@([[input substringWithRange:result.range] doubleValue])];
+                    }];
+  return output;
+}
+
+NSString *RCTInterpolateString(
+    NSString *pattern,
+    CGFloat inputValue,
+    NSArray<NSNumber *> *inputRange,
+    NSArray<NSArray<NSNumber *> *> *outputRange,
+    NSString *extrapolateLeft,
+    NSString *extrapolateRight)
+{
+  NSUInteger rangeIndex = RCTFindIndexOfNearestValue(inputValue, inputRange);
+
+  NSMutableString *output = [NSMutableString stringWithString:pattern];
+  NSArray<NSTextCheckingResult *> *matches =
+      [getNumericComponentRegex() matchesInString:pattern options:0 range:NSMakeRange(0, pattern.length)];
+  NSInteger matchIndex = matches.count - 1;
+  for (NSTextCheckingResult *match in [matches reverseObjectEnumerator]) {
+    CGFloat val = RCTInterpolateValue(
+        inputValue,
+        [inputRange[rangeIndex] doubleValue],
+        [inputRange[rangeIndex + 1] doubleValue],
+        [outputRange[rangeIndex][matchIndex] doubleValue],
+        [outputRange[rangeIndex + 1][matchIndex] doubleValue],
+        extrapolateLeft,
+        extrapolateRight);
+    [output replaceCharactersInRange:match.range withString:[@(val) stringValue]];
+    matchIndex--;
+  }
+  return output;
+}
+
 @implementation RCTInterpolationAnimatedNode {
   __weak RCTValueAnimatedNode *_parentNode;
   NSArray<NSNumber *> *_inputRange;
-  NSArray<NSNumber *> *_outputRange;
-  NSArray<NSArray<NSNumber *> *> *_outputs;
-  NSArray<NSString *> *_soutputRange;
+  NSArray *_outputRange;
   NSString *_extrapolateLeft;
   NSString *_extrapolateRight;
-  NSUInteger _numVals;
-  bool _hasStringOutput;
-  bool _shouldRound;
+  RCTInterpolationOutputType _outputType;
+  id _Nullable _outputvalue;
+  NSString *_Nullable _outputPattern;
+
   NSArray<NSTextCheckingResult *> *_matches;
 }
 
 - (instancetype)initWithTag:(NSNumber *)tag config:(NSDictionary<NSString *, id> *)config
 {
-  static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^{
-    NSString *fpRegex = @"[+-]?(\\d+\\.?\\d*|\\.\\d+)([eE][+-]?\\d+)?";
-    regex = [NSRegularExpression regularExpressionWithPattern:fpRegex
-                                                      options:NSRegularExpressionCaseInsensitive
-                                                        error:nil];
-  });
   if ((self = [super initWithTag:tag config:config])) {
-    _inputRange = [config[@"inputRange"] copy];
-    NSMutableArray *outputRange = [NSMutableArray array];
-    NSMutableArray *soutputRange = [NSMutableArray array];
-    NSMutableArray<NSMutableArray<NSNumber *> *> *_outputRanges = [NSMutableArray array];
-
-    _hasStringOutput = NO;
-    for (id value in config[@"outputRange"]) {
-      if ([value isKindOfClass:[NSNumber class]]) {
-        [outputRange addObject:value];
-      } else if ([value isKindOfClass:[NSString class]]) {
-        /**
-         * Supports string shapes by extracting numbers so new values can be computed,
-         * and recombines those values into new strings of the same shape.  Supports
-         * things like:
-         *
-         *   rgba(123, 42, 99, 0.36) // colors
-         *   -45deg                  // values with units
-         */
-        NSMutableArray *output = [NSMutableArray array];
-        [_outputRanges addObject:output];
-        [soutputRange addObject:value];
-
-        _matches = [regex matchesInString:value options:0 range:NSMakeRange(0, [value length])];
-        for (NSTextCheckingResult *match in _matches) {
-          NSString *strNumber = [value substringWithRange:match.range];
-          [output addObject:[NSNumber numberWithDouble:strNumber.doubleValue]];
-        }
+    _inputRange = config[@"inputRange"];
 
-        _hasStringOutput = YES;
-        [outputRange addObject:[output objectAtIndex:0]];
-      }
+    NSArray *outputRangeConfig = config[@"outputRange"];
+    if ([config[@"outputType"] isEqual:@"color"]) {
+      _outputType = RCTInterpolationOutputColor;
+    } else if ([outputRangeConfig[0] isKindOfClass:[NSString class]]) {
+      _outputType = RCTInterpolationOutputString;
+      _outputPattern = outputRangeConfig[0];
+    } else {
+      _outputType = RCTInterpolationOutputNumber;
     }
-    if (_hasStringOutput) {
-      // ['rgba(0, 100, 200, 0)', 'rgba(50, 150, 250, 0.5)']
-      // ->
-      // [
-      //   [0, 50],
-      //   [100, 150],
-      //   [200, 250],
-      //   [0, 0.5],
-      // ]
-      _numVals = [_matches count];
-      NSString *value = [soutputRange objectAtIndex:0];
-      _shouldRound = [value containsString:@"rgb"];
-      _matches = [regex matchesInString:value options:0 range:NSMakeRange(0, [value length])];
-      NSMutableArray<NSMutableArray<NSNumber *> *> *outputs = [NSMutableArray arrayWithCapacity:_numVals];
-      NSUInteger size = [soutputRange count];
-      for (NSUInteger j = 0; j < _numVals; j++) {
-        NSMutableArray *output = [NSMutableArray arrayWithCapacity:size];
-        [outputs addObject:output];
-        for (int i = 0; i < size; i++) {
-          [output addObject:[[_outputRanges objectAtIndex:i] objectAtIndex:j]];
+
+    NSMutableArray *outputRange = [NSMutableArray arrayWithCapacity:outputRangeConfig.count];
+    for (id value in outputRangeConfig) {
+      switch (_outputType) {
+        case RCTInterpolationOutputColor: {
+          UIColor *color = [RCTConvert UIColor:value];
+          [outputRange addObject:color ? color : [UIColor whiteColor]];
+          break;
         }
+        case RCTInterpolationOutputString:
+          [outputRange addObject:outputFromStringPattern(value)];
+          break;
+        case RCTInterpolationOutputNumber:
+          [outputRange addObject:value];
+          break;
       }
-      _outputs = [outputs copy];
     }
-    _outputRange = [outputRange copy];
-    _soutputRange = [soutputRange copy];
+    _outputRange = outputRange;
     _extrapolateLeft = config[@"extrapolateLeft"];
     _extrapolateRight = config[@"extrapolateRight"];
   }
@@ -123,43 +148,24 @@ static NSRegularExpression *regex;
   }
 
   CGFloat inputValue = _parentNode.value;
-
-  CGFloat interpolated =
-      RCTInterpolateValueInRange(inputValue, _inputRange, _outputRange, _extrapolateLeft, _extrapolateRight);
-  self.value = interpolated;
-  if (_hasStringOutput) {
-    // 'rgba(0, 100, 200, 0)'
-    // ->
-    // 'rgba(${interpolations[0](input)}, ${interpolations[1](input)}, ...'
-    if (_numVals > 1) {
-      NSString *text = _soutputRange[0];
-      NSMutableString *formattedText = [NSMutableString stringWithString:text];
-      NSUInteger i = _numVals;
-      for (NSTextCheckingResult *match in [_matches reverseObjectEnumerator]) {
-        CGFloat val =
-            RCTInterpolateValueInRange(inputValue, _inputRange, _outputs[--i], _extrapolateLeft, _extrapolateRight);
-        NSString *str;
-        if (_shouldRound) {
-          // rgba requires that the r,g,b are integers.... so we want to round them, but we *dont* want to
-          // round the opacity (4th column).
-          bool isAlpha = i == 3;
-          CGFloat rounded = isAlpha ? round(val * 1000) / 1000 : round(val);
-          str = isAlpha ? [NSString stringWithFormat:@"%1.3f", rounded] : [NSString stringWithFormat:@"%1.0f", rounded];
-        } else {
-          NSNumber *numberValue = [NSNumber numberWithDouble:val];
-          str = [numberValue stringValue];
-        }
-
-        [formattedText replaceCharactersInRange:[match range] withString:str];
-      }
-      self.animatedObject = formattedText;
-    } else {
-      self.animatedObject = [regex stringByReplacingMatchesInString:_soutputRange[0]
-                                                            options:0
-                                                              range:NSMakeRange(0, _soutputRange[0].length)
-                                                       withTemplate:[NSString stringWithFormat:@"%1f", interpolated]];
-    }
+  switch (_outputType) {
+    case RCTInterpolationOutputColor:
+      _outputvalue = @(RCTInterpolateColorInRange(inputValue, _inputRange, _outputRange));
+      break;
+    case RCTInterpolationOutputString:
+      _outputvalue = RCTInterpolateString(
+          _outputPattern, inputValue, _inputRange, _outputRange, _extrapolateLeft, _extrapolateRight);
+      break;
+    case RCTInterpolationOutputNumber:
+      self.value =
+          RCTInterpolateValueInRange(inputValue, _inputRange, _outputRange, _extrapolateLeft, _extrapolateRight);
+      break;
   }
 }
 
+- (id)animatedObject
+{
+  return _outputvalue;
+}
+
 @end

package/Libraries/NativeAnimation/Nodes/RCTPropsAnimatedNode.m

@@ -76,7 +76,7 @@
 {
   if (_managedByFabric) {
     // Restoring to default values causes render of inconsistent state
-    // to the user because it isn't synchonised with Fabric's UIManager.
+    // to the user because it isn't synchronised with Fabric's UIManager.
     return;
   }
   // Restore the default value for all props that were modified by this node.

package/Libraries/NativeAnimation/Nodes/RCTStyleAnimatedNode.m

@@ -38,7 +38,12 @@
     if (node) {
       if ([node isKindOfClass:[RCTValueAnimatedNode class]]) {
         RCTValueAnimatedNode *valueAnimatedNode = (RCTValueAnimatedNode *)node;
-        _propsDictionary[property] = @(valueAnimatedNode.value);
+        id animatedObject = valueAnimatedNode.animatedObject;
+        if (animatedObject) {
+          _propsDictionary[property] = animatedObject;
+        } else {
+          _propsDictionary[property] = @(valueAnimatedNode.value);
+        }
       } else if ([node isKindOfClass:[RCTTransformAnimatedNode class]]) {
         RCTTransformAnimatedNode *transformAnimatedNode = (RCTTransformAnimatedNode *)node;
         [_propsDictionary addEntriesFromDictionary:transformAnimatedNode.propsDictionary];

package/Libraries/NativeAnimation/Nodes/RCTValueAnimatedNode.h

@@ -24,7 +24,7 @@
 - (void)extractOffset;
 
 @property (nonatomic, assign) CGFloat value;
-@property (nonatomic, strong) id animatedObject;
+@property (nonatomic, strong, readonly) id animatedObject;
 @property (nonatomic, weak) id<RCTValueAnimatedNodeObserver> valueObserver;
 
 @end

package/Libraries/NativeAnimation/Nodes/RCTValueAnimatedNode.m

@@ -43,6 +43,11 @@
   return _value + _offset;
 }
 
+- (id)animatedObject
+{
+  return nil;
+}
+
 - (void)setValue:(CGFloat)value
 {
   _value = value;

package/Libraries/NativeAnimation/RCTAnimationUtils.h

@@ -10,16 +10,11 @@
 
 #import <React/RCTDefines.h>
 
-static NSString *const EXTRAPOLATE_TYPE_IDENTITY = @"identity";
-static NSString *const EXTRAPOLATE_TYPE_CLAMP = @"clamp";
-static NSString *const EXTRAPOLATE_TYPE_EXTEND = @"extend";
+RCT_EXTERN NSString *const EXTRAPOLATE_TYPE_IDENTITY;
+RCT_EXTERN NSString *const EXTRAPOLATE_TYPE_CLAMP;
+RCT_EXTERN NSString *const EXTRAPOLATE_TYPE_EXTEND;
 
-RCT_EXTERN CGFloat RCTInterpolateValueInRange(
-    CGFloat value,
-    NSArray<NSNumber *> *inputRange,
-    NSArray<NSNumber *> *outputRange,
-    NSString *extrapolateLeft,
-    NSString *extrapolateRight);
+RCT_EXTERN NSUInteger RCTFindIndexOfNearestValue(CGFloat value, NSArray<NSNumber *> *range);
 
 RCT_EXTERN CGFloat RCTInterpolateValue(
     CGFloat value,
@@ -30,8 +25,18 @@ RCT_EXTERN CGFloat RCTInterpolateValue(
     NSString *extrapolateLeft,
     NSString *extrapolateRight);
 
-RCT_EXTERN CGFloat RCTRadiansToDegrees(CGFloat radians);
-RCT_EXTERN CGFloat RCTDegreesToRadians(CGFloat degrees);
+RCT_EXTERN CGFloat RCTInterpolateValueInRange(
+    CGFloat value,
+    NSArray<NSNumber *> *inputRange,
+    NSArray<NSNumber *> *outputRange,
+    NSString *extrapolateLeft,
+    NSString *extrapolateRight);
+
+RCT_EXTERN uint32_t
+RCTInterpolateColorInRange(CGFloat value, NSArray<NSNumber *> *inputRange, NSArray<UIColor *> *outputRange);
+
+// Represents a color as a int32_t. RGB components are assumed to be in [0-255] range and alpha in [0-1] range
+RCT_EXTERN uint32_t RCTColorFromComponents(CGFloat red, CGFloat green, CGFloat blue, CGFloat alpha);
 
 /**
  * Coefficient to slow down animations, respects the ios

package/Libraries/NativeAnimation/RCTAnimationUtils.m

@@ -9,7 +9,11 @@
 
 #import <React/RCTLog.h>
 
-static NSUInteger _RCTFindIndexOfNearestValue(CGFloat value, NSArray<NSNumber *> *range)
+NSString *const EXTRAPOLATE_TYPE_IDENTITY = @"identity";
+NSString *const EXTRAPOLATE_TYPE_CLAMP = @"clamp";
+NSString *const EXTRAPOLATE_TYPE_EXTEND = @"extend";
+
+NSUInteger RCTFindIndexOfNearestValue(CGFloat value, NSArray<NSNumber *> *range)
 {
   NSUInteger index;
   NSUInteger rangeCount = range.count;
@@ -71,7 +75,7 @@ CGFloat RCTInterpolateValueInRange(
     NSString *extrapolateLeft,
     NSString *extrapolateRight)
 {
-  NSUInteger rangeIndex = _RCTFindIndexOfNearestValue(value, inputRange);
+  NSUInteger rangeIndex = RCTFindIndexOfNearestValue(value, inputRange);
   CGFloat inputMin = inputRange[rangeIndex].doubleValue;
   CGFloat inputMax = inputRange[rangeIndex + 1].doubleValue;
   CGFloat outputMin = outputRange[rangeIndex].doubleValue;
@@ -80,14 +84,28 @@ CGFloat RCTInterpolateValueInRange(
   return RCTInterpolateValue(value, inputMin, inputMax, outputMin, outputMax, extrapolateLeft, extrapolateRight);
 }
 
-CGFloat RCTRadiansToDegrees(CGFloat radians)
+uint32_t RCTInterpolateColorInRange(CGFloat value, NSArray<NSNumber *> *inputRange, NSArray<UIColor *> *outputRange)
 {
-  return radians * 180.0 / M_PI;
+  NSUInteger rangeIndex = RCTFindIndexOfNearestValue(value, inputRange);
+  CGFloat inputMin = inputRange[rangeIndex].doubleValue;
+  CGFloat inputMax = inputRange[rangeIndex + 1].doubleValue;
+
+  CGFloat redMin, greenMin, blueMin, alphaMin;
+  [outputRange[rangeIndex] getRed:&redMin green:&greenMin blue:&blueMin alpha:&alphaMin];
+  CGFloat redMax, greenMax, blueMax, alphaMax;
+  [outputRange[rangeIndex + 1] getRed:&redMax green:&greenMax blue:&blueMax alpha:&alphaMax];
+
+  return RCTColorFromComponents(
+      0xFF * (redMin + (value - inputMin) * (redMax - redMin) / (inputMax - inputMin)),
+      0xFF * (greenMin + (value - inputMin) * (greenMax - greenMin) / (inputMax - inputMin)),
+      0xFF * (blueMin + (value - inputMin) * (blueMax - blueMin) / (inputMax - inputMin)),
+      alphaMin + (value - inputMin) * (alphaMax - alphaMin) / (inputMax - inputMin));
 }
 
-CGFloat RCTDegreesToRadians(CGFloat degrees)
+uint32_t RCTColorFromComponents(CGFloat red, CGFloat green, CGFloat blue, CGFloat alpha)
 {
-  return degrees / 180.0 * M_PI;
+  return ((uint32_t)round(alpha * 255) & 0xFF) << 24 | ((uint32_t)round(red) & 0xFF) << 16 |
+      ((uint32_t)round(green) & 0xFF) << 8 | ((uint32_t)round(blue) & 0xFF);
 }
 
 #if TARGET_IPHONE_SIMULATOR

package/Libraries/NativeAnimation/React-RCTAnimation.podspec

@@ -19,13 +19,26 @@ end
 folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
 folly_version = '2021.07.22.00'
 
+header_search_paths = [
+  "\"$(PODS_ROOT)/RCT-Folly\"",
+  "\"${PODS_ROOT}/Headers/Public/React-Codegen/react/renderer/components\"",
+  "\"${PODS_CONFIGURATION_BUILD_DIR}/React-Codegen/React_Codegen.framework/Headers\""
+]
+
+if ENV["USE_FRAMEWORKS"]
+  header_search_paths = header_search_paths.concat([
+    "\"$(PODS_CONFIGURATION_BUILD_DIR)/ReactCommon/ReactCommon.framework/Headers/react/nativemodule/core\"",
+    "\"$(PODS_CONFIGURATION_BUILD_DIR)/React-NativeModulesApple/React_NativeModulesApple.framework/Headers\""
+  ])
+end
+
 Pod::Spec.new do |s|
   s.name                   = "React-RCTAnimation"
   s.version                = version
   s.summary                = "A native driver for the Animated API."
   s.homepage               = "https://reactnative.dev/"
   s.license                = package["license"]
-  s.author                 = "Facebook, Inc. and its affiliates"
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
   s.platforms              = { :ios => "12.4" }
   s.compiler_flags         = folly_compiler_flags + ' -Wno-nullability-completeness'
   s.source                 = source
@@ -35,7 +48,7 @@ Pod::Spec.new do |s|
   s.pod_target_xcconfig    = {
                                "USE_HEADERMAP" => "YES",
                                "CLANG_CXX_LANGUAGE_STANDARD" => "c++17",
-                               "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/RCT-Folly\" \"${PODS_ROOT}/Headers/Public/React-Codegen/react/renderer/components\" \"${PODS_CONFIGURATION_BUILD_DIR}/React-Codegen/React_Codegen.framework/Headers\""
+                               "HEADER_SEARCH_PATHS" => header_search_paths.join(" ")
                              }
 
   s.dependency "RCT-Folly", folly_version