expo-dev-menu 2.2.0 → 3.0.0

package/vendored/react-native-reanimated/src/reanimated2/animation/sequence.ts

@@ -1,98 +0,0 @@
-import { defineAnimation } from './util';
-import { NextAnimation, SequenceAnimation } from './commonTypes';
-import {
-  Animation,
-  AnimatableValue,
-  AnimationObject,
-  Timestamp,
-} from '../commonTypes';
-
-export function withSequence(
-  ..._animations: NextAnimation<AnimationObject>[]
-): Animation<SequenceAnimation> {
-  'worklet';
-  return defineAnimation<SequenceAnimation>(
-    _animations[0] as SequenceAnimation,
-    () => {
-      'worklet';
-      const animations = _animations.map((a) => {
-        const result = typeof a === 'function' ? a() : a;
-        result.finished = false;
-        return result;
-      });
-      const firstAnimation = animations[0];
-
-      const callback = (finished: boolean): void => {
-        if (finished) {
-          // we want to call the callback after every single animation
-          // not after all of them
-          return;
-        }
-        // this is going to be called only if sequence has been cancelled
-        animations.forEach((animation) => {
-          if (typeof animation.callback === 'function' && !animation.finished) {
-            animation.callback(finished);
-          }
-        });
-      };
-
-      function sequence(animation: SequenceAnimation, now: Timestamp): boolean {
-        const currentAnim = animations[animation.animationIndex];
-        const finished = currentAnim.onFrame(currentAnim, now);
-        animation.current = currentAnim.current;
-        if (finished) {
-          // we want to call the callback after every single animation
-          if (currentAnim.callback) {
-            currentAnim.callback(true /* finished */);
-          }
-          currentAnim.finished = true;
-          animation.animationIndex += 1;
-          if (animation.animationIndex < animations.length) {
-            const nextAnim = animations[animation.animationIndex];
-            nextAnim.onStart(nextAnim, currentAnim.current, now, currentAnim);
-            return false;
-          }
-          return true;
-        }
-        return false;
-      }
-
-      function onStart(
-        animation: SequenceAnimation,
-        value: AnimatableValue,
-        now: Timestamp,
-        previousAnimation: SequenceAnimation
-      ): void {
-        animation.animationIndex = 0;
-        if (previousAnimation === undefined) {
-          previousAnimation = animations[
-            animations.length - 1
-          ] as SequenceAnimation;
-        }
-        firstAnimation.onStart(firstAnimation, value, now, previousAnimation);
-      }
-
-      return {
-        isHigherOrder: true,
-        onFrame: sequence,
-        onStart,
-        animationIndex: 0,
-        current: firstAnimation.current,
-        callback,
-      } as SequenceAnimation;
-    }
-  );
-}
-
-/**
- * @deprecated Kept for backward compatibility. Will be removed soon.
- */
-export function sequence(
-  ..._animations: NextAnimation<SequenceAnimation>[]
-): Animation<SequenceAnimation> {
-  'worklet';
-  console.warn(
-    'Method `sequence` is deprecated. Please use `withSequence` instead'
-  );
-  return withSequence(..._animations);
-}

package/vendored/react-native-reanimated/src/reanimated2/animation/spring.ts

