yeet

node_modules/react-native/Libraries/NativeAnimation/Drivers/RCTAnimationDriver.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <CoreGraphics/CoreGraphics.h>
+#import <Foundation/Foundation.h>
+
+#import <React/RCTBridgeModule.h>
+
+static CGFloat RCTSingleFrameInterval = (CGFloat)(1.0 / 60.0);
+
+@class RCTValueAnimatedNode;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol RCTAnimationDriver <NSObject>
+
+@property (nonatomic, readonly) NSNumber *animationId;
+@property (nonatomic, readonly) RCTValueAnimatedNode *valueNode;
+@property (nonatomic, readonly) BOOL animationHasBegun;
+@property (nonatomic, readonly) BOOL animationHasFinished;
+
+- (instancetype)initWithId:(NSNumber *)animationId
+                    config:(NSDictionary *)config
+                   forNode:(RCTValueAnimatedNode *)valueNode
+                  callBack:(nullable RCTResponseSenderBlock)callback;
+
+- (void)startAnimation;
+- (void)stepAnimationWithTime:(NSTimeInterval)currentTime;
+- (void)stopAnimation;
+- (void)resetAnimationConfig:(NSDictionary *)config;
+
+NS_ASSUME_NONNULL_END
+
+@end

node_modules/react-native/Libraries/NativeAnimation/Drivers/RCTDecayAnimation.h

@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTAnimationDriver.h"
+
+@interface RCTDecayAnimation : NSObject<RCTAnimationDriver>
+
+@end

node_modules/react-native/Libraries/NativeAnimation/Drivers/RCTDecayAnimation.m

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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/RCTDecayAnimation.h>
+
+#import <UIKit/UIKit.h>
+#import <React/RCTConvert.h>
+
+#import <React/RCTAnimationUtils.h>
+#import <React/RCTValueAnimatedNode.h>
+
+@interface RCTDecayAnimation ()
+
+@property (nonatomic, strong) NSNumber *animationId;
+@property (nonatomic, strong) RCTValueAnimatedNode *valueNode;
+@property (nonatomic, assign) BOOL animationHasBegun;
+@property (nonatomic, assign) BOOL animationHasFinished;
+
+@end
+
+@implementation RCTDecayAnimation
+{
+  CGFloat _velocity;
+  CGFloat _deceleration;
+  NSTimeInterval _frameStartTime;
+  CGFloat _fromValue;
+  CGFloat _lastValue;
+  NSInteger _iterations;
+  NSInteger _currentLoop;
+  RCTResponseSenderBlock _callback;
+}
+
+- (instancetype)initWithId:(NSNumber *)animationId
+                    config:(NSDictionary *)config
+                   forNode:(RCTValueAnimatedNode *)valueNode
+                  callBack:(nullable RCTResponseSenderBlock)callback
+{
+  if ((self = [super init])) {
+    _callback = [callback copy];
+    _animationId = animationId;
+    _valueNode = valueNode;
+    _fromValue = 0;
+    _lastValue = 0;
+    _velocity = [RCTConvert CGFloat:config[@"velocity"]]; // initial velocity
+    [self resetAnimationConfig:config];
+  }
+  return self;
+}
+
+- (void)resetAnimationConfig:(NSDictionary *)config
+{
+  NSNumber *iterations = [RCTConvert NSNumber:config[@"iterations"]] ?: @1;
+  _fromValue = _lastValue;
+  _deceleration = [RCTConvert CGFloat:config[@"deceleration"]];
+  _iterations = iterations.integerValue;
+  _currentLoop = 1;
+  _animationHasFinished = iterations.integerValue == 0;
+}
+
+RCT_NOT_IMPLEMENTED(- (instancetype)init)
+
+- (void)startAnimation
+{
+  _frameStartTime = -1;
+  _animationHasBegun = YES;
+}
+
+- (void)stopAnimation
+{
+  _valueNode = nil;
+  if (_callback) {
+    _callback(@[@{
+      @"finished": @(_animationHasFinished)
+    }]);
+  }
+}
+
+- (void)stepAnimationWithTime:(NSTimeInterval)currentTime
+{
+  if (!_animationHasBegun || _animationHasFinished) {
+    // Animation has not begun or animation has already finished.
+    return;
+  }
+
+  if (_frameStartTime == -1) {
+    // Since this is the first animation step, consider the start to be on the previous frame.
+    _frameStartTime = currentTime - RCTSingleFrameInterval;
+    if (_fromValue == _lastValue) {
+      // First iteration, assign _fromValue based on _valueNode.
+      _fromValue = _valueNode.value;
+    } else {
+      // Not the first iteration, reset _valueNode based on _fromValue.
+      [self updateValue:_fromValue];
+    }
+    _lastValue = _valueNode.value;
+  }
+
+  CGFloat value = _fromValue +
+    (_velocity / (1 - _deceleration)) *
+    (1 - exp(-(1 - _deceleration) * (currentTime - _frameStartTime) * 1000.0 / RCTAnimationDragCoefficient()));
+
+  [self updateValue:value];
+
+  if (fabs(_lastValue - value) < 0.1) {
+    if (_iterations == -1 || _currentLoop < _iterations) {
+      // Set _frameStartTime to -1 to reset instance variables on the next runAnimationStep.
+      _frameStartTime = -1;
+      _currentLoop++;
+    } else {
+      _animationHasFinished = true;
+      return;
+    }
+  }
+
+  _lastValue = value;
+}
+
+- (void)updateValue:(CGFloat)outputValue
+{
+  _valueNode.value = outputValue;
+  [_valueNode setNeedsUpdate];
+}
+
+@end

