@nativescript/core 8.9.0-alpha.3 → 8.9.0-napi-es5.0

package/ui/animation/index.ios.js

@@ -1,5 +1,6 @@
-// Requires
-import { AnimationBase, Properties, CubicBezierAnimationCurve } from './animation-common';
+// Types
+import { AnimationBase, Properties } from './animation-common';
+import { CubicBezierAnimationCurve } from './animation-interfaces';
 import { Trace } from '../../trace';
 import { opacityProperty, backgroundColorProperty, rotateProperty, rotateXProperty, rotateYProperty, translateXProperty, translateYProperty, scaleXProperty, scaleYProperty, heightProperty, widthProperty, PercentLength } from '../styling/style-properties';
 import { ios as iosBackground } from '../styling/background';
@@ -8,11 +9,14 @@ import { ios as iosHelper } from '../../utils/native-helper';
 import { Screen } from '../../platform';
 export * from './animation-common';
 export { KeyframeAnimation, KeyframeAnimationInfo, KeyframeDeclaration, KeyframeInfo } from './keyframe-animation';
-const _transform = '_transform';
-const _skip = '_skip';
-const FLT_MAX = 340282346638528859811704183484516925440.0;
-class AnimationInfo {
-}
+var _transform = '_transform';
+var _skip = '_skip';
+var FLT_MAX = 340282346638528859811704183484516925440.0;
+var AnimationInfo = /** @class */ (function () {
+    function AnimationInfo() {
+    }
+    return AnimationInfo;
+}());
 var AnimationDelegateImpl = /** @class */ (function (_super) {
     __extends(AnimationDelegateImpl, _super);
     function AnimationDelegateImpl() {
@@ -107,84 +111,86 @@ export function _resolveAnimationCurve(curve) {
                 return curve;
             }
             else if (curve instanceof CubicBezierAnimationCurve) {
-                const animationCurve = curve;
-                return CAMediaTimingFunction.functionWithControlPoints(animationCurve.x1, animationCurve.y1, animationCurve.x2, animationCurve.y2);
+                return CAMediaTimingFunction.functionWithControlPoints(curve.x1, curve.y1, curve.x2, curve.y2);
             }
             else {
-                console.error(`Invalid animation curve: ${curve}`);
+                console.error("Invalid animation curve: ".concat(curve));
             }
     }
 }
-export class Animation extends AnimationBase {
-    constructor(animationDefinitions, playSequentially) {
-        super(animationDefinitions, playSequentially);
-        this._valueSource = 'animation';
+var Animation = /** @class */ (function (_super) {
+    __extends(Animation, _super);
+    function Animation(animationDefinitions, playSequentially) {
+        var _this = _super.call(this, animationDefinitions, playSequentially) || this;
+        _this._valueSource = 'animation';
         if (animationDefinitions.length > 0 && animationDefinitions[0].valueSource !== undefined) {
-            this._valueSource = animationDefinitions[0].valueSource;
+            _this._valueSource = animationDefinitions[0].valueSource;
         }
         if (!playSequentially) {
             if (Trace.isEnabled()) {
-                Trace.write('Non-merged Property Animations: ' + this._propertyAnimations.length, Trace.categories.Animation);
+                Trace.write('Non-merged Property Animations: ' + _this._propertyAnimations.length, Trace.categories.Animation);
             }
-            this._mergedPropertyAnimations = Animation._mergeAffineTransformAnimations(this._propertyAnimations);
+            _this._mergedPropertyAnimations = Animation._mergeAffineTransformAnimations(_this._propertyAnimations);
             if (Trace.isEnabled()) {
-                Trace.write('Merged Property Animations: ' + this._mergedPropertyAnimations.length, Trace.categories.Animation);
+                Trace.write('Merged Property Animations: ' + _this._mergedPropertyAnimations.length, Trace.categories.Animation);
             }
         }
         else {
-            this._mergedPropertyAnimations = this._propertyAnimations;
+            _this._mergedPropertyAnimations = _this._propertyAnimations;
         }
-        const animationFinishedCallback = (cancelled) => {
-            if (this._playSequentially) {
+        var animationFinishedCallback = function (cancelled) {
+            if (_this._playSequentially) {
                 // This function will be called by the last animation when done or by another animation if the user cancels them halfway through.
                 if (!cancelled) {
-                    this._resolveAnimationFinishedPromise();
+                    _this._resolveAnimationFinishedPromise();
                 }
             }
             else {
                 // This callback will be called by each INDIVIDUAL animation when it finishes or is cancelled.
                 if (cancelled) {
-                    this._cancelledAnimations++;
+                    _this._cancelledAnimations++;
                 }
                 else {
-                    this._finishedAnimations++;
+                    _this._finishedAnimations++;
                 }
-                if (this._cancelledAnimations > 0 && this._cancelledAnimations + this._finishedAnimations === this._mergedPropertyAnimations.length) {
+                if (_this._cancelledAnimations > 0 && _this._cancelledAnimations + _this._finishedAnimations === _this._mergedPropertyAnimations.length) {
                     if (Trace.isEnabled()) {
-                        Trace.write(this._cancelledAnimations + ' animations cancelled.', Trace.categories.Animation);
+                        Trace.write(_this._cancelledAnimations + ' animations cancelled.', Trace.categories.Animation);
                     }
                 }
-                else if (this._finishedAnimations === this._mergedPropertyAnimations.length) {
+                else if (_this._finishedAnimations === _this._mergedPropertyAnimations.length) {
                     if (Trace.isEnabled()) {
-                        Trace.write(this._finishedAnimations + ' animations finished.', Trace.categories.Animation);
+                        Trace.write(_this._finishedAnimations + ' animations finished.', Trace.categories.Animation);
                     }
-                    this._resolveAnimationFinishedPromise();
+                    _this._resolveAnimationFinishedPromise();
                 }
             }
         };
-        this._iOSAnimationFunction = Animation._createiOSAnimationFunction(this._mergedPropertyAnimations, 0, this._playSequentially, this._valueSource, animationFinishedCallback);
+        _this._iOSAnimationFunction = Animation._createiOSAnimationFunction(_this._mergedPropertyAnimations, 0, _this._playSequentially, _this._valueSource, animationFinishedCallback);
+        return _this;
     }
-    play() {
+    Animation.prototype.play = function () {
         if (this.isPlaying) {
             return this._rejectAlreadyPlaying();
         }
-        const animationFinishedPromise = super.play();
+        var animationFinishedPromise = _super.prototype.play.call(this);
         this._finishedAnimations = 0;
         this._cancelledAnimations = 0;
         this._iOSAnimationFunction();
         return animationFinishedPromise;
-    }
-    cancel() {
+    };
+    Animation.prototype.cancel = function () {
+        var _a;
         if (!this.isPlaying) {
             Trace.write('Animation is not currently playing.', Trace.categories.Animation, Trace.messageType.warn);
             return;
         }
         if (this._mergedPropertyAnimations) {
-            for (let i = 0; i < this._mergedPropertyAnimations.length; i++) {
-                const propertyAnimation = this._mergedPropertyAnimations[i];
+            for (var i = 0; i < this._mergedPropertyAnimations.length; i++) {
+                var propertyAnimation = this._mergedPropertyAnimations[i];
                 if (propertyAnimation) {
-                    if (propertyAnimation.target?.nativeViewProtected) {
-                        const nativeView = propertyAnimation.target.nativeViewProtected;
+                    if ((_a = propertyAnimation.target) === null || _a === void 0 ? void 0 : _a.nativeViewProtected) {
+                        var nativeView = propertyAnimation.target.nativeViewProtected;
                         if (nativeView.layer.mask) {
                             nativeView.layer.mask.removeAllAnimations();
                         }
@@ -198,10 +204,10 @@ export class Animation extends AnimationBase {
                             if (nativeView.borderLayer.mask) {
                                 nativeView.borderLayer.mask.removeAllAnimations();
                             }
-                            const borderLayers = nativeView.borderLayer.sublayers;
-                            if (borderLayers?.count) {
-                                for (let i = 0, count = borderLayers.count; i < count; i++) {
-                                    borderLayers[i].removeAllAnimations();
+                            var borderLayers = nativeView.borderLayer.sublayers;
+                            if (borderLayers === null || borderLayers === void 0 ? void 0 : borderLayers.count) {
+                                for (var i_1 = 0, count = borderLayers.count; i_1 < count; i_1++) {
+                                    borderLayers[i_1].removeAllAnimations();
                                 }
                             }
                             nativeView.borderLayer.removeAllAnimations();
@@ -211,10 +217,10 @@ export class Animation extends AnimationBase {
                             if (nativeView.outerShadowContainerLayer.mask) {
                                 nativeView.outerShadowContainerLayer.mask.removeAllAnimations();
                             }
-                            const outerShadowLayers = nativeView.outerShadowContainerLayer.sublayers;
-                            if (outerShadowLayers?.count) {
-                                for (let i = 0, count = outerShadowLayers.count; i < count; i++) {
-                                    const shadowLayer = outerShadowLayers[i];
+                            var outerShadowLayers = nativeView.outerShadowContainerLayer.sublayers;
+                            if (outerShadowLayers === null || outerShadowLayers === void 0 ? void 0 : outerShadowLayers.count) {
+                                for (var i_2 = 0, count = outerShadowLayers.count; i_2 < count; i_2++) {
+                                    var shadowLayer = outerShadowLayers[i_2];
                                     if (shadowLayer.mask) {
                                         shadowLayer.mask.removeAllAnimations();
                                     }
@@ -230,12 +236,12 @@ export class Animation extends AnimationBase {
                 }
             }
         }
-    }
-    _resolveAnimationCurve(curve) {
+    };
+    Animation.prototype._resolveAnimationCurve = function (curve) {
         return _resolveAnimationCurve(curve);
-    }
-    static _createiOSAnimationFunction(propertyAnimations, index, playSequentially, valueSource, finishedCallback) {
-        return (cancelled) => {
+    };
+    Animation._createiOSAnimationFunction = function (propertyAnimations, index, playSequentially, valueSource, finishedCallback) {
+        return function (cancelled) {
             if (cancelled && finishedCallback) {
                 if (Trace.isEnabled()) {
                     Trace.write('Animation ' + (index - 1).toString() + ' was cancelled. Will skip the rest of animations and call finishedCallback(true).', Trace.categories.Animation);
@@ -243,8 +249,8 @@ export class Animation extends AnimationBase {
                 finishedCallback(cancelled);
                 return;
             }
-            const animation = propertyAnimations[index];
-            const args = Animation._getNativeAnimationArguments(animation, valueSource);
+            var animation = propertyAnimations[index];
+            var args = Animation._getNativeAnimationArguments(animation, valueSource);
             if (animation.curve === 'spring') {
                 Animation._createNativeSpringAnimation(propertyAnimations, index, playSequentially, args, animation, valueSource, finishedCallback);
             }
@@ -252,34 +258,35 @@ export class Animation extends AnimationBase {
                 Animation._createNativeAnimation(propertyAnimations, index, playSequentially, args, animation, valueSource, finishedCallback);
             }
         };
-    }
-    static _getNativeAnimationArguments(animation, valueSource) {
-        const view = animation.target;
-        const style = view.style;
-        const nativeView = view.nativeViewProtected;
-        const parent = view.parent;
-        let propertyNameToAnimate = animation.property;
-        let subPropertyNameToAnimate;
-        let toValue = animation.value;
-        let fromValue;
+    };
+    Animation._getNativeAnimationArguments = function (animation, valueSource) {
+        var _a;
+        var view = animation.target;
+        var style = view.style;
+        var nativeView = view.nativeViewProtected;
+        var parent = view.parent;
+        var propertyNameToAnimate = animation.property;
+        var subPropertyNameToAnimate;
+        var toValue = animation.value;
+        var fromValue;
         if (nativeView) {
-            const setLocal = valueSource === 'animation';
+            var setLocal_1 = valueSource === 'animation';
             switch (animation.property) {
                 case Properties.backgroundColor:
                     animation._originalValue = view.backgroundColor;
-                    animation._propertyResetCallback = (value, valueSource) => {
-                        style[setLocal ? backgroundColorProperty.name : backgroundColorProperty.keyframe] = value;
+                    animation._propertyResetCallback = function (value, valueSource) {
+                        style[setLocal_1 ? backgroundColorProperty.name : backgroundColorProperty.keyframe] = value;
                     };
                     fromValue = nativeView.layer.backgroundColor;
                     if (nativeView instanceof UILabel) {
                         nativeView.setValueForKey(UIColor.clearColor, 'backgroundColor');
                     }
-                    toValue = toValue?.ios?.CGColor;
+                    toValue = (_a = toValue === null || toValue === void 0 ? void 0 : toValue.ios) === null || _a === void 0 ? void 0 : _a.CGColor;
                     break;
                 case Properties.opacity:
                     animation._originalValue = view.opacity;
-                    animation._propertyResetCallback = (value, valueSource) => {
-                        style[setLocal ? opacityProperty.name : opacityProperty.keyframe] = value;
+                    animation._propertyResetCallback = function (value, valueSource) {
+                        style[setLocal_1 ? opacityProperty.name : opacityProperty.keyframe] = value;
                     };
                     fromValue = nativeView.layer.opacity;
                     break;
@@ -289,10 +296,10 @@ export class Animation extends AnimationBase {
                         y: view.rotateY,
                         z: view.rotate,
                     };
-                    animation._propertyResetCallback = (value, valueSource) => {
-                        style[setLocal ? rotateProperty.name : rotateProperty.keyframe] = value.z;
-                        style[setLocal ? rotateXProperty.name : rotateXProperty.keyframe] = value.x;
-                        style[setLocal ? rotateYProperty.name : rotateYProperty.keyframe] = value.y;
+                    animation._propertyResetCallback = function (value, valueSource) {
+                        style[setLocal_1 ? rotateProperty.name : rotateProperty.keyframe] = value.z;
+                        style[setLocal_1 ? rotateXProperty.name : rotateXProperty.keyframe] = value.x;
+                        style[setLocal_1 ? rotateYProperty.name : rotateYProperty.keyframe] = value.y;
                     };
                     propertyNameToAnimate = 'transform.rotation';
                     subPropertyNameToAnimate = ['x', 'y', 'z'];
@@ -322,9 +329,9 @@ export class Animation extends AnimationBase {
                         x: view.translateX,
                         y: view.translateY,
                     };
-                    animation._propertyResetCallback = (value, valueSource) => {
-                        style[setLocal ? translateXProperty.name : translateXProperty.keyframe] = value.x;
-                        style[setLocal ? translateYProperty.name : translateYProperty.keyframe] = value.y;
+                    animation._propertyResetCallback = function (value, valueSource) {
+                        style[setLocal_1 ? translateXProperty.name : translateXProperty.keyframe] = value.x;
+                        style[setLocal_1 ? translateYProperty.name : translateYProperty.keyframe] = value.y;
                     };
                     propertyNameToAnimate = 'transform';
                     fromValue = NSValue.valueWithCATransform3D(nativeView.layer.transform);
@@ -338,9 +345,9 @@ export class Animation extends AnimationBase {
                         toValue.y = 0.001;
                     }
                     animation._originalValue = { x: view.scaleX, y: view.scaleY };
-                    animation._propertyResetCallback = (value, valueSource) => {
-                        style[setLocal ? scaleXProperty.name : scaleXProperty.keyframe] = value.x;
-                        style[setLocal ? scaleYProperty.name : scaleYProperty.keyframe] = value.y;
+                    animation._propertyResetCallback = function (value, valueSource) {
+                        style[setLocal_1 ? scaleXProperty.name : scaleXProperty.keyframe] = value.x;
+                        style[setLocal_1 ? scaleYProperty.name : scaleYProperty.keyframe] = value.y;
                     };
                     propertyNameToAnimate = 'transform';
                     fromValue = NSValue.valueWithCATransform3D(nativeView.layer.transform);
@@ -357,53 +364,53 @@ export class Animation extends AnimationBase {
                         ry: view.rotateY,
                         rz: view.rotate,
                     };
-                    animation._propertyResetCallback = (value, valueSource) => {
-                        style[setLocal ? translateXProperty.name : translateXProperty.keyframe] = value.xt;
-                        style[setLocal ? translateYProperty.name : translateYProperty.keyframe] = value.yt;
-                        style[setLocal ? scaleXProperty.name : scaleXProperty.keyframe] = value.xs;
-                        style[setLocal ? scaleYProperty.name : scaleYProperty.keyframe] = value.ys;
-                        style[setLocal ? rotateXProperty.name : rotateXProperty.keyframe] = value.rx;
-                        style[setLocal ? rotateYProperty.name : rotateYProperty.keyframe] = value.ry;
-                        style[setLocal ? rotateProperty.name : rotateProperty.keyframe] = value.rz;
+                    animation._propertyResetCallback = function (value, valueSource) {
+                        style[setLocal_1 ? translateXProperty.name : translateXProperty.keyframe] = value.xt;
+                        style[setLocal_1 ? translateYProperty.name : translateYProperty.keyframe] = value.yt;
+                        style[setLocal_1 ? scaleXProperty.name : scaleXProperty.keyframe] = value.xs;
+                        style[setLocal_1 ? scaleYProperty.name : scaleYProperty.keyframe] = value.ys;
+                        style[setLocal_1 ? rotateXProperty.name : rotateXProperty.keyframe] = value.rx;
+                        style[setLocal_1 ? rotateYProperty.name : rotateYProperty.keyframe] = value.ry;
+                        style[setLocal_1 ? rotateProperty.name : rotateProperty.keyframe] = value.rz;
                     };
                     propertyNameToAnimate = 'transform';
                     toValue = NSValue.valueWithCATransform3D(Animation._createNativeAffineTransform(animation));
                     break;
                 case Properties.width:
                 case Properties.height: {
-                    const direction = animation.property;
-                    const isHeight = direction === 'height';
+                    var direction = animation.property;
+                    var isHeight_1 = direction === 'height';
                     propertyNameToAnimate = 'bounds';
                     if (!parent) {
-                        console.error(`cannot animate ${direction} on root view`);
+                        console.error("cannot animate ".concat(direction, " on root view"));
                     }
-                    const parentExtent = isHeight ? parent.getMeasuredHeight() : parent.getMeasuredWidth();
-                    const asNumber = PercentLength.toDevicePixels(PercentLength.parse(toValue), parentExtent, parentExtent) / Screen.mainScreen.scale;
-                    const currentBounds = nativeView.layer.bounds;
-                    const extentX = isHeight ? currentBounds.size.width : asNumber;
-                    const extentY = isHeight ? asNumber : currentBounds.size.height;
+                    var parentExtent = isHeight_1 ? parent.getMeasuredHeight() : parent.getMeasuredWidth();
+                    var asNumber = PercentLength.toDevicePixels(PercentLength.parse(toValue), parentExtent, parentExtent) / Screen.mainScreen.scale;
+                    var currentBounds = nativeView.layer.bounds;
+                    var extentX = isHeight_1 ? currentBounds.size.width : asNumber;
+                    var extentY = isHeight_1 ? asNumber : currentBounds.size.height;
                     fromValue = NSValue.valueWithCGRect(currentBounds);
                     toValue = NSValue.valueWithCGRect(CGRectMake(currentBounds.origin.x, currentBounds.origin.y, extentX, extentY));
-                    animation._originalValue = view[isHeight ? 'height' : 'width'];
-                    animation._propertyResetCallback = (value, valueSource) => {
-                        const prop = isHeight ? heightProperty : widthProperty;
-                        style[setLocal ? prop.name : prop.keyframe] = value;
+                    animation._originalValue = view[isHeight_1 ? 'height' : 'width'];
+                    animation._propertyResetCallback = function (value, valueSource) {
+                        var prop = isHeight_1 ? heightProperty : widthProperty;
+                        style[setLocal_1 ? prop.name : prop.keyframe] = value;
                     };
                     break;
                 }
                 default:
-                    console.error(`Animating property '${animation.property}' is unsupported`);
+                    console.error("Animating property '".concat(animation.property, "' is unsupported"));
             }
         }
-        let duration = 0.3;
+        var duration = 0.3;
         if (animation.duration !== undefined) {
             duration = animation.duration / 1000.0;
         }
-        let delay = undefined;
+        var delay = undefined;
         if (animation.delay) {
             delay = animation.delay / 1000.0;
         }
-        let repeatCount = undefined;
+        var repeatCount = undefined;
         if (animation.iterations !== undefined) {
             if (animation.iterations === Number.POSITIVE_INFINITY) {
                 repeatCount = FLT_MAX;
@@ -421,17 +428,17 @@ export class Animation extends AnimationBase {
             repeatCount: repeatCount,
             delay: delay,
         };
-    }
-    static _createNativeAnimation(propertyAnimations, index, playSequentially, args, animation, valueSource, finishedCallback) {
-        const nativeView = animation.target.nativeViewProtected;
-        let nativeAnimation;
+    };
+    Animation._createNativeAnimation = function (propertyAnimations, index, playSequentially, args, animation, valueSource, finishedCallback) {
+        var nativeView = animation.target.nativeViewProtected;
+        var nativeAnimation;
         if (args.subPropertiesToAnimate) {
             nativeAnimation = this._createGroupAnimation(args, animation);
         }
         else {
             nativeAnimation = this._createBasicAnimation(args, animation);
         }
-        const animationDelegate = AnimationDelegateImpl.initWithFinishedCallback(finishedCallback, animation, valueSource);
+        var animationDelegate = AnimationDelegateImpl.initWithFinishedCallback(finishedCallback, animation, valueSource);
         nativeAnimation.setValueForKey(animationDelegate, 'delegate');
         if (nativeView) {
             nativeView.layer.addAnimationForKey(nativeAnimation, args.propertyNameToAnimate);
@@ -443,7 +450,7 @@ export class Animation extends AnimationBase {
                 nativeView.outerShadowContainerLayer.addAnimationForKey(nativeAnimation, args.propertyNameToAnimate);
             }
         }
-        let callback = undefined;
+        var callback = undefined;
         if (index + 1 < propertyAnimations.length) {
             callback = Animation._createiOSAnimationFunction(propertyAnimations, index + 1, playSequentially, valueSource, finishedCallback);
             if (!playSequentially) {
@@ -453,9 +460,10 @@ export class Animation extends AnimationBase {
                 animationDelegate.nextAnimation = callback;
             }
         }
-    }
-    static _createGroupAnimation(args, animation) {
-        const groupAnimation = CAAnimationGroup.new();
+    };
+    Animation._createGroupAnimation = function (args, animation) {
+        var _this = this;
+        var groupAnimation = CAAnimationGroup.new();
         groupAnimation.duration = args.duration;
         if (args.repeatCount !== undefined) {
             groupAnimation.repeatCount = args.repeatCount;
@@ -466,20 +474,20 @@ export class Animation extends AnimationBase {
         if (animation.curve !== undefined) {
             groupAnimation.timingFunction = animation.curve;
         }
-        const animations = NSMutableArray.alloc().initWithCapacity(3);
-        args.subPropertiesToAnimate.forEach((property) => {
-            const basicAnimationArgs = { ...args, duration: undefined, repeatCount: undefined, delay: undefined, curve: undefined };
-            basicAnimationArgs.propertyNameToAnimate = `${args.propertyNameToAnimate}.${property}`;
+        var animations = NSMutableArray.alloc().initWithCapacity(3);
+        args.subPropertiesToAnimate.forEach(function (property) {
+            var basicAnimationArgs = __assign(__assign({}, args), { duration: undefined, repeatCount: undefined, delay: undefined, curve: undefined });
+            basicAnimationArgs.propertyNameToAnimate = "".concat(args.propertyNameToAnimate, ".").concat(property);
             basicAnimationArgs.fromValue = args.fromValue[property];
             basicAnimationArgs.toValue = args.toValue[property];
-            const basicAnimation = this._createBasicAnimation(basicAnimationArgs, animation);
+            var basicAnimation = _this._createBasicAnimation(basicAnimationArgs, animation);
             animations.addObject(basicAnimation);
         });
         groupAnimation.animations = animations;
         return groupAnimation;
-    }
-    static _createBasicAnimation(args, animation) {
-        const basicAnimation = CABasicAnimation.animationWithKeyPath(args.propertyNameToAnimate);
+    };
+    Animation._createBasicAnimation = function (args, animation) {
+        var basicAnimation = CABasicAnimation.animationWithKeyPath(args.propertyNameToAnimate);
         basicAnimation.fromValue = args.fromValue;
         basicAnimation.toValue = args.toValue;
         basicAnimation.duration = args.duration;
@@ -493,11 +501,11 @@ export class Animation extends AnimationBase {
             basicAnimation.timingFunction = animation.curve;
         }
         return basicAnimation;
-    }
-    static _createNativeSpringAnimation(propertyAnimations, index, playSequentially, args, animation, valueSource, finishedCallback) {
-        const nativeView = animation.target.nativeViewProtected;
-        let callback = undefined;
-        let nextAnimation;
+    };
+    Animation._createNativeSpringAnimation = function (propertyAnimations, index, playSequentially, args, animation, valueSource, finishedCallback) {
+        var nativeView = animation.target.nativeViewProtected;
+        var callback = undefined;
+        var nextAnimation;
         if (index + 1 < propertyAnimations.length) {
             callback = Animation._createiOSAnimationFunction(propertyAnimations, index + 1, playSequentially, valueSource, finishedCallback);
             if (!playSequentially) {
@@ -507,11 +515,11 @@ export class Animation extends AnimationBase {
                 nextAnimation = callback;
             }
         }
-        let delay = 0;
+        var delay = 0;
         if (args.delay) {
             delay = args.delay;
         }
-        UIView.animateWithDurationDelayUsingSpringWithDampingInitialSpringVelocityOptionsAnimationsCompletion(args.duration, delay, 0.2, 0, 196608 /* UIViewAnimationOptions.CurveLinear */, () => {
+        UIView.animateWithDurationDelayUsingSpringWithDampingInitialSpringVelocityOptionsAnimationsCompletion(args.duration, delay, 0.2, 0, 196608 /* UIViewAnimationOptions.CurveLinear */, function () {
             if (args.repeatCount !== undefined) {
                 UIView.setAnimationRepeatCount(args.repeatCount);
             }
@@ -568,41 +576,41 @@ export class Animation extends AnimationBase {
                 }
             }
             if (finishedCallback) {
-                const cancelled = !animationDidFinish;
+                var cancelled = !animationDidFinish;
                 finishedCallback(cancelled);
             }
             if (animationDidFinish && nextAnimation) {
                 nextAnimation();
             }
         });
-    }
-    static _createNativeAffineTransform(animation) {
-        const value = animation.value;
-        let result = CATransform3DIdentity;
+    };
+    Animation._createNativeAffineTransform = function (animation) {
+        var value = animation.value;
+        var result = CATransform3DIdentity;
         if (value[Properties.translate] !== undefined) {
-            const x = value[Properties.translate].x;
-            const y = value[Properties.translate].y;
+            var x = value[Properties.translate].x;
+            var y = value[Properties.translate].y;
             result = CATransform3DTranslate(result, x, y, 0);
         }
         if (value[Properties.scale] !== undefined) {
-            const x = value[Properties.scale].x;
-            const y = value[Properties.scale].y;
+            var x = value[Properties.scale].x;
+            var y = value[Properties.scale].y;
             result = CATransform3DScale(result, x === 0 ? 0.001 : x, y === 0 ? 0.001 : y, 1);
         }
         return result;
-    }
-    static _isAffineTransform(property) {
+    };
+    Animation._isAffineTransform = function (property) {
         return property === _transform || property === Properties.translate || property === Properties.scale;
-    }
-    static _canBeMerged(animation1, animation2) {
-        const result = Animation._isAffineTransform(animation1.property) && Animation._isAffineTransform(animation2.property) && animation1.target === animation2.target && animation1.duration === animation2.duration && animation1.delay === animation2.delay && animation1.iterations === animation2.iterations && animation1.curve === animation2.curve;
+    };
+    Animation._canBeMerged = function (animation1, animation2) {
+        var result = Animation._isAffineTransform(animation1.property) && Animation._isAffineTransform(animation2.property) && animation1.target === animation2.target && animation1.duration === animation2.duration && animation1.delay === animation2.delay && animation1.iterations === animation2.iterations && animation1.curve === animation2.curve;
         return result;
-    }
-    static _mergeAffineTransformAnimations(propertyAnimations) {
-        const result = new Array();
-        let i = 0;
-        let j;
-        const length = propertyAnimations.length;
+    };
+    Animation._mergeAffineTransformAnimations = function (propertyAnimations) {
+        var result = new Array();
+        var i = 0;
+        var j;
+        var length = propertyAnimations.length;
         for (; i < length; i++) {
             if (propertyAnimations[i][_skip]) {
                 continue;
@@ -619,7 +627,7 @@ export class Animation extends AnimationBase {
                 //    rotate: 90,
                 //    scale: {x: 2, y: 2 }
                 // }
-                const newTransformAnimation = {
+                var newTransformAnimation = {
                     target: propertyAnimations[i].target,
                     property: _transform,
                     value: {},
@@ -653,17 +661,17 @@ export class Animation extends AnimationBase {
             }
         }
         return result;
-    }
-    static animateNestedLayerSizeUsingBasicAnimation(nativeView, bounds, animation, args, nativeAnimation) {
-        const view = animation.target;
+    };
+    Animation.animateNestedLayerSizeUsingBasicAnimation = function (nativeView, bounds, animation, args, nativeAnimation) {
+        var view = animation.target;
         // Gradient background animation
         if (nativeView.gradientLayer) {
             nativeView.gradientLayer.addAnimationForKey(nativeAnimation, 'bounds');
         }
-        let clipPath; // This is also used for animating shadow
+        var clipPath; // This is also used for animating shadow
         // Clipping mask animation
         if (nativeView.layer.mask instanceof CAShapeLayer) {
-            let toValue;
+            var toValue = void 0;
             if (nativeView.maskType === iosViewUtils.LayerMask.BORDER) {
                 toValue = iosBackground.generateNonUniformBorderOuterClipRoundedPath(view, bounds);
             }
@@ -675,51 +683,31 @@ export class Animation extends AnimationBase {
                 Trace.write('Unknown mask on animating view: ' + view, Trace.categories.Animation, Trace.messageType.info);
             }
             if (toValue) {
-                nativeView.layer.mask.addAnimationForKey(this._createBasicAnimation({
-                    ...args,
-                    propertyNameToAnimate: 'path',
-                    fromValue: nativeView.layer.mask.path,
-                    toValue,
-                }, animation), 'path');
+                nativeView.layer.mask.addAnimationForKey(this._createBasicAnimation(__assign(__assign({}, args), { propertyNameToAnimate: 'path', fromValue: nativeView.layer.mask.path, toValue: toValue }), animation), 'path');
             }
         }
         // Border animations (uniform and non-uniform)
         if (nativeView.hasNonUniformBorder) {
             if (nativeView.borderLayer) {
-                const innerClipPath = iosBackground.generateNonUniformBorderInnerClipRoundedPath(animation.target, bounds);
+                var innerClipPath = iosBackground.generateNonUniformBorderInnerClipRoundedPath(animation.target, bounds);
                 if (nativeView.hasNonUniformBorderColor) {
-                    const borderMask = nativeView.borderLayer.mask;
+                    var borderMask = nativeView.borderLayer.mask;
                     if (borderMask instanceof CAShapeLayer) {
-                        borderMask.addAnimationForKey(this._createBasicAnimation({
-                            ...args,
-                            propertyNameToAnimate: 'path',
-                            fromValue: borderMask.path,
-                            toValue: innerClipPath,
-                        }, animation), 'path');
+                        borderMask.addAnimationForKey(this._createBasicAnimation(__assign(__assign({}, args), { propertyNameToAnimate: 'path', fromValue: borderMask.path, toValue: innerClipPath }), animation), 'path');
                     }
-                    const borderLayers = nativeView.borderLayer.sublayers;
-                    if (borderLayers?.count) {
-                        const paths = iosBackground.generateNonUniformMultiColorBorderRoundedPaths(animation.target, bounds);
-                        for (let i = 0, count = borderLayers.count; i < count; i++) {
-                            const layer = nativeView.borderLayer.sublayers[i];
+                    var borderLayers = nativeView.borderLayer.sublayers;
+                    if (borderLayers === null || borderLayers === void 0 ? void 0 : borderLayers.count) {
+                        var paths = iosBackground.generateNonUniformMultiColorBorderRoundedPaths(animation.target, bounds);
+                        for (var i = 0, count = borderLayers.count; i < count; i++) {
+                            var layer = nativeView.borderLayer.sublayers[i];
                             if (layer instanceof CAShapeLayer) {
-                                layer.addAnimationForKey(this._createBasicAnimation({
-                                    ...args,
-                                    propertyNameToAnimate: 'path',
-                                    fromValue: layer.path,
-                                    toValue: paths[i],
-                                }, animation), 'path');
+                                layer.addAnimationForKey(this._createBasicAnimation(__assign(__assign({}, args), { propertyNameToAnimate: 'path', fromValue: layer.path, toValue: paths[i] }), animation), 'path');
                             }
                         }
                     }
                 }
                 else {
-                    nativeView.borderLayer.addAnimationForKey(this._createBasicAnimation({
-                        ...args,
-                        propertyNameToAnimate: 'path',
-                        fromValue: nativeView.borderLayer.path,
-                        toValue: innerClipPath,
-                    }, animation), 'path');
+                    nativeView.borderLayer.addAnimationForKey(this._createBasicAnimation(__assign(__assign({}, args), { propertyNameToAnimate: 'path', fromValue: nativeView.borderLayer.path, toValue: innerClipPath }), animation), 'path');
                 }
             }
         }
@@ -727,65 +715,47 @@ export class Animation extends AnimationBase {
             // TODO: Animate border width when borders get support for percentage values
             // Uniform corner radius also relies on view size
             if (nativeView.layer.cornerRadius) {
-                nativeView.layer.addAnimationForKey(this._createBasicAnimation({
-                    ...args,
-                    propertyNameToAnimate: 'cornerRadius',
-                    fromValue: nativeView.layer.cornerRadius,
-                    toValue: iosBackground.getUniformBorderRadius(animation.target, bounds),
-                }, animation), 'cornerRadius');
+                nativeView.layer.addAnimationForKey(this._createBasicAnimation(__assign(__assign({}, args), { propertyNameToAnimate: 'cornerRadius', fromValue: nativeView.layer.cornerRadius, toValue: iosBackground.getUniformBorderRadius(animation.target, bounds) }), animation), 'cornerRadius');
             }
         }
         // Shadow layers do not inherit from animating view layer
         if (nativeView.outerShadowContainerLayer) {
-            const shadowClipMask = nativeView.outerShadowContainerLayer.mask;
+            var shadowClipMask = nativeView.outerShadowContainerLayer.mask;
             // This is for animating view clip path on shadow
             if (clipPath && shadowClipMask instanceof CAShapeLayer) {
-                shadowClipMask.addAnimationForKey(this._createBasicAnimation({
-                    ...args,
-                    propertyNameToAnimate: 'path',
-                    fromValue: shadowClipMask.path,
-                    toValue: clipPath,
-                }, animation), 'path');
-            }
-            const outerShadowLayers = nativeView.outerShadowContainerLayer.sublayers;
-            if (outerShadowLayers?.count) {
-                const { maskPath, shadowPath } = iosBackground.generateShadowLayerPaths(view, bounds);
-                for (let i = 0, count = outerShadowLayers.count; i < count; i++) {
-                    const shadowLayer = outerShadowLayers[i];
-                    shadowLayer.addAnimationForKey(this._createBasicAnimation({
-                        ...args,
-                        propertyNameToAnimate: 'shadowPath',
-                        fromValue: shadowLayer.shadowPath,
-                        toValue: shadowPath,
-                    }, animation), 'shadowPath');
+                shadowClipMask.addAnimationForKey(this._createBasicAnimation(__assign(__assign({}, args), { propertyNameToAnimate: 'path', fromValue: shadowClipMask.path, toValue: clipPath }), animation), 'path');
+            }
+            var outerShadowLayers = nativeView.outerShadowContainerLayer.sublayers;
+            if (outerShadowLayers === null || outerShadowLayers === void 0 ? void 0 : outerShadowLayers.count) {
+                var _a = iosBackground.generateShadowLayerPaths(view, bounds), maskPath = _a.maskPath, shadowPath = _a.shadowPath;
+                for (var i = 0, count = outerShadowLayers.count; i < count; i++) {
+                    var shadowLayer = outerShadowLayers[i];
+                    shadowLayer.addAnimationForKey(this._createBasicAnimation(__assign(__assign({}, args), { propertyNameToAnimate: 'shadowPath', fromValue: shadowLayer.shadowPath, toValue: shadowPath }), animation), 'shadowPath');
                     if (shadowLayer.mask instanceof CAShapeLayer) {
-                        shadowLayer.mask.addAnimationForKey(this._createBasicAnimation({
-                            ...args,
-                            propertyNameToAnimate: 'path',
-                            fromValue: shadowLayer.mask.path,
-                            toValue: maskPath,
-                        }, animation), 'path');
+                        shadowLayer.mask.addAnimationForKey(this._createBasicAnimation(__assign(__assign({}, args), { propertyNameToAnimate: 'path', fromValue: shadowLayer.mask.path, toValue: maskPath }), animation), 'path');
                     }
                 }
             }
         }
-    }
-}
+    };
+    return Animation;
+}(AnimationBase));
+export { Animation };
 export function _getTransformMismatchErrorMessage(view) {
-    const expectedTransform = calculateTransform(view);
-    const expectedTransformString = getCATransform3DString(expectedTransform);
-    const actualTransformString = getCATransform3DString(view.nativeViewProtected.layer.transform);
+    var expectedTransform = calculateTransform(view);
+    var expectedTransformString = getCATransform3DString(expectedTransform);
+    var actualTransformString = getCATransform3DString(view.nativeViewProtected.layer.transform);
     if (actualTransformString !== expectedTransformString) {
         return 'View and Native transforms do not match.\nActual: ' + actualTransformString + ';\nExpected: ' + expectedTransformString;
     }
     return undefined;
 }
 function calculateTransform(view) {
-    const scaleX = view.scaleX || 1e-6;
-    const scaleY = view.scaleY || 1e-6;
-    const perspective = view.perspective || 300;
+    var scaleX = view.scaleX || 1e-6;
+    var scaleY = view.scaleY || 1e-6;
+    var perspective = view.perspective || 300;
     // Order is important: translate, rotate, scale
-    let expectedTransform = new CATransform3D(CATransform3DIdentity);
+    var expectedTransform = new CATransform3D(CATransform3DIdentity);
     // Only set perspective if there is 3D rotation
     if (view.rotateX || view.rotateY) {
         expectedTransform.m34 = -1 / perspective;
@@ -796,10 +766,6 @@ function calculateTransform(view) {
     return expectedTransform;
 }
 function getCATransform3DString(t) {
-    return `[
-    ${t.m11}, ${t.m12}, ${t.m13}, ${t.m14},
-    ${t.m21}, ${t.m22}, ${t.m23}, ${t.m24},
-    ${t.m31}, ${t.m32}, ${t.m33}, ${t.m34},
-    ${t.m41}, ${t.m42}, ${t.m43}, ${t.m44}]`;
+    return "[\n    ".concat(t.m11, ", ").concat(t.m12, ", ").concat(t.m13, ", ").concat(t.m14, ",\n    ").concat(t.m21, ", ").concat(t.m22, ", ").concat(t.m23, ", ").concat(t.m24, ",\n    ").concat(t.m31, ", ").concat(t.m32, ", ").concat(t.m33, ", ").concat(t.m34, ",\n    ").concat(t.m41, ", ").concat(t.m42, ", ").concat(t.m43, ", ").concat(t.m44, "]");
 }
 //# sourceMappingURL=index.ios.js.map