react-native-ui-lib 8.1.1 → 8.1.5

package/lib/ios/reactnativeuilib/dynamicfont/DynamicFont.m

@@ -0,0 +1,115 @@
+#import "DynamicFont.h"
+#import <CoreText/CoreText.h>
+#import <UIKit/UIKit.h>
+#import <Foundation/Foundation.h>
+
+@implementation DynamicFont
+
+- (dispatch_queue_t)methodQueue
+{
+    return dispatch_get_main_queue();
+}
+RCT_EXPORT_MODULE()
+
+// TODO: Needs to be tested (notice param name "path" here)
+// RCT_EXPORT_METHOD(
+//   loadFontFromFile:(NSDictionary *)options callback:(RCTResponseSenderBlock)callback)
+// {
+//     NSString *path = [options valueForKey:@"path"];
+//     NSString *name = [options valueForKey:@"name"];
+//     NSData *data = [[NSFileManager defaultManager] contentsAtPath:path];
+//     CFErrorRef error;
+//     CGDataProviderRef provider = CGDataProviderCreateWithCFData((CFDataRef)data);
+//     CGFontRef font = CGFontCreateWithDataProvider(provider);
+//     NSString *newFontName = (__bridge NSString *)CGFontCopyPostScriptName(font);
+//     if (! CTFontManagerRegisterGraphicsFont(font, &error)) {
+//         CFStringRef errorDescription = CFErrorCopyDescription(error);
+//         NSLog(@"Failed to load font: %@", errorDescription);
+//         CFRelease(errorDescription);
+//         callback(@[@"Failed to load font: %@", (__bridge NSString *)errorDescription]);
+//     }
+//     CFRelease(font);
+//     CFRelease(provider);
+//     // Resolve to the caller.
+//     callback(@[[NSNull null], newFontName]);
+// }
+
+RCT_EXPORT_METHOD(loadFont:(NSDictionary *)options callback:(RCTResponseSenderBlock)callback)
+{
+  NSString *name = [options valueForKey:@"name"];
+  NSString *data = [options valueForKey:@"data"];
+  NSString *type = NULL;
+  
+  if ([name isEqual:[NSNull null]]) {
+    callback(@[@"Name property is empty"]);
+    return;
+  }
+
+  if ([data isEqual:[NSNull null]]) {
+    callback(@[@"Data property is empty"]);
+    return;
+  }
+
+  if ([[[data substringWithRange:NSMakeRange(0, 5)] lowercaseString] isEqualToString:@"data:"]) {
+    NSArray *parts = [data componentsSeparatedByString:@","];
+    NSString *mimeType = [parts objectAtIndex:0];
+
+    data = [parts objectAtIndex:1];
+
+    if (![mimeType isEqual:[NSNull null]]) {
+      mimeType = [[[mimeType substringFromIndex:5] componentsSeparatedByString:@";"] objectAtIndex:0];
+
+      if ([mimeType isEqualToString:@"application/x-font-ttf"] ||
+          [mimeType isEqualToString:@"application/x-font-truetype"] ||
+          [mimeType isEqualToString:@"font/ttf"]) {
+        type = @"ttf";
+      } else if ( [mimeType isEqualToString:@"application/x-font-opentype"] ||
+                  [mimeType isEqualToString:@"font/opentype"]) {
+        type = @"otf";
+      }
+    }
+  }
+
+  if ([type isEqual:[NSNull null]])
+    type = [options valueForKey:@"type"];
+
+  if ([type isEqual:[NSNull null]])
+    type = @"ttf";
+    
+  NSData *decodedData = [[NSData alloc]initWithBase64EncodedString:data options:NSDataBase64DecodingIgnoreUnknownCharacters];
+  CGDataProviderRef fontDataProvider = CGDataProviderCreateWithCFData((__bridge CFDataRef)decodedData);
+
+  [UIFont familyNames];
+  
+  CGFontRef newFont = CGFontCreateWithDataProvider(fontDataProvider);
+  NSString *newFontName = (__bridge NSString *)CGFontCopyPostScriptName(newFont);
+
+  UIFont* font = [UIFont fontWithName:newFontName size:16];
+  if (font != nil) {
+    CGDataProviderRelease(fontDataProvider);
+    callback(@[[NSNull null], newFontName]);
+    return;
+  }
+  
+  CFErrorRef error;
+  if (! CTFontManagerRegisterGraphicsFont(newFont, &error)) {
+    CFStringRef errorDescription = CFErrorCopyDescription(error);
+    NSLog(@"Failed to register font: %@", errorDescription);
+
+    callback(@[@"Failed to register font: %@", (__bridge NSString *)errorDescription]);
+    
+    CFRelease(errorDescription);
+    CGFontRelease(newFont);
+    CGDataProviderRelease(fontDataProvider);
+      
+    return;
+  }
+
+  CGFontRelease(newFont);
+  CGDataProviderRelease(fontDataProvider);
+
+  callback(@[[NSNull null], newFontName]);
+}
+
+@end
+  