node_modules/react-native/Libraries/NativeAnimation/Drivers/RCTEventAnimation.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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/RCTEventDispatcher.h>
+
+#import "RCTValueAnimatedNode.h"
+
+@interface RCTEventAnimation : NSObject
+
+@property (nonatomic, readonly, weak) RCTValueAnimatedNode *valueNode;
+
+- (instancetype)initWithEventPath:(NSArray<NSString *> *)eventPath
+                        valueNode:(RCTValueAnimatedNode *)valueNode;
+
+- (void)updateWithEvent:(id<RCTEvent>)event;
+
+@end

node_modules/react-native/Libraries/NativeAnimation/Drivers/RCTEventAnimation.m

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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/RCTEventAnimation.h>
+
+@implementation RCTEventAnimation
+{
+  NSArray<NSString *> *_eventPath;
+}
+
+- (instancetype)initWithEventPath:(NSArray<NSString *> *)eventPath
+                        valueNode:(RCTValueAnimatedNode *)valueNode
+{
+  if ((self = [super init])) {
+    _eventPath = eventPath;
+    _valueNode = valueNode;
+  }
+  return self;
+}
+
+- (void)updateWithEvent:(id<RCTEvent>)event
+{
+  NSArray *args = event.arguments;
+  // Supported events args are in the following order: viewTag, eventName, eventData.
+  id currentValue = args[2];
+  for (NSString *key in _eventPath) {
+    currentValue = [currentValue valueForKey:key];
+  }
+
+  _valueNode.value = ((NSNumber *)currentValue).doubleValue;
+  [_valueNode setNeedsUpdate];
+}
+
+@end

node_modules/react-native/Libraries/NativeAnimation/Drivers/RCTFrameAnimation.h

@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTAnimationDriver.h"
+
+@interface RCTFrameAnimation : NSObject<RCTAnimationDriver>
+
+@end

node_modules/react-native/Libraries/NativeAnimation/Drivers/RCTFrameAnimation.m

