react-native-ui-lib 8.1.1 → 8.1.5

package/lib/ios/reactnativeuilib/keyboardinput/lninterpolation/LNAnimatorTemp.m

@@ -0,0 +1,121 @@
+//
+//  LNFrameAnimator.m
+//  KeyboardTransitionDemo
+//
+//  Created by Leo Natan (Wix) on 11/05/2017.
+//  Copyright © 2017 Wix. All rights reserved.
+//
+
+#import "LNAnimatorTemp.h"
+
+#import "LNInterpolation.h"
+
+@implementation LNViewAnimationTemp
+{
+    id _fromValue;
+}
+
+@synthesize progress = _progress;
+
+- (instancetype)init
+{
+    [NSException raise:NSInvalidArgumentException format:@"Use animationWithView:keyPath:toValue: to create LNViewAnimationTemp objects."];
+    return nil;
+}
+
+- (instancetype)_init
+{
+    return [super init];
+}
+
++ (instancetype)animationWithView:(UIView*)view keyPath:(NSString*)keyPath toValue:(id)toValue
+{
+    LNViewAnimationTemp* rv = [[LNViewAnimationTemp alloc] _init];
+    
+    if(rv)
+    {
+        rv->_view = view;
+        rv->_keyPath = keyPath;
+        rv->_toValue = toValue;
+        rv->_fromValue = [view valueForKeyPath:keyPath];
+    }
+    
+    return rv;
+}
+
+- (void)setProgress:(CGFloat)progress
+{
+    _progress = progress;
+    [_view setValue:[_fromValue interpolateToValue:_toValue progress:progress] forKeyPath:_keyPath];
+    [_view layoutIfNeeded];
+}
+
+@end
+
+@implementation LNAnimatorTemp
+{
+    void (^_completionHandler)(BOOL);
+    CADisplayLink* _displayLink;
+    CFTimeInterval _previousFrameTimestamp;
+    CFTimeInterval _elapsedTime;
+}
+
+- (instancetype)init
+{
+    [NSException raise:NSInvalidArgumentException format:@"Use animationWithView:keyPath:toValue: to create LNViewAnimationTemp objects."];
+    return nil;
+}
+
+- (instancetype)_init
+{
+    return [super init];
+}
+
++ (instancetype)animatorWithDuration:(NSTimeInterval)duration animations:(NSArray<id<LNAnimationTemp>>*)animations completionHandler:(void(^)(BOOL completed))completionHandler
+{
+    LNAnimatorTemp* rv = [[LNAnimatorTemp alloc] _init];
+    if(rv)
+    {
+        rv->_duration = duration;
+        
+        NSAssert(animations.count > 0, @"At least one animation must be provided.");
+        
+        rv->_animations = animations;
+        rv->_completionHandler = completionHandler;
+    }
+    
+    return rv;
+}
+
+- (void)start
+{
+    _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(_displayLinkDidTick)];
+//    _displayLink.preferredFramesPerSecond = 30;
+    [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
+}
+
+- (void)_displayLinkDidTick
+{
+    if(_previousFrameTimestamp != 0)
+    {
+        _elapsedTime += _displayLink.timestamp - _previousFrameTimestamp;
+    }
+    _previousFrameTimestamp = _displayLink.timestamp;
+    
+    [_animations enumerateObjectsUsingBlock:^(id<LNAnimationTemp>  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
+        obj.progress = MIN(_elapsedTime / _duration, 1.0);
+    }];
+    
+    if(_elapsedTime / _duration >= 1.0)
+    {
+        [_displayLink invalidate];
+        _displayLink = nil;
+        
+        if(_completionHandler)
+        {
+            _completionHandler(YES);
+        }
+    }
+}
+
+@end

package/lib/ios/reactnativeuilib/keyboardinput/lninterpolation/LNInterpolable.h

@@ -0,0 +1,48 @@
+//
+//  LNInterpolable.h
+//
+//  Created by Leo Natan on 01/10/2016.
+//  Copyright © 2016 Leo Natan. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+NS_SWIFT_NAME(InterpolationBehavior)
+typedef const NSString* LNInterpolationBehavior CF_STRING_ENUM;
+
+/**
+ Interpolate using the default behavor of each implementation.
+ */
+extern LNInterpolationBehavior const LNInterpolationBehaviorUseDefault;
+
+
+/**
+ Classes implementing this protocol support interpolation.
+ */
+NS_SWIFT_NAME(Interpolable)
+@protocol LNInterpolable <NSObject>
+
+/**
+ Interpolates between @c self and @c toValue accodring to @c progress using the default behavior.
+
+ @param toValue The value to interpolate to
+ @param progress The progress of the interpolation
+ @return An object representing the interpolated value at the requested progress
+ */
+- (instancetype)interpolateToValue:(id)toValue progress:(double)progress NS_SWIFT_NAME(interpolate(to:progress:));
+
+/**
+ Interpolates between @c self and @c toValue according to @c progress using @c behavior.
+
+ @param toValue The value to interpolate to
+ @param behavior The bahvior to use for interpolation
+ @param progress The progress of the interpolation
+ @return An object representing the interpolated value at the requested progress
+ */
+- (instancetype)interpolateToValue:(id)toValue progress:(double)progress behavior:(LNInterpolationBehavior)behavior NS_SWIFT_NAME(interpolate(to:progress:behavior:));
+
+NS_ASSUME_NONNULL_END
+
+@end

