react-native-reanimated/lib/commonjs/reanimated2/layoutReanimation/defaultTransitions/EntryExitTransition.js

More powerful alternative to Animated library for React Native.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.EntryExitTransition = void 0;
exports.combineTransition = combineTransition;

var _animationBuilder = require("../animationBuilder");

var _animation = require("../../animation");

var _Fade = require("../defaultAnimations/Fade");

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 EntryExitTransition extends _animationBuilder.BaseAnimationBuilder {
  constructor() {
    super(...arguments);

    _defineProperty(this, "enteringV", _Fade.FadeIn);

    _defineProperty(this, "exitingV", _Fade.FadeOut);

    _defineProperty(this, "build", () => {
      const delayFunction = this.getDelayFunction();
      const callback = this.callbackV;
      const delay = this.getDelay();
      const enteringAnimation = this.enteringV.build();
      const exitingAnimation = this.exitingV.build();
      const exitingDuration = this.exitingV.getDuration();
      return values => {
        'worklet';

        const enteringValues = enteringAnimation(values);
        const exitingValues = exitingAnimation(values);
        const animations = {
          transform: []
        };

        for (const prop of Object.keys(exitingValues.animations)) {
          if (prop === 'transform') {
            var _exitingValues$animat;

            (_exitingValues$animat = exitingValues.animations[prop]) === null || _exitingValues$animat === void 0 ? void 0 : _exitingValues$animat.forEach((value, index) => {
              for (const transformProp of Object.keys(value)) {
                var _animations$transform;

                (_animations$transform = animations.transform) === null || _animations$transform === void 0 ? void 0 : _animations$transform.push({
                  [transformProp]: delayFunction(delay, (0, _animation.withSequence)(value[transformProp], (0, _animation.withTiming)(exitingValues.initialValues.transform ? exitingValues.initialValues.transform[index][transformProp] : 0, {
                    duration: 0
                  })))
                });
              }
            });
          } else {
            const sequence = enteringValues.animations[prop] !== undefined ? [exitingValues.animations[prop], (0, _animation.withTiming)(enteringValues.initialValues[prop], {
              duration: 0
            }), enteringValues.animations[prop]] : [exitingValues.animations[prop], (0, _animation.withTiming)(Object.keys(values).includes(prop) ? values[prop] : exitingValues.initialValues[prop], {
              duration: 0
            })];
            animations[prop] = delayFunction(delay, (0, _animation.withSequence)(...sequence));
          }
        }

        for (const prop of Object.keys(enteringValues.animations)) {
          if (prop === 'transform') {
            var _enteringValues$anima;

            (_enteringValues$anima = enteringValues.animations[prop]) === null || _enteringValues$anima === void 0 ? void 0 : _enteringValues$anima.forEach((value, index) => {
              for (const transformProp of Object.keys(value)) {
                var _animations$transform2;

                (_animations$transform2 = animations.transform) === null || _animations$transform2 === void 0 ? void 0 : _animations$transform2.push({
                  [transformProp]: delayFunction(delay + exitingDuration, (0, _animation.withSequence)((0, _animation.withTiming)(enteringValues.initialValues.transform ? enteringValues.initialValues.transform[index][transformProp] : 0, {
                    duration: exitingDuration
                  }), value[transformProp]))
                });
              }
            });
          } else if (animations[prop] !== undefined) {
            // it was already added in the previous loop
            continue;
          } else {
            animations[prop] = delayFunction(delay, (0, _animation.withSequence)((0, _animation.withTiming)(enteringValues.initialValues[prop], {
              duration: 0
            }), enteringValues.animations[prop]));
          }
        }

        const mergedTransform = (exitingValues.initialValues.transform ?? []).concat((enteringValues.animations.transform ?? []).map(value => {
          const objectKeys = Object.keys(value);

          if ((objectKeys === null || objectKeys === void 0 ? void 0 : objectKeys.length) < 1) {
            console.error(`[Reanimated]: \${value} is not a valid Transform object`);
            return value;
          }

          const transformProp = objectKeys[0];
          const current = value[transformProp].current;

          if (typeof current === 'string') {
            if (current.includes('deg')) return {
              [transformProp]: '0deg'
            };else return {
              [transformProp]: '0'
            };
          } else if (transformProp.includes('translate')) {
            return {
              [transformProp]: 0
            };
          } else {
            return {
              [transformProp]: 1
            };
          }

          return value;
        }));
        return {
          initialValues: { ...exitingValues.initialValues,
            originX: values.currentOriginX,
            originY: values.currentOriginY,
            width: values.currentWidth,
            height: values.currentHeight,
            transform: mergedTransform
          },
          animations: {
            originX: delayFunction(delay + exitingDuration, (0, _animation.withTiming)(values.targetOriginX, {
              duration: exitingDuration
            })),
            originY: delayFunction(delay + exitingDuration, (0, _animation.withTiming)(values.targetOriginY, {
              duration: exitingDuration
            })),
            width: delayFunction(delay + exitingDuration, (0, _animation.withTiming)(values.targetWidth, {
              duration: exitingDuration
            })),
            height: delayFunction(delay + exitingDuration, (0, _animation.withTiming)(values.targetHeight, {
              duration: exitingDuration
            })),
            ...animations
          },
          callback: callback
        };
      };
    });
  }

  static createInstance() {
    return new EntryExitTransition();
  }

  static entering(animation) {
    const instance = this.createInstance();
    return instance.entering(animation);
  }

  entering(animation) {
    this.enteringV = animation;
    return this;
  }

  static exiting(animation) {
    const instance = this.createInstance();
    return instance.exiting(animation);
  }

  exiting(animation) {
    this.exitingV = animation;
    return this;
  }

}

exports.EntryExitTransition = EntryExitTransition;

function combineTransition(exiting, entering) {
  return EntryExitTransition.entering(entering).exiting(exiting);
}
//# sourceMappingURL=EntryExitTransition.js.map