expo-dev-menu 2.2.0 → 3.0.0

package/vendored/react-native-reanimated/src/reanimated2/UpdateProps.ts

@@ -1,93 +0,0 @@
-/* global _updateProps */
-import { MutableRefObject } from 'react';
-import { processColor } from './Colors';
-import { AnimatedStyle, SharedValue, StyleProps } from './commonTypes';
-import { makeShareable, isConfigured } from './core';
-import { Descriptor } from './hook/commonTypes';
-import { _updatePropsJS } from './js-reanimated';
-import { shouldBeUseWeb } from './PlatformChecker';
-import { ViewRefSet } from './ViewDescriptorsSet';
-
-// copied from react-native/Libraries/Components/View/ReactNativeStyleAttributes
-export const colorProps = [
-  'backgroundColor',
-  'borderBottomColor',
-  'borderColor',
-  'borderLeftColor',
-  'borderRightColor',
-  'borderTopColor',
-  'borderStartColor',
-  'borderEndColor',
-  'color',
-  'shadowColor',
-  'textDecorationColor',
-  'tintColor',
-  'textShadowColor',
-  'overlayColor',
-];
-
-export const ColorProperties = !isConfigured() ? [] : makeShareable(colorProps);
-
-let updatePropsByPlatform;
-if (shouldBeUseWeb()) {
-  updatePropsByPlatform = (
-    _: SharedValue<Descriptor[]>,
-    updates: StyleProps | AnimatedStyle,
-    maybeViewRef: ViewRefSet<any> | undefined
-  ): void => {
-    'worklet';
-    if (maybeViewRef) {
-      maybeViewRef.items.forEach((item, _) => {
-        _updatePropsJS(updates, item);
-      });
-    }
-  };
-} else {
-  updatePropsByPlatform = (
-    viewDescriptors: SharedValue<Descriptor[]>,
-    updates: StyleProps | AnimatedStyle,
-    _: ViewRefSet<any> | undefined
-  ): void => {
-    'worklet';
-
-    for (const key in updates) {
-      if (ColorProperties.indexOf(key) !== -1) {
-        updates[key] = processColor(updates[key]);
-      }
-    }
-
-    viewDescriptors.value.forEach((viewDescriptor) => {
-      _updateProps(
-        viewDescriptor.tag,
-        viewDescriptor.name || 'RCTView',
-        updates
-      );
-    });
-  };
-}
-
-export const updateProps: (
-  viewDescriptor: SharedValue<Descriptor[]>,
-  updates: StyleProps | AnimatedStyle,
-  maybeViewRef: ViewRefSet<any> | undefined
-) => void = updatePropsByPlatform;
-
-export const updatePropsJestWrapper = (
-  viewDescriptors: SharedValue<Descriptor[]>,
-  updates: AnimatedStyle,
-  maybeViewRef: ViewRefSet<any> | undefined,
-  animatedStyle: MutableRefObject<AnimatedStyle>,
-  adapters: ((updates: AnimatedStyle) => void)[]
-): void => {
-  adapters.forEach((adapter) => {
-    adapter(updates);
-  });
-  animatedStyle.current.value = {
-    ...animatedStyle.current.value,
-    ...updates,
-  };
-
-  updateProps(viewDescriptors, updates, maybeViewRef);
-};
-
-export default updateProps;

package/vendored/react-native-reanimated/src/reanimated2/ViewDescriptorsSet.ts

