expo-dev-menu 2.1.4 → 3.0.0

package/vendored/react-native-reanimated/src/reanimated2/hook/useAnimatedGestureHandler.ts

@@ -1,109 +0,0 @@
-import { MutableRefObject } from 'react';
-import { WorkletFunction } from '../commonTypes';
-import WorkletEventHandler from '../WorkletEventHandler';
-import { Context, DependencyList } from './commonTypes';
-import { useEvent, useHandler } from './Hooks';
-
-interface Handler<T, TContext extends Context> extends WorkletFunction {
-  (event: T, context: TContext, isCanceledOrFailed?: boolean): void;
-}
-
-export interface GestureHandlers<T, TContext extends Context> {
-  [key: string]: Handler<T, TContext> | undefined;
-  onStart?: Handler<T, TContext>;
-  onActive?: Handler<T, TContext>;
-  onEnd?: Handler<T, TContext>;
-  onFail?: Handler<T, TContext>;
-  onCancel?: Handler<T, TContext>;
-  onFinish?: Handler<T, TContext>;
-}
-
-export enum EventType {
-  UNDETERMINED = 0,
-  FAILED,
-  BEGAN,
-  CANCELLED,
-  ACTIVE,
-  END,
-}
-
-export interface GestureHandlerStateChangeNativeEvent {
-  handlerTag: number;
-  numberOfPointers: number;
-  state: EventType;
-  oldState: EventType;
-}
-
-export interface GestureHandlerEvent<T>
-  extends GestureHandlerStateChangeNativeEvent {
-  nativeEvent: T;
-}
-
-export function useAnimatedGestureHandler<
-  T extends GestureHandlerEvent<T>,
-  TContext extends Context
->(
-  handlers: GestureHandlers<T, TContext>,
-  dependencies?: DependencyList
-): MutableRefObject<WorkletEventHandler<T> | null> | ((e: T) => void) {
-  const { context, doDependenciesDiffer, useWeb } = useHandler<T, TContext>(
-    handlers,
-    dependencies
-  );
-
-  const handler = (e: T) => {
-    'worklet';
-    const event = useWeb ? e.nativeEvent : e;
-
-    if (event.state === EventType.BEGAN && handlers.onStart) {
-      handlers.onStart(event, context);
-    }
-    if (event.state === EventType.ACTIVE && handlers.onActive) {
-      handlers.onActive(event, context);
-    }
-    if (
-      event.oldState === EventType.ACTIVE &&
-      event.state === EventType.END &&
-      handlers.onEnd
-    ) {
-      handlers.onEnd(event, context);
-    }
-    if (
-      event.oldState === EventType.BEGAN &&
-      event.state === EventType.FAILED &&
-      handlers.onFail
-    ) {
-      handlers.onFail(event, context);
-    }
-    if (
-      event.oldState === EventType.ACTIVE &&
-      event.state === EventType.CANCELLED &&
-      handlers.onCancel
-    ) {
-      handlers.onCancel(event, context);
-    }
-    if (
-      (event.oldState === EventType.BEGAN ||
-        event.oldState === EventType.ACTIVE) &&
-      event.state !== EventType.BEGAN &&
-      event.state !== EventType.ACTIVE &&
-      handlers.onFinish
-    ) {
-      handlers.onFinish(
-        event,
-        context,
-        event.state === EventType.CANCELLED || event.state === EventType.FAILED
-      );
-    }
-  };
-
-  if (useWeb) {
-    return handler;
-  }
-
-  return useEvent<T>(
-    handler,
-    ['onGestureHandlerStateChange', 'onGestureHandlerEvent'],
-    doDependenciesDiffer
-  );
-}

package/vendored/react-native-reanimated/src/reanimated2/hook/useAnimatedKeyboard.ts

@@ -1,35 +0,0 @@
-import { useEffect, useRef } from 'react';
-import NativeReanimated from '../NativeReanimated';
-import { makeMutable } from '../core';
-import { AnimatedKeyboardInfo, KeyboardState } from '../commonTypes';
-
-export function useAnimatedKeyboard(): AnimatedKeyboardInfo {
-  const ref = useRef<AnimatedKeyboardInfo | null>(null);
-  const listenerId = useRef<number>(-1);
-  const isSubscribed = useRef<boolean>(false);
-
-  if (ref.current === null) {
-    const keyboardEventData: AnimatedKeyboardInfo = {
-      state: makeMutable(KeyboardState.UNKNOWN),
-      height: makeMutable(0),
-    };
-    listenerId.current =
-      NativeReanimated.subscribeForKeyboardEvents(keyboardEventData);
-    ref.current = keyboardEventData;
-    isSubscribed.current = true;
-  }
-  useEffect(() => {
-    if (isSubscribed.current === false && ref.current !== null) {
-      // subscribe again after Fast Refresh
-      listenerId.current = NativeReanimated.subscribeForKeyboardEvents(
-        ref.current
-      );
-      isSubscribed.current = true;
-    }
-    return () => {
-      NativeReanimated.unsubscribeFromKeyboardEvents(listenerId.current);
-      isSubscribed.current = false;
-    };
-  }, []);
-  return ref.current;
-}

