react-native-reanimated 2.9.1 → 3.0.0-rc.2

package/lib/commonjs/reanimated2/layoutReanimation/LayoutAnimationRepository.js

@@ -0,0 +1,97 @@
+"use strict";
+
+var _core = require("../core");
+
+var _styleAnimation = require("../animation/styleAnimation");
+
+var _UpdateProps = require("../UpdateProps");
+
+var _Colors = require("../Colors");
+
+/* global _stopObservingProgress, _startObservingProgress */
+(0, _core.runOnUI)(() => {
+  'worklet';
+
+  const configs = Object.create(null);
+  const enteringAnimationForTag = {};
+  global.LayoutAnimationRepository = {
+    configs,
+
+    registerConfig(tag, config) {
+      configs[tag] = config;
+      enteringAnimationForTag[tag] = null;
+    },
+
+    removeConfig(tag) {
+      delete configs[tag];
+      delete enteringAnimationForTag[tag];
+    },
+
+    startAnimationForTag(tag, type, yogaValues) {
+      if (configs[tag] == null) {
+        return; // :(
+      }
+
+      const style = configs[tag][type](yogaValues);
+      let currentAnimation = style.animations;
+
+      if (type === 'entering') {
+        enteringAnimationForTag[tag] = style;
+      } else if (type === 'layout' && enteringAnimationForTag[tag] !== null) {
+        const entryAniamtion = enteringAnimationForTag[tag].animations;
+        const layoutAnimation = style.animations;
+        currentAnimation = {};
+
+        for (const key in entryAniamtion) {
+          currentAnimation[key] = entryAniamtion[key];
+        }
+
+        for (const key in layoutAnimation) {
+          currentAnimation[key] = layoutAnimation[key];
+        }
+      }
+
+      const sv = configs[tag].sv;
+
+      _stopObservingProgress(tag, false);
+
+      _startObservingProgress(tag, sv);
+
+      const backupColor = {};
+
+      for (const key in style.initialValues) {
+        if (_UpdateProps.ColorProperties.includes(key)) {
+          const value = style.initialValues[key];
+          backupColor[key] = value;
+          style.initialValues[key] = (0, _Colors.processColor)(value);
+        }
+      }
+
+      sv.value = Object.assign({}, sv._value, style.initialValues);
+
+      _stopObservingProgress(tag, false);
+
+      const animation = (0, _styleAnimation.withStyleAnimation)(currentAnimation);
+
+      animation.callback = finished => {
+        if (finished) {
+          _stopObservingProgress(tag, finished);
+        }
+
+        style.callback && style.callback(finished);
+      };
+
+      if (backupColor) {
+        configs[tag].sv._value = { ...configs[tag].sv.value,
+          ...backupColor
+        };
+      }
+
+      configs[tag].sv.value = animation;
+
+      _startObservingProgress(tag, sv);
+    }
+
+  };
+})();
+//# sourceMappingURL=LayoutAnimationRepository.js.map