@@ -1,166 +0,0 @@
-import { defineAnimation } from './util';
-import {
-  Animation,
-  AnimationCallback,
-  AnimatableValue,
-  Timestamp,
-} from '../commonTypes';
-
-interface SpringConfig {
-  mass?: number;
-  stiffness?: number;
-  overshootClamping?: boolean;
-  restDisplacementThreshold?: number;
-  restSpeedThreshold?: number;
-  velocity?: number;
-  damping?: number;
-}
-
-export interface SpringAnimation extends Animation<SpringAnimation> {
-  current: AnimatableValue;
-  toValue: AnimatableValue;
-  velocity: number;
-  lastTimestamp: Timestamp;
-}
-
-export interface InnerSpringAnimation
-  extends Omit<SpringAnimation, 'toValue' | 'current'> {
-  toValue: number;
-  current: number;
-}
-
-export function withSpring(
-  toValue: AnimatableValue,
-  userConfig?: SpringConfig,
-  callback?: AnimationCallback
-): Animation<SpringAnimation> {
-  'worklet';
-
-  return defineAnimation<SpringAnimation>(toValue, () => {
-    'worklet';
-
-    // TODO: figure out why we can't use spread or Object.assign here
-    // when user config is "frozen object" we can't enumerate it (perhaps
-    // something is wrong with the object prototype).
-    const config: Required<SpringConfig> = {
-      damping: 10,
-      mass: 1,
-      stiffness: 100,
-      overshootClamping: false,
-      restDisplacementThreshold: 0.01,
-      restSpeedThreshold: 2,
-      velocity: 0,
-    };
-    if (userConfig) {
-      Object.keys(userConfig).forEach(
-        (key) =>
-          ((config as any)[key] = userConfig[key as keyof typeof userConfig])
-      );
-    }
-
-    function spring(animation: InnerSpringAnimation, now: Timestamp): boolean {
-      const { toValue, lastTimestamp, current, velocity } = animation;
-
-      const deltaTime = Math.min(now - lastTimestamp, 64);
-      animation.lastTimestamp = now;
-
-      const c = config.damping;
-      const m = config.mass;
-      const k = config.stiffness;
-
-      const v0 = -velocity;
-      const x0 = toValue - current;
-
-      const zeta = c / (2 * Math.sqrt(k * m)); // damping ratio
-      const omega0 = Math.sqrt(k / m); // undamped angular frequency of the oscillator (rad/ms)
-      const omega1 = omega0 * Math.sqrt(1 - zeta ** 2); // exponential decay
-
-      const t = deltaTime / 1000;
-
-      const sin1 = Math.sin(omega1 * t);
-      const cos1 = Math.cos(omega1 * t);
-
-      // under damped
-      const underDampedEnvelope = Math.exp(-zeta * omega0 * t);
-      const underDampedFrag1 =
-        underDampedEnvelope *
-        (sin1 * ((v0 + zeta * omega0 * x0) / omega1) + x0 * cos1);
-
-      const underDampedPosition = toValue - underDampedFrag1;
-      // This looks crazy -- it's actually just the derivative of the oscillation function
-      const underDampedVelocity =
-        zeta * omega0 * underDampedFrag1 -
-        underDampedEnvelope *
-          (cos1 * (v0 + zeta * omega0 * x0) - omega1 * x0 * sin1);
-
-      // critically damped
-      const criticallyDampedEnvelope = Math.exp(-omega0 * t);
-      const criticallyDampedPosition =
-        toValue - criticallyDampedEnvelope * (x0 + (v0 + omega0 * x0) * t);
-
-      const criticallyDampedVelocity =
-        criticallyDampedEnvelope *
-        (v0 * (t * omega0 - 1) + t * x0 * omega0 * omega0);
-
-      const isOvershooting = () => {
-        if (config.overshootClamping && config.stiffness !== 0) {
-          return current < toValue
-            ? animation.current > toValue
-            : animation.current < toValue;
-        } else {
-          return false;
-        }
-      };
-
-      const isVelocity = Math.abs(velocity) < config.restSpeedThreshold;
-      const isDisplacement =
-        config.stiffness === 0 ||
-        Math.abs(toValue - current) < config.restDisplacementThreshold;
-
-      if (zeta < 1) {
-        animation.current = underDampedPosition;
-        animation.velocity = underDampedVelocity;
-      } else {
-        animation.current = criticallyDampedPosition;
-        animation.velocity = criticallyDampedVelocity;
-      }
-
-      if (isOvershooting() || (isVelocity && isDisplacement)) {
-        if (config.stiffness !== 0) {
-          animation.velocity = 0;
-          animation.current = toValue;
-        }
-        // clear lastTimestamp to avoid using stale value by the next spring animation that starts after this one
-        animation.lastTimestamp = 0;
-        return true;
-      }
-      return false;
-    }
-
-    function onStart(
-      animation: SpringAnimation,
-      value: number,
-      now: Timestamp,
-      previousAnimation: SpringAnimation
-    ): void {
-      animation.current = value;
-      if (previousAnimation) {
-        animation.velocity =
-          previousAnimation.velocity || animation.velocity || 0;
-        animation.lastTimestamp = previousAnimation.lastTimestamp || now;
-      } else {
-        animation.lastTimestamp = now;
-      }
-    }
-
-    return {
-      onFrame: spring,
-      onStart,
-      toValue,
-      velocity: config.velocity || 0,
-      current: toValue,
-      callback,
-      lastTimestamp: 0,
-    } as SpringAnimation;
-  });
-}