package/vendored/react-native-reanimated/src/reanimated2/hook/useAnimatedReaction.ts

@@ -1,49 +0,0 @@
-import { useEffect } from 'react';
-import { BasicWorkletFunction, WorkletFunction } from '../commonTypes';
-import { startMapper, stopMapper } from '../core';
-import { DependencyList } from './commonTypes';
-import { useSharedValue } from './useSharedValue';
-
-export interface AnimatedReactionWorkletFunction<T> extends WorkletFunction {
-  (prepared: T, previous: T | null): void;
-}
-/**
- * @param prepare - worklet used for data preparation for the second parameter
- * @param react - worklet which takes data prepared by the one in the first parameter and performs certain actions
- * the first worklet defines the inputs, in other words on which shared values change will it be called.
- * the second one can modify any shared values but those which are mentioned in the first worklet. Beware of that, because this may result in endless loop and high cpu usage.
- */
-export function useAnimatedReaction<T>(
-  prepare: BasicWorkletFunction<T>,
-  react: AnimatedReactionWorkletFunction<T>,
-  dependencies: DependencyList
-): void {
-  const previous = useSharedValue<T | null>(null);
-  if (dependencies === undefined) {
-    dependencies = [
-      Object.values(prepare._closure ?? {}),
-      Object.values(react._closure ?? {}),
-      prepare.__workletHash,
-      react.__workletHash,
-    ];
-  } else {
-    dependencies.push(prepare.__workletHash, react.__workletHash);
-  }
-
-  useEffect(() => {
-    const fun = () => {
-      'worklet';
-      const input = prepare();
-      react(input, previous.value);
-      previous.value = input;
-    };
-    const mapperId = startMapper(
-      fun,
-      Object.values(prepare._closure ?? {}),
-      []
-    );
-    return () => {
-      stopMapper(mapperId);
-    };
-  }, dependencies);
-}

package/vendored/react-native-reanimated/src/reanimated2/hook/useAnimatedRef.ts

@@ -1,30 +0,0 @@
-import { Component, useRef } from 'react';
-import { getTag } from '../NativeMethods';
-import { useSharedValue } from './useSharedValue';
-import { RefObjectFunction } from './commonTypes';
-
-export function useAnimatedRef<T extends Component>(): RefObjectFunction<T> {
-  const tag = useSharedValue<number | null>(-1);
-  const ref = useRef<RefObjectFunction<T>>();
-
-  if (!ref.current) {
-    const fun: RefObjectFunction<T> = <RefObjectFunction<T>>((component) => {
-      'worklet';
-      // enters when ref is set by attaching to a component
-      if (component) {
-        tag.value = getTag(component);
-        fun.current = component;
-      }
-      return tag.value;
-    });
-
-    Object.defineProperty(fun, 'current', {
-      value: null,
-      writable: true,
-      enumerable: false,
-    });
-    ref.current = fun;
-  }
-
-  return ref.current;
-}

package/vendored/react-native-reanimated/src/reanimated2/hook/useAnimatedScrollHandler.ts