package/lib/ios/reactnativeuilib/highlighterview/HighlighterView.h

@@ -0,0 +1,19 @@
+#import <UIKit/UIKit.h>
+#import <React/RCTBridge.h>
+
+@interface HighlighterView : UIView
+
+- (id)initWithFrame:(CGRect)frame bridge:(RCTBridge*)bridge;
+
+@property (nonatomic) CGRect highlightFrame;
+@property (nonatomic, strong) NSNumber *borderRadius;
+@property (nonatomic, strong) UIColor *overlayColor;
+@property (nonatomic, strong) UIColor *strokeColor;
+@property (nonatomic, strong) NSNumber *strokeWidth;
+@property (nonatomic, strong) NSNumber *highlightViewTag;
+@property (nonatomic, strong) NSDictionary *highlightViewTagParams;
+@property (nonatomic) CGSize minimumRectSize;
+@property (nonatomic) CGFloat innerPadding;
+
+
+@end

package/lib/ios/reactnativeuilib/highlighterview/HighlighterView.m

@@ -0,0 +1,216 @@
+
+#import "HighlighterView.h"
+#import <React/RCTUIManager.h>
+
+#define kDefaultOverlayColor [UIColor colorWithWhite:0 alpha:0.8]
+
+@interface HighlighterView ()
+{
+    RCTBridge* _bridge;
+    CGRect _viewBasedHighlightFrame;
+    UIView *_highlightedView;
+}
+@end
+
+@implementation HighlighterView
+
+- (id)initWithFrame:(CGRect)frame bridge:(RCTBridge*)bridge
+{
+    self = [super initWithFrame:frame];
+    if (self)
+    {
+        _bridge = bridge;
+        self.highlightFrame = CGRectNull;
+        _viewBasedHighlightFrame = CGRectNull;
+        self.backgroundColor = [UIColor clearColor];
+        self.overlayColor = kDefaultOverlayColor;
+        self.minimumRectSize = CGSizeZero;
+        self.innerPadding = 0;
+    }
+    return self;
+}
+
+- (void)dealloc
+{
+    [self clearObserver];
+}
+
+- (BOOL)isFrameValid:(CGRect)frame
+{
+    return !CGRectIsNull(frame) && frame.size.width > 0 && frame.size.height > 0;
+}
+
+-(CGRect)adjustFrame:(CGRect)frame {
+    CGFloat x = frame.origin.x;
+    CGFloat y = frame.origin.y;
+    CGFloat width = frame.size.width + self.innerPadding * 2;
+    CGFloat height = frame.size.height + self.innerPadding * 2;
+    
+    width = width < self.minimumRectSize.width ? self.minimumRectSize.width : width;
+    height = height < self.minimumRectSize.height ? self.minimumRectSize.height : height;
+    x = x - ((width - frame.size.width) / 2);
+    y = y - ((height - frame.size.height) / 2);
+    
+    return CGRectMake(x, y, width, height);
+}
+
+-(CGRect)getHighlightRect
+{
+    CGRect highlightRect = self.highlightFrame;
+    if ([self isFrameValid:_viewBasedHighlightFrame]) {
+//        highlightRect = _viewBasedHighlightFrame;
+        highlightRect = [self adjustFrame: _viewBasedHighlightFrame];
+        if (_highlightViewTagParams != nil) {
+            id padding = _highlightViewTagParams[@"padding"];
+            if (padding != nil) {
+                if ([padding isKindOfClass:[NSNumber class]]) {
+                    CGFloat paddingValue = [(NSNumber*)padding floatValue];
+                    highlightRect = CGRectMake(_viewBasedHighlightFrame.origin.x - paddingValue,
+                                               _viewBasedHighlightFrame.origin.y - paddingValue,
+                                               _viewBasedHighlightFrame.size.width + paddingValue * 2,
+                                               _viewBasedHighlightFrame.size.height + paddingValue * 2);
+                } else if ([padding isKindOfClass:[NSDictionary class]]) {
+                    NSDictionary *paddingDic = (NSDictionary*)padding;
+                    CGFloat top = [paddingDic[@"top"] floatValue];
+                    CGFloat left = [paddingDic[@"left"] floatValue];
+                    CGFloat bottom = [paddingDic[@"bottom"] floatValue];
+                    CGFloat right = [paddingDic[@"right"] floatValue];
+                    highlightRect = CGRectMake(_viewBasedHighlightFrame.origin.x - left,
+                                               _viewBasedHighlightFrame.origin.y - top,
+                                               _viewBasedHighlightFrame.size.width + right + left,
+                                               _viewBasedHighlightFrame.size.height + bottom + top);
+                }
+            }
+            
+            NSDictionary *offset = _highlightViewTagParams[@"offset"];
+            if (offset != nil) {
+                highlightRect = CGRectOffset(highlightRect, [offset[@"x"] floatValue], [offset[@"y"] floatValue]);
+            }
+        }
+    }
+    return highlightRect;
+}
+
+- (CGSize)getCornerRadiiForHighlightRect:(CGRect)highlightRect {
+    CGSize cornerRadii = CGSizeMake(highlightRect.size.width/2, highlightRect.size.height/2);
+    if (self.borderRadius != nil) {
+        CGFloat radius = [self.borderRadius floatValue];
+        cornerRadii = CGSizeMake(radius, radius);
+    }
+    return cornerRadii;
+}
+
+- (void)drawRect:(CGRect)rect
+{
+    if (![self isFrameValid:self.highlightFrame] && ![self isFrameValid:_viewBasedHighlightFrame]) {
+        UIColor *color = self.overlayColor ? self.overlayColor : [UIColor clearColor];
+        [color setFill];
+        UIRectFill(rect);
+        return;
+    }
+
+    CGContextRef context = UIGraphicsGetCurrentContext();
+    CGContextClearRect(context, rect);
+
+    CGRect highlightRect = [self getHighlightRect];
+    CGSize cornerRadii = [self getCornerRadiiForHighlightRect:highlightRect];
+    
+    UIBezierPath *clipPath = [UIBezierPath bezierPathWithRect:CGRectInfinite];
+    UIBezierPath *roundPath = [UIBezierPath bezierPathWithRoundedRect:highlightRect byRoundingCorners:UIRectCornerAllCorners cornerRadii:cornerRadii];
+    [clipPath appendPath:roundPath];
+    clipPath.usesEvenOddFillRule = YES;
+
+    CGContextSaveGState(context);
+    [clipPath addClip];
+    [self.overlayColor setFill];
+    UIRectFill(rect);
+    
+    if (self.strokeColor && self.strokeWidth) {
+        CGContextAddPath(context, roundPath.CGPath);
+        [self.strokeColor setStroke];
+        CGContextSetLineWidth(context, [self.strokeWidth floatValue]);
+        CGContextStrokePath(context);
+    }
+    
+    CGContextRestoreGState(context);
+}
+
+-(void)setHighlightFrame:(CGRect)highlightFrame
+{
+    if ([self isFrameValid:highlightFrame]) {
+        _highlightFrame = highlightFrame;
+        [self setNeedsDisplay];
+    }
+}
+
+-(void)setOverlayColor:(UIColor *)overlayColor
+{
+    _overlayColor = overlayColor;
+    [self setNeedsDisplay];
+}
+
+-(void)setMinimumRectSize:(CGSize)minimumRectSize
+{
+    _minimumRectSize = minimumRectSize;
+    [self setNeedsDisplay];
+}
+
+-(void)setInnerPadding:(CGFloat)innerPadding
+{
+    _innerPadding = innerPadding;
+    [self setNeedsDisplay];
+}
+
+-(void)setViewBasedHighlightFrameFromView:(UIView*)view {
+    _viewBasedHighlightFrame = [self convertRect:view.frame fromView:view.superview];
+    [self setNeedsDisplay];
+}
+
+-(void)setHighlightViewTag:(NSNumber *)highlightViewTag
+{
+    if (highlightViewTag) {
+        UIView *view = [_bridge.uiManager viewForReactTag:highlightViewTag];
+        if (view != nil) {
+            if (view.frame.size.width == 0 || view.frame.size.height == 0) {
+                _highlightedView = view;
+                [_highlightedView.layer addObserver:self forKeyPath:@"frame" options:NSKeyValueObservingOptionNew context:nil];
+                [_highlightedView.layer addObserver:self forKeyPath:@"bounds" options:NSKeyValueObservingOptionNew context:NULL];
+            } else {
+                [self setViewBasedHighlightFrameFromView:view];
+            }
+        }
+    }
+}
+
+-(void)setHighlightViewTagParams:(NSDictionary*)highlightViewTagParams
+{
+    _highlightViewTagParams = highlightViewTagParams;
+    [self setNeedsDisplay];
+}
+
+#pragma mark - KVO
+
+-(void)clearObserver
+{
+    if (_highlightedView != nil) {
+        [_highlightedView.layer removeObserver:self forKeyPath:@"frame"];
+        [_highlightedView.layer removeObserver:self forKeyPath:@"bounds"];
+        _highlightedView = nil;
+    }
+}
+
+- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
+{
+    if ((object == _highlightedView.layer) && ([keyPath isEqualToString:@"frame"] || [keyPath isEqualToString:@"bounds"]))
+    {
+        CGRect frame = [change[NSKeyValueChangeNewKey] CGRectValue];
+        if (frame.size.width > 0 && frame.size.height > 0) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                [self setViewBasedHighlightFrameFromView:_highlightedView];
+                [self clearObserver];
+            });
+        }
+    }
+}
+
+@end