@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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/RCTFrameAnimation.h>
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTConvert.h>
+#import <React/RCTDefines.h>
+
+#import <React/RCTAnimationUtils.h>
+#import <React/RCTValueAnimatedNode.h>
+
+@interface RCTFrameAnimation ()
+
+@property (nonatomic, strong) NSNumber *animationId;
+@property (nonatomic, strong) RCTValueAnimatedNode *valueNode;
+@property (nonatomic, assign) BOOL animationHasBegun;
+@property (nonatomic, assign) BOOL animationHasFinished;
+
+@end
+
+@implementation RCTFrameAnimation
+{
+  NSArray<NSNumber *> *_frames;
+  CGFloat _toValue;
+  CGFloat _fromValue;
+  CGFloat _lastPosition;
+  NSTimeInterval _animationStartTime;
+  NSTimeInterval _animationCurrentTime;
+  RCTResponseSenderBlock _callback;
+  NSInteger _iterations;
+  NSInteger _currentLoop;
+}
+
+- (instancetype)initWithId:(NSNumber *)animationId
+                    config:(NSDictionary *)config
+                   forNode:(RCTValueAnimatedNode *)valueNode
+                  callBack:(nullable RCTResponseSenderBlock)callback
+{
+  if ((self = [super init])) {
+    _animationId = animationId;
+    _lastPosition = _fromValue = valueNode.value;
+    _valueNode = valueNode;
+    _callback = [callback copy];
+    [self resetAnimationConfig:config];
+  }
+  return self;
+}
+
+- (void)resetAnimationConfig:(NSDictionary *)config
+{
+  NSNumber *toValue = [RCTConvert NSNumber:config[@"toValue"]] ?: @1;
+  NSArray<NSNumber *> *frames = [RCTConvert NSNumberArray:config[@"frames"]];
+  NSNumber *iterations = [RCTConvert NSNumber:config[@"iterations"]] ?: @1;
+
+  _fromValue = _lastPosition;
+  _toValue = toValue.floatValue;
+  _frames = [frames copy];
+  _animationStartTime = _animationCurrentTime = -1;
+  _animationHasFinished = iterations.integerValue == 0;
+  _iterations = iterations.integerValue;
+  _currentLoop = 1;
+}
+
+RCT_NOT_IMPLEMENTED(- (instancetype)init)
+
+- (void)startAnimation
+{
+  _animationStartTime = _animationCurrentTime = -1;
+  _animationHasBegun = YES;
+}
+
+- (void)stopAnimation
+{
+  _valueNode = nil;
+  if (_callback) {
+    _callback(@[@{
+      @"finished": @(_animationHasFinished)
+    }]);
+  }
+}
+
+- (void)stepAnimationWithTime:(NSTimeInterval)currentTime
+{
+  if (!_animationHasBegun || _animationHasFinished || _frames.count == 0) {
+    // Animation has not begun or animation has already finished.
+    return;
+  }
+
+  if (_animationStartTime == -1) {
+    _animationStartTime = _animationCurrentTime = currentTime;
+  }
+
+  _animationCurrentTime = currentTime;
+  NSTimeInterval currentDuration = (_animationCurrentTime - _animationStartTime) / RCTAnimationDragCoefficient();
+
+  // Determine how many frames have passed since last update.
+  // Get index of frames that surround the current interval
+  NSUInteger startIndex = floor(currentDuration / RCTSingleFrameInterval);
+  NSUInteger nextIndex = startIndex + 1;
+
+  if (nextIndex >= _frames.count) {
+    if (_iterations == -1 || _currentLoop < _iterations) {
+      // Looping, reset to the first frame value.
+      _animationStartTime = currentTime;
+      _currentLoop++;
+      NSNumber *firstValue = _frames.firstObject;
+      [self updateOutputWithFrameOutput:firstValue.doubleValue];
+    } else {
+      _animationHasFinished = YES;
+      // We are at the end of the animation
+      // Update value and flag animation has ended.
+      NSNumber *finalValue = _frames.lastObject;
+      [self updateOutputWithFrameOutput:finalValue.doubleValue];
+    }
+    return;
+  }
+
+  // Do a linear remap of the two frames to safeguard against variable framerates
+  NSNumber *fromFrameValue = _frames[startIndex];
+  NSNumber *toFrameValue = _frames[nextIndex];
+  NSTimeInterval fromInterval = startIndex * RCTSingleFrameInterval;
+  NSTimeInterval toInterval = nextIndex * RCTSingleFrameInterval;
+
+  // Interpolate between the individual frames to ensure the animations are
+  //smooth and of the proper duration regardless of the framerate.
+  CGFloat frameOutput = RCTInterpolateValue(currentDuration,
+                                            fromInterval,
+                                            toInterval,
+                                            fromFrameValue.doubleValue,
+                                            toFrameValue.doubleValue,
+                                            EXTRAPOLATE_TYPE_EXTEND,
+                                            EXTRAPOLATE_TYPE_EXTEND);
+
+  [self updateOutputWithFrameOutput:frameOutput];
+}
+
+- (void)updateOutputWithFrameOutput:(CGFloat)frameOutput
+{
+  CGFloat outputValue = RCTInterpolateValue(frameOutput,
+                                            0,
+                                            1,
+                                            _fromValue,
+                                            _toValue,
+                                            EXTRAPOLATE_TYPE_EXTEND,
+                                            EXTRAPOLATE_TYPE_EXTEND);
+
+  _lastPosition = outputValue;
+  _valueNode.value = outputValue;
+  [_valueNode setNeedsUpdate];
+}
+
+@end

