@react-native-oh/react-native-harmony 0.72.86 → 0.77.18-1

package/Libraries/NativeAnimation/Nodes/RCTAnimatedNode.mm

@@ -0,0 +1,126 @@
+/*
+ * 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/RCTAnimatedNode.h>
+
+#import <React/RCTDefines.h>
+
+@implementation RCTAnimatedNode {
+  NSMapTable<NSNumber *, RCTAnimatedNode *> *_childNodes;
+  NSMapTable<NSNumber *, RCTAnimatedNode *> *_parentNodes;
+}
+
+- (instancetype)initWithTag:(NSNumber *)tag config:(NSDictionary<NSString *, id> *)config
+{
+  if ((self = [super init])) {
+    _nodeTag = tag;
+    _config = [config copy];
+  }
+  return self;
+}
+
+RCT_NOT_IMPLEMENTED(-(instancetype)init)
+
+- (NSMapTable<NSNumber *, RCTAnimatedNode *> *)childNodes
+{
+  return _childNodes;
+}
+
+- (NSMapTable<NSNumber *, RCTAnimatedNode *> *)parentNodes
+{
+  return _parentNodes;
+}
+
+- (void)addChild:(RCTAnimatedNode *)child
+{
+  if (!_childNodes) {
+    _childNodes = [NSMapTable strongToWeakObjectsMapTable];
+  }
+  if (child) {
+    [_childNodes setObject:child forKey:child.nodeTag];
+    [child onAttachedToNode:self];
+  }
+}
+
+- (void)removeChild:(RCTAnimatedNode *)child
+{
+  if (!_childNodes) {
+    return;
+  }
+  if (child) {
+    [_childNodes removeObjectForKey:child.nodeTag];
+    [child onDetachedFromNode:self];
+  }
+}
+
+- (void)onAttachedToNode:(RCTAnimatedNode *)parent
+{
+  if (!_parentNodes) {
+    _parentNodes = [NSMapTable strongToWeakObjectsMapTable];
+  }
+  if (parent) {
+    [_parentNodes setObject:parent forKey:parent.nodeTag];
+  }
+}
+
+- (void)onDetachedFromNode:(RCTAnimatedNode *)parent
+{
+  if (!_parentNodes) {
+    return;
+  }
+  if (parent) {
+    [_parentNodes removeObjectForKey:parent.nodeTag];
+  }
+}
+
+- (void)detachNode
+{
+  for (RCTAnimatedNode *parent in _parentNodes.objectEnumerator) {
+    [parent removeChild:self];
+  }
+  for (RCTAnimatedNode *child in _childNodes.objectEnumerator) {
+    [self removeChild:child];
+  }
+}
+
+- (void)setNeedsUpdate
+{
+  _needsUpdate = YES;
+  for (RCTAnimatedNode *child in _childNodes.objectEnumerator) {
+    [child setNeedsUpdate];
+  }
+}
+
+- (void)updateNodeIfNecessary
+{
+  if (_needsUpdate) {
+    for (RCTAnimatedNode *parent in _parentNodes.objectEnumerator) {
+      [parent updateNodeIfNecessary];
+    }
+    [self performUpdate];
+  }
+}
+
+- (void)performUpdate
+{
+  _needsUpdate = NO;
+  // To be overridden by subclasses
+  // This method is called on a node only if it has been marked for update
+  // during the current update loop
+}
+
+- (BOOL)isManagedByFabric
+{
+  for (RCTAnimatedNode *child in _childNodes.objectEnumerator) {
+    if ([child isManagedByFabric]) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+@end

package/Libraries/NativeAnimation/Nodes/RCTColorAnimatedNode.h

@@ -0,0 +1,14 @@
+/*
+ * 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/RCTAnimatedNode.h>
+
+@interface RCTColorAnimatedNode : RCTAnimatedNode
+
+@property (nonatomic, assign) int32_t color;
+
+@end

package/Libraries/NativeAnimation/Nodes/RCTColorAnimatedNode.mm

@@ -0,0 +1,29 @@
+/*
+ * 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/RCTColorAnimatedNode.h>
+#import <React/RCTValueAnimatedNode.h>
+
+#import <React/RCTAnimationUtils.h>
+
+@implementation RCTColorAnimatedNode
+
+- (void)performUpdate
+{
+  [super performUpdate];
+
+  RCTValueAnimatedNode *rNode = (RCTValueAnimatedNode *)[self.parentNodes objectForKey:self.config[@"r"]];
+  RCTValueAnimatedNode *gNode = (RCTValueAnimatedNode *)[self.parentNodes objectForKey:self.config[@"g"]];
+  RCTValueAnimatedNode *bNode = (RCTValueAnimatedNode *)[self.parentNodes objectForKey:self.config[@"b"]];
+  RCTValueAnimatedNode *aNode = (RCTValueAnimatedNode *)[self.parentNodes objectForKey:self.config[@"a"]];
+
+  _color = RCTColorFromComponents(rNode.value, gNode.value, bNode.value, aNode.value);
+
+  // TODO (T111179606): Support platform colors for color animations
+}
+
+@end

package/Libraries/NativeAnimation/Nodes/RCTDiffClampAnimatedNode.h

@@ -0,0 +1,12 @@
+/*
+ * 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 "RCTValueAnimatedNode.h"
+
+@interface RCTDiffClampAnimatedNode : RCTValueAnimatedNode
+
+@end

package/Libraries/NativeAnimation/Nodes/RCTDiffClampAnimatedNode.mm

@@ -0,0 +1,64 @@
+/*
+ * 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/RCTDiffClampAnimatedNode.h>
+
+#import <React/RCTLog.h>
+
+@implementation RCTDiffClampAnimatedNode {
+  NSNumber *_inputNodeTag;
+  CGFloat _min;
+  CGFloat _max;
+  CGFloat _lastValue;
+}
+
+- (instancetype)initWithTag:(NSNumber *)tag config:(NSDictionary<NSString *, id> *)config
+{
+  if (self = [super initWithTag:tag config:config]) {
+    _inputNodeTag = config[@"input"];
+    _min = [config[@"min"] floatValue];
+    _max = [config[@"max"] floatValue];
+  }
+
+  return self;
+}
+
+- (void)onAttachedToNode:(RCTAnimatedNode *)parent
+{
+  [super onAttachedToNode:parent];
+
+  self.value = _lastValue = [self inputNodeValue];
+}
+
+- (void)performUpdate
+{
+  [super performUpdate];
+
+  CGFloat value = [self inputNodeValue];
+
+  CGFloat diff = value - _lastValue;
+  _lastValue = value;
+  self.value = MIN(MAX(self.value + diff, _min), _max);
+}
+
+- (CGFloat)inputNodeValue
+{
+  if (self.parentNodes == nil) {
+    RCTLogWarn(@"Animated.DiffClamp node has not been fully initialised.");
+    return 0;
+  }
+
+  RCTValueAnimatedNode *inputNode = (RCTValueAnimatedNode *)[self.parentNodes objectForKey:_inputNodeTag];
+  if (![inputNode isKindOfClass:[RCTValueAnimatedNode class]]) {
+    RCTLogError(@"Illegal node ID set as an input for Animated.DiffClamp node");
+    return 0;
+  }
+
+  return inputNode.value;
+}
+
+@end

package/Libraries/NativeAnimation/Nodes/RCTDivisionAnimatedNode.h

@@ -0,0 +1,12 @@
+/*
+ * 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 "RCTValueAnimatedNode.h"
+
+@interface RCTDivisionAnimatedNode : RCTValueAnimatedNode
+
+@end

package/Libraries/NativeAnimation/Nodes/RCTDivisionAnimatedNode.mm

@@ -0,0 +1,32 @@
+/*
+ * 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/RCTDivisionAnimatedNode.h>
+
+#import <React/RCTLog.h>
+
+@implementation RCTDivisionAnimatedNode
+
+- (void)performUpdate
+{
+  [super performUpdate];
+
+  NSArray<NSNumber *> *inputNodes = self.config[@"input"];
+  if (inputNodes.count > 1) {
+    RCTValueAnimatedNode *parent1 = (RCTValueAnimatedNode *)[self.parentNodes objectForKey:inputNodes[0]];
+    RCTValueAnimatedNode *parent2 = (RCTValueAnimatedNode *)[self.parentNodes objectForKey:inputNodes[1]];
+    if ([parent1 isKindOfClass:[RCTValueAnimatedNode class]] && [parent2 isKindOfClass:[RCTValueAnimatedNode class]]) {
+      if (parent2.value == 0) {
+        RCTLogError(@"Detected a division by zero in Animated.divide node");
+        return;
+      }
+      self.value = parent1.value / parent2.value;
+    }
+  }
+}
+
+@end

package/Libraries/NativeAnimation/Nodes/RCTInterpolationAnimatedNode.h

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

package/Libraries/NativeAnimation/Nodes/RCTInterpolationAnimatedNode.mm

@@ -0,0 +1,169 @@
+/*
+ * 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 "RCTInterpolationAnimatedNode.h"
+
+#import <React/RCTAnimationUtils.h>
+#import <React/RCTConvert.h>
+
+typedef NS_ENUM(NSInteger, RCTInterpolationOutputType) {
+  RCTInterpolationOutputNumber,
+  RCTInterpolationOutputColor,
+  RCTInterpolationOutputString,
+};
+
+static NSRegularExpression *getNumericComponentRegex(void)
+{
+  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 *_outputRange;
+  NSString *_extrapolateLeft;
+  NSString *_extrapolateRight;
+  RCTInterpolationOutputType _outputType;
+  id _Nullable _outputvalue;
+  NSString *_Nullable _outputPattern;
+
+  NSArray<NSTextCheckingResult *> *_matches;
+}
+
+- (instancetype)initWithTag:(NSNumber *)tag config:(NSDictionary<NSString *, id> *)config
+{
+  if ((self = [super initWithTag:tag config:config])) {
+    _inputRange = config[@"inputRange"];
+
+    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;
+    }
+
+    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;
+      }
+    }
+    _outputRange = outputRange;
+    _extrapolateLeft = config[@"extrapolateLeft"];
+    _extrapolateRight = config[@"extrapolateRight"];
+  }
+  return self;
+}
+
+- (void)onAttachedToNode:(RCTAnimatedNode *)parent
+{
+  [super onAttachedToNode:parent];
+  if ([parent isKindOfClass:[RCTValueAnimatedNode class]]) {
+    _parentNode = (RCTValueAnimatedNode *)parent;
+  }
+}
+
+- (void)onDetachedFromNode:(RCTAnimatedNode *)parent
+{
+  [super onDetachedFromNode:parent];
+  if (_parentNode == parent) {
+    _parentNode = nil;
+  }
+}
+
+- (void)performUpdate
+{
+  [super performUpdate];
+  if (!_parentNode) {
+    return;
+  }
+
+  CGFloat inputValue = _parentNode.value;
+  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/RCTModuloAnimatedNode.h

@@ -0,0 +1,12 @@
+/*
+ * 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 "RCTValueAnimatedNode.h"
+
+@interface RCTModuloAnimatedNode : RCTValueAnimatedNode
+
+@end

package/Libraries/NativeAnimation/Nodes/RCTModuloAnimatedNode.mm

@@ -0,0 +1,22 @@
+/*
+ * 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/RCTModuloAnimatedNode.h>
+
+@implementation RCTModuloAnimatedNode
+
+- (void)performUpdate
+{
+  [super performUpdate];
+  NSNumber *inputNode = self.config[@"input"];
+  NSNumber *modulus = self.config[@"modulus"];
+  RCTValueAnimatedNode *parent = (RCTValueAnimatedNode *)[self.parentNodes objectForKey:inputNode];
+  const float m = modulus.floatValue;
+  self.value = fmodf(fmodf(parent.value, m) + m, m);
+}
+
+@end

package/Libraries/NativeAnimation/Nodes/RCTMultiplicationAnimatedNode.h

@@ -0,0 +1,12 @@
+/*
+ * 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 "RCTValueAnimatedNode.h"
+
+@interface RCTMultiplicationAnimatedNode : RCTValueAnimatedNode
+
+@end

package/Libraries/NativeAnimation/Nodes/RCTMultiplicationAnimatedNode.mm

@@ -0,0 +1,26 @@
+/*
+ * 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/RCTMultiplicationAnimatedNode.h>
+
+@implementation RCTMultiplicationAnimatedNode
+
+- (void)performUpdate
+{
+  [super performUpdate];
+
+  NSArray<NSNumber *> *inputNodes = self.config[@"input"];
+  if (inputNodes.count > 1) {
+    RCTValueAnimatedNode *parent1 = (RCTValueAnimatedNode *)[self.parentNodes objectForKey:inputNodes[0]];
+    RCTValueAnimatedNode *parent2 = (RCTValueAnimatedNode *)[self.parentNodes objectForKey:inputNodes[1]];
+    if ([parent1 isKindOfClass:[RCTValueAnimatedNode class]] && [parent2 isKindOfClass:[RCTValueAnimatedNode class]]) {
+      self.value = parent1.value * parent2.value;
+    }
+  }
+}
+
+@end

package/Libraries/NativeAnimation/Nodes/RCTObjectAnimatedNode.h

@@ -0,0 +1,14 @@
+/*
+ * 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 "RCTAnimatedNode.h"
+
+@interface RCTObjectAnimatedNode : RCTAnimatedNode
+
+@property (nonatomic, strong, readonly) id value;
+
+@end

package/Libraries/NativeAnimation/Nodes/RCTObjectAnimatedNode.mm

@@ -0,0 +1,66 @@
+/*
+ * 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 "RCTObjectAnimatedNode.h"
+#import "RCTValueAnimatedNode.h"
+
+NSString *const VALUE_KEY = @"value";
+NSString *const NODE_TAG_KEY = @"nodeTag";
+
+@implementation RCTObjectAnimatedNode
+
+- (void)performUpdate
+{
+  [super performUpdate];
+
+  id value = self.config[VALUE_KEY];
+  if ([value isKindOfClass:[NSDictionary class]]) {
+    _value = [self _performUpdateHelperDictionary:(NSDictionary *)value];
+  } else if ([value isKindOfClass:[NSArray class]]) {
+    _value = [self _performUpdateHelperArray:(NSArray *)value];
+  }
+}
+
+- (NSDictionary<NSString *, id> *)_performUpdateHelperDictionary:(NSDictionary<NSString *, id> *)source
+{
+  NSMutableDictionary<NSString *, id> *result = [NSMutableDictionary new];
+  for (NSString *key in source) {
+    result[key] = [self _convertValue:source[key]];
+  }
+  return result;
+}
+
+- (NSArray *)_performUpdateHelperArray:(NSArray *)source
+{
+  NSMutableArray *result = [NSMutableArray array];
+  for (id value in source) {
+    [result addObject:[self _convertValue:value]];
+  }
+  return result;
+}
+
+- (id)_convertValue:(id)value
+{
+  if ([value isKindOfClass:[NSDictionary class]]) {
+    NSDictionary<NSString *, id> *dict = (NSDictionary *)value;
+    id nodeTag = [dict objectForKey:NODE_TAG_KEY];
+    if (nodeTag && [nodeTag isKindOfClass:[NSNumber class]]) {
+      RCTAnimatedNode *node = [self.parentNodes objectForKey:(NSNumber *)nodeTag];
+      if ([node isKindOfClass:[RCTValueAnimatedNode class]]) {
+        RCTValueAnimatedNode *valueNode = (RCTValueAnimatedNode *)node;
+        return @(valueNode.value);
+      }
+    }
+    return [self _performUpdateHelperDictionary:dict];
+  } else if ([value isKindOfClass:[NSArray class]]) {
+    return [self _performUpdateHelperArray:(NSArray *)value];
+  } else {
+    return value;
+  }
+}
+
+@end

package/Libraries/NativeAnimation/Nodes/RCTPropsAnimatedNode.h

@@ -0,0 +1,26 @@
+/*
+ * 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 "RCTAnimatedNode.h"
+
+#import <React/RCTSurfacePresenterStub.h>
+
+@class RCTBridge;
+@class RCTViewPropertyMapper;
+
+@interface RCTPropsAnimatedNode : RCTAnimatedNode
+
+- (void)connectToView:(NSNumber *)viewTag
+             viewName:(NSString *)viewName
+               bridge:(RCTBridge *)bridge
+     surfacePresenter:(id<RCTSurfacePresenterStub>)surfacePresenter;
+
+- (void)disconnectFromView:(NSNumber *)viewTag;
+
+- (void)restoreDefaultValues;
+
+@end