package/lib/ios/reactnativeuilib/highlighterview/HighlighterViewManager.h

@@ -0,0 +1,6 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTViewManager.h>
+
+@interface HighlighterViewManager : RCTViewManager
+
+@end

package/lib/ios/reactnativeuilib/highlighterview/HighlighterViewManager.m

@@ -0,0 +1,28 @@
+#import "HighlighterViewManager.h"
+#import "HighlighterView.h"
+
+@implementation HighlighterViewManager
+
+RCT_EXPORT_MODULE()
+
+- (dispatch_queue_t)methodQueue {
+    return dispatch_get_main_queue();
+}
+
+- (UIView *)view
+{
+  return [[HighlighterView alloc] initWithFrame:CGRectZero bridge:self.bridge];
+}
+
+RCT_REMAP_VIEW_PROPERTY(highlightFrame, highlightFrame, CGRect)
+RCT_REMAP_VIEW_PROPERTY(highlightViewTag, highlightViewTag, NSNumber)
+RCT_REMAP_VIEW_PROPERTY(highlightViewTagParams, highlightViewTagParams, NSDictionary)
+RCT_REMAP_VIEW_PROPERTY(overlayColor, overlayColor, UIColor)
+RCT_REMAP_VIEW_PROPERTY(borderRadius, borderRadius, NSNumber)
+RCT_REMAP_VIEW_PROPERTY(strokeColor, strokeColor, UIColor)
+RCT_REMAP_VIEW_PROPERTY(strokeWidth, strokeWidth, NSNumber)
+RCT_REMAP_VIEW_PROPERTY(minimumRectSize, minimumRectSize, CGSize)
+RCT_REMAP_VIEW_PROPERTY(innerPadding, innerPadding, CGFloat)
+
+
+@end

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