@@ -1,85 +0,0 @@
-import { RefObject } from 'react';
-import { NativeScrollEvent } from 'react-native';
-import { NativeEvent, WorkletFunction } from '../commonTypes';
-import WorkletEventHandler from '../WorkletEventHandler';
-import { Context, DependencyList } from './commonTypes';
-import { useEvent, useHandler } from './Hooks';
-
-export interface ScrollHandler<TContext extends Context>
-  extends WorkletFunction {
-  (event: NativeScrollEvent, context?: TContext): void;
-}
-
-export interface ScrollEvent
-  extends NativeScrollEvent,
-    NativeEvent<ScrollEvent> {
-  eventName: string;
-}
-export interface ScrollHandlers<TContext extends Context> {
-  [key: string]: ScrollHandler<TContext> | undefined;
-  onScroll?: ScrollHandler<TContext>;
-  onBeginDrag?: ScrollHandler<TContext>;
-  onEndDrag?: ScrollHandler<TContext>;
-  onMomentumBegin?: ScrollHandler<TContext>;
-  onMomentumEnd?: ScrollHandler<TContext>;
-}
-
-export function useAnimatedScrollHandler<TContext extends Context>(
-  handlers: ScrollHandlers<TContext> | ScrollHandler<TContext>,
-  dependencies?: DependencyList
-): RefObject<WorkletEventHandler<ScrollEvent>> {
-  // case when handlers is a function
-  const scrollHandlers: ScrollHandlers<TContext> =
-    typeof handlers === 'function' ? { onScroll: handlers } : handlers;
-  const { context, doDependenciesDiffer } = useHandler<ScrollEvent, TContext>(
-    scrollHandlers,
-    dependencies
-  );
-
-  // build event subscription array
-  const subscribeForEvents = ['onScroll'];
-  if (scrollHandlers.onBeginDrag !== undefined) {
-    subscribeForEvents.push('onScrollBeginDrag');
-  }
-  if (scrollHandlers.onEndDrag !== undefined) {
-    subscribeForEvents.push('onScrollEndDrag');
-  }
-  if (scrollHandlers.onMomentumBegin !== undefined) {
-    subscribeForEvents.push('onMomentumScrollBegin');
-  }
-  if (scrollHandlers.onMomentumEnd !== undefined) {
-    subscribeForEvents.push('onMomentumScrollEnd');
-  }
-
-  return useEvent<ScrollEvent>(
-    (event: ScrollEvent) => {
-      'worklet';
-      const {
-        onScroll,
-        onBeginDrag,
-        onEndDrag,
-        onMomentumBegin,
-        onMomentumEnd,
-      } = scrollHandlers;
-      if (onScroll && event.eventName.endsWith('onScroll')) {
-        onScroll(event, context);
-      } else if (onBeginDrag && event.eventName.endsWith('onScrollBeginDrag')) {
-        onBeginDrag(event, context);
-      } else if (onEndDrag && event.eventName.endsWith('onScrollEndDrag')) {
-        onEndDrag(event, context);
-      } else if (
-        onMomentumBegin &&
-        event.eventName.endsWith('onMomentumScrollBegin')
-      ) {
-        onMomentumBegin(event, context);
-      } else if (
-        onMomentumEnd &&
-        event.eventName.endsWith('onMomentumScrollEnd')
-      ) {
-        onMomentumEnd(event, context);
-      }
-    },
-    subscribeForEvents,
-    doDependenciesDiffer
-  );
-}

package/vendored/react-native-reanimated/src/reanimated2/hook/useAnimatedSensor.ts

@@ -1,89 +0,0 @@
-import { useEffect, useRef } from 'react';
-import { makeMutable } from '../core';
-import NativeReanimated from '../NativeReanimated';
-import { SensorValue3D, SensorValueRotation } from '../commonTypes';
-
-export enum SensorType {
-  ACCELEROMETER = 1,
-  GYROSCOPE = 2,
-  GRAVITY = 3,
-  MAGNETIC_FIELD = 4,
-  ROTATION = 5,
-}
-
-export type SensorConfig = {
-  interval: number | 'auto';
-};
-
-export type AnimatedSensor = {
-  sensor: SensorValue3D | SensorValueRotation | null;
-  unregister: () => void;
-  isAvailable: boolean;
-  config: SensorConfig;
-};
-
-export function useAnimatedSensor(
-  sensorType: SensorType,
-  userConfig?: SensorConfig
-): AnimatedSensor {
-  const ref = useRef<AnimatedSensor>({
-    sensor: null,
-    unregister: () => {
-      // NOOP
-    },
-    isAvailable: false,
-    config: {
-      interval: 0,
-    },
-  });
-
-  if (ref.current.sensor === null) {
-    ref.current.config = { interval: 'auto', ...userConfig };
-    let sensorData;
-    if (sensorType === SensorType.ROTATION) {
-      sensorData = {
-        qw: 0,
-        qx: 0,
-        qy: 0,
-        qz: 0,
-        yaw: 0,
-        pitch: 0,
-        roll: 0,
-      };
-    } else {
-      sensorData = {
-        x: 0,
-        y: 0,
-        z: 0,
-      };
-    }
-    ref.current.sensor = makeMutable(sensorData) as any;
-  }
-
-  useEffect(() => {
-    ref.current.config = { interval: 'auto', ...userConfig };
-    const id = NativeReanimated.registerSensor(
-      sensorType,
-      ref.current.config.interval === 'auto' ? -1 : ref.current.config.interval,
-      ref.current.sensor as any
-    );
-
-    if (id !== -1) {
-      // if sensor is available
-      ref.current.unregister = () => NativeReanimated.unregisterSensor(id);
-      ref.current.isAvailable = true;
-    } else {
-      // if sensor is unavailable
-      ref.current.unregister = () => {
-        // NOOP
-      };
-      ref.current.isAvailable = false;
-    }
-
-    return () => {
-      ref.current.unregister();
-    };
-  }, [sensorType, userConfig]);
-
-  return ref.current;
-}