@@ -1,111 +0,0 @@
-import { useRef } from 'react';
-import { makeMutable } from './core';
-import { SharedValue } from './commonTypes';
-import { Descriptor } from './hook/commonTypes';
-import { shouldBeUseWeb } from './PlatformChecker';
-
-export interface ViewRefSet<T> {
-  items: Set<T>;
-  add: (item: T) => void;
-  remove: (item: T) => void;
-}
-
-export interface ViewDescriptorsSet {
-  batchToRemove: Set<number>;
-  tags: Set<number>;
-  waitForInsertSync: boolean;
-  waitForRemoveSync: boolean;
-  sharableViewDescriptors: SharedValue<Descriptor[]>;
-  items: Descriptor[];
-  add: (item: Descriptor) => void;
-  remove: (viewTag: number) => void;
-  rebuildsharableViewDescriptors: (
-    sharableViewDescriptor: SharedValue<Descriptor[]>
-  ) => void;
-}
-
-const scheduleUpdates = shouldBeUseWeb() ? requestAnimationFrame : setImmediate;
-
-export function makeViewDescriptorsSet(): ViewDescriptorsSet {
-  const ref = useRef<ViewDescriptorsSet | null>(null);
-  if (ref.current === null) {
-    const data: ViewDescriptorsSet = {
-      batchToRemove: new Set(),
-      tags: new Set(),
-      waitForInsertSync: false,
-      waitForRemoveSync: false,
-      sharableViewDescriptors: makeMutable([]),
-      items: [],
-
-      add: (item: Descriptor) => {
-        if (data.tags.has(item.tag)) {
-          return;
-        }
-        data.tags.add(item.tag);
-        data.items.push(item);
-
-        if (!data.waitForInsertSync) {
-          data.waitForInsertSync = true;
-
-          scheduleUpdates(() => {
-            data.sharableViewDescriptors.value = data.items;
-            data.waitForInsertSync = false;
-          });
-        }
-      },
-
-      remove: (viewTag: number) => {
-        data.batchToRemove.add(viewTag);
-
-        if (!data.waitForRemoveSync) {
-          data.waitForRemoveSync = true;
-
-          scheduleUpdates(() => {
-            const items = [];
-            for (const item of data.items) {
-              if (data.batchToRemove.has(item.tag)) {
-                data.tags.delete(item.tag);
-              } else {
-                items.push(item);
-              }
-            }
-            data.items = items;
-            data.sharableViewDescriptors.value = items;
-            data.batchToRemove = new Set();
-            data.waitForRemoveSync = false;
-          });
-        }
-      },
-
-      rebuildsharableViewDescriptors: (
-        sharableViewDescriptors: SharedValue<Descriptor[]>
-      ) => {
-        data.sharableViewDescriptors = sharableViewDescriptors;
-      },
-    };
-    ref.current = data;
-  }
-
-  return ref.current;
-}
-
-export function makeViewsRefSet<T>(): ViewRefSet<T> {
-  const ref = useRef<ViewRefSet<T> | null>(null);
-  if (ref.current === null) {
-    const data: ViewRefSet<T> = {
-      items: new Set(),
-
-      add: (item: T) => {
-        if (data.items.has(item)) return;
-        data.items.add(item);
-      },
-
-      remove: (item: T) => {
-        data.items.delete(item);
-      },
-    };
-    ref.current = data;
-  }
-
-  return ref.current;
-}

package/vendored/react-native-reanimated/src/reanimated2/WorkletEventHandler.ts

@@ -1,68 +0,0 @@
-import { NativeEvent } from './commonTypes';
-import NativeReanimatedModule from './NativeReanimated';
-
-function jsListener<T extends NativeEvent<T>>(
-  eventName: string,
-  handler: (event: T) => void
-) {
-  return (evt: T) => {
-    handler({ ...evt.nativeEvent, eventName });
-  };
-}
-
-export default class WorkletEventHandler<T extends NativeEvent<T>> {
-  worklet: (event: T) => void;
-  eventNames: string[];
-  reattachNeeded: boolean;
-  listeners: Record<string, (event: T) => void>;
-  viewTag: number | undefined;
-  registrations: string[];
-  constructor(worklet: (event: T) => void, eventNames: string[] = []) {
-    this.worklet = worklet;
-    this.eventNames = eventNames;
-    this.reattachNeeded = false;
-    this.listeners = {};
-    this.viewTag = undefined;
-    this.registrations = [];
-
-    if (!NativeReanimatedModule.native) {
-      this.listeners = eventNames.reduce(
-        (acc: Record<string, (event: T) => void>, eventName: string) => {
-          acc[eventName] = jsListener(eventName, worklet);
-          return acc;
-        },
-        {}
-      );
-    }
-  }
-
-  updateWorklet(newWorklet: (event: T) => void): void {
-    this.worklet = newWorklet;
-    this.reattachNeeded = true;
-  }
-
-  registerForEvents(viewTag: number, fallbackEventName?: string): void {
-    this.viewTag = viewTag;
-    this.registrations = this.eventNames.map((eventName) =>
-      NativeReanimatedModule.registerEventHandler(
-        viewTag + eventName,
-        this.worklet
-      )
-    );
-    if (this.registrations.length === 0 && fallbackEventName) {
-      this.registrations.push(
-        NativeReanimatedModule.registerEventHandler(
-          viewTag + fallbackEventName,
-          this.worklet
-        )
-      );
-    }
-  }
-
-  unregisterFromEvents(): void {
-    this.registrations.forEach((id) =>
-      NativeReanimatedModule.unregisterEventHandler(id)
-    );
-    this.registrations = [];
-  }
-}

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

