@telus-uds/components-base 4.0.0 → 4.1.0

package/.cache/jest-cache-react-17/jest-transform-cache-351fb7c9421020ab4cca8f7975c30d61-1324230084614362f519ae4cb2580aab/14/AnimatedImplementation_145b84d1c648104fb7fd26d0f4941534

@@ -0,0 +1,416 @@
+732bb37f1ef75d9e4995a1c1df94b848
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _AnimatedEvent = require("./AnimatedEvent");
+var _DecayAnimation = _interopRequireDefault(require("./animations/DecayAnimation"));
+var _SpringAnimation = _interopRequireDefault(require("./animations/SpringAnimation"));
+var _TimingAnimation = _interopRequireDefault(require("./animations/TimingAnimation"));
+var _createAnimatedComponent = _interopRequireDefault(require("./createAnimatedComponent"));
+var _AnimatedAddition = _interopRequireDefault(require("./nodes/AnimatedAddition"));
+var _AnimatedColor = _interopRequireDefault(require("./nodes/AnimatedColor"));
+var _AnimatedDiffClamp = _interopRequireDefault(require("./nodes/AnimatedDiffClamp"));
+var _AnimatedDivision = _interopRequireDefault(require("./nodes/AnimatedDivision"));
+var _AnimatedInterpolation = _interopRequireDefault(require("./nodes/AnimatedInterpolation"));
+var _AnimatedModulo = _interopRequireDefault(require("./nodes/AnimatedModulo"));
+var _AnimatedMultiplication = _interopRequireDefault(require("./nodes/AnimatedMultiplication"));
+var _AnimatedNode = _interopRequireDefault(require("./nodes/AnimatedNode"));
+var _AnimatedSubtraction = _interopRequireDefault(require("./nodes/AnimatedSubtraction"));
+var _AnimatedTracking = _interopRequireDefault(require("./nodes/AnimatedTracking"));
+var _AnimatedValue = _interopRequireDefault(require("./nodes/AnimatedValue"));
+var _AnimatedValueXY = _interopRequireDefault(require("./nodes/AnimatedValueXY"));
+var addImpl = function addImpl(a, b) {
+  return new _AnimatedAddition.default(a, b);
+};
+var subtractImpl = function subtractImpl(a, b) {
+  return new _AnimatedSubtraction.default(a, b);
+};
+var divideImpl = function divideImpl(a, b) {
+  return new _AnimatedDivision.default(a, b);
+};
+var multiplyImpl = function multiplyImpl(a, b) {
+  return new _AnimatedMultiplication.default(a, b);
+};
+var moduloImpl = function moduloImpl(a, modulus) {
+  return new _AnimatedModulo.default(a, modulus);
+};
+var diffClampImpl = function diffClampImpl(a, min, max) {
+  return new _AnimatedDiffClamp.default(a, min, max);
+};
+var _combineCallbacks = function _combineCallbacks(callback, config) {
+  if (callback && config.onComplete) {
+    return function () {
+      config.onComplete && config.onComplete.apply(config, arguments);
+      callback && callback.apply(void 0, arguments);
+    };
+  } else {
+    return callback || config.onComplete;
+  }
+};
+var maybeVectorAnim = function maybeVectorAnim(value, config, anim) {
+  if (value instanceof _AnimatedValueXY.default) {
+    var configX = Object.assign({}, config);
+    var configY = Object.assign({}, config);
+    for (var key in config) {
+      var _config$key = config[key],
+        x = _config$key.x,
+        y = _config$key.y;
+      if (x !== undefined && y !== undefined) {
+        configX[key] = x;
+        configY[key] = y;
+      }
+    }
+    var aX = anim(value.x, configX);
+    var aY = anim(value.y, configY);
+    return parallelImpl([aX, aY], {
+      stopTogether: false
+    });
+  } else if (value instanceof _AnimatedColor.default) {
+    var configR = Object.assign({}, config);
+    var configG = Object.assign({}, config);
+    var configB = Object.assign({}, config);
+    var configA = Object.assign({}, config);
+    for (var _key in config) {
+      var _config$_key = config[_key],
+        r = _config$_key.r,
+        g = _config$_key.g,
+        b = _config$_key.b,
+        a = _config$_key.a;
+      if (r !== undefined && g !== undefined && b !== undefined && a !== undefined) {
+        configR[_key] = r;
+        configG[_key] = g;
+        configB[_key] = b;
+        configA[_key] = a;
+      }
+    }
+    var aR = anim(value.r, configR);
+    var aG = anim(value.g, configG);
+    var aB = anim(value.b, configB);
+    var aA = anim(value.a, configA);
+    return parallelImpl([aR, aG, aB, aA], {
+      stopTogether: false
+    });
+  }
+  return null;
+};
+var _springImpl = function springImpl(value, config) {
+  var _start = function start(animatedValue, configuration, callback) {
+    callback = _combineCallbacks(callback, configuration);
+    var singleValue = animatedValue;
+    var singleConfig = configuration;
+    singleValue.stopTracking();
+    if (configuration.toValue instanceof _AnimatedNode.default) {
+      singleValue.track(new _AnimatedTracking.default(singleValue, configuration.toValue, _SpringAnimation.default, singleConfig, callback));
+    } else {
+      singleValue.animate(new _SpringAnimation.default(singleConfig), callback);
+    }
+  };
+  return maybeVectorAnim(value, config, _springImpl) || {
+    start: function start(callback) {
+      _start(value, config, callback);
+    },
+    stop: function stop() {
+      value.stopAnimation();
+    },
+    reset: function reset() {
+      value.resetAnimation();
+    },
+    _startNativeLoop: function _startNativeLoop(iterations) {
+      var singleConfig = Object.assign({}, config, {
+        iterations: iterations
+      });
+      _start(value, singleConfig);
+    },
+    _isUsingNativeDriver: function _isUsingNativeDriver() {
+      return config.useNativeDriver || false;
+    }
+  };
+};
+var _timingImpl = function timingImpl(value, config) {
+  var _start2 = function start(animatedValue, configuration, callback) {
+    callback = _combineCallbacks(callback, configuration);
+    var singleValue = animatedValue;
+    var singleConfig = configuration;
+    singleValue.stopTracking();
+    if (configuration.toValue instanceof _AnimatedNode.default) {
+      singleValue.track(new _AnimatedTracking.default(singleValue, configuration.toValue, _TimingAnimation.default, singleConfig, callback));
+    } else {
+      singleValue.animate(new _TimingAnimation.default(singleConfig), callback);
+    }
+  };
+  return maybeVectorAnim(value, config, _timingImpl) || {
+    start: function start(callback, isLooping) {
+      _start2(value, Object.assign({}, config, {
+        isLooping: isLooping
+      }), callback);
+    },
+    stop: function stop() {
+      value.stopAnimation();
+    },
+    reset: function reset() {
+      value.resetAnimation();
+    },
+    _startNativeLoop: function _startNativeLoop(iterations) {
+      var singleConfig = Object.assign({}, config, {
+        iterations: iterations
+      });
+      _start2(value, singleConfig);
+    },
+    _isUsingNativeDriver: function _isUsingNativeDriver() {
+      return config.useNativeDriver || false;
+    }
+  };
+};
+var _decayImpl = function decayImpl(value, config) {
+  var _start3 = function start(animatedValue, configuration, callback) {
+    callback = _combineCallbacks(callback, configuration);
+    var singleValue = animatedValue;
+    var singleConfig = configuration;
+    singleValue.stopTracking();
+    singleValue.animate(new _DecayAnimation.default(singleConfig), callback);
+  };
+  return maybeVectorAnim(value, config, _decayImpl) || {
+    start: function start(callback) {
+      _start3(value, config, callback);
+    },
+    stop: function stop() {
+      value.stopAnimation();
+    },
+    reset: function reset() {
+      value.resetAnimation();
+    },
+    _startNativeLoop: function _startNativeLoop(iterations) {
+      var singleConfig = Object.assign({}, config, {
+        iterations: iterations
+      });
+      _start3(value, singleConfig);
+    },
+    _isUsingNativeDriver: function _isUsingNativeDriver() {
+      return config.useNativeDriver || false;
+    }
+  };
+};
+var sequenceImpl = function sequenceImpl(animations) {
+  var current = 0;
+  return {
+    start: function start(callback, isLooping) {
+      var _onComplete = function onComplete(result) {
+        if (!result.finished) {
+          callback && callback(result);
+          return;
+        }
+        current++;
+        if (current === animations.length) {
+          current = 0;
+          callback && callback(result);
+          return;
+        }
+        animations[current].start(_onComplete, isLooping);
+      };
+      if (animations.length === 0) {
+        callback && callback({
+          finished: true
+        });
+      } else {
+        animations[current].start(_onComplete, isLooping);
+      }
+    },
+    stop: function stop() {
+      if (current < animations.length) {
+        animations[current].stop();
+      }
+    },
+    reset: function reset() {
+      animations.forEach(function (animation, idx) {
+        if (idx <= current) {
+          animation.reset();
+        }
+      });
+      current = 0;
+    },
+    _startNativeLoop: function _startNativeLoop() {
+      throw new Error('Loops run using the native driver cannot contain Animated.sequence animations');
+    },
+    _isUsingNativeDriver: function _isUsingNativeDriver() {
+      return false;
+    }
+  };
+};
+var parallelImpl = function parallelImpl(animations, config) {
+  var doneCount = 0;
+  var hasEnded = {};
+  var stopTogether = !(config && config.stopTogether === false);
+  var result = {
+    start: function start(callback, isLooping) {
+      if (doneCount === animations.length) {
+        callback && callback({
+          finished: true
+        });
+        return;
+      }
+      animations.forEach(function (animation, idx) {
+        var cb = function cb(endResult) {
+          hasEnded[idx] = true;
+          doneCount++;
+          if (doneCount === animations.length) {
+            doneCount = 0;
+            callback && callback(endResult);
+            return;
+          }
+          if (!endResult.finished && stopTogether) {
+            result.stop();
+          }
+        };
+        if (!animation) {
+          cb({
+            finished: true
+          });
+        } else {
+          animation.start(cb, isLooping);
+        }
+      });
+    },
+    stop: function stop() {
+      animations.forEach(function (animation, idx) {
+        !hasEnded[idx] && animation.stop();
+        hasEnded[idx] = true;
+      });
+    },
+    reset: function reset() {
+      animations.forEach(function (animation, idx) {
+        animation.reset();
+        hasEnded[idx] = false;
+        doneCount = 0;
+      });
+    },
+    _startNativeLoop: function _startNativeLoop() {
+      throw new Error('Loops run using the native driver cannot contain Animated.parallel animations');
+    },
+    _isUsingNativeDriver: function _isUsingNativeDriver() {
+      return false;
+    }
+  };
+  return result;
+};
+var delayImpl = function delayImpl(time) {
+  return _timingImpl(new _AnimatedValue.default(0), {
+    toValue: 0,
+    delay: time,
+    duration: 0,
+    useNativeDriver: false
+  });
+};
+var staggerImpl = function staggerImpl(time, animations) {
+  return parallelImpl(animations.map(function (animation, i) {
+    return sequenceImpl([delayImpl(time * i), animation]);
+  }));
+};
+var loopImpl = function loopImpl(animation) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref$iterations = _ref.iterations,
+    iterations = _ref$iterations === void 0 ? -1 : _ref$iterations,
+    _ref$resetBeforeItera = _ref.resetBeforeIteration,
+    resetBeforeIteration = _ref$resetBeforeItera === void 0 ? true : _ref$resetBeforeItera;
+  var isFinished = false;
+  var iterationsSoFar = 0;
+  return {
+    start: function start(callback) {
+      var _restart = function restart() {
+        var result = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+          finished: true
+        };
+        if (isFinished || iterationsSoFar === iterations || result.finished === false) {
+          callback && callback(result);
+        } else {
+          iterationsSoFar++;
+          resetBeforeIteration && animation.reset();
+          animation.start(_restart, iterations === -1);
+        }
+      };
+      if (!animation || iterations === 0) {
+        callback && callback({
+          finished: true
+        });
+      } else {
+        if (animation._isUsingNativeDriver()) {
+          animation._startNativeLoop(iterations);
+        } else {
+          _restart();
+        }
+      }
+    },
+    stop: function stop() {
+      isFinished = true;
+      animation.stop();
+    },
+    reset: function reset() {
+      iterationsSoFar = 0;
+      isFinished = false;
+      animation.reset();
+    },
+    _startNativeLoop: function _startNativeLoop() {
+      throw new Error('Loops run using the native driver cannot contain Animated.loop animations');
+    },
+    _isUsingNativeDriver: function _isUsingNativeDriver() {
+      return animation._isUsingNativeDriver();
+    }
+  };
+};
+function forkEventImpl(event, listener) {
+  if (!event) {
+    return listener;
+  } else if (event instanceof _AnimatedEvent.AnimatedEvent) {
+    event.__addListener(listener);
+    return event;
+  } else {
+    return function () {
+      typeof event === 'function' && event.apply(void 0, arguments);
+      listener.apply(void 0, arguments);
+    };
+  }
+}
+function unforkEventImpl(event, listener) {
+  if (event && event instanceof _AnimatedEvent.AnimatedEvent) {
+    event.__removeListener(listener);
+  }
+}
+var eventImpl = function eventImpl(argMapping, config) {
+  var animatedEvent = new _AnimatedEvent.AnimatedEvent(argMapping, config);
+  if (animatedEvent.__isNative) {
+    return animatedEvent;
+  } else {
+    return animatedEvent.__getHandler();
+  }
+};
+var _default = exports.default = {
+  Value: _AnimatedValue.default,
+  ValueXY: _AnimatedValueXY.default,
+  Color: _AnimatedColor.default,
+  Interpolation: _AnimatedInterpolation.default,
+  Node: _AnimatedNode.default,
+  decay: _decayImpl,
+  timing: _timingImpl,
+  spring: _springImpl,
+  add: addImpl,
+  subtract: subtractImpl,
+  divide: divideImpl,
+  multiply: multiplyImpl,
+  modulo: moduloImpl,
+  diffClamp: diffClampImpl,
+  delay: delayImpl,
+  sequence: sequenceImpl,
+  parallel: parallelImpl,
+  stagger: staggerImpl,
+  loop: loopImpl,
+  event: eventImpl,
+  createAnimatedComponent: _createAnimatedComponent.default,
+  attachNativeEvent: _AnimatedEvent.attachNativeEventImpl,
+  forkEvent: forkEventImpl,
+  unforkEvent: unforkEventImpl,
+  Event: _AnimatedEvent.AnimatedEvent
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_interopRequireDefault","require","Object","defineProperty","exports","value","default","_AnimatedEvent","_DecayAnimation","_SpringAnimation","_TimingAnimation","_createAnimatedComponent","_AnimatedAddition","_AnimatedColor","_AnimatedDiffClamp","_AnimatedDivision","_AnimatedInterpolation","_AnimatedModulo","_AnimatedMultiplication","_AnimatedNode","_AnimatedSubtraction","_AnimatedTracking","_AnimatedValue","_AnimatedValueXY","addImpl","a","b","AnimatedAddition","subtractImpl","AnimatedSubtraction","divideImpl","AnimatedDivision","multiplyImpl","AnimatedMultiplication","moduloImpl","modulus","AnimatedModulo","diffClampImpl","min","max","AnimatedDiffClamp","_combineCallbacks","callback","config","onComplete","apply","arguments","maybeVectorAnim","anim","AnimatedValueXY","configX","assign","configY","key","_config$key","x","y","undefined","aX","aY","parallelImpl","stopTogether","AnimatedColor","configR","configG","configB","configA","_config$_key","r","g","aR","aG","aB","aA","springImpl","start","animatedValue","configuration","singleValue","singleConfig","stopTracking","toValue","AnimatedNode","track","AnimatedTracking","SpringAnimation","animate","stop","stopAnimation","reset","resetAnimation","_startNativeLoop","iterations","_isUsingNativeDriver","useNativeDriver","timingImpl","TimingAnimation","isLooping","decayImpl","DecayAnimation","sequenceImpl","animations","current","result","finished","length","forEach","animation","idx","Error","doneCount","hasEnded","cb","endResult","delayImpl","time","AnimatedValue","delay","duration","staggerImpl","map","i","loopImpl","_ref","_ref$iterations","_ref$resetBeforeItera","resetBeforeIteration","isFinished","iterationsSoFar","restart","forkEventImpl","event","listener","AnimatedEvent","__addListener","unforkEventImpl","__removeListener","eventImpl","argMapping","animatedEvent","__isNative","__getHandler","_default","Value","ValueXY","Color","Interpolation","AnimatedInterpolation","Node","decay","timing","spring","add","subtract","divide","multiply","modulo","diffClamp","sequence","parallel","stagger","loop","createAnimatedComponent","attachNativeEvent","attachNativeEventImpl","forkEvent","unforkEvent","Event"],"sources":["AnimatedImplementation.js"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n * @format\n */\n\n'use strict';\n\nimport type {EventConfig, Mapping} from './AnimatedEvent';\nimport type {\n  AnimationConfig,\n  EndCallback,\n  EndResult,\n} from './animations/Animation';\nimport type {DecayAnimationConfig} from './animations/DecayAnimation';\nimport type {SpringAnimationConfig} from './animations/SpringAnimation';\nimport type {TimingAnimationConfig} from './animations/TimingAnimation';\n\nimport {AnimatedEvent, attachNativeEventImpl} from './AnimatedEvent';\nimport DecayAnimation from './animations/DecayAnimation';\nimport SpringAnimation from './animations/SpringAnimation';\nimport TimingAnimation from './animations/TimingAnimation';\nimport createAnimatedComponent from './createAnimatedComponent';\nimport AnimatedAddition from './nodes/AnimatedAddition';\nimport AnimatedColor from './nodes/AnimatedColor';\nimport AnimatedDiffClamp from './nodes/AnimatedDiffClamp';\nimport AnimatedDivision from './nodes/AnimatedDivision';\nimport AnimatedInterpolation from './nodes/AnimatedInterpolation';\nimport AnimatedModulo from './nodes/AnimatedModulo';\nimport AnimatedMultiplication from './nodes/AnimatedMultiplication';\nimport AnimatedNode from './nodes/AnimatedNode';\nimport AnimatedSubtraction from './nodes/AnimatedSubtraction';\nimport AnimatedTracking from './nodes/AnimatedTracking';\nimport AnimatedValue from './nodes/AnimatedValue';\nimport AnimatedValueXY from './nodes/AnimatedValueXY';\n\nexport type CompositeAnimation = {\n  start: (callback?: ?EndCallback, isLooping?: boolean) => void,\n  stop: () => void,\n  reset: () => void,\n  _startNativeLoop: (iterations?: number) => void,\n  _isUsingNativeDriver: () => boolean,\n  ...\n};\n\nconst addImpl = function (\n  a: AnimatedNode | number,\n  b: AnimatedNode | number,\n): AnimatedAddition {\n  return new AnimatedAddition(a, b);\n};\n\nconst subtractImpl = function (\n  a: AnimatedNode | number,\n  b: AnimatedNode | number,\n): AnimatedSubtraction {\n  return new AnimatedSubtraction(a, b);\n};\n\nconst divideImpl = function (\n  a: AnimatedNode | number,\n  b: AnimatedNode | number,\n): AnimatedDivision {\n  return new AnimatedDivision(a, b);\n};\n\nconst multiplyImpl = function (\n  a: AnimatedNode | number,\n  b: AnimatedNode | number,\n): AnimatedMultiplication {\n  return new AnimatedMultiplication(a, b);\n};\n\nconst moduloImpl = function (a: AnimatedNode, modulus: number): AnimatedModulo {\n  return new AnimatedModulo(a, modulus);\n};\n\nconst diffClampImpl = function (\n  a: AnimatedNode,\n  min: number,\n  max: number,\n): AnimatedDiffClamp {\n  return new AnimatedDiffClamp(a, min, max);\n};\n\nconst _combineCallbacks = function (\n  callback: ?EndCallback,\n  config: $ReadOnly<{...AnimationConfig, ...}>,\n) {\n  if (callback && config.onComplete) {\n    return (...args: Array<EndResult>) => {\n      config.onComplete && config.onComplete(...args);\n      callback && callback(...args);\n    };\n  } else {\n    return callback || config.onComplete;\n  }\n};\n\nconst maybeVectorAnim = function (\n  value: AnimatedValue | AnimatedValueXY | AnimatedColor,\n  config: Object,\n  anim: (value: AnimatedValue, config: Object) => CompositeAnimation,\n): ?CompositeAnimation {\n  if (value instanceof AnimatedValueXY) {\n    const configX = {...config};\n    const configY = {...config};\n    for (const key in config) {\n      const {x, y} = config[key];\n      if (x !== undefined && y !== undefined) {\n        configX[key] = x;\n        configY[key] = y;\n      }\n    }\n    const aX = anim((value: AnimatedValueXY).x, configX);\n    const aY = anim((value: AnimatedValueXY).y, configY);\n    // We use `stopTogether: false` here because otherwise tracking will break\n    // because the second animation will get stopped before it can update.\n    return parallelImpl([aX, aY], {stopTogether: false});\n  } else if (value instanceof AnimatedColor) {\n    const configR = {...config};\n    const configG = {...config};\n    const configB = {...config};\n    const configA = {...config};\n    for (const key in config) {\n      const {r, g, b, a} = config[key];\n      if (\n        r !== undefined &&\n        g !== undefined &&\n        b !== undefined &&\n        a !== undefined\n      ) {\n        configR[key] = r;\n        configG[key] = g;\n        configB[key] = b;\n        configA[key] = a;\n      }\n    }\n    const aR = anim((value: AnimatedColor).r, configR);\n    const aG = anim((value: AnimatedColor).g, configG);\n    const aB = anim((value: AnimatedColor).b, configB);\n    const aA = anim((value: AnimatedColor).a, configA);\n    // We use `stopTogether: false` here because otherwise tracking will break\n    // because the second animation will get stopped before it can update.\n    return parallelImpl([aR, aG, aB, aA], {stopTogether: false});\n  }\n  return null;\n};\n\nconst springImpl = function (\n  value: AnimatedValue | AnimatedValueXY | AnimatedColor,\n  config: SpringAnimationConfig,\n): CompositeAnimation {\n  const start = function (\n    animatedValue: AnimatedValue | AnimatedValueXY | AnimatedColor,\n    configuration: SpringAnimationConfig,\n    callback?: ?EndCallback,\n  ): void {\n    callback = _combineCallbacks(callback, configuration);\n    const singleValue: any = animatedValue;\n    const singleConfig: any = configuration;\n    singleValue.stopTracking();\n    if (configuration.toValue instanceof AnimatedNode) {\n      singleValue.track(\n        new AnimatedTracking(\n          singleValue,\n          configuration.toValue,\n          SpringAnimation,\n          singleConfig,\n          callback,\n        ),\n      );\n    } else {\n      singleValue.animate(new SpringAnimation(singleConfig), callback);\n    }\n  };\n  return (\n    maybeVectorAnim(value, config, springImpl) || {\n      start: function (callback?: ?EndCallback): void {\n        start(value, config, callback);\n      },\n\n      stop: function (): void {\n        value.stopAnimation();\n      },\n\n      reset: function (): void {\n        value.resetAnimation();\n      },\n\n      _startNativeLoop: function (iterations?: number): void {\n        const singleConfig = {...config, iterations};\n        start(value, singleConfig);\n      },\n\n      _isUsingNativeDriver: function (): boolean {\n        return config.useNativeDriver || false;\n      },\n    }\n  );\n};\n\nconst timingImpl = function (\n  value: AnimatedValue | AnimatedValueXY | AnimatedColor,\n  config: TimingAnimationConfig,\n): CompositeAnimation {\n  const start = function (\n    animatedValue: AnimatedValue | AnimatedValueXY | AnimatedColor,\n    configuration: TimingAnimationConfig,\n    callback?: ?EndCallback,\n  ): void {\n    callback = _combineCallbacks(callback, configuration);\n    const singleValue: any = animatedValue;\n    const singleConfig: any = configuration;\n    singleValue.stopTracking();\n    if (configuration.toValue instanceof AnimatedNode) {\n      singleValue.track(\n        new AnimatedTracking(\n          singleValue,\n          configuration.toValue,\n          TimingAnimation,\n          singleConfig,\n          callback,\n        ),\n      );\n    } else {\n      singleValue.animate(new TimingAnimation(singleConfig), callback);\n    }\n  };\n\n  return (\n    maybeVectorAnim(value, config, timingImpl) || {\n      start: function (callback?: ?EndCallback, isLooping?: boolean): void {\n        start(value, {...config, isLooping}, callback);\n      },\n\n      stop: function (): void {\n        value.stopAnimation();\n      },\n\n      reset: function (): void {\n        value.resetAnimation();\n      },\n\n      _startNativeLoop: function (iterations?: number): void {\n        const singleConfig = {...config, iterations};\n        start(value, singleConfig);\n      },\n\n      _isUsingNativeDriver: function (): boolean {\n        return config.useNativeDriver || false;\n      },\n    }\n  );\n};\n\nconst decayImpl = function (\n  value: AnimatedValue | AnimatedValueXY | AnimatedColor,\n  config: DecayAnimationConfig,\n): CompositeAnimation {\n  const start = function (\n    animatedValue: AnimatedValue | AnimatedValueXY | AnimatedColor,\n    configuration: DecayAnimationConfig,\n    callback?: ?EndCallback,\n  ): void {\n    callback = _combineCallbacks(callback, configuration);\n    const singleValue: any = animatedValue;\n    const singleConfig: any = configuration;\n    singleValue.stopTracking();\n    singleValue.animate(new DecayAnimation(singleConfig), callback);\n  };\n\n  return (\n    maybeVectorAnim(value, config, decayImpl) || {\n      start: function (callback?: ?EndCallback): void {\n        start(value, config, callback);\n      },\n\n      stop: function (): void {\n        value.stopAnimation();\n      },\n\n      reset: function (): void {\n        value.resetAnimation();\n      },\n\n      _startNativeLoop: function (iterations?: number): void {\n        const singleConfig = {...config, iterations};\n        start(value, singleConfig);\n      },\n\n      _isUsingNativeDriver: function (): boolean {\n        return config.useNativeDriver || false;\n      },\n    }\n  );\n};\n\nconst sequenceImpl = function (\n  animations: Array<CompositeAnimation>,\n): CompositeAnimation {\n  let current = 0;\n  return {\n    start: function (callback?: ?EndCallback, isLooping?: boolean) {\n      const onComplete = function (result: EndResult) {\n        if (!result.finished) {\n          callback && callback(result);\n          return;\n        }\n\n        current++;\n\n        if (current === animations.length) {\n          // if the start is called, even without a reset, it should start from the beginning\n          current = 0;\n          callback && callback(result);\n          return;\n        }\n\n        animations[current].start(onComplete, isLooping);\n      };\n\n      if (animations.length === 0) {\n        callback && callback({finished: true});\n      } else {\n        animations[current].start(onComplete, isLooping);\n      }\n    },\n\n    stop: function () {\n      if (current < animations.length) {\n        animations[current].stop();\n      }\n    },\n\n    reset: function () {\n      animations.forEach((animation, idx) => {\n        if (idx <= current) {\n          animation.reset();\n        }\n      });\n      current = 0;\n    },\n\n    _startNativeLoop: function () {\n      throw new Error(\n        'Loops run using the native driver cannot contain Animated.sequence animations',\n      );\n    },\n\n    _isUsingNativeDriver: function (): boolean {\n      return false;\n    },\n  };\n};\n\ntype ParallelConfig = {\n  // If one is stopped, stop all.  default: true\n  stopTogether?: boolean,\n  ...\n};\nconst parallelImpl = function (\n  animations: Array<CompositeAnimation>,\n  config?: ?ParallelConfig,\n): CompositeAnimation {\n  let doneCount = 0;\n  // Make sure we only call stop() at most once for each animation\n  const hasEnded: {[number]: boolean} = {};\n  const stopTogether = !(config && config.stopTogether === false);\n\n  const result = {\n    start: function (callback?: ?EndCallback, isLooping?: boolean) {\n      if (doneCount === animations.length) {\n        callback && callback({finished: true});\n        return;\n      }\n\n      animations.forEach((animation, idx) => {\n        const cb = function (endResult: EndResult) {\n          hasEnded[idx] = true;\n          doneCount++;\n          if (doneCount === animations.length) {\n            doneCount = 0;\n            callback && callback(endResult);\n            return;\n          }\n\n          if (!endResult.finished && stopTogether) {\n            result.stop();\n          }\n        };\n\n        if (!animation) {\n          cb({finished: true});\n        } else {\n          animation.start(cb, isLooping);\n        }\n      });\n    },\n\n    stop: function (): void {\n      animations.forEach((animation, idx) => {\n        !hasEnded[idx] && animation.stop();\n        hasEnded[idx] = true;\n      });\n    },\n\n    reset: function (): void {\n      animations.forEach((animation, idx) => {\n        animation.reset();\n        hasEnded[idx] = false;\n        doneCount = 0;\n      });\n    },\n\n    _startNativeLoop: function (): empty {\n      throw new Error(\n        'Loops run using the native driver cannot contain Animated.parallel animations',\n      );\n    },\n\n    _isUsingNativeDriver: function (): boolean {\n      return false;\n    },\n  };\n\n  return result;\n};\n\nconst delayImpl = function (time: number): CompositeAnimation {\n  // Would be nice to make a specialized implementation\n  return timingImpl(new AnimatedValue(0), {\n    toValue: 0,\n    delay: time,\n    duration: 0,\n    useNativeDriver: false,\n  });\n};\n\nconst staggerImpl = function (\n  time: number,\n  animations: Array<CompositeAnimation>,\n): CompositeAnimation {\n  return parallelImpl(\n    animations.map((animation, i) => {\n      return sequenceImpl([delayImpl(time * i), animation]);\n    }),\n  );\n};\n\ntype LoopAnimationConfig = {\n  iterations: number,\n  resetBeforeIteration?: boolean,\n  ...\n};\n\nconst loopImpl = function (\n  animation: CompositeAnimation,\n  // $FlowFixMe[prop-missing]\n  {iterations = -1, resetBeforeIteration = true}: LoopAnimationConfig = {},\n): CompositeAnimation {\n  let isFinished = false;\n  let iterationsSoFar = 0;\n  return {\n    start: function (callback?: ?EndCallback) {\n      const restart = function (result: EndResult = {finished: true}): void {\n        if (\n          isFinished ||\n          iterationsSoFar === iterations ||\n          result.finished === false\n        ) {\n          callback && callback(result);\n        } else {\n          iterationsSoFar++;\n          resetBeforeIteration && animation.reset();\n          animation.start(restart, iterations === -1);\n        }\n      };\n      if (!animation || iterations === 0) {\n        callback && callback({finished: true});\n      } else {\n        if (animation._isUsingNativeDriver()) {\n          animation._startNativeLoop(iterations);\n        } else {\n          restart(); // Start looping recursively on the js thread\n        }\n      }\n    },\n\n    stop: function (): void {\n      isFinished = true;\n      animation.stop();\n    },\n\n    reset: function (): void {\n      iterationsSoFar = 0;\n      isFinished = false;\n      animation.reset();\n    },\n\n    _startNativeLoop: function () {\n      throw new Error(\n        'Loops run using the native driver cannot contain Animated.loop animations',\n      );\n    },\n\n    _isUsingNativeDriver: function (): boolean {\n      return animation._isUsingNativeDriver();\n    },\n  };\n};\n\nfunction forkEventImpl(\n  event: ?AnimatedEvent | ?Function,\n  listener: Function,\n): AnimatedEvent | Function {\n  if (!event) {\n    return listener;\n  } else if (event instanceof AnimatedEvent) {\n    event.__addListener(listener);\n    return event;\n  } else {\n    return (...args) => {\n      typeof event === 'function' && event(...args);\n      listener(...args);\n    };\n  }\n}\n\nfunction unforkEventImpl(\n  event: ?AnimatedEvent | ?Function,\n  listener: Function,\n): void {\n  if (event && event instanceof AnimatedEvent) {\n    event.__removeListener(listener);\n  }\n}\n\nconst eventImpl = function <T>(\n  argMapping: $ReadOnlyArray<?Mapping>,\n  config: EventConfig<T>,\n): any {\n  const animatedEvent = new AnimatedEvent(argMapping, config);\n  if (animatedEvent.__isNative) {\n    return animatedEvent;\n  } else {\n    return animatedEvent.__getHandler();\n  }\n};\n\n// All types of animated nodes that represent scalar numbers and can be interpolated (etc)\ntype AnimatedNumeric =\n  | AnimatedAddition\n  | AnimatedDiffClamp\n  | AnimatedDivision\n  | AnimatedInterpolation<number>\n  | AnimatedModulo\n  | AnimatedMultiplication\n  | AnimatedSubtraction\n  | AnimatedValue;\n\nexport type {AnimatedNumeric as Numeric};\n\n/**\n * The `Animated` library is designed to make animations fluid, powerful, and\n * easy to build and maintain. `Animated` focuses on declarative relationships\n * between inputs and outputs, with configurable transforms in between, and\n * simple `start`/`stop` methods to control time-based animation execution.\n * If additional transforms are added, be sure to include them in\n * AnimatedMock.js as well.\n *\n * See https://reactnative.dev/docs/animated\n */\nexport default {\n  /**\n   * Standard value class for driving animations.  Typically initialized with\n   * `new Animated.Value(0);`\n   *\n   * See https://reactnative.dev/docs/animated#value\n   */\n  Value: AnimatedValue,\n  /**\n   * 2D value class for driving 2D animations, such as pan gestures.\n   *\n   * See https://reactnative.dev/docs/animatedvaluexy\n   */\n  ValueXY: AnimatedValueXY,\n  /**\n   * Value class for driving color animations.\n   */\n  Color: AnimatedColor,\n  /**\n   * Exported to use the Interpolation type in flow.\n   *\n   * See https://reactnative.dev/docs/animated#interpolation\n   */\n  Interpolation: AnimatedInterpolation,\n  /**\n   * Exported for ease of type checking. All animated values derive from this\n   * class.\n   *\n   * See https://reactnative.dev/docs/animated#node\n   */\n  Node: AnimatedNode,\n  decay: decayImpl,\n  timing: timingImpl,\n  spring: springImpl,\n  add: addImpl,\n  subtract: subtractImpl,\n  divide: divideImpl,\n  multiply: multiplyImpl,\n  modulo: moduloImpl,\n  diffClamp: diffClampImpl,\n  delay: delayImpl,\n  sequence: sequenceImpl,\n  parallel: parallelImpl,\n  stagger: staggerImpl,\n  loop: loopImpl,\n  event: eventImpl,\n  createAnimatedComponent,\n  attachNativeEvent: attachNativeEventImpl,\n  forkEvent: forkEventImpl,\n  unforkEvent: unforkEventImpl,\n\n  /**\n   * Expose Event class, so it can be used as a type for type checkers.\n   */\n  Event: AnimatedEvent,\n};\n"],"mappings":"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","ignoreList":[]}