@@ -0,0 +1,39 @@
+//
+//  Color+Interpolation.h
+//
+//  Created by Leo Natan on 01/10/2016.
+//  Copyright © 2016 Leo Natan. All rights reserved.
+//
+
+#if __has_include(<UIKit/UIKit.h>) || __has_include(<AppKit/AppKit.h>)
+
+#import "LNInterpolable.h"
+
+#if __has_include(<UIKit/UIKit.h>)
+#import <UIKit/UIKit.h>
+#else
+#import <AppKit/AppKit.h>
+#endif
+
+/**
+ Interpolate using the LAB color space for optimal quality. This constant is equal to @c LNUseDefaultInterpolationBehavior.
+ */
+extern LNInterpolationBehavior const RNUIInterpolationBehaviorUseLABColorSpace;
+
+/**
+ Interpolate using the RGB color space.
+ */
+extern LNInterpolationBehavior const RNUIInterpolationBehaviorUseRGBColorSpace;
+
+/**
+ Interpolates between colors.
+ 
+ By default, colors are interpolated in the Lab color space for optimal quality at the expense of some performance. Use @c LNUseRGBInterpolationBehavior for better performance but suboptimal quality.
+ */
+#if __has_include(<UIKit/UIKit.h>)
+@interface UIColor (LNInterpolation) <LNInterpolable> @end
+#else
+@interface NSColor (LNInterpolation) <LNInterpolable> @end
+#endif
+
+#endif