@@ -1,52 +0,0 @@
-import {
-  AnimatedStyle,
-  StyleProps,
-  AnimatableValue,
-  AnimationObject,
-  Animation,
-  Timestamp,
-  AnimationCallback,
-} from '../commonTypes';
-
-export interface HigherOrderAnimation {
-  isHigherOrder?: boolean;
-}
-
-export type NextAnimation<T extends AnimationObject> = T | (() => T);
-
-export interface DelayAnimation
-  extends Animation<DelayAnimation>,
-    HigherOrderAnimation {
-  startTime: Timestamp;
-  started: boolean;
-  previousAnimation: DelayAnimation | null;
-  current: AnimatableValue;
-}
-
-export interface RepeatAnimation
-  extends Animation<RepeatAnimation>,
-    HigherOrderAnimation {
-  reps: number;
-  startValue: AnimatableValue;
-  toValue?: AnimatableValue;
-  previousAnimation?: RepeatAnimation;
-}
-
-export interface SequenceAnimation
-  extends Animation<SequenceAnimation>,
-    HigherOrderAnimation {
-  animationIndex: number;
-}
-
-export interface StyleLayoutAnimation extends HigherOrderAnimation {
-  current: StyleProps;
-  styleAnimations: AnimatedStyle;
-  onFrame: (animation: StyleLayoutAnimation, timestamp: Timestamp) => boolean;
-  onStart: (
-    nextAnimation: StyleLayoutAnimation,
-    current: AnimatedStyle,
-    timestamp: Timestamp,
-    previousAnimation: StyleLayoutAnimation
-  ) => void;
-  callback?: AnimationCallback;
-}

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

@@ -1,141 +0,0 @@
-import { defineAnimation } from './util';
-import {
-  Animation,
-  AnimationCallback,
-  AnimationObject,
-  AnimatableValue,
-  Timestamp,
-} from '../commonTypes';
-import { Platform } from 'react-native';
-
-interface DecayConfig {
-  deceleration?: number;
-  velocityFactor?: number;
-  clamp?: number[];
-  velocity?: number;
-}
-
-interface DefaultDecayConfig {
-  deceleration: number;
-  velocityFactor: number;
-  clamp?: number[];
-  velocity: number;
-}
-
-export interface DecayAnimation extends Animation<DecayAnimation> {
-  lastTimestamp: Timestamp;
-  startTimestamp: Timestamp;
-  initialVelocity: number;
-  velocity: number;
-  current: AnimatableValue;
-}
-
-export interface InnerDecayAnimation
-  extends Omit<DecayAnimation, 'current'>,
-    AnimationObject {
-  current: number;
-}
-
-export function withDecay(
-  userConfig: DecayConfig,
-  callback?: AnimationCallback
-): Animation<DecayAnimation> {
-  'worklet';
-
-  return defineAnimation<DecayAnimation>(0, () => {
-    'worklet';
-    const config: DefaultDecayConfig = {
-      deceleration: 0.998,
-      velocityFactor: Platform.OS !== 'web' ? 1 : 1000,
-      velocity: 0,
-    };
-    if (userConfig) {
-      Object.keys(userConfig).forEach(
-        (key) =>
-          ((config as any)[key] = userConfig[key as keyof typeof userConfig])
-      );
-    }
-
-    const VELOCITY_EPS = Platform.OS !== 'web' ? 1 : 1 / 20;
-    const SLOPE_FACTOR = 0.1;
-
-    function decay(animation: InnerDecayAnimation, now: number): boolean {
-      const {
-        lastTimestamp,
-        startTimestamp,
-        initialVelocity,
-        current,
-        velocity,
-      } = animation;
-
-      const deltaTime = Math.min(now - lastTimestamp, 64);
-      const v =
-        velocity *
-        Math.exp(
-          -(1 - config.deceleration) * (now - startTimestamp) * SLOPE_FACTOR
-        );
-      animation.current =
-        current + (v * config.velocityFactor * deltaTime) / 1000; // /1000 because time is in ms not in s
-      animation.velocity = v;
-      animation.lastTimestamp = now;
-
-      if (config.clamp) {
-        if (initialVelocity < 0 && animation.current <= config.clamp[0]) {
-          animation.current = config.clamp[0];
-          return true;
-        } else if (
-          initialVelocity > 0 &&
-          animation.current >= config.clamp[1]
-        ) {
-          animation.current = config.clamp[1];
-          return true;
-        }
-      }
-
-      return Math.abs(v) < VELOCITY_EPS;
-    }
-
-    function validateConfig(): void {
-      if (config.clamp) {
-        if (!Array.isArray(config.clamp)) {
-          throw Error(
-            `config.clamp must be an array but is ${typeof config.clamp}`
-          );
-        }
-        if (config.clamp.length !== 2) {
-          throw Error(
-            `clamp array must contain 2 items but is given ${config.clamp.length}`
-          );
-        }
-      }
-      if (config.velocityFactor <= 0) {
-        throw Error(
-          `config.velocityFactor must be greather then 0 but is ${config.velocityFactor}`
-        );
-      }
-    }
-
-    function onStart(
-      animation: DecayAnimation,
-      value: number,
-      now: Timestamp
-    ): void {
-      animation.current = value;
-      animation.lastTimestamp = now;
-      animation.startTimestamp = now;
-      animation.initialVelocity = config.velocity;
-      validateConfig();
-    }
-
-    return {
-      onFrame: decay,
-      onStart,
-      callback,
-      velocity: config.velocity ?? 0,
-      initialVelocity: 0,
-      current: 0,
-      lastTimestamp: 0,
-      startTimestamp: 0,
-    } as DecayAnimation;
-  });
-}

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