package/.cache/jest-cache-react-17/jest-transform-cache-351fb7c9421020ab4cca8f7975c30d61-1324230084614362f519ae4cb2580aab/14/AnimatedImplementation_145b84d1c648104fb7fd26d0f4941534.map

@@ -0,0 +1 @@
+{"version":3,"names":["_interopRequireDefault","require","Object","defineProperty","exports","value","default","_AnimatedEvent","_DecayAnimation","_SpringAnimation","_TimingAnimation","_createAnimatedComponent","_AnimatedAddition","_AnimatedColor","_AnimatedDiffClamp","_AnimatedDivision","_AnimatedInterpolation","_AnimatedModulo","_AnimatedMultiplication","_AnimatedNode","_AnimatedSubtraction","_AnimatedTracking","_AnimatedValue","_AnimatedValueXY","addImpl","a","b","AnimatedAddition","subtractImpl","AnimatedSubtraction","divideImpl","AnimatedDivision","multiplyImpl","AnimatedMultiplication","moduloImpl","modulus","AnimatedModulo","diffClampImpl","min","max","AnimatedDiffClamp","_combineCallbacks","callback","config","onComplete","apply","arguments","maybeVectorAnim","anim","AnimatedValueXY","configX","assign","configY","key","_config$key","x","y","undefined","aX","aY","parallelImpl","stopTogether","AnimatedColor","configR","configG","configB","configA","_config$_key","r","g","aR","aG","aB","aA","springImpl","start","animatedValue","configuration","singleValue","singleConfig","stopTracking","toValue","AnimatedNode","track","AnimatedTracking","SpringAnimation","animate","stop","stopAnimation","reset","resetAnimation","_startNativeLoop","iterations","_isUsingNativeDriver","useNativeDriver","timingImpl","TimingAnimation","isLooping","decayImpl","DecayAnimation","sequenceImpl","animations","current","result","finished","length","forEach","animation","idx","Error","doneCount","hasEnded","cb","endResult","delayImpl","time","AnimatedValue","delay","duration","staggerImpl","map","i","loopImpl","_ref","_ref$iterations","_ref$resetBeforeItera","resetBeforeIteration","isFinished","iterationsSoFar","restart","forkEventImpl","event","listener","AnimatedEvent","__addListener","unforkEventImpl","__removeListener","eventImpl","argMapping","animatedEvent","__isNative","__getHandler","_default","Value","ValueXY","Color","Interpolation","AnimatedInterpolation","Node","decay","timing","spring","add","subtract","divide","multiply","modulo","diffClamp","sequence","parallel","stagger","loop","createAnimatedComponent","attachNativeEvent","attachNativeEventImpl","forkEvent","unforkEvent","Event"],"sources":["AnimatedImplementation.js"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n * @format\n */\n\n'use strict';\n\nimport type {EventConfig, Mapping} from './AnimatedEvent';\nimport type {\n  AnimationConfig,\n  EndCallback,\n  EndResult,\n} from './animations/Animation';\nimport type {DecayAnimationConfig} from './animations/DecayAnimation';\nimport type {SpringAnimationConfig} from './animations/SpringAnimation';\nimport type {TimingAnimationConfig} from './animations/TimingAnimation';\n\nimport {AnimatedEvent, attachNativeEventImpl} from './AnimatedEvent';\nimport DecayAnimation from './animations/DecayAnimation';\nimport SpringAnimation from './animations/SpringAnimation';\nimport TimingAnimation from './animations/TimingAnimation';\nimport createAnimatedComponent from './createAnimatedComponent';\nimport AnimatedAddition from './nodes/AnimatedAddition';\nimport AnimatedColor from './nodes/AnimatedColor';\nimport AnimatedDiffClamp from './nodes/AnimatedDiffClamp';\nimport AnimatedDivision from './nodes/AnimatedDivision';\nimport AnimatedInterpolation from './nodes/AnimatedInterpolation';\nimport AnimatedModulo from './nodes/AnimatedModulo';\nimport AnimatedMultiplication from './nodes/AnimatedMultiplication';\nimport AnimatedNode from './nodes/AnimatedNode';\nimport AnimatedSubtraction from './nodes/AnimatedSubtraction';\nimport AnimatedTracking from './nodes/AnimatedTracking';\nimport AnimatedValue from './nodes/AnimatedValue';\nimport AnimatedValueXY from './nodes/AnimatedValueXY';\n\nexport type CompositeAnimation = {\n  start: (callback?: ?EndCallback, isLooping?: boolean) => void,\n  stop: () => void,\n  reset: () => void,\n  _startNativeLoop: (iterations?: number) => void,\n  _isUsingNativeDriver: () => boolean,\n  ...\n};\n\nconst addImpl = function (\n  a: AnimatedNode | number,\n  b: AnimatedNode | number,\n): AnimatedAddition {\n  return new AnimatedAddition(a, b);\n};\n\nconst subtractImpl = function (\n  a: AnimatedNode | number,\n  b: AnimatedNode | number,\n): AnimatedSubtraction {\n  return new AnimatedSubtraction(a, b);\n};\n\nconst divideImpl = function (\n  a: AnimatedNode | number,\n  b: AnimatedNode | number,\n): AnimatedDivision {\n  return new AnimatedDivision(a, b);\n};\n\nconst multiplyImpl = function (\n  a: AnimatedNode | number,\n  b: AnimatedNode | number,\n): AnimatedMultiplication {\n  return new AnimatedMultiplication(a, b);\n};\n\nconst moduloImpl = function (a: AnimatedNode, modulus: number): AnimatedModulo {\n  return new AnimatedModulo(a, modulus);\n};\n\nconst diffClampImpl = function (\n  a: AnimatedNode,\n  min: number,\n  max: number,\n): AnimatedDiffClamp {\n  return new AnimatedDiffClamp(a, min, max);\n};\n\nconst _combineCallbacks = function (\n  callback: ?EndCallback,\n  config: $ReadOnly<{...AnimationConfig, ...}>,\n) {\n  if (callback && config.onComplete) {\n    return (...args: Array<EndResult>) => {\n      config.onComplete && config.onComplete(...args);\n      callback && callback(...args);\n    };\n  } else {\n    return callback || config.onComplete;\n  }\n};\n\nconst maybeVectorAnim = function (\n  value: AnimatedValue | AnimatedValueXY | AnimatedColor,\n  config: Object,\n  anim: (value: AnimatedValue, config: Object) => CompositeAnimation,\n): ?CompositeAnimation {\n  if (value instanceof AnimatedValueXY) {\n    const configX = {...config};\n    const configY = {...config};\n    for (const key in config) {\n      const {x, y} = config[key];\n      if (x !== undefined && y !== undefined) {\n        configX[key] = x;\n        configY[key] = y;\n      }\n    }\n    const aX = anim((value: AnimatedValueXY).x, configX);\n    const aY = anim((value: AnimatedValueXY).y, configY);\n    // We use `stopTogether: false` here because otherwise tracking will break\n    // because the second animation will get stopped before it can update.\n    return parallelImpl([aX, aY], {stopTogether: false});\n  } else if (value instanceof AnimatedColor) {\n    const configR = {...config};\n    const configG = {...config};\n    const configB = {...config};\n    const configA = {...config};\n    for (const key in config) {\n      const {r, g, b, a} = config[key];\n      if (\n        r !== undefined &&\n        g !== undefined &&\n        b !== undefined &&\n        a !== undefined\n      ) {\n        configR[key] = r;\n        configG[key] = g;\n        configB[key] = b;\n        configA[key] = a;\n      }\n    }\n    const aR = anim((value: AnimatedColor).r, configR);\n    const aG = anim((value: AnimatedColor).g, configG);\n    const aB = anim((value: AnimatedColor).b, configB);\n    const aA = anim((value: AnimatedColor).a, configA);\n    // We use `stopTogether: false` here because otherwise tracking will break\n    // because the second animation will get stopped before it can update.\n    return parallelImpl([aR, aG, aB, aA], {stopTogether: false});\n  }\n  return null;\n};\n\nconst springImpl = function (\n  value: AnimatedValue | AnimatedValueXY | AnimatedColor,\n  config: SpringAnimationConfig,\n): CompositeAnimation {\n  const start = function (\n    animatedValue: AnimatedValue | AnimatedValueXY | AnimatedColor,\n    configuration: SpringAnimationConfig,\n    callback?: ?EndCallback,\n  ): void {\n    callback = _combineCallbacks(callback, configuration);\n    const singleValue: any = animatedValue;\n    const singleConfig: any = configuration;\n    singleValue.stopTracking();\n    if (configuration.toValue instanceof AnimatedNode) {\n      singleValue.track(\n        new AnimatedTracking(\n          singleValue,\n          configuration.toValue,\n          SpringAnimation,\n          singleConfig,\n          callback,\n        ),\n      );\n    } else {\n      singleValue.animate(new SpringAnimation(singleConfig), callback);\n    }\n  };\n  return (\n    maybeVectorAnim(value, config, springImpl) || {\n      start: function (callback?: ?EndCallback): void {\n        start(value, config, callback);\n      },\n\n      stop: function (): void {\n        value.stopAnimation();\n      },\n\n      reset: function (): void {\n        value.resetAnimation();\n      },\n\n      _startNativeLoop: function (iterations?: number): void {\n        const singleConfig = {...config, iterations};\n        start(value, singleConfig);\n      },\n\n      _isUsingNativeDriver: function (): boolean {\n        return config.useNativeDriver || false;\n      },\n    }\n  );\n};\n\nconst timingImpl = function (\n  value: AnimatedValue | AnimatedValueXY | AnimatedColor,\n  config: TimingAnimationConfig,\n): CompositeAnimation {\n  const start = function (\n    animatedValue: AnimatedValue | AnimatedValueXY | AnimatedColor,\n    configuration: TimingAnimationConfig,\n    callback?: ?EndCallback,\n  ): void {\n    callback = _combineCallbacks(callback, configuration);\n    const singleValue: any = animatedValue;\n    const singleConfig: any = configuration;\n    singleValue.stopTracking();\n    if (configuration.toValue instanceof AnimatedNode) {\n      singleValue.track(\n        new AnimatedTracking(\n          singleValue,\n          configuration.toValue,\n          TimingAnimation,\n          singleConfig,\n          callback,\n        ),\n      );\n    } else {\n      singleValue.animate(new TimingAnimation(singleConfig), callback);\n    }\n  };\n\n  return (\n    maybeVectorAnim(value, config, timingImpl) || {\n      start: function (callback?: ?EndCallback, isLooping?: boolean): void {\n        start(value, {...config, isLooping}, callback);\n      },\n\n      stop: function (): void {\n        value.stopAnimation();\n      },\n\n      reset: function (): void {\n        value.resetAnimation();\n      },\n\n      _startNativeLoop: function (iterations?: number): void {\n        const singleConfig = {...config, iterations};\n        start(value, singleConfig);\n      },\n\n      _isUsingNativeDriver: function (): boolean {\n        return config.useNativeDriver || false;\n      },\n    }\n  );\n};\n\nconst decayImpl = function (\n  value: AnimatedValue | AnimatedValueXY | AnimatedColor,\n  config: DecayAnimationConfig,\n): CompositeAnimation {\n  const start = function (\n    animatedValue: AnimatedValue | AnimatedValueXY | AnimatedColor,\n    configuration: DecayAnimationConfig,\n    callback?: ?EndCallback,\n  ): void {\n    callback = _combineCallbacks(callback, configuration);\n    const singleValue: any = animatedValue;\n    const singleConfig: any = configuration;\n    singleValue.stopTracking();\n    singleValue.animate(new DecayAnimation(singleConfig), callback);\n  };\n\n  return (\n    maybeVectorAnim(value, config, decayImpl) || {\n      start: function (callback?: ?EndCallback): void {\n        start(value, config, callback);\n      },\n\n      stop: function (): void {\n        value.stopAnimation();\n      },\n\n      reset: function (): void {\n        value.resetAnimation();\n      },\n\n      _startNativeLoop: function (iterations?: number): void {\n        const singleConfig = {...config, iterations};\n        start(value, singleConfig);\n      },\n\n      _isUsingNativeDriver: function (): boolean {\n        return config.useNativeDriver || false;\n      },\n    }\n  );\n};\n\nconst sequenceImpl = function (\n  animations: Array<CompositeAnimation>,\n): CompositeAnimation {\n  let current = 0;\n  return {\n    start: function (callback?: ?EndCallback, isLooping?: boolean) {\n      const onComplete = function (result: EndResult) {\n        if (!result.finished) {\n          callback && callback(result);\n          return;\n        }\n\n        current++;\n\n        if (current === animations.length) {\n          // if the start is called, even without a reset, it should start from the beginning\n          current = 0;\n          callback && callback(result);\n          return;\n        }\n\n        animations[current].start(onComplete, isLooping);\n      };\n\n      if (animations.length === 0) {\n        callback && callback({finished: true});\n      } else {\n        animations[current].start(onComplete, isLooping);\n      }\n    },\n\n    stop: function () {\n      if (current < animations.length) {\n        animations[current].stop();\n      }\n    },\n\n    reset: function () {\n      animations.forEach((animation, idx) => {\n        if (idx <= current) {\n          animation.reset();\n        }\n      });\n      current = 0;\n    },\n\n    _startNativeLoop: function () {\n      throw new Error(\n        'Loops run using the native driver cannot contain Animated.sequence animations',\n      );\n    },\n\n    _isUsingNativeDriver: function (): boolean {\n      return false;\n    },\n  };\n};\n\ntype ParallelConfig = {\n  // If one is stopped, stop all.  default: true\n  stopTogether?: boolean,\n  ...\n};\nconst parallelImpl = function (\n  animations: Array<CompositeAnimation>,\n  config?: ?ParallelConfig,\n): CompositeAnimation {\n  let doneCount = 0;\n  // Make sure we only call stop() at most once for each animation\n  const hasEnded: {[number]: boolean} = {};\n  const stopTogether = !(config && config.stopTogether === false);\n\n  const result = {\n    start: function (callback?: ?EndCallback, isLooping?: boolean) {\n      if (doneCount === animations.length) {\n        callback && callback({finished: true});\n        return;\n      }\n\n      animations.forEach((animation, idx) => {\n        const cb = function (endResult: EndResult) {\n          hasEnded[idx] = true;\n          doneCount++;\n          if (doneCount === animations.length) {\n            doneCount = 0;\n            callback && callback(endResult);\n            return;\n          }\n\n          if (!endResult.finished && stopTogether) {\n            result.stop();\n          }\n        };\n\n        if (!animation) {\n          cb({finished: true});\n        } else {\n          animation.start(cb, isLooping);\n        }\n      });\n    },\n\n    stop: function (): void {\n      animations.forEach((animation, idx) => {\n        !hasEnded[idx] && animation.stop();\n        hasEnded[idx] = true;\n      });\n    },\n\n    reset: function (): void {\n      animations.forEach((animation, idx) => {\n        animation.reset();\n        hasEnded[idx] = false;\n        doneCount = 0;\n      });\n    },\n\n    _startNativeLoop: function (): empty {\n      throw new Error(\n        'Loops run using the native driver cannot contain Animated.parallel animations',\n      );\n    },\n\n    _isUsingNativeDriver: function (): boolean {\n      return false;\n    },\n  };\n\n  return result;\n};\n\nconst delayImpl = function (time: number): CompositeAnimation {\n  // Would be nice to make a specialized implementation\n  return timingImpl(new AnimatedValue(0), {\n    toValue: 0,\n    delay: time,\n    duration: 0,\n    useNativeDriver: false,\n  });\n};\n\nconst staggerImpl = function (\n  time: number,\n  animations: Array<CompositeAnimation>,\n): CompositeAnimation {\n  return parallelImpl(\n    animations.map((animation, i) => {\n      return sequenceImpl([delayImpl(time * i), animation]);\n    }),\n  );\n};\n\ntype LoopAnimationConfig = {\n  iterations: number,\n  resetBeforeIteration?: boolean,\n  ...\n};\n\nconst loopImpl = function (\n  animation: CompositeAnimation,\n  // $FlowFixMe[prop-missing]\n  {iterations = -1, resetBeforeIteration = true}: LoopAnimationConfig = {},\n): CompositeAnimation {\n  let isFinished = false;\n  let iterationsSoFar = 0;\n  return {\n    start: function (callback?: ?EndCallback) {\n      const restart = function (result: EndResult = {finished: true}): void {\n        if (\n          isFinished ||\n          iterationsSoFar === iterations ||\n          result.finished === false\n        ) {\n          callback && callback(result);\n        } else {\n          iterationsSoFar++;\n          resetBeforeIteration && animation.reset();\n          animation.start(restart, iterations === -1);\n        }\n      };\n      if (!animation || iterations === 0) {\n        callback && callback({finished: true});\n      } else {\n        if (animation._isUsingNativeDriver()) {\n          animation._startNativeLoop(iterations);\n        } else {\n          restart(); // Start looping recursively on the js thread\n        }\n      }\n    },\n\n    stop: function (): void {\n      isFinished = true;\n      animation.stop();\n    },\n\n    reset: function (): void {\n      iterationsSoFar = 0;\n      isFinished = false;\n      animation.reset();\n    },\n\n    _startNativeLoop: function () {\n      throw new Error(\n        'Loops run using the native driver cannot contain Animated.loop animations',\n      );\n    },\n\n    _isUsingNativeDriver: function (): boolean {\n      return animation._isUsingNativeDriver();\n    },\n  };\n};\n\nfunction forkEventImpl(\n  event: ?AnimatedEvent | ?Function,\n  listener: Function,\n): AnimatedEvent | Function {\n  if (!event) {\n    return listener;\n  } else if (event instanceof AnimatedEvent) {\n    event.__addListener(listener);\n    return event;\n  } else {\n    return (...args) => {\n      typeof event === 'function' && event(...args);\n      listener(...args);\n    };\n  }\n}\n\nfunction unforkEventImpl(\n  event: ?AnimatedEvent | ?Function,\n  listener: Function,\n): void {\n  if (event && event instanceof AnimatedEvent) {\n    event.__removeListener(listener);\n  }\n}\n\nconst eventImpl = function <T>(\n  argMapping: $ReadOnlyArray<?Mapping>,\n  config: EventConfig<T>,\n): any {\n  const animatedEvent = new AnimatedEvent(argMapping, config);\n  if (animatedEvent.__isNative) {\n    return animatedEvent;\n  } else {\n    return animatedEvent.__getHandler();\n  }\n};\n\n// All types of animated nodes that represent scalar numbers and can be interpolated (etc)\ntype AnimatedNumeric =\n  | AnimatedAddition\n  | AnimatedDiffClamp\n  | AnimatedDivision\n  | AnimatedInterpolation<number>\n  | AnimatedModulo\n  | AnimatedMultiplication\n  | AnimatedSubtraction\n  | AnimatedValue;\n\nexport type {AnimatedNumeric as Numeric};\n\n/**\n * The `Animated` library is designed to make animations fluid, powerful, and\n * easy to build and maintain. `Animated` focuses on declarative relationships\n * between inputs and outputs, with configurable transforms in between, and\n * simple `start`/`stop` methods to control time-based animation execution.\n * If additional transforms are added, be sure to include them in\n * AnimatedMock.js as well.\n *\n * See https://reactnative.dev/docs/animated\n */\nexport default {\n  /**\n   * Standard value class for driving animations.  Typically initialized with\n   * `new Animated.Value(0);`\n   *\n   * See https://reactnative.dev/docs/animated#value\n   */\n  Value: AnimatedValue,\n  /**\n   * 2D value class for driving 2D animations, such as pan gestures.\n   *\n   * See https://reactnative.dev/docs/animatedvaluexy\n   */\n  ValueXY: AnimatedValueXY,\n  /**\n   * Value class for driving color animations.\n   */\n  Color: AnimatedColor,\n  /**\n   * Exported to use the Interpolation type in flow.\n   *\n   * See https://reactnative.dev/docs/animated#interpolation\n   */\n  Interpolation: AnimatedInterpolation,\n  /**\n   * Exported for ease of type checking. All animated values derive from this\n   * class.\n   *\n   * See https://reactnative.dev/docs/animated#node\n   */\n  Node: AnimatedNode,\n  decay: decayImpl,\n  timing: timingImpl,\n  spring: springImpl,\n  add: addImpl,\n  subtract: subtractImpl,\n  divide: divideImpl,\n  multiply: multiplyImpl,\n  modulo: moduloImpl,\n  diffClamp: diffClampImpl,\n  delay: delayImpl,\n  sequence: sequenceImpl,\n  parallel: parallelImpl,\n  stagger: staggerImpl,\n  loop: loopImpl,\n  event: eventImpl,\n  createAnimatedComponent,\n  attachNativeEvent: attachNativeEventImpl,\n  forkEvent: forkEventImpl,\n  unforkEvent: unforkEventImpl,\n\n  /**\n   * Expose Event class, so it can be used as a type for type checkers.\n   */\n  Event: AnimatedEvent,\n};\n"],"mappings":"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","ignoreList":[]}

package/.cache/jest-cache-react-17/jest-transform-cache-351fb7c9421020ab4cca8f7975c30d61-1324230084614362f519ae4cb2580aab/14/BatteryCarnative_149ae601872972b8fba325068cfb5e39

@@ -0,0 +1,46 @@
+3e0323a5fa42de5a7b75a8040f864b6b
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _excluded = ["title", "titleId", "size", "color", "gradient"];
+var _reactNativeSvg = require("react-native-svg");
+var _jsxRuntime = require("react/jsx-runtime");
+module.exports = function (_ref) {
+  var title = _ref.title,
+    titleId = _ref.titleId,
+    size = _ref.size,
+    color = _ref.color,
+    gradient = _ref.gradient,
+    props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+  var iconSharedUtils = require('./utils/icon-shared-utils');
+  var hasGradient = iconSharedUtils.hasValidGradient(gradient);
+  var fillValue = color;
+  var gradientDefs;
+  var gradientUtils;
+  if (hasGradient) {
+    gradientUtils = iconSharedUtils.getGradientUtils();
+    var iconNativeUtils = require('./utils/icon-native-utils');
+    var gradientId = gradientUtils.generateGradientId(gradient);
+    fillValue = `url(#${gradientId})`;
+    gradientDefs = iconNativeUtils.renderNativeGradientDefs(gradient, gradientId);
+  }
+  var svgContent = (0, _jsxRuntime.jsxs)(_reactNativeSvg.default, Object.assign({}, props, {
+    xmlns: "http://www.w3.org/2000/svg",
+    viewBox: "0 0 24 24",
+    height: size,
+    width: size,
+    fill: fillValue,
+    "aria-labelledby": titleId,
+    children: [title ? (0, _jsxRuntime.jsx)("title", {
+      id: titleId,
+      children: title
+    }) : null, (0, _jsxRuntime.jsx)(_reactNativeSvg.Path, {
+      fillRule: "evenodd",
+      d: "M4.5 3a.5.5 0 0 1 .5.5V5h.5a.5.5 0 0 1 .447.276L6.309 6H8v-.5C8 4.673 8.673 4 9.5 4h5c.827 0 1.5.673 1.5 1.5V6h1.692l.361-.724A.5.5 0 0 1 18.5 5h.5V3.5a.5.5 0 0 1 .5-.5h2a.5.5 0 0 1 .5.5V5h.5c.827 0 1.5.673 1.5 1.5v13c0 .827-.673 1.5-1.5 1.5h-21C.673 21 0 20.327 0 19.5v-13C0 5.673.673 5 1.5 5H2V3.5a.5.5 0 0 1 .5-.5h2Zm.691 3H1.5a.5.5 0 0 0-.5.5v13a.5.5 0 0 0 .5.5h21a.5.5 0 0 0 .5-.5v-13a.5.5 0 0 0-.5-.5h-3.691l-.361.724A.503.503 0 0 1 18 7H6a.5.5 0 0 1-.447-.276L5.191 6Zm.309 5a.5.5 0 0 1 .5.5V13h1.5a.5.5 0 0 1 0 1H6v1.5a.5.5 0 0 1-1 0V14H3.5a.5.5 0 0 1 0-1H5v-1.5a.5.5 0 0 1 .5-.5Zm15 2a.5.5 0 0 1 0 1h-4a.5.5 0 0 1 0-1h4Zm-6-8h-5a.5.5 0 0 0-.5.5V6h6v-.5a.5.5 0 0 0-.5-.5ZM21 4h-1v1h1V4ZM4 4H3v1h1V4Z",
+      clipRule: "evenodd"
+    })]
+  }));
+  return hasGradient ? gradientUtils.addGradientToSvg(svgContent, gradientDefs) : svgContent;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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