node_modules/react-native/Libraries/NativeAnimation/Drivers/RCTSpringAnimation.h

@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTAnimationDriver.h"
+
+@interface RCTSpringAnimation : NSObject<RCTAnimationDriver>
+
+@end

node_modules/react-native/Libraries/NativeAnimation/Drivers/RCTSpringAnimation.m

@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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/RCTSpringAnimation.h>
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTConvert.h>
+#import <React/RCTDefines.h>
+
+#import <React/RCTAnimationUtils.h>
+#import <React/RCTValueAnimatedNode.h>
+
+@interface RCTSpringAnimation ()
+
+@property (nonatomic, strong) NSNumber *animationId;
+@property (nonatomic, strong) RCTValueAnimatedNode *valueNode;
+@property (nonatomic, assign) BOOL animationHasBegun;
+@property (nonatomic, assign) BOOL animationHasFinished;
+
+@end
+
+const NSTimeInterval MAX_DELTA_TIME = 0.064;
+
+@implementation RCTSpringAnimation
+{
+  CGFloat _toValue;
+  CGFloat _fromValue;
+  BOOL _overshootClamping;
+  CGFloat _restDisplacementThreshold;
+  CGFloat _restSpeedThreshold;
+  CGFloat _stiffness;
+  CGFloat _damping;
+  CGFloat _mass;
+  CGFloat _initialVelocity;
+  NSTimeInterval _animationStartTime;
+  NSTimeInterval _animationCurrentTime;
+  RCTResponseSenderBlock _callback;
+
+  CGFloat _lastPosition;
+  CGFloat _lastVelocity;
+
+  NSInteger _iterations;
+  NSInteger _currentLoop;
+
+  NSTimeInterval _t; // Current time (startTime + dt)
+}
+
+- (instancetype)initWithId:(NSNumber *)animationId
+                    config:(NSDictionary *)config
+                   forNode:(RCTValueAnimatedNode *)valueNode
+                  callBack:(nullable RCTResponseSenderBlock)callback
+{
+  if ((self = [super init])) {
+    _animationId = animationId;
+    _lastPosition = valueNode.value;
+    _valueNode = valueNode;
+    _lastVelocity = [RCTConvert CGFloat:config[@"initialVelocity"]];
+    _callback = [callback copy];
+    [self resetAnimationConfig:config];
+  }
+  return self;
+}
+
+- (void)resetAnimationConfig:(NSDictionary *)config
+{
+  NSNumber *iterations = [RCTConvert NSNumber:config[@"iterations"]] ?: @1;
+  _toValue = [RCTConvert CGFloat:config[@"toValue"]];
+  _overshootClamping = [RCTConvert BOOL:config[@"overshootClamping"]];
+  _restDisplacementThreshold = [RCTConvert CGFloat:config[@"restDisplacementThreshold"]];
+  _restSpeedThreshold = [RCTConvert CGFloat:config[@"restSpeedThreshold"]];
+  _stiffness = [RCTConvert CGFloat:config[@"stiffness"]];
+  _damping = [RCTConvert CGFloat:config[@"damping"]];
+  _mass = [RCTConvert CGFloat:config[@"mass"]];
+  _initialVelocity = _lastVelocity;
+  _fromValue = _lastPosition;
+  _fromValue = _lastPosition;
+  _lastVelocity = _initialVelocity;
+  _animationHasFinished = iterations.integerValue == 0;
+  _iterations = iterations.integerValue;
+  _currentLoop = 1;
+  _animationStartTime = _animationCurrentTime = -1;
+  _animationHasBegun = YES;
+}
+
+RCT_NOT_IMPLEMENTED(- (instancetype)init)
+
+- (void)startAnimation
+{
+  _animationStartTime = _animationCurrentTime = -1;
+  _animationHasBegun = YES;
+}
+
+- (void)stopAnimation
+{
+  _valueNode = nil;
+  if (_callback) {
+    _callback(@[@{
+      @"finished": @(_animationHasFinished)
+    }]);
+  }
+}
+
+- (void)stepAnimationWithTime:(NSTimeInterval)currentTime
+{
+  if (!_animationHasBegun || _animationHasFinished) {
+    // Animation has not begun or animation has already finished.
+    return;
+  }
+
+  // calculate delta time
+  if(_animationStartTime == -1) {
+    _t = 0.0;
+    _animationStartTime = currentTime;
+  } else {
+    // Handle frame drops, and only advance dt by a max of MAX_DELTA_TIME
+    NSTimeInterval deltaTime = MIN(MAX_DELTA_TIME, currentTime - _animationCurrentTime);
+    _t = _t + deltaTime / RCTAnimationDragCoefficient();
+  }
+
+  // store the timestamp
+  _animationCurrentTime = currentTime;
+
+  CGFloat c = _damping;
+  CGFloat m = _mass;
+  CGFloat k = _stiffness;
+  CGFloat v0 = -_initialVelocity;
+
+  CGFloat zeta = c / (2 * sqrtf(k * m));
+  CGFloat omega0 = sqrtf(k / m);
+  CGFloat omega1 = omega0 * sqrtf(1.0 - (zeta * zeta));
+  CGFloat x0 = _toValue - _fromValue;
+
+  CGFloat position;
+  CGFloat velocity;
+  if (zeta < 1) {
+    // Under damped
+    CGFloat envelope = expf(-zeta * omega0 * _t);
+    position =
+      _toValue -
+      envelope *
+      ((v0 + zeta * omega0 * x0) / omega1 * sinf(omega1 * _t) +
+        x0 * cosf(omega1 * _t));
+    // This looks crazy -- it's actually just the derivative of the
+    // oscillation function
+    velocity =
+      zeta *
+        omega0 *
+        envelope *
+        (sinf(omega1 * _t) * (v0 + zeta * omega0 * x0) / omega1 +
+          x0 * cosf(omega1 * _t)) -
+      envelope *
+        (cosf(omega1 * _t) * (v0 + zeta * omega0 * x0) -
+          omega1 * x0 * sinf(omega1 * _t));
+  } else {
+    CGFloat envelope = expf(-omega0 * _t);
+    position = _toValue - envelope * (x0 + (v0 + omega0 * x0) * _t);
+    velocity =
+      envelope * (v0 * (_t * omega0 - 1) + _t * x0 * (omega0 * omega0));
+  }
+
+  _lastPosition = position;
+  _lastVelocity = velocity;
+
+  [self onUpdate:position];
+
+  // Conditions for stopping the spring animation
+  BOOL isOvershooting = NO;
+  if (_overshootClamping && _stiffness != 0) {
+    if (_fromValue < _toValue) {
+      isOvershooting = position > _toValue;
+    } else {
+      isOvershooting = position < _toValue;
+    }
+  }
+  BOOL isVelocity = ABS(velocity) <= _restSpeedThreshold;
+  BOOL isDisplacement = YES;
+  if (_stiffness != 0) {
+    isDisplacement = ABS(_toValue - position) <= _restDisplacementThreshold;
+  }
+
+  if (isOvershooting || (isVelocity && isDisplacement)) {
+    if (_stiffness != 0) {
+      // Ensure that we end up with a round value
+      if (_animationHasFinished) {
+        return;
+      }
+      [self onUpdate:_toValue];
+    }
+
+    if (_iterations == -1 || _currentLoop < _iterations) {
+      _lastPosition = _fromValue;
+      _lastVelocity = _initialVelocity;
+      // Set _animationStartTime to -1 to reset instance variables on the next animation step.
+      _animationStartTime = -1;
+      _currentLoop++;
+      [self onUpdate:_fromValue];
+    } else {
+      _animationHasFinished = YES;
+    }
+  }
+}
+
+- (void)onUpdate:(CGFloat)outputValue
+{
+  _valueNode.value = outputValue;
+  [_valueNode setNeedsUpdate];
+}
+
+@end