@@ -1,89 +0,0 @@
-import { defineAnimation } from './util';
-import { Animation, Timestamp, AnimatableValue } from '../commonTypes';
-import { NextAnimation, DelayAnimation } from './commonTypes';
-
-export function withDelay(
-  delayMs: number,
-  _nextAnimation: NextAnimation<DelayAnimation>
-): Animation<DelayAnimation> {
-  'worklet';
-  return defineAnimation<DelayAnimation>(_nextAnimation, () => {
-    'worklet';
-    const nextAnimation =
-      typeof _nextAnimation === 'function' ? _nextAnimation() : _nextAnimation;
-
-    function delay(animation: DelayAnimation, now: Timestamp): boolean {
-      const { startTime, started, previousAnimation } = animation;
-
-      if (now - startTime > delayMs) {
-        if (!started) {
-          nextAnimation.onStart(
-            nextAnimation,
-            animation.current,
-            now,
-            previousAnimation as DelayAnimation
-          );
-          animation.previousAnimation = null;
-          animation.started = true;
-        }
-        const finished = nextAnimation.onFrame(nextAnimation, now);
-        animation.current = nextAnimation.current;
-        return finished;
-      } else if (previousAnimation) {
-        const finished =
-          previousAnimation.finished ||
-          previousAnimation.onFrame(previousAnimation, now);
-        animation.current = previousAnimation.current;
-        if (finished) {
-          animation.previousAnimation = null;
-        }
-      }
-      return false;
-    }
-
-    function onStart(
-      animation: DelayAnimation,
-      value: AnimatableValue,
-      now: Timestamp,
-      previousAnimation: DelayAnimation
-    ): void {
-      animation.startTime = now;
-      animation.started = false;
-      animation.current = value;
-      if (previousAnimation === animation) {
-        animation.previousAnimation = previousAnimation.previousAnimation;
-      } else {
-        animation.previousAnimation = previousAnimation;
-      }
-    }
-
-    const callback = (finished?: boolean): void => {
-      if (nextAnimation.callback) {
-        nextAnimation.callback(finished);
-      }
-    };
-
-    return {
-      isHigherOrder: true,
-      onFrame: delay,
-      onStart,
-      current: nextAnimation.current,
-      callback,
-      previousAnimation: null,
-      startTime: 0,
-      started: false,
-    };
-  });
-}
-
-/**
- * @deprecated Kept for backward compatibility. Will be removed soon.
- */
-export function delay(
-  delayMs: number,
-  _nextAnimation: NextAnimation<DelayAnimation>
-): Animation<DelayAnimation> {
-  'worklet';
-  console.warn('Method `delay` is deprecated. Please use `withDelay` instead');
-  return withDelay(delayMs, _nextAnimation);
-}

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