package/lib/ios/reactnativeuilib/keyboardinput/lninterpolation/LNInterpolable.m

@@ -0,0 +1,27 @@
+//
+//  LNInterpolable.c
+//
+//  Created by Leo Natan on 04/10/2016.
+//  Copyright © 2016 Leo Natan. All rights reserved.
+//
+
+#import "LNInterpolable.h"
+
+LNInterpolationBehavior const LNInterpolationBehaviorUseDefault = @"LNInterpolationBehaviorUseDefault";
+
+double BackEaseOut(double p)
+{
+    double f = (1 - p);
+    return 1 - (f * f * f - 0.4*f * sin(f * M_PI));
+}
+
+double QuarticEaseOut(double p)
+{
+    double f = (p - 1);
+    return f * f * f * (1 - p) + 1;
+}
+
+double LNLinearInterpolate(double from, double to, double p)
+{
+    return from + QuarticEaseOut(p) * (to - from);
+}

package/lib/ios/reactnativeuilib/keyboardinput/lninterpolation/LNInterpolation.h

@@ -0,0 +1,16 @@
+//
+//  LNInterpolation.h
+//
+//  Created by Leo Natan on 05/10/2016.
+//  Copyright © 2016 Leo Natan. All rights reserved.
+//
+
+#import "LNInterpolable.h"
+#import "NSValue+Interpolation.h"
+#import "Color+Interpolation.h"
+
+//! Project version number for LNInterpolationFramework.
+FOUNDATION_EXPORT double LNInterpolationFrameworkVersionNumber;
+
+//! Project version string for LNInterpolationFramework.
+FOUNDATION_EXPORT const unsigned char LNInterpolationFrameworkVersionString[];

package/lib/ios/reactnativeuilib/keyboardinput/lninterpolation/NSValue+Interpolation.h

@@ -0,0 +1,19 @@
+//
+//  NSValue+Interpolation.h
+//
+//  Created by Leo Natan on 01/10/2016.
+//  Copyright © 2016 Leo Natan. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "LNInterpolable.h"
+
+/**
+ Interpolates between @c NSValue objects.
+ Currently, the following value types are supported:
+    Numbers (@c NSNumber), decimal numbers (@c NSDecimalNumber)
+    Core Graphics: CGPoint, CGSize, CGVector, CGRect, CGAffineTransform (@c NSValue)
+    UIKit: UIOffset, UIEdgeInsets (@c NSValue)
+    AppKit: NSEdgeInsets (@c NSValue)
+ */
+@interface NSValue (Interpolation) <LNInterpolable> @end

package/lib/ios/reactnativeuilib/keyboardinput/lninterpolation/NSValue+Interpolation.mm