package/lib/ios/reactnativeuilib/keyboardinput/lninterpolation/Color+Interpolation.m

@@ -0,0 +1,160 @@
+//
+//  Color+Interpolation.m
+//
+//  Created by Leo Natan on 01/10/2016.
+//  Copyright © 2016 Leo Natan. All rights reserved.
+//
+
+#if __has_include(<UIKit/UIKit.h>) || __has_include(<AppKit/AppKit.h>)
+
+#import "Color+Interpolation.h"
+
+#if __has_include(<UIKit/UIKit.h>)
+#define Color UIColor
+#else
+#define Color NSColor
+#endif
+
+#define SWAP(x, y) do { __typeof(x) __ZZZZ__SWAP = x; x = y; y = __ZZZZ__SWAP; } while(0)
+
+//Same value as LNInterpolationBehaviorUseDefault
+LNInterpolationBehavior const RNUIInterpolationBehaviorUseLABColorSpace = @"LNInterpolationBehaviorUseDefault";
+LNInterpolationBehavior const RNUIInterpolationBehaviorUseRGBColorSpace = @"LNInterpolationBehaviorUseRGB";
+
+extern double LNLinearInterpolate(double from, double to, double p);
+
+static NSArray<NSNumber*>* LNRGBComponentsFromColor(Color* color)
+{
+    size_t numberOfComponents = CGColorGetNumberOfComponents(color.CGColor);
+    const CGFloat* components = CGColorGetComponents(color.CGColor);
+    
+    return numberOfComponents == 2 ? @[@(components[0]), @(components[0]), @(components[0]), @(components[1])] : @[@(components[0]), @(components[1]), @(components[2]), @(components[3])];
+}
+
+static Color* LNColorFromRGBComponents(NSArray<NSNumber*>* components)
+{
+    return [Color colorWithRed:components[0].doubleValue green:components[1].doubleValue blue:components[2].doubleValue alpha:components[3].doubleValue];
+}
+
+static NSArray<NSNumber*>* LNLabComponentsFromColor(Color* color)
+{
+    NSArray<NSNumber*>* rgbComponents = LNRGBComponentsFromColor(color);
+    CGFloat r = rgbComponents[0].doubleValue;
+    CGFloat g = rgbComponents[1].doubleValue;
+    CGFloat b = rgbComponents[2].doubleValue;
+    
+    //RGB -> XYZ
+    //http://www.brucelindbloom.com/index.html?Eqn_RGB_to_XYZ.html
+
+    r = (r > 0.04045) ? pow((r + 0.055) / 1.055, 2.4) : (r / 12.92);
+    g = (g > 0.04045) ? pow((g + 0.055) / 1.055, 2.4) : (g / 12.92);
+    b = (b > 0.04045) ? pow((b + 0.055) / 1.055, 2.4) : (b / 12.92);
+    
+    //http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html (sRGB -> XYZ)
+    CGFloat x = r * 41.24564 + g * 35.75761 + b * 18.04375;
+    CGFloat y = r * 21.26729 + g * 71.51522 + b * 07.21750;
+    CGFloat z = r * 01.93339 + g * 11.91920 + b * 95.03041;
+    
+    //XYZ -> Lab
+    //http://www.brucelindbloom.com/index.html?Eqn_XYZ_to_Lab.html
+    
+    static const CGFloat eps = 216.0 / 24389.0;
+    static const CGFloat k = 24389.0 / 27.0;
+    
+    x = x / 100.0;//95.047;
+    y = y / 100.0;//100.000;
+    z = z / 100.0;//108.883;
+    
+    x = x > eps ? pow(x, 1.0 / 3.0) : (k * x + 16.0) / 116.0;
+    y = y > eps ? pow(y, 1.0 / 3.0) : (k * y + 16.0) / 116.0;
+    z = z > eps ? pow(z, 1.0 / 3.0) : (k * z + 16.0) / 116.0;
+    
+    CGFloat l = 116 * y - 16;
+    CGFloat a = 500 * (x - y);
+            b = 200 * (y - z);
+    
+    return @[@(l), @(a), @(b), rgbComponents[3]];
+}
+
+static Color* LNColorFromLabComponents(NSArray<NSNumber*>* components)
+{
+    CGFloat l = components[0].doubleValue;
+    CGFloat a = components[1].doubleValue;
+    CGFloat b = components[2].doubleValue;
+    
+    //Lab -> XYZ
+    //http://www.brucelindbloom.com/index.html?Eqn_Lab_to_XYZ.html
+    
+    static const CGFloat eps = 216.0 / 24389.0;
+    static const CGFloat k = 24389.0 / 27.0;
+    
+    CGFloat y = (l + 16.0) / 116.0;
+    CGFloat x = a / 500 + y;
+    CGFloat z = y - b / 200;
+
+    x = pow(x, 3.0) > eps ? pow(x, 3.0) : (116 * x - 16) / k;
+    y = l > k * eps ? pow((l + 16) / 116, 3.0) : l / k;
+    z = pow(z, 3.0) > eps ? pow(z, 3.0) : (116 * z - 16) / k;
+    
+    x = x * 1.0;//.95047;
+    y = y * 1.0;//1.00000;
+    z = z * 1.0;//1.08883;
+    
+    //XYZ -> RGB
+    
+    //http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html (XYZ -> sRGB)
+    CGFloat r = x *  3.2404542 + y * -1.5371385 + z * -0.4985314;
+    CGFloat g = x * -0.9692660 + y *  1.8760108 + z *  0.0415560;
+            b = x *  0.0556434 + y * -0.2040259 + z *  1.0572252;
+    
+    r = r <= 0.0031308 ? 12.92 * r : 1.055 * pow(r, 1.0 / 2.4) - 0.055;
+    g = g <= 0.0031308 ? 12.92 * g : 1.055 * pow(g, 1.0 / 2.4) - 0.055;
+    b = b <= 0.0031308 ? 12.92 * b : 1.055 * pow(b, 1.0 / 2.4) - 0.055;
+    
+    // return Color
+    return LNColorFromRGBComponents(@[@(r), @(g), @(b), components[3]]);
+}
+
+static inline Color* LNInterpolateColor(Color* fromValue, Color* toValue, CGFloat p, NSArray* (*compConverter)(Color*), Color* (*colorConverter)(NSArray*))
+{
+    NSArray<NSNumber*>* arrayC1 = compConverter(fromValue);
+    NSArray<NSNumber*>* arrayC2 = compConverter(toValue);
+    
+    NSMutableArray<NSNumber*>* arrayOutput = [NSMutableArray new];
+    [arrayC1 enumerateObjectsUsingBlock:^(NSNumber * _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
+        arrayOutput[idx] = @(LNLinearInterpolate(obj.doubleValue, arrayC2[idx].doubleValue, p));
+    }];
+    
+    return colorConverter(arrayOutput);
+}
+
+@implementation Color (Interpolation)
+
+- (instancetype)interpolateToValue:(Color*)toValue progress:(double)p
+{
+    return [self interpolateToValue:toValue progress:p behavior:LNInterpolationBehaviorUseDefault];
+}
+
+- (instancetype)interpolateToValue:(id)toValue progress:(double)p behavior:(LNInterpolationBehavior)behavior
+{
+    if([toValue isKindOfClass:[Color class]] == NO)
+    {
+        return nil;
+    }
+    
+    if(p <= 0)
+    {
+        return self;
+    }
+    
+    if(p >= 1)
+    {
+        return toValue;
+    }
+    
+    return LNInterpolateColor(self, toValue, p, behavior == RNUIInterpolationBehaviorUseRGBColorSpace ? LNRGBComponentsFromColor : LNLabComponentsFromColor, behavior == RNUIInterpolationBehaviorUseRGBColorSpace ? LNColorFromRGBComponents : LNColorFromLabComponents);
+}
+
+@end
+
+#endif

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