package/lib/commonjs/reanimated2/layoutReanimation/LayoutAnimationRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["runOnUI","configs","Object","create","enteringAnimationForTag","global","LayoutAnimationRepository","registerConfig","tag","config","removeConfig","startAnimationForTag","type","yogaValues","style","currentAnimation","animations","entryAniamtion","layoutAnimation","key","sv","_stopObservingProgress","_startObservingProgress","backupColor","initialValues","ColorProperties","includes","value","processColor","assign","_value","animation","withStyleAnimation","callback","finished"],"sources":["LayoutAnimationRepository.ts"],"sourcesContent":["/* global _stopObservingProgress, _startObservingProgress */\nimport { runOnUI } from '../core';\nimport { withStyleAnimation } from '../animation/styleAnimation';\nimport { ColorProperties } from '../UpdateProps';\nimport { processColor } from '../Colors';\n\nrunOnUI(() => {\n  'worklet';\n\n  const configs: Record<string, any> = Object.create(null);\n  const enteringAnimationForTag: Record<string, any> = {};\n\n  global.LayoutAnimationRepository = {\n    configs,\n    registerConfig(tag, config) {\n      configs[tag] = config;\n      enteringAnimationForTag[tag] = null;\n    },\n    removeConfig(tag) {\n      delete configs[tag];\n      delete enteringAnimationForTag[tag];\n    },\n    startAnimationForTag(tag, type, yogaValues) {\n      if (configs[tag] == null) {\n        return; // :(\n      }\n      const style = configs[tag][type](yogaValues);\n      let currentAnimation = style.animations;\n      if (type === 'entering') {\n        enteringAnimationForTag[tag] = style;\n      } else if (type === 'layout' && enteringAnimationForTag[tag] !== null) {\n        const entryAniamtion = enteringAnimationForTag[tag].animations;\n        const layoutAnimation = style.animations;\n        currentAnimation = {};\n        for (const key in entryAniamtion) {\n          currentAnimation[key] = entryAniamtion[key];\n        }\n        for (const key in layoutAnimation) {\n          currentAnimation[key] = layoutAnimation[key];\n        }\n      }\n\n      const sv: { value: boolean; _value: boolean } = configs[tag].sv;\n      _stopObservingProgress(tag, false);\n      _startObservingProgress(tag, sv);\n\n      const backupColor: Record<string, string> = {};\n      for (const key in style.initialValues) {\n        if (ColorProperties.includes(key)) {\n          const value = style.initialValues[key];\n          backupColor[key] = value;\n          style.initialValues[key] = processColor(value);\n        }\n      }\n\n      sv.value = Object.assign({}, sv._value, style.initialValues);\n      _stopObservingProgress(tag, false);\n      const animation = withStyleAnimation(currentAnimation);\n\n      animation.callback = (finished?: boolean) => {\n        if (finished) {\n          _stopObservingProgress(tag, finished);\n        }\n        style.callback && style.callback(finished);\n      };\n\n      if (backupColor) {\n        configs[tag].sv._value = { ...configs[tag].sv.value, ...backupColor };\n      }\n\n      configs[tag].sv.value = animation;\n      _startObservingProgress(tag, sv);\n    },\n  };\n})();\n"],"mappings":"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"}

package/lib/commonjs/reanimated2/layoutReanimation/animationBuilder/BaseAnimationBuilder.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BaseAnimationBuilder = void 0;
+
+var _animation = require("../../animation");
+
+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; }
+
+class BaseAnimationBuilder {
+  constructor() {
+    _defineProperty(this, "durationV", void 0);
+
+    _defineProperty(this, "delayV", void 0);
+
+    _defineProperty(this, "randomizeDelay", false);
+
+    _defineProperty(this, "callbackV", void 0);
+
+    _defineProperty(this, "build", () => {
+      throw Error('Unimplemented method in child class.');
+    });
+  }
+
+  static duration(durationMs) {
+    const instance = this.createInstance();
+    return instance.duration(durationMs);
+  }
+
+  duration(durationMs) {
+    this.durationV = durationMs;
+    return this;
+  }
+
+  static delay(delayMs) {
+    const instance = this.createInstance();
+    return instance.delay(delayMs);
+  }
+
+  delay(delayMs) {
+    this.delayV = delayMs;
+    return this;
+  }
+
+  static withCallback(callback) {
+    const instance = this.createInstance();
+    return instance.withCallback(callback);
+  }
+
+  withCallback(callback) {
+    this.callbackV = callback;
+    return this;
+  } // 300ms is the default animation duration. If any animation has different default has to override this method.
+
+
+  static getDuration() {
+    return 300;
+  }
+
+  getDuration() {
+    return this.durationV ?? 300;
+  }
+
+  static randomDelay() {
+    const instance = this.createInstance();
+    return instance.randomDelay();
+  }
+
+  randomDelay() {
+    this.randomizeDelay = true;
+    return this;
+  } // when randomizeDelay is set to true, randomize delay between 0 and provided value (or 1000ms if delay is not provided)
+
+
+  getDelay() {
+    return this.randomizeDelay ? Math.random() * (this.delayV ?? 1000) : this.delayV ?? 0;
+  }
+
+  getDelayFunction() {
+    const isDelayProvided = this.randomizeDelay || this.delayV;
+    return isDelayProvided ? _animation.withDelay : (_, animation) => {
+      'worklet';
+
+      return animation;
+    };
+  }
+
+  static build() {
+    const instance = this.createInstance();
+    return instance.build();
+  }
+
+}
+
+exports.BaseAnimationBuilder = BaseAnimationBuilder;
+
+_defineProperty(BaseAnimationBuilder, "createInstance", void 0);
+//# sourceMappingURL=BaseAnimationBuilder.js.map