@@ -0,0 +1,155 @@
+//
+//  NSValue+Interpolation.mm
+//
+//  Created by Leo Natan on 01/10/2016.
+//  Copyright © 2016 Leo Natan. All rights reserved.
+//
+
+#import "NSValue+Interpolation.h"
+
+#if __has_include(<CoreGraphics/CoreGraphics.h>)
+#import <CoreGraphics/CoreGraphics.h>
+#endif
+
+#if __has_include(<UIKit/UIKit.h>)
+#import <UIKit/UIKit.h>
+#endif
+
+#if __has_include(<AppKit/AppKit.h>)
+#import <AppKit/AppKit.h>
+
+#define CGPointValue pointValue
+#define CGRectValue rectValue
+#define valueWithCGPoint valueWithPoint
+#define UIEdgeInsets NSEdgeInsets
+#define valueWithCGRect valueWithRect
+
+#endif
+
+extern "C" double LNLinearInterpolate(double from, double to, double p);
+
+#if __has_include(<UIKit/UIKit.h>)
+static inline CGAffineTransform _LNInterpolateCGAffineTransform(const CGAffineTransform& fromTransform, const CGAffineTransform& toTransform, CGFloat p)
+{
+    CGAffineTransform rv;
+    rv.a = LNLinearInterpolate(fromTransform.a, toTransform.a, p);
+    rv.b = LNLinearInterpolate(fromTransform.b, toTransform.b, p);
+    rv.c = LNLinearInterpolate(fromTransform.c, toTransform.c, p);
+    rv.d = LNLinearInterpolate(fromTransform.d, toTransform.d, p);
+    rv.tx = LNLinearInterpolate(fromTransform.tx, toTransform.tx, p);
+    rv.ty = LNLinearInterpolate(fromTransform.ty, toTransform.ty, p);
+    
+    return rv;
+}
+#endif
+
+@implementation NSValue (Interpolation)
+
+- (instancetype)interpolateToValue:(id)toValue progress:(double)p
+{
+    return [self interpolateToValue:toValue progress:p behavior:LNInterpolationBehaviorUseDefault];
+}
+
+- (instancetype)interpolateToValue:(id)toValue progress:(double)p behavior:(LNInterpolationBehavior)behavior
+{
+    if(p <= 0)
+    {
+        return self;
+    }
+    
+    if(p >= 1)
+    {
+        return toValue;
+    }
+    
+    if([self isKindOfClass:[NSNumber class]])
+    {
+        if([self isKindOfClass:[NSDecimalNumber class]])
+        {
+            //Special case for decimal numbers.
+            NSDecimalNumber* from = (id)self;
+            NSDecimalNumber* to = (id)toValue;
+            
+            return [[[to decimalNumberBySubtracting:from] decimalNumberByMultiplyingBy:[[NSDecimalNumber alloc] initWithDouble:p]] decimalNumberByAdding:from];
+        }
+        
+        double f = [(NSNumber*)self doubleValue];
+        double f2 = [(NSNumber*)toValue doubleValue];
+        
+        return [NSNumber numberWithDouble:LNLinearInterpolate(f, f2, p)];
+    }
+    
+#if __has_include(<UIKit/UIKit.h>) || __has_include(<AppKit/AppKit.h>)
+    if((strcmp(self.objCType, @encode(CGPoint)) == 0) || (strcmp(self.objCType, @encode(CGSize)) == 0) || (strcmp(self.objCType, @encode(CGVector)) == 0)
+#if __has_include(<UIKit/UIKit.h>)
+       || (strcmp(self.objCType, @encode(UIOffset)) == 0)
+#endif
+       )
+    {
+        CGPoint v = [self CGPointValue];
+        CGPoint v2 = [self CGPointValue];
+        v.x = LNLinearInterpolate(v.x, v2.y, p);
+        v.y = LNLinearInterpolate(v.x, v2.y, p);
+
+        return [NSValue valueWithCGPoint:v];
+    }
+    
+    if((strcmp(self.objCType, @encode(CGRect)) == 0)
+       || (strcmp(self.objCType, @encode(UIEdgeInsets)) == 0))
+    {
+        CGRect v = [self CGRectValue];
+        CGRect v2 = [toValue CGRectValue];
+        v.origin.x = LNLinearInterpolate(v.origin.x, v2.origin.x, p);
+        v.origin.y = LNLinearInterpolate(v.origin.y, v2.origin.y, p);
+        v.size.width = LNLinearInterpolate(v.size.width, v2.size.width, p);
+        v.size.height = LNLinearInterpolate(v.size.height, v2.size.height, p);
+        
+        return [NSValue valueWithCGRect:v];
+    }
+    
+#if __has_include(<UIKit/UIKit.h>)
+    if(strcmp(self.objCType, @encode(CGAffineTransform)) == 0)
+    {
+        return [NSValue valueWithCGAffineTransform:_LNInterpolateCGAffineTransform([self CGAffineTransformValue], [toValue CGAffineTransformValue], p)];
+    }
+#endif
+#endif
+    
+    //Unsupported value type.
+    
+    return self;
+}
+
+@end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/lib/ios/reactnativeuilib/keyboardinput/rctcustomInputcontroller/RCTCustomInputControllerTemp.h

@@ -0,0 +1,16 @@
+//
+//  RCTCustomInputControllerTemp.h
+//
+//  Created by Leo Natan (Wix) on 13/12/2016.
+//  Copyright © 2016 Leo Natan. All rights reserved.
+//
+
+#if __has_include(<React/RCTEventEmitter.h>)
+#import <React/RCTEventEmitter.h>
+#else
+#import "RCTEventEmitter.h"
+#endif
+
+@interface RCTCustomInputControllerTemp : RCTEventEmitter
+
+@end