package/vendored/react-native-reanimated/src/reanimated2/animation/styleAnimation.ts

@@ -1,258 +0,0 @@
-import { defineAnimation } from './util';
-import {
-  Timestamp,
-  AnimatableValue,
-  AnimationObject,
-  Animation,
-  AnimatedStyle,
-  NestedObject,
-  NestedObjectValues,
-} from '../commonTypes';
-import { StyleLayoutAnimation } from './commonTypes';
-import { withTiming } from './timing';
-import { ColorProperties } from '../UpdateProps';
-import { processColor } from '../Colors';
-
-// resolves path to value for nested objects
-// if path cannot be resolved returns undefined
-export function resolvePath<T>(
-  obj: NestedObject<T>,
-  path: AnimatableValue[] | AnimatableValue
-): NestedObjectValues<T> | undefined {
-  'worklet';
-  const keys: AnimatableValue[] = Array.isArray(path) ? path : [path];
-  return keys.reduce<NestedObjectValues<T> | undefined>((acc, current) => {
-    if (Array.isArray(acc) && typeof current === 'number') {
-      return acc[current];
-    } else if (typeof acc === 'object' && (current as number | string) in acc) {
-      return (acc as { [key: string]: NestedObjectValues<T> })[
-        current as number | string
-      ];
-    }
-    return undefined;
-  }, obj);
-}
-
-// set value at given path
-type Path = Array<string | number> | string | number;
-export function setPath<T>(
-  obj: NestedObject<T>,
-  path: Path,
-  value: NestedObjectValues<T>
-): void {
-  'worklet';
-  const keys: Path = Array.isArray(path) ? path : [path];
-  let currObj: NestedObjectValues<T> = obj;
-  for (let i = 0; i < keys.length - 1; i++) {
-    // creates entry if there isn't one
-    currObj = currObj as { [key: string]: NestedObjectValues<T> };
-    if (!(keys[i] in currObj)) {
-      // if next key is a number create an array
-      if (typeof keys[i + 1] === 'number') {
-        currObj[keys[i]] = [];
-      } else {
-        currObj[keys[i]] = {};
-      }
-    }
-    currObj = currObj[keys[i]];
-  }
-
-  (currObj as { [key: string]: NestedObjectValues<T> })[keys[keys.length - 1]] =
-    value;
-}
-
-interface NestedObjectEntry<T> {
-  value: NestedObjectValues<T>;
-  path: (string | number)[];
-}
-
-export function withStyleAnimation(
-  styleAnimations: AnimatedStyle
-): StyleLayoutAnimation {
-  'worklet';
-  return defineAnimation<StyleLayoutAnimation>({}, () => {
-    'worklet';
-
-    const onFrame = (
-      animation: StyleLayoutAnimation,
-      now: Timestamp
-    ): boolean => {
-      let stillGoing = false;
-      const entriesToCheck: NestedObjectEntry<AnimationObject>[] = [
-        { value: animation.styleAnimations, path: [] },
-      ];
-      while (entriesToCheck.length > 0) {
-        const currentEntry: NestedObjectEntry<AnimationObject> =
-          entriesToCheck.pop() as NestedObjectEntry<AnimationObject>;
-        if (Array.isArray(currentEntry.value)) {
-          for (let index = 0; index < currentEntry.value.length; index++) {
-            entriesToCheck.push({
-              value: currentEntry.value[index],
-              path: currentEntry.path.concat(index),
-            });
-          }
-        } else if (
-          typeof currentEntry.value === 'object' &&
-          currentEntry.value.onFrame === undefined
-        ) {
-          // nested object
-          for (const key of Object.keys(currentEntry.value)) {
-            entriesToCheck.push({
-              value: currentEntry.value[key],
-              path: currentEntry.path.concat(key),
-            });
-          }
-        } else {
-          const currentStyleAnimation: AnimationObject =
-            currentEntry.value as AnimationObject;
-          if (currentStyleAnimation.finished) {
-            continue;
-          }
-          const finished = currentStyleAnimation.onFrame(
-            currentStyleAnimation,
-            now
-          );
-          if (finished) {
-            currentStyleAnimation.finished = true;
-            if (currentStyleAnimation.callback) {
-              currentStyleAnimation.callback(true);
-            }
-          } else {
-            stillGoing = true;
-          }
-
-          if (ColorProperties.includes(currentEntry.path[0] as string)) {
-            currentStyleAnimation.current = processColor(
-              currentStyleAnimation.current
-            ) as number;
-          }
-
-          setPath(
-            animation.current,
-            currentEntry.path,
-            currentStyleAnimation.current
-          );
-        }
-      }
-      return !stillGoing;
-    };
-
-    const onStart = (
-      animation: StyleLayoutAnimation,
-      value: AnimatedStyle,
-      now: Timestamp,
-      previousAnimation: StyleLayoutAnimation
-    ): void => {
-      const entriesToCheck: NestedObjectEntry<
-        AnimationObject | AnimatableValue
-      >[] = [{ value: styleAnimations, path: [] }];
-      while (entriesToCheck.length > 0) {
-        const currentEntry: NestedObjectEntry<
-          AnimationObject | AnimatableValue
-        > = entriesToCheck.pop() as NestedObjectEntry<
-          AnimationObject | AnimatableValue
-        >;
-        if (Array.isArray(currentEntry.value)) {
-          for (let index = 0; index < currentEntry.value.length; index++) {
-            entriesToCheck.push({
-              value: currentEntry.value[index],
-              path: currentEntry.path.concat(index),
-            });
-          }
-        } else if (
-          typeof currentEntry.value === 'object' &&
-          currentEntry.value.onStart === undefined
-        ) {
-          for (const key of Object.keys(currentEntry.value)) {
-            entriesToCheck.push({
-              value: currentEntry.value[key],
-              path: currentEntry.path.concat(key),
-            });
-          }
-        } else {
-          const prevAnimation = resolvePath(
-            previousAnimation?.styleAnimations,
-            currentEntry.path
-          );
-          let prevVal = resolvePath(value, currentEntry.path);
-          if (prevAnimation && !prevVal) {
-            prevVal = prevAnimation.current;
-          }
-          if (prevVal === undefined) {
-            console.warn(
-              `Initial values for animation are missing for property ${currentEntry.path.join(
-                '.'
-              )}`
-            );
-          }
-          setPath(animation.current, currentEntry.path, prevVal);
-          let currentAnimation: AnimationObject;
-          if (
-            typeof currentEntry.value !== 'object' ||
-            !currentEntry.value.onStart
-          ) {
-            currentAnimation = withTiming(
-              currentEntry.value as AnimatableValue,
-              { duration: 0 }
-            );
-            setPath(
-              animation.styleAnimations,
-              currentEntry.path,
-              currentAnimation
-            );
-          } else {
-            currentAnimation = currentEntry.value as Animation<AnimationObject>;
-          }
-          currentAnimation.onStart(
-            currentAnimation,
-            prevVal,
-            now,
-            prevAnimation
-          );
-        }
-      }
-    };
-
-    const callback = (finished: boolean): void => {
-      if (!finished) {
-        const animationsToCheck: NestedObjectValues<AnimationObject>[] = [
-          styleAnimations,
-        ];
-        while (animationsToCheck.length > 0) {
-          const currentAnimation: NestedObjectValues<AnimationObject> =
-            animationsToCheck.pop() as NestedObjectValues<AnimationObject>;
-          if (Array.isArray(currentAnimation)) {
-            for (const element of currentAnimation) {
-              animationsToCheck.push(element);
-            }
-          } else if (
-            typeof currentAnimation === 'object' &&
-            currentAnimation.onStart === undefined
-          ) {
-            for (const value of Object.values(currentAnimation)) {
-              animationsToCheck.push(value);
-            }
-          } else {
-            const currentStyleAnimation: AnimationObject =
-              currentAnimation as AnimationObject;
-            if (
-              !currentStyleAnimation.finished &&
-              currentStyleAnimation.callback
-            ) {
-              currentStyleAnimation.callback(false);
-            }
-          }
-        }
-      }
-    };
-
-    return {
-      isHigherOrder: true,
-      onFrame,
-      onStart,
-      current: {},
-      styleAnimations,
-      callback,
-    } as StyleLayoutAnimation;
-  });
-}

