react-native-reanimated 2.9.0 → 3.0.0-rc.1

package/lib/module/reanimated2/layoutReanimation/animationBuilder/Keyframe.js

@@ -0,0 +1,233 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import { Easing } from '../../Easing';
+import { withDelay, withSequence, withTiming } from '../../animation';
+export class Keyframe {
+  /*
+    Keyframe definition should be passed in the constructor as the map
+    which keys are between range 0 - 100 (%) and correspond to the point in the animation progress.
+  */
+  constructor(definitions) {
+    _defineProperty(this, "durationV", void 0);
+
+    _defineProperty(this, "delayV", void 0);
+
+    _defineProperty(this, "callbackV", void 0);
+
+    _defineProperty(this, "definitions", void 0);
+
+    _defineProperty(this, "build", () => {
+      const delay = this.delayV;
+      const delayFunction = this.getDelayFunction();
+      const {
+        keyframes,
+        initialValues
+      } = this.parseDefinitions();
+      const callback = this.callbackV;
+      return _targetValues => {
+        'worklet';
+
+        const animations = {};
+        /* 
+              For each style property, an animations sequence is created that corresponds with its key points.
+              Transform style properties require special handling because of their nested structure.
+        */
+
+        const addAnimation = key => {
+          const keyframePoints = keyframes[key]; // in case if property was only passed as initial value
+
+          if (keyframePoints.length === 0) return;
+          const animation = delayFunction(delay, keyframePoints.length === 1 ? withTiming(keyframePoints[0].value, {
+            duration: keyframePoints[0].duration,
+            easing: keyframePoints[0].easing ? keyframePoints[0].easing : Easing.linear
+          }) : withSequence.apply(this, keyframePoints.map(keyframePoint => withTiming(keyframePoint.value, {
+            duration: keyframePoint.duration,
+            easing: keyframePoint.easing ? keyframePoint.easing : Easing.linear
+          }))));
+
+          if (key.includes('transform')) {
+            var _animations$transform;
+
+            if (!('transform' in animations)) {
+              animations.transform = [];
+            }
+
+            (_animations$transform = animations.transform) === null || _animations$transform === void 0 ? void 0 : _animations$transform.push({
+              [key.split(':')[1]]: animation
+            });
+          } else {
+            animations[key] = animation;
+          }
+        };
+
+        Object.keys(initialValues).forEach(key => {
+          if (key.includes('transform')) {
+            initialValues[key].forEach((transformProp, index) => {
+              Object.keys(transformProp).forEach(transformPropKey => {
+                addAnimation(index.toString() + '_transform:' + transformPropKey);
+              });
+            });
+          } else {
+            addAnimation(key);
+          }
+        });
+        return {
+          animations: animations,
+          initialValues: initialValues,
+          callback: callback
+        };
+      };
+    });
+
+    this.definitions = definitions;
+  }
+
+  parseDefinitions() {
+    /* 
+        Each style property contain an array with all their key points: 
+        value, duration of transition to that value, and optional easing function (defaults to Linear)
+    */
+    const parsedKeyframes = {};
+    /*
+      Parsing keyframes 'from' and 'to'.
+    */
+
+    if (this.definitions.from) {
+      if (this.definitions['0']) {
+        throw Error("You cannot provide both keyframe 0 and 'from' as they both specified initial values");
+      }
+
+      this.definitions['0'] = this.definitions.from;
+      delete this.definitions.from;
+    }
+
+    if (this.definitions.to) {
+      if (this.definitions['100']) {
+        throw Error("You cannot provide both keyframe 100 and 'to' as they both specified values at the end of the animation.");
+      }
+
+      this.definitions['100'] = this.definitions.to;
+      delete this.definitions.to;
+    }
+    /* 
+       One of the assumptions is that keyframe  0 is required to properly set initial values.
+       Every other keyframe should contain properties from the set provided as initial values.
+    */
+
+
+    if (!this.definitions['0']) {
+      throw Error("Please provide 0, or 'from' keyframe with initial state of your object.");
+    }
+
+    const initialValues = this.definitions['0'];
+    /*
+      Initialize parsedKeyframes for properties provided in initial keyframe
+    */
+
+    Object.keys(initialValues).forEach(styleProp => {
+      if (styleProp === 'transform') {
+        var _initialValues$styleP;
+
+        (_initialValues$styleP = initialValues[styleProp]) === null || _initialValues$styleP === void 0 ? void 0 : _initialValues$styleP.forEach((transformStyle, index) => {
+          Object.keys(transformStyle).forEach(transformProp => {
+            parsedKeyframes[index.toString() + '_transform:' + transformProp] = [];
+          });
+        });
+      } else {
+        parsedKeyframes[styleProp] = [];
+      }
+    });
+    const duration = this.durationV ? this.durationV : 500;
+    const animationKeyPoints = Array.from(Object.keys(this.definitions));
+
+    const getAnimationDuration = (key, currentKeyPoint) => {
+      const maxDuration = currentKeyPoint / 100 * duration;
+      const currentDuration = parsedKeyframes[key].reduce((acc, value) => acc + value.duration, 0);
+      return maxDuration - currentDuration;
+    };
+    /* 
+       Other keyframes can't contain properties that were not specified in initial keyframe.
+    */
+
+
+    const addKeyPoint = _ref => {
+      let {
+        key,
+        value,
+        currentKeyPoint,
+        easing
+      } = _ref;
+
+      if (!(key in parsedKeyframes)) {
+        throw Error("Keyframe can contain only that set of properties that were provide with initial values (keyframe 0 or 'from')");
+      }
+
+      parsedKeyframes[key].push({
+        duration: getAnimationDuration(key, currentKeyPoint),
+        value: value,
+        easing: easing
+      });
+    };
+
+    animationKeyPoints.filter(value => parseInt(value) !== 0).sort((a, b) => parseInt(a) - parseInt(b)).forEach(keyPoint => {
+      if (parseInt(keyPoint) < 0 || parseInt(keyPoint) > 100) {
+        throw Error('Keyframe should be in between range 0 - 100.');
+      }
+
+      const keyframe = this.definitions[keyPoint];
+      const easing = keyframe.easing;
+      delete keyframe.easing;
+
+      const addKeyPointWith = (key, value) => addKeyPoint({
+        key,
+        value,
+        currentKeyPoint: parseInt(keyPoint),
+        easing
+      });
+
+      Object.keys(keyframe).forEach(key => {
+        if (key === 'transform') {
+          var _keyframe$key;
+
+          (_keyframe$key = keyframe[key]) === null || _keyframe$key === void 0 ? void 0 : _keyframe$key.forEach((transformStyle, index) => {
+            Object.keys(transformStyle).forEach(transformProp => {
+              addKeyPointWith(index.toString() + '_transform:' + transformProp, transformStyle[transformProp]);
+            });
+          });
+        } else {
+          addKeyPointWith(key, keyframe[key]);
+        }
+      });
+    });
+    return {
+      initialValues: initialValues,
+      keyframes: parsedKeyframes
+    };
+  }
+
+  duration(durationMs) {
+    this.durationV = durationMs;
+    return this;
+  }
+
+  delay(delayMs) {
+    this.delayV = delayMs;
+    return this;
+  }
+
+  withCallback(callback) {
+    this.callbackV = callback;
+    return this;
+  }
+
+  getDelayFunction() {
+    const delay = this.delayV;
+    return delay ? withDelay : (_, animation) => {
+      'worklet';
+
+      return animation;
+    };
+  }
+
+}
+//# sourceMappingURL=Keyframe.js.map