@@ -0,0 +1,36 @@
+//
+//  LNFrameAnimator.h
+//  KeyboardTransitionDemo
+//
+//  Created by Leo Natan (Wix) on 11/05/2017.
+//  Copyright © 2017 Wix. All rights reserved.
+//
+
+@import UIKit;
+
+@protocol LNAnimationTemp <NSObject>
+
+@property (nonatomic) CGFloat progress;
+
+@end
+
+@interface LNViewAnimationTemp : NSObject <LNAnimationTemp>
+
+@property (nonatomic, strong, readonly) UIView* view;
+@property (nonatomic, strong, readonly) NSString* keyPath;
+@property (nonatomic, strong, readonly) id toValue;
+
++ (instancetype)animationWithView:(UIView*)view keyPath:(NSString*)keyPath toValue:(id)toValue;
+
+@end
+
+@interface LNAnimatorTemp : NSObject
+
+@property (nonatomic, readonly) NSTimeInterval duration;
+@property (nonatomic, strong, readonly) NSArray<id<LNAnimationTemp>>* animations;
+
++ (instancetype)animatorWithDuration:(NSTimeInterval)duration animations:(NSArray<id<LNAnimationTemp>>*)animations completionHandler:(void(^)(BOOL completed))completionHandler;
+
+- (void)start;
+
+@end