package/lib/commonjs/reanimated2/layoutReanimation/animationBuilder/BaseAnimationBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BaseAnimationBuilder","Error","duration","durationMs","instance","createInstance","durationV","delay","delayMs","delayV","withCallback","callback","callbackV","getDuration","randomDelay","randomizeDelay","getDelay","Math","random","getDelayFunction","isDelayProvided","withDelay","_","animation","build"],"sources":["BaseAnimationBuilder.ts"],"sourcesContent":["import { withDelay } from '../../animation';\nimport {\n  EntryExitAnimationFunction,\n  AnimationFunction,\n  LayoutAnimationFunction,\n} from './commonTypes';\n\nexport class BaseAnimationBuilder {\n  durationV?: number;\n  delayV?: number;\n  randomizeDelay = false;\n  callbackV?: (finished: boolean) => void;\n\n  static createInstance: () => BaseAnimationBuilder;\n  build = (): EntryExitAnimationFunction | LayoutAnimationFunction => {\n    throw Error('Unimplemented method in child class.');\n  };\n\n  static duration(durationMs: number): BaseAnimationBuilder {\n    const instance = this.createInstance();\n    return instance.duration(durationMs);\n  }\n\n  duration(durationMs: number): BaseAnimationBuilder {\n    this.durationV = durationMs;\n    return this;\n  }\n\n  static delay(delayMs: number): BaseAnimationBuilder {\n    const instance = this.createInstance();\n    return instance.delay(delayMs);\n  }\n\n  delay(delayMs: number): BaseAnimationBuilder {\n    this.delayV = delayMs;\n    return this;\n  }\n\n  static withCallback(\n    callback: (finished: boolean) => void\n  ): BaseAnimationBuilder {\n    const instance = this.createInstance();\n    return instance.withCallback(callback);\n  }\n\n  withCallback(callback: (finsihed: boolean) => void): BaseAnimationBuilder {\n    this.callbackV = callback;\n    return this;\n  }\n\n  // 300ms is the default animation duration. If any animation has different default has to override this method.\n  static getDuration(): number {\n    return 300;\n  }\n\n  getDuration(): number {\n    return this.durationV ?? 300;\n  }\n\n  static randomDelay(): BaseAnimationBuilder {\n    const instance = this.createInstance();\n    return instance.randomDelay();\n  }\n\n  randomDelay(): BaseAnimationBuilder {\n    this.randomizeDelay = true;\n    return this;\n  }\n\n  // when randomizeDelay is set to true, randomize delay between 0 and provided value (or 1000ms if delay is not provided)\n  getDelay(): number {\n    return this.randomizeDelay\n      ? Math.random() * (this.delayV ?? 1000)\n      : this.delayV ?? 0;\n  }\n\n  getDelayFunction(): AnimationFunction {\n    const isDelayProvided = this.randomizeDelay || this.delayV;\n    return isDelayProvided\n      ? withDelay\n      : (_, animation) => {\n          'worklet';\n          return animation;\n        };\n  }\n\n  static build(): EntryExitAnimationFunction | LayoutAnimationFunction {\n    const instance = this.createInstance();\n    return instance.build();\n  }\n}\n"],"mappings":";;;;;;;AAAA;;;;AAOO,MAAMA,oBAAN,CAA2B;EAAA;IAAA;;IAAA;;IAAA,wCAGf,KAHe;;IAAA;;IAAA,+BAOxB,MAA4D;MAClE,MAAMC,KAAK,CAAC,sCAAD,CAAX;IACD,CAT+B;EAAA;;EAWjB,OAARC,QAAQ,CAACC,UAAD,EAA2C;IACxD,MAAMC,QAAQ,GAAG,KAAKC,cAAL,EAAjB;IACA,OAAOD,QAAQ,CAACF,QAAT,CAAkBC,UAAlB,CAAP;EACD;;EAEDD,QAAQ,CAACC,UAAD,EAA2C;IACjD,KAAKG,SAAL,GAAiBH,UAAjB;IACA,OAAO,IAAP;EACD;;EAEW,OAALI,KAAK,CAACC,OAAD,EAAwC;IAClD,MAAMJ,QAAQ,GAAG,KAAKC,cAAL,EAAjB;IACA,OAAOD,QAAQ,CAACG,KAAT,CAAeC,OAAf,CAAP;EACD;;EAEDD,KAAK,CAACC,OAAD,EAAwC;IAC3C,KAAKC,MAAL,GAAcD,OAAd;IACA,OAAO,IAAP;EACD;;EAEkB,OAAZE,YAAY,CACjBC,QADiB,EAEK;IACtB,MAAMP,QAAQ,GAAG,KAAKC,cAAL,EAAjB;IACA,OAAOD,QAAQ,CAACM,YAAT,CAAsBC,QAAtB,CAAP;EACD;;EAEDD,YAAY,CAACC,QAAD,EAA8D;IACxE,KAAKC,SAAL,GAAiBD,QAAjB;IACA,OAAO,IAAP;EACD,CAzC+B,CA2ChC;;;EACkB,OAAXE,WAAW,GAAW;IAC3B,OAAO,GAAP;EACD;;EAEDA,WAAW,GAAW;IACpB,OAAO,KAAKP,SAAL,IAAkB,GAAzB;EACD;;EAEiB,OAAXQ,WAAW,GAAyB;IACzC,MAAMV,QAAQ,GAAG,KAAKC,cAAL,EAAjB;IACA,OAAOD,QAAQ,CAACU,WAAT,EAAP;EACD;;EAEDA,WAAW,GAAyB;IAClC,KAAKC,cAAL,GAAsB,IAAtB;IACA,OAAO,IAAP;EACD,CA5D+B,CA8DhC;;;EACAC,QAAQ,GAAW;IACjB,OAAO,KAAKD,cAAL,GACHE,IAAI,CAACC,MAAL,MAAiB,KAAKT,MAAL,IAAe,IAAhC,CADG,GAEH,KAAKA,MAAL,IAAe,CAFnB;EAGD;;EAEDU,gBAAgB,GAAsB;IACpC,MAAMC,eAAe,GAAG,KAAKL,cAAL,IAAuB,KAAKN,MAApD;IACA,OAAOW,eAAe,GAClBC,oBADkB,GAElB,CAACC,CAAD,EAAIC,SAAJ,KAAkB;MAChB;;MACA,OAAOA,SAAP;IACD,CALL;EAMD;;EAEW,OAALC,KAAK,GAAyD;IACnE,MAAMpB,QAAQ,GAAG,KAAKC,cAAL,EAAjB;IACA,OAAOD,QAAQ,CAACoB,KAAT,EAAP;EACD;;AAlF+B;;;;gBAArBxB,oB"}

package/lib/commonjs/reanimated2/layoutReanimation/animationBuilder/ComplexAnimationBuilder.js

@@ -0,0 +1,203 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ComplexAnimationBuilder = void 0;
+
+var _animation = require("../../animation");
+
+var _BaseAnimationBuilder = require("./BaseAnimationBuilder");
+
+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; }
+
+class ComplexAnimationBuilder extends _BaseAnimationBuilder.BaseAnimationBuilder {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "easingV", void 0);
+
+    _defineProperty(this, "rotateV", void 0);
+
+    _defineProperty(this, "type", void 0);
+
+    _defineProperty(this, "dampingV", void 0);
+
+    _defineProperty(this, "massV", void 0);
+
+    _defineProperty(this, "stiffnessV", void 0);
+
+    _defineProperty(this, "overshootClampingV", void 0);
+
+    _defineProperty(this, "restDisplacementThresholdV", void 0);
+
+    _defineProperty(this, "restSpeedThresholdV", void 0);
+
+    _defineProperty(this, "initialValues", void 0);
+  }
+
+  static easing(easingFunction) {
+    const instance = this.createInstance();
+    return instance.easing(easingFunction);
+  }
+
+  easing(easingFunction) {
+    this.easingV = easingFunction;
+    return this;
+  }
+
+  static rotate(degree) {
+    const instance = this.createInstance();
+    return instance.rotate(degree);
+  }
+
+  rotate(degree) {
+    this.rotateV = degree;
+    return this;
+  }
+
+  static springify() {
+    const instance = this.createInstance();
+    return instance.springify();
+  }
+
+  springify() {
+    this.type = _animation.withSpring;
+    return this;
+  }
+
+  static damping(damping) {
+    const instance = this.createInstance();
+    return instance.damping(damping);
+  }
+
+  damping(damping) {
+    this.dampingV = damping;
+    return this;
+  }
+
+  static mass(mass) {
+    const instance = this.createInstance();
+    return instance.mass(mass);
+  }
+
+  mass(mass) {
+    this.massV = mass;
+    return this;
+  }
+
+  static stiffness(stiffness) {
+    const instance = this.createInstance();
+    return instance.stiffness(stiffness);
+  }
+
+  stiffness(stiffness) {
+    this.stiffnessV = stiffness;
+    return this;
+  }
+
+  static overshootClamping(overshootClamping) {
+    const instance = this.createInstance();
+    return instance.overshootClamping(overshootClamping);
+  }
+
+  overshootClamping(overshootClamping) {
+    this.overshootClampingV = overshootClamping;
+    return this;
+  }
+
+  static restDisplacementThreshold(restDisplacementThreshold) {
+    const instance = this.createInstance();
+    return instance.restDisplacementThreshold(restDisplacementThreshold);
+  }
+
+  restDisplacementThreshold(restDisplacementThreshold) {
+    this.restDisplacementThresholdV = restDisplacementThreshold;
+    return this;
+  }
+
+  static restSpeedThreshold(restSpeedThreshold) {
+    const instance = this.createInstance();
+    return instance.restSpeedThreshold(restSpeedThreshold);
+  }
+
+  restSpeedThreshold(restSpeedThreshold) {
+    this.restSpeedThresholdV = restSpeedThreshold;
+    return this;
+  }
+
+  static withInitialValues(values) {
+    const instance = this.createInstance();
+    return instance.withInitialValues(values);
+  }
+
+  withInitialValues(values) {
+    this.initialValues = values;
+    return this;
+  }
+
+  getAnimationAndConfig() {
+    const duration = this.durationV;
+    const easing = this.easingV;
+    const rotate = this.rotateV;
+    const type = this.type ? this.type : _animation.withTiming;
+    const damping = this.dampingV;
+    const mass = this.massV;
+    const stiffness = this.stiffnessV;
+    const overshootClamping = this.overshootClampingV;
+    const restDisplacementThreshold = this.restDisplacementThresholdV;
+    const restSpeedThreshold = this.restSpeedThresholdV;
+    const animation = type;
+    const config = {};
+
+    if (type === _animation.withTiming) {
+      if (easing) {
+        config.easing = easing;
+      }
+
+      if (duration) {
+        config.duration = duration;
+      }
+
+      if (rotate) {
+        config.rotate = rotate;
+      }
+    } else {
+      if (damping) {
+        config.damping = damping;
+      }
+
+      if (mass) {
+        config.mass = mass;
+      }
+
+      if (stiffness) {
+        config.stiffness = stiffness;
+      }
+
+      if (overshootClamping) {
+        config.overshootClamping = overshootClamping;
+      }
+
+      if (restDisplacementThreshold) {
+        config.restDisplacementThreshold = restDisplacementThreshold;
+      }
+
+      if (restSpeedThreshold) {
+        config.restSpeedThreshold = restSpeedThreshold;
+      }
+
+      if (rotate) {
+        config.rotate = rotate;
+      }
+    }
+
+    return [animation, config];
+  }
+
+}
+
+exports.ComplexAnimationBuilder = ComplexAnimationBuilder;
+
+_defineProperty(ComplexAnimationBuilder, "createInstance", void 0);
+//# sourceMappingURL=ComplexAnimationBuilder.js.map

