What to use instead parallel(...)?

What to use instead native parallel(…) method of for example in such a function?

`const open = () => {
  
  scrollRef && scrollRef.current
    ? scrollRef.current.scrollTo({x: 0, y: 0, animated: true})
    : null;
  setBabyOpened(true);
  Animated.parallel([
    Animated.timing(animationPositionX, {
      toValue: 0,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationPositionY, {
      toValue: 0,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationButtonCloseTop, {
      toValue: base * 12,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationButtonCloseRight, {
      toValue: base * 12,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationWidth, {
      toValue: screenWidth,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationViewHeight, {
      toValue: OPENEDHEIGHT,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationHeight, {
      toValue: screenHeight,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationPreViewHeight, {
      toValue: screenHeight,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationRadius, {
      toValue: 0,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationImageWidth, {
      toValue: OPENEDHEIGHT - base * 128,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationImageHeight, {
      toValue: OPENEDHEIGHT - base * 128,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationImagePositionX, {
      toValue: -base * 24,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationImagePositionY, {
      toValue: base * 24,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationImageRotate, {
      toValue: 0.15,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationCloseOpacity, {
      toValue: 1,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationProgressWidth, {
      toValue: screenWidth * 1 - base * 48,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationProgressBottom, {
      toValue: base * 88,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationInfoOpacity, {
      toValue: 1,
      duration: animationDuration,
      useNativeDriver: false,
    }),
    Animated.timing(animationFruitHeight, {
      toValue:
        screenHeight <= 580
          ? screenHeight - OPENEDHEIGHT + base * 72
          : screenHeight - OPENEDHEIGHT,
      duration: animationDuration * 2,
      useNativeDriver: false,
    }),
    Animated.timing(animationGradientHeight, {
      toValue:
        screenHeight <= 670
          ? screenHeight <= 580
            ? -base * 163
            : -base * 83
          : -base * 63,
      duration: animationDuration,
      useNativeDriver: false,
    }),
  ]).start();
  };`

[jakub-gonet]

Hi @Goldyukol,

you can try using Transitions or keep a list of Value nodes which will act like flags, so you can use cond(eq(flag, 1), (your animation)) and just set it off like that: map(flags, flag => flag.setValue(1))

I believe there are more ways to do that too.

Related issue: #81

Hope that helps.

[pbtkhoa]

I would suggest to have single animation value, animation from 0 to 1 and to use interpolate for everything else where input is [0, 1] and output is [currentValue, toValue]

Could it parallel? Could you give me any simple example? I got stuck T__T