package/lib/module/reanimated2/layoutReanimation/animationBuilder/Keyframe.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Easing","withDelay","withSequence","withTiming","Keyframe","constructor","definitions","delay","delayV","delayFunction","getDelayFunction","keyframes","initialValues","parseDefinitions","callback","callbackV","_targetValues","animations","addAnimation","key","keyframePoints","length","animation","value","duration","easing","linear","apply","map","keyframePoint","includes","transform","push","split","Object","keys","forEach","transformProp","index","transformPropKey","toString","parsedKeyframes","from","Error","to","styleProp","transformStyle","durationV","animationKeyPoints","Array","getAnimationDuration","currentKeyPoint","maxDuration","currentDuration","reduce","acc","addKeyPoint","filter","parseInt","sort","a","b","keyPoint","keyframe","addKeyPointWith","durationMs","delayMs","withCallback","_"],"sources":["Keyframe.ts"],"sourcesContent":["import { Easing, EasingFn } from '../../Easing';\nimport { withDelay, withSequence, withTiming } from '../../animation';\nimport {\n  AnimationFunction,\n  EntryExitAnimationFunction,\n  IEntryExitAnimationBuilder,\n  KeyframeProps,\n} from './commonTypes';\nimport { TransformProperty, StyleProps } from '../../commonTypes';\nexport interface KeyframePoint {\n  duration: number;\n  value: number | string;\n  easing?: EasingFn;\n}\nexport interface ParsedKeyframesDefinition {\n  initialValues: StyleProps;\n  keyframes: Record<string, KeyframePoint[]>;\n}\nexport class Keyframe implements IEntryExitAnimationBuilder {\n  durationV?: number;\n  delayV?: number;\n  callbackV?: (finished: boolean) => void;\n  definitions: Record<string, KeyframeProps>;\n\n  /*\n    Keyframe definition should be passed in the constructor as the map\n    which keys are between range 0 - 100 (%) and correspond to the point in the animation progress.\n  */\n  constructor(definitions: Record<string, KeyframeProps>) {\n    this.definitions = definitions;\n  }\n\n  private parseDefinitions(): ParsedKeyframesDefinition {\n    /* \n        Each style property contain an array with all their key points: \n        value, duration of transition to that value, and optional easing function (defaults to Linear)\n    */\n    const parsedKeyframes: Record<string, KeyframePoint[]> = {};\n    /*\n      Parsing keyframes 'from' and 'to'.\n    */\n    if (this.definitions.from) {\n      if (this.definitions['0']) {\n        throw Error(\n          \"You cannot provide both keyframe 0 and 'from' as they both specified initial values\"\n        );\n      }\n      this.definitions['0'] = this.definitions.from;\n      delete this.definitions.from;\n    }\n    if (this.definitions.to) {\n      if (this.definitions['100']) {\n        throw Error(\n          \"You cannot provide both keyframe 100 and 'to' as they both specified values at the end of the animation.\"\n        );\n      }\n      this.definitions['100'] = this.definitions.to;\n      delete this.definitions.to;\n    }\n    /* \n       One of the assumptions is that keyframe  0 is required to properly set initial values.\n       Every other keyframe should contain properties from the set provided as initial values.\n    */\n    if (!this.definitions['0']) {\n      throw Error(\n        \"Please provide 0, or 'from' keyframe with initial state of your object.\"\n      );\n    }\n    const initialValues: StyleProps = this.definitions['0'] as StyleProps;\n    /*\n      Initialize parsedKeyframes for properties provided in initial keyframe\n    */\n    Object.keys(initialValues).forEach((styleProp: string) => {\n      if (styleProp === 'transform') {\n        initialValues[styleProp]?.forEach((transformStyle, index) => {\n          Object.keys(transformStyle).forEach((transformProp: string) => {\n            parsedKeyframes[index.toString() + '_transform:' + transformProp] =\n              [];\n          });\n        });\n      } else {\n        parsedKeyframes[styleProp] = [];\n      }\n    });\n\n    const duration: number = this.durationV ? this.durationV : 500;\n    const animationKeyPoints: Array<string> = Array.from(\n      Object.keys(this.definitions)\n    );\n\n    const getAnimationDuration = (\n      key: string,\n      currentKeyPoint: number\n    ): number => {\n      const maxDuration = (currentKeyPoint / 100) * duration;\n      const currentDuration = parsedKeyframes[key].reduce(\n        (acc: number, value: KeyframePoint) => acc + value.duration,\n        0\n      );\n      return maxDuration - currentDuration;\n    };\n\n    /* \n       Other keyframes can't contain properties that were not specified in initial keyframe.\n    */\n    const addKeyPoint = ({\n      key,\n      value,\n      currentKeyPoint,\n      easing,\n    }: {\n      key: string;\n      value: string | number;\n      currentKeyPoint: number;\n      easing?: EasingFn;\n    }): void => {\n      if (!(key in parsedKeyframes)) {\n        throw Error(\n          \"Keyframe can contain only that set of properties that were provide with initial values (keyframe 0 or 'from')\"\n        );\n      }\n      parsedKeyframes[key].push({\n        duration: getAnimationDuration(key, currentKeyPoint),\n        value: value,\n        easing: easing,\n      });\n    };\n    animationKeyPoints\n      .filter((value: string) => parseInt(value) !== 0)\n      .sort((a: string, b: string) => parseInt(a) - parseInt(b))\n      .forEach((keyPoint: string) => {\n        if (parseInt(keyPoint) < 0 || parseInt(keyPoint) > 100) {\n          throw Error('Keyframe should be in between range 0 - 100.');\n        }\n        const keyframe: KeyframeProps = this.definitions[keyPoint];\n        const easing = keyframe.easing;\n        delete keyframe.easing;\n        const addKeyPointWith = (key: string, value: string | number) =>\n          addKeyPoint({\n            key,\n            value,\n            currentKeyPoint: parseInt(keyPoint),\n            easing,\n          });\n        Object.keys(keyframe).forEach((key: string) => {\n          if (key === 'transform') {\n            keyframe[key]?.forEach(\n              (transformStyle: { [key: string]: any }, index) => {\n                Object.keys(transformStyle).forEach((transformProp: string) => {\n                  addKeyPointWith(\n                    index.toString() + '_transform:' + transformProp,\n                    transformStyle[transformProp]\n                  );\n                });\n              }\n            );\n          } else {\n            addKeyPointWith(key, keyframe[key]);\n          }\n        });\n      });\n    return { initialValues: initialValues, keyframes: parsedKeyframes };\n  }\n\n  duration(durationMs: number): Keyframe {\n    this.durationV = durationMs;\n    return this;\n  }\n\n  delay(delayMs: number): Keyframe {\n    this.delayV = delayMs;\n    return this;\n  }\n\n  withCallback(callback: (finsihed: boolean) => void): Keyframe {\n    this.callbackV = callback;\n    return this;\n  }\n\n  private getDelayFunction(): AnimationFunction {\n    const delay = this.delayV;\n    return delay\n      ? withDelay\n      : (_, animation) => {\n          'worklet';\n          return animation;\n        };\n  }\n\n  build = (): EntryExitAnimationFunction => {\n    const delay = this.delayV;\n    const delayFunction = this.getDelayFunction();\n    const { keyframes, initialValues } = this.parseDefinitions();\n    const callback = this.callbackV;\n\n    return (_targetValues) => {\n      'worklet';\n      const animations: StyleProps = {};\n\n      /* \n            For each style property, an animations sequence is created that corresponds with its key points.\n            Transform style properties require special handling because of their nested structure.\n      */\n      const addAnimation = (key: string) => {\n        const keyframePoints = keyframes[key];\n        // in case if property was only passed as initial value\n        if (keyframePoints.length === 0) return;\n        const animation = delayFunction(\n          delay,\n          keyframePoints.length === 1\n            ? withTiming(keyframePoints[0].value, {\n                duration: keyframePoints[0].duration,\n                easing: keyframePoints[0].easing\n                  ? keyframePoints[0].easing\n                  : Easing.linear,\n              })\n            : withSequence.apply(\n                this,\n                keyframePoints.map((keyframePoint: KeyframePoint) =>\n                  withTiming(keyframePoint.value, {\n                    duration: keyframePoint.duration,\n                    easing: keyframePoint.easing\n                      ? keyframePoint.easing\n                      : Easing.linear,\n                  })\n                )\n              )\n        );\n        if (key.includes('transform')) {\n          if (!('transform' in animations)) {\n            animations.transform = [];\n          }\n          animations.transform?.push(<TransformProperty>{\n            [key.split(':')[1]]: animation,\n          });\n        } else {\n          animations[key] = animation;\n        }\n      };\n      Object.keys(initialValues).forEach((key: string) => {\n        if (key.includes('transform')) {\n          initialValues[key].forEach(\n            (transformProp: Record<string, number | string>, index: number) => {\n              Object.keys(transformProp).forEach((transformPropKey: string) => {\n                addAnimation(\n                  index.toString() + '_transform:' + transformPropKey\n                );\n              });\n            }\n          );\n        } else {\n          addAnimation(key);\n        }\n      });\n      return {\n        animations: animations,\n        initialValues: initialValues,\n        callback: callback,\n      };\n    };\n  };\n}\n"],"mappings":"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"}

package/lib/module/reanimated2/layoutReanimation/animationBuilder/commonTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=commonTypes.js.map

package/lib/module/reanimated2/layoutReanimation/animationBuilder/commonTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["commonTypes.ts"],"sourcesContent":["import { EasingFn } from '../../Easing';\nimport { StyleProps } from '../../commonTypes';\n\nexport interface KeyframeProps extends StyleProps {\n  easing?: EasingFn;\n  [key: string]: any;\n}\n\nexport type LayoutAnimation = {\n  initialValues: StyleProps;\n  animations: StyleProps;\n  callback?: (finished: boolean) => void;\n};\n\nexport type AnimationFunction = (a?: any, b?: any, c?: any) => any; // this is just a temporary mock\n\nexport interface EntryAnimationsValues {\n  targetOriginX: number;\n  targetOriginY: number;\n  targetWidth: number;\n  targetHeight: number;\n  targetGlobalOriginX: number;\n  targetGlobalOriginY: number;\n}\n\nexport interface ExitAnimationsValues {\n  currentOriginX: number;\n  currentOriginY: number;\n  currentWidth: number;\n  currentHeight: number;\n  currentGlobalOriginX: number;\n  currentGlobalOriginY: number;\n}\n\nexport type EntryExitAnimationFunction = (\n  targetValues: EntryAnimationsValues | ExitAnimationsValues\n) => LayoutAnimation;\n\nexport type AnimationConfigFunction<T> = (targetValues: T) => LayoutAnimation;\n\nexport interface LayoutAnimationsValues {\n  currentOriginX: number;\n  currentOriginY: number;\n  currentWidth: number;\n  currentHeight: number;\n  currentGlobalOriginX: number;\n  currentGlobalOriginY: number;\n  targetOriginX: number;\n  targetOriginY: number;\n  targetWidth: number;\n  targetHeight: number;\n  targetGlobalOriginX: number;\n  targetGlobalOriginY: number;\n  windowWidth: number;\n  windowHeight: number;\n}\n\nexport type LayoutAnimationFunction = (\n  targetValues: LayoutAnimationsValues\n) => LayoutAnimation;\n\nexport interface ILayoutAnimationBuilder {\n  build: () => LayoutAnimationFunction;\n}\n\nexport interface BaseLayoutAnimationConfig {\n  duration?: number;\n  easing?: EasingFn;\n  type?: AnimationFunction;\n  damping?: number;\n  mass?: number;\n  stiffness?: number;\n  overshootClamping?: number;\n  restDisplacementThreshold?: number;\n  restSpeedThreshold?: number;\n}\n\nexport interface BaseBuilderAnimationConfig extends BaseLayoutAnimationConfig {\n  rotate?: number | string;\n}\n\nexport type LayoutAnimationAndConfig = [\n  AnimationFunction,\n  BaseBuilderAnimationConfig\n];\n\nexport interface IEntryExitAnimationBuilder {\n  build: () => EntryExitAnimationFunction;\n}\n\nexport interface IEntryAnimationBuilder {\n  build: () => AnimationConfigFunction<EntryAnimationsValues>;\n}\n\nexport interface IExitAnimationBuilder {\n  build: () => AnimationConfigFunction<ExitAnimationsValues>;\n}\n"],"mappings":""}

package/lib/module/reanimated2/layoutReanimation/animationBuilder/index.js

@@ -0,0 +1,4 @@
+export { BaseAnimationBuilder } from './BaseAnimationBuilder';
+export { ComplexAnimationBuilder } from './ComplexAnimationBuilder';
+export { Keyframe } from './Keyframe';
+//# sourceMappingURL=index.js.map

package/lib/module/reanimated2/layoutReanimation/animationBuilder/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BaseAnimationBuilder","ComplexAnimationBuilder","Keyframe"],"sources":["index.ts"],"sourcesContent":["export { BaseAnimationBuilder } from './BaseAnimationBuilder';\nexport { ComplexAnimationBuilder } from './ComplexAnimationBuilder';\nexport { Keyframe } from './Keyframe';\nexport type {\n  LayoutAnimation,\n  AnimationFunction,\n  EntryAnimationsValues,\n  ExitAnimationsValues,\n  EntryExitAnimationFunction,\n  AnimationConfigFunction,\n  IEntryAnimationBuilder,\n  IExitAnimationBuilder,\n  LayoutAnimationsValues,\n  LayoutAnimationFunction,\n  ILayoutAnimationBuilder,\n  BaseLayoutAnimationConfig,\n  BaseBuilderAnimationConfig,\n  LayoutAnimationAndConfig,\n  IEntryExitAnimationBuilder,\n} from './commonTypes';\n"],"mappings":"AAAA,SAASA,oBAAT,QAAqC,wBAArC;AACA,SAASC,uBAAT,QAAwC,2BAAxC;AACA,SAASC,QAAT,QAAyB,YAAzB"}