package/lib/commonjs/reanimated2/layoutReanimation/animationBuilder/ComplexAnimationBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ComplexAnimationBuilder","BaseAnimationBuilder","easing","easingFunction","instance","createInstance","easingV","rotate","degree","rotateV","springify","type","withSpring","damping","dampingV","mass","massV","stiffness","stiffnessV","overshootClamping","overshootClampingV","restDisplacementThreshold","restDisplacementThresholdV","restSpeedThreshold","restSpeedThresholdV","withInitialValues","values","initialValues","getAnimationAndConfig","duration","durationV","withTiming","animation","config"],"sources":["ComplexAnimationBuilder.ts"],"sourcesContent":["import { withTiming, withSpring } from '../../animation';\nimport {\n  AnimationFunction,\n  BaseBuilderAnimationConfig,\n  LayoutAnimationAndConfig,\n} from './commonTypes';\nimport { EasingFn } from '../../Easing';\nimport { BaseAnimationBuilder } from './BaseAnimationBuilder';\nimport { StyleProps } from '../../commonTypes';\n\nexport class ComplexAnimationBuilder extends BaseAnimationBuilder {\n  easingV?: EasingFn;\n  rotateV?: string;\n  type?: AnimationFunction;\n  dampingV?: number;\n  massV?: number;\n  stiffnessV?: number;\n  overshootClampingV?: number;\n  restDisplacementThresholdV?: number;\n  restSpeedThresholdV?: number;\n  initialValues?: StyleProps;\n\n  static createInstance: () => ComplexAnimationBuilder;\n\n  static easing(easingFunction: EasingFn): ComplexAnimationBuilder {\n    const instance = this.createInstance();\n    return instance.easing(easingFunction);\n  }\n\n  easing(easingFunction: EasingFn): ComplexAnimationBuilder {\n    this.easingV = easingFunction;\n    return this;\n  }\n\n  static rotate(degree: string): ComplexAnimationBuilder {\n    const instance = this.createInstance();\n    return instance.rotate(degree);\n  }\n\n  rotate(degree: string): ComplexAnimationBuilder {\n    this.rotateV = degree;\n    return this;\n  }\n\n  static springify(): ComplexAnimationBuilder {\n    const instance = this.createInstance();\n    return instance.springify();\n  }\n\n  springify(): ComplexAnimationBuilder {\n    this.type = withSpring as AnimationFunction;\n    return this;\n  }\n\n  static damping(damping: number): ComplexAnimationBuilder {\n    const instance = this.createInstance();\n    return instance.damping(damping);\n  }\n\n  damping(damping: number): ComplexAnimationBuilder {\n    this.dampingV = damping;\n    return this;\n  }\n\n  static mass(mass: number): ComplexAnimationBuilder {\n    const instance = this.createInstance();\n    return instance.mass(mass);\n  }\n\n  mass(mass: number): ComplexAnimationBuilder {\n    this.massV = mass;\n    return this;\n  }\n\n  static stiffness(stiffness: number): ComplexAnimationBuilder {\n    const instance = this.createInstance();\n    return instance.stiffness(stiffness);\n  }\n\n  stiffness(stiffness: number): ComplexAnimationBuilder {\n    this.stiffnessV = stiffness;\n    return this;\n  }\n\n  static overshootClamping(overshootClamping: number): ComplexAnimationBuilder {\n    const instance = this.createInstance();\n    return instance.overshootClamping(overshootClamping);\n  }\n\n  overshootClamping(overshootClamping: number): ComplexAnimationBuilder {\n    this.overshootClampingV = overshootClamping;\n    return this;\n  }\n\n  static restDisplacementThreshold(\n    restDisplacementThreshold: number\n  ): ComplexAnimationBuilder {\n    const instance = this.createInstance();\n    return instance.restDisplacementThreshold(restDisplacementThreshold);\n  }\n\n  restDisplacementThreshold(\n    restDisplacementThreshold: number\n  ): ComplexAnimationBuilder {\n    this.restDisplacementThresholdV = restDisplacementThreshold;\n    return this;\n  }\n\n  static restSpeedThreshold(\n    restSpeedThreshold: number\n  ): ComplexAnimationBuilder {\n    const instance = this.createInstance();\n    return instance.restSpeedThreshold(restSpeedThreshold);\n  }\n\n  restSpeedThreshold(restSpeedThreshold: number): ComplexAnimationBuilder {\n    this.restSpeedThresholdV = restSpeedThreshold;\n    return this;\n  }\n\n  static withInitialValues(values: StyleProps): BaseAnimationBuilder {\n    const instance = this.createInstance();\n    return instance.withInitialValues(values);\n  }\n\n  withInitialValues(values: StyleProps): BaseAnimationBuilder {\n    this.initialValues = values;\n    return this;\n  }\n\n  getAnimationAndConfig(): LayoutAnimationAndConfig {\n    const duration = this.durationV;\n    const easing = this.easingV;\n    const rotate = this.rotateV;\n    const type = this.type ? this.type : (withTiming as AnimationFunction);\n    const damping = this.dampingV;\n    const mass = this.massV;\n    const stiffness = this.stiffnessV;\n    const overshootClamping = this.overshootClampingV;\n    const restDisplacementThreshold = this.restDisplacementThresholdV;\n    const restSpeedThreshold = this.restSpeedThresholdV;\n\n    const animation = type;\n\n    const config: BaseBuilderAnimationConfig = {};\n\n    if (type === withTiming) {\n      if (easing) {\n        config.easing = easing;\n      }\n      if (duration) {\n        config.duration = duration;\n      }\n      if (rotate) {\n        config.rotate = rotate;\n      }\n    } else {\n      if (damping) {\n        config.damping = damping;\n      }\n      if (mass) {\n        config.mass = mass;\n      }\n      if (stiffness) {\n        config.stiffness = stiffness;\n      }\n      if (overshootClamping) {\n        config.overshootClamping = overshootClamping;\n      }\n      if (restDisplacementThreshold) {\n        config.restDisplacementThreshold = restDisplacementThreshold;\n      }\n      if (restSpeedThreshold) {\n        config.restSpeedThreshold = restSpeedThreshold;\n      }\n      if (rotate) {\n        config.rotate = rotate;\n      }\n    }\n    return [animation, config];\n  }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,244 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Keyframe = void 0;
+
+var _Easing = require("../../Easing");
+
+var _animation = require("../../animation");
+
+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; }
+
+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 ? (0, _animation.withTiming)(keyframePoints[0].value, {
+            duration: keyframePoints[0].duration,
+            easing: keyframePoints[0].easing ? keyframePoints[0].easing : _Easing.Easing.linear
+          }) : _animation.withSequence.apply(this, keyframePoints.map(keyframePoint => (0, _animation.withTiming)(keyframePoint.value, {
+            duration: keyframePoint.duration,
+            easing: keyframePoint.easing ? keyframePoint.easing : _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 ? _animation.withDelay : (_, animation) => {
+      'worklet';
+
+      return animation;
+    };
+  }
+
+}
+
+exports.Keyframe = Keyframe;
+//# sourceMappingURL=Keyframe.js.map