@@ -1,16 +0,0 @@
-export {
-  HigherOrderAnimation,
-  NextAnimation,
-  DelayAnimation,
-  RepeatAnimation,
-  SequenceAnimation,
-  StyleLayoutAnimation,
-} from './commonTypes';
-export { cancelAnimation, defineAnimation, initialUpdaterRun } from './util';
-export { withTiming, TimingAnimation } from './timing';
-export { withSpring, SpringAnimation } from './spring';
-export { withDecay, DecayAnimation } from './decay';
-export { withDelay } from './delay';
-export { withRepeat } from './repeat';
-export { withSequence } from './sequence';
-export { withStyleAnimation } from './styleAnimation';

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

@@ -1,118 +0,0 @@
-import { defineAnimation } from './util';
-import {
-  Animation,
-  AnimationCallback,
-  AnimatableValue,
-  Timestamp,
-} from '../commonTypes';
-import { NextAnimation, RepeatAnimation } from './commonTypes';
-
-export interface InnerRepeatAnimation
-  extends Omit<RepeatAnimation, 'toValue' | 'startValue'> {
-  toValue: number;
-  startValue: number;
-}
-
-export function withRepeat(
-  _nextAnimation: NextAnimation<RepeatAnimation>,
-  numberOfReps = 2,
-  reverse = false,
-  callback?: AnimationCallback
-): Animation<RepeatAnimation> {
-  'worklet';
-
-  return defineAnimation<RepeatAnimation>(_nextAnimation, () => {
-    'worklet';
-
-    const nextAnimation: RepeatAnimation =
-      typeof _nextAnimation === 'function' ? _nextAnimation() : _nextAnimation;
-
-    function repeat(animation: InnerRepeatAnimation, now: Timestamp): boolean {
-      const finished = nextAnimation.onFrame(nextAnimation, now);
-      animation.current = nextAnimation.current;
-      if (finished) {
-        animation.reps += 1;
-        // call inner animation's callback on every repetition
-        // as the second argument the animation's current value is passed
-        if (nextAnimation.callback) {
-          nextAnimation.callback(true /* finished */, animation.current);
-        }
-        if (numberOfReps > 0 && animation.reps >= numberOfReps) {
-          return true;
-        }
-
-        const startValue = reverse
-          ? (nextAnimation.current as number)
-          : animation.startValue;
-        if (reverse) {
-          nextAnimation.toValue = animation.startValue;
-          animation.startValue = startValue;
-        }
-        nextAnimation.onStart(
-          nextAnimation,
-          startValue,
-          now,
-          nextAnimation.previousAnimation as RepeatAnimation
-        );
-        return false;
-      }
-      return false;
-    }
-
-    const repCallback = (finished: boolean): void => {
-      if (callback) {
-        callback(finished);
-      }
-      // when cancelled call inner animation's callback
-      if (!finished && nextAnimation.callback) {
-        nextAnimation.callback(false /* finished */);
-      }
-    };
-
-    function onStart(
-      animation: RepeatAnimation,
-      value: AnimatableValue,
-      now: Timestamp,
-      previousAnimation: RepeatAnimation
-    ): void {
-      animation.startValue = value;
-      animation.reps = 0;
-      nextAnimation.onStart(nextAnimation, value, now, previousAnimation);
-    }
-
-    return {
-      isHigherOrder: true,
-      onFrame: repeat,
-      onStart,
-      reps: 0,
-      current: nextAnimation.current,
-      callback: repCallback,
-      startValue: 0,
-    } as RepeatAnimation;
-  });
-}
-
-/**
- * @deprecated Kept for backward compatibility. Will be removed soon.
- */
-export function repeat(
-  _nextAnimation: NextAnimation<RepeatAnimation>,
-  numberOfReps = 2,
-  reverse = false,
-  callback?: AnimationCallback
-): Animation<RepeatAnimation> {
-  'worklet';
-  console.warn(
-    'Method `repeat` is deprecated. Please use `withRepeat` instead'
-  );
-  return withRepeat(_nextAnimation, numberOfReps, reverse, callback);
-}
-
-export function loop(
-  nextAnimation: NextAnimation<RepeatAnimation>,
-  numberOfLoops = 1
-): Animation<RepeatAnimation> {
-  'worklet';
-  console.warn('Method `loop` is deprecated. Please use `withRepeat` instead');
-  return repeat(nextAnimation, Math.round(numberOfLoops * 2), true);
-}