package/vendored/react-native-reanimated/src/reanimated2/animation/timing.ts

@@ -1,111 +0,0 @@
-import { Easing, EasingFn, EasingFactoryFn } from '../Easing';
-import { defineAnimation } from './util';
-import {
-  Animation,
-  AnimationCallback,
-  Timestamp,
-  AnimatableValue,
-} from '../commonTypes';
-
-interface TimingConfig {
-  duration?: number;
-  easing?: EasingFn | EasingFactoryFn;
-}
-
-export interface TimingAnimation extends Animation<TimingAnimation> {
-  type: string;
-  easing: EasingFn;
-  startValue: AnimatableValue;
-  startTime: Timestamp;
-  progress: number;
-  toValue: AnimatableValue;
-  current: AnimatableValue;
-}
-
-export interface InnerTimingAnimation
-  extends Omit<TimingAnimation, 'toValue' | 'current'> {
-  toValue: number;
-  current: number;
-}
-
-export function withTiming(
-  toValue: AnimatableValue,
-  userConfig?: TimingConfig,
-  callback?: AnimationCallback
-): Animation<TimingAnimation> {
-  'worklet';
-
-  return defineAnimation<TimingAnimation>(toValue, () => {
-    'worklet';
-    const config: Required<TimingConfig> = {
-      duration: 300,
-      easing: Easing.inOut(Easing.quad),
-    };
-    if (userConfig) {
-      Object.keys(userConfig).forEach(
-        (key) =>
-          ((config as any)[key] = userConfig[key as keyof typeof userConfig])
-      );
-    }
-
-    function timing(animation: InnerTimingAnimation, now: Timestamp): boolean {
-      const { toValue, startTime, startValue } = animation;
-      const runtime = now - startTime;
-
-      if (runtime >= config.duration) {
-        // reset startTime to avoid reusing finished animation config in `start` method
-        animation.startTime = 0;
-        animation.current = toValue;
-        return true;
-      }
-      const progress = animation.easing(runtime / config.duration);
-      animation.current =
-        (startValue as number) + (toValue - (startValue as number)) * progress;
-      return false;
-    }
-
-    function onStart(
-      animation: TimingAnimation,
-      value: number,
-      now: Timestamp,
-      previousAnimation: Animation<TimingAnimation>
-    ): void {
-      if (
-        previousAnimation &&
-        (previousAnimation as TimingAnimation).type === 'timing' &&
-        (previousAnimation as TimingAnimation).toValue === toValue &&
-        (previousAnimation as TimingAnimation).startTime
-      ) {
-        // to maintain continuity of timing animations we check if we are starting
-        // new timing over the old one with the same parameters. If so, we want
-        // to copy animation timeline properties
-        animation.startTime = (previousAnimation as TimingAnimation).startTime;
-        animation.startValue = (
-          previousAnimation as TimingAnimation
-        ).startValue;
-      } else {
-        animation.startTime = now;
-        animation.startValue = value;
-      }
-      animation.current = value;
-      if (typeof config.easing === 'object') {
-        animation.easing = config.easing.factory();
-      } else {
-        animation.easing = config.easing;
-      }
-    }
-
-    return {
-      type: 'timing',
-      onFrame: timing,
-      onStart: onStart as (animation: TimingAnimation, now: number) => boolean,
-      progress: 0,
-      toValue,
-      startValue: 0,
-      startTime: 0,
-      easing: () => 0,
-      current: toValue,
-      callback,
-    } as TimingAnimation;
-  });
-}