expo-dev-menu 2.2.0 → 3.0.0

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

@@ -1,376 +0,0 @@
-/* global _WORKLET _getCurrentTime _frameTimestamp _eventTimestamp, _setGlobalConsole */
-import NativeReanimatedModule from './NativeReanimated';
-import { Platform } from 'react-native';
-import { nativeShouldBeMock, shouldBeUseWeb, isWeb } from './PlatformChecker';
-import {
-  BasicWorkletFunction,
-  ComplexWorkletFunction,
-  SharedValue,
-  AnimationObject,
-  AnimatableValue,
-  Timestamp,
-} from './commonTypes';
-import { Descriptor } from './hook/commonTypes';
-import JSReanimated from './js-reanimated/JSReanimated';
-
-if (global._setGlobalConsole === undefined) {
-  // it can happen when Reanimated plugin wasn't added, but the user uses the only API from version 1
-  global._setGlobalConsole = () => {
-    // noop
-  };
-}
-
-export type ReanimatedConsole = Pick<
-  Console,
-  'debug' | 'log' | 'warn' | 'info' | 'error'
->;
-
-export type WorkletValue =
-  | (() => AnimationObject)
-  | AnimationObject
-  | AnimatableValue
-  | Descriptor;
-interface WorkletValueSetterContext {
-  _animation?: AnimationObject | null;
-  _value?: AnimatableValue | Descriptor;
-  value?: AnimatableValue;
-  _setValue?: (val: AnimatableValue | Descriptor) => void;
-}
-
-const testWorklet: BasicWorkletFunction<void> = () => {
-  'worklet';
-};
-
-const throwUninitializedReanimatedException = () => {
-  throw new Error(
-    "Failed to initialize react-native-reanimated library, make sure you followed installation steps here: https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/installation/ \n1) Make sure reanimated's babel plugin is installed in your babel.config.js (you should have 'react-native-reanimated/plugin' listed there - also see the above link for details) \n2) Make sure you reset build cache after updating the config, run: yarn start --reset-cache"
-  );
-};
-
-export const checkPluginState: (throwError: boolean) => boolean = (
-  throwError = true
-) => {
-  if (!testWorklet.__workletHash && !shouldBeUseWeb()) {
-    if (throwError) {
-      throwUninitializedReanimatedException();
-    }
-    return false;
-  }
-  return true;
-};
-
-export const isConfigured: (throwError?: boolean) => boolean = (
-  throwError = false
-) => {
-  return checkPluginState(throwError);
-};
-
-export const isConfiguredCheck: () => void = () => {
-  checkPluginState(true);
-};
-
-function pushFrame(frame: (timestamp: Timestamp) => void): void {
-  (NativeReanimatedModule as JSReanimated).pushFrame(frame);
-}
-
-export function requestFrame(frame: (timestamp: Timestamp) => void): void {
-  'worklet';
-  if (NativeReanimatedModule.native) {
-    requestAnimationFrame(frame);
-  } else {
-    pushFrame(frame);
-  }
-}
-
-global._WORKLET = false;
-global._log = function (s: string) {
-  console.log(s);
-};
-
-export function runOnUI<A extends any[], R>(
-  worklet: ComplexWorkletFunction<A, R>
-): (...args: A) => void {
-  return makeShareable(worklet);
-}
-
-export function makeShareable<T>(value: T): T {
-  isConfiguredCheck();
-  return NativeReanimatedModule.makeShareable(value);
-}
-
-export function getViewProp<T>(viewTag: string, propName: string): Promise<T> {
-  return new Promise((resolve, reject) => {
-    return NativeReanimatedModule.getViewProp(
-      viewTag,
-      propName,
-      (result: T) => {
-        if (typeof result === 'string' && result.substr(0, 6) === 'error:') {
-          reject(result);
-        } else {
-          resolve(result);
-        }
-      }
-    );
-  });
-}
-
-let _getTimestamp: () => number;
-if (nativeShouldBeMock()) {
-  _getTimestamp = () => {
-    return (NativeReanimatedModule as JSReanimated).getTimestamp();
-  };
-} else {
-  _getTimestamp = () => {
-    'worklet';
-    if (_frameTimestamp) {
-      return _frameTimestamp;
-    }
-    if (_eventTimestamp) {
-      return _eventTimestamp;
-    }
-    return _getCurrentTime();
-  };
-}
-
-export function getTimestamp(): number {
-  'worklet';
-  if (Platform.OS === 'web') {
-    return (NativeReanimatedModule as JSReanimated).getTimestamp();
-  }
-  return _getTimestamp();
-}
-
-function workletValueSetter<T extends WorkletValue>(
-  this: WorkletValueSetterContext,
-  value: T
-): void {
-  'worklet';
-  const previousAnimation = this._animation;
-  if (previousAnimation) {
-    previousAnimation.cancelled = true;
-    this._animation = null;
-  }
-  if (
-    typeof value === 'function' ||
-    (value !== null &&
-      typeof value === 'object' &&
-      (value as AnimationObject).onFrame !== undefined)
-  ) {
-    const animation: AnimationObject =
-      typeof value === 'function'
-        ? (value as () => AnimationObject)()
-        : (value as AnimationObject);
-    // prevent setting again to the same value
-    // and triggering the mappers that treat this value as an input
-    // this happens when the animation's target value(stored in animation.current until animation.onStart is called) is set to the same value as a current one(this._value)
-    // built in animations that are not higher order(withTiming, withSpring) hold target value in .current
-    if (this._value === animation.current && !animation.isHigherOrder) {
-      animation.callback && animation.callback(true);
-      return;
-    }
-    // animated set
-    const initializeAnimation = (timestamp: number) => {
-      animation.onStart(animation, this.value, timestamp, previousAnimation);
-    };
-    initializeAnimation(getTimestamp());
-    const step = (timestamp: number) => {
-      if (animation.cancelled) {
-        animation.callback && animation.callback(false /* finished */);
-        return;
-      }
-      const finished = animation.onFrame(animation, timestamp);
-      animation.finished = true;
-      animation.timestamp = timestamp;
-      this._value = animation.current;
-      if (finished) {
-        animation.callback && animation.callback(true /* finished */);
-      } else {
-        requestAnimationFrame(step);
-      }
-    };
-
-    this._animation = animation;
-
-    if (_frameTimestamp) {
-      // frame
-      step(_frameTimestamp);
-    } else {
-      requestAnimationFrame(step);
-    }
-  } else {
-    // prevent setting again to the same value
-    // and triggering the mappers that treat this value as an input
-    if (this._value === value) {
-      return;
-    }
-    this._value = value as Descriptor | AnimatableValue;
-  }
-}
-
-// We cannot use pushFrame
-// so we use own implementation for js
-function workletValueSetterJS<T extends WorkletValue>(
-  this: WorkletValueSetterContext,
-  value: T
-): void {
-  const previousAnimation = this._animation;
-  if (previousAnimation) {
-    previousAnimation.cancelled = true;
-    this._animation = null;
-  }
-  if (
-    typeof value === 'function' ||
-    (value !== null &&
-      typeof value === 'object' &&
-      (value as AnimationObject).onFrame)
-  ) {
-    // animated set
-    const animation: AnimationObject =
-      typeof value === 'function'
-        ? (value as () => AnimationObject)()
-        : (value as AnimationObject);
-    let initializeAnimation: ((timestamp: number) => void) | null = (
-      timestamp: number
-    ) => {
-      animation.onStart(animation, this.value, timestamp, previousAnimation);
-    };
-    const step = (timestamp: number) => {
-      if (animation.cancelled) {
-        animation.callback && animation.callback(false /* finished */);
-        return;
-      }
-      if (initializeAnimation) {
-        initializeAnimation(timestamp);
-        initializeAnimation = null; // prevent closure from keeping ref to previous animation
-      }
-      const finished = animation.onFrame(animation, timestamp);
-      animation.timestamp = timestamp;
-      this._setValue && this._setValue(animation.current as AnimatableValue);
-      if (finished) {
-        animation.callback && animation.callback(true /* finished */);
-      } else {
-        requestFrame(step);
-      }
-    };
-
-    this._animation = animation;
-
-    requestFrame(step);
-  } else {
-    this._setValue && this._setValue(value as AnimatableValue | Descriptor);
-  }
-}
-
-export function makeMutable<T>(value: T): SharedValue<T> {
-  isConfiguredCheck();
-  return NativeReanimatedModule.makeMutable(value);
-}
-
-export function makeRemote<T>(object = {}): T {
-  isConfiguredCheck();
-  return NativeReanimatedModule.makeRemote(object);
-}
-
-export function startMapper(
-  mapper: () => void,
-  inputs: any[] = [],
-  outputs: any[] = [],
-  updater: () => void = () => {
-    // noop
-  },
-  viewDescriptors: Descriptor[] | SharedValue<Descriptor[]> = []
-): number {
-  isConfiguredCheck();
-  return NativeReanimatedModule.startMapper(
-    mapper,
-    inputs,
-    outputs,
-    updater,
-    viewDescriptors
-  );
-}
-
-export function stopMapper(mapperId: number): void {
-  NativeReanimatedModule.stopMapper(mapperId);
-}
-
-export interface RunOnJSFunction<A extends any[], R> {
-  __callAsync?: (...args: A) => void;
-  (...args: A): R;
-}
-
-export function runOnJS<A extends any[], R>(
-  fun: RunOnJSFunction<A, R>
-): () => void {
-  'worklet';
-  if (!_WORKLET) {
-    return fun;
-  }
-  if (!fun.__callAsync) {
-    throw new Error(
-      "Attempting to call runOnJS with an object that is not a host function. Using runOnJS is only possible with methods that are defined on the main React-Native Javascript thread and that aren't marked as worklets"
-    );
-  } else {
-    return fun.__callAsync;
-  }
-}
-
-NativeReanimatedModule.installCoreFunctions(
-  NativeReanimatedModule.native
-    ? (workletValueSetter as <T>(value: T) => void)
-    : (workletValueSetterJS as <T>(value: T) => void)
-);
-
-if (!isWeb() && isConfigured()) {
-  const capturableConsole = console;
-  runOnUI(() => {
-    'worklet';
-    const console = {
-      debug: runOnJS(capturableConsole.debug),
-      log: runOnJS(capturableConsole.log),
-      warn: runOnJS(capturableConsole.warn),
-      error: runOnJS(capturableConsole.error),
-      info: runOnJS(capturableConsole.info),
-    };
-    _setGlobalConsole(console);
-  })();
-}
-
-type FeaturesConfig = {
-  enableLayoutAnimations: boolean;
-  setByUser: boolean;
-};
-
-let featuresConfig: FeaturesConfig = {
-  enableLayoutAnimations: false,
-  setByUser: false,
-};
-
-export function enableLayoutAnimations(
-  flag: boolean,
-  isCallByUser = true
-): void {
-  if (isCallByUser) {
-    featuresConfig = {
-      enableLayoutAnimations: flag,
-      setByUser: true,
-    };
-    NativeReanimatedModule.enableLayoutAnimations(flag);
-  } else if (
-    !featuresConfig.setByUser &&
-    featuresConfig.enableLayoutAnimations !== flag
-  ) {
-    featuresConfig.enableLayoutAnimations = flag;
-    NativeReanimatedModule.enableLayoutAnimations(flag);
-  }
-}
-
-export function configureProps(uiProps: string[], nativeProps: string[]): void {
-  if (!nativeShouldBeMock()) {
-    NativeReanimatedModule.configureProps(uiProps, nativeProps);
-  }
-}
-
-export function jestResetJsReanimatedModule() {
-  (NativeReanimatedModule as JSReanimated).jestResetModule();
-}

package/vendored/react-native-reanimated/src/reanimated2/frameCallback/FrameCallbackRegistryJS.ts

@@ -1,40 +0,0 @@
-import { runOnUI } from '../core';
-import { FrameInfo, prepareUIRegistry } from './FrameCallbackRegistryUI';
-
-export default class FrameCallbackRegistryJS {
-  private nextCallbackId = 0;
-
-  constructor() {
-    prepareUIRegistry();
-  }
-
-  registerFrameCallback(callback: (frameInfo: FrameInfo) => void): number {
-    if (!callback) {
-      return -1;
-    }
-
-    const callbackId = this.nextCallbackId;
-    this.nextCallbackId++;
-
-    runOnUI(() => {
-      'worklet';
-      global._frameCallbackRegistry.registerFrameCallback(callback, callbackId);
-    })();
-
-    return callbackId;
-  }
-
-  unregisterFrameCallback(callbackId: number): void {
-    runOnUI(() => {
-      'worklet';
-      global._frameCallbackRegistry.unregisterFrameCallback(callbackId);
-    })();
-  }
-
-  manageStateFrameCallback(callbackId: number, state: boolean): void {
-    runOnUI(() => {
-      'worklet';
-      global._frameCallbackRegistry.manageStateFrameCallback(callbackId, state);
-    })();
-  }
-}

package/vendored/react-native-reanimated/src/reanimated2/frameCallback/FrameCallbackRegistryUI.ts

@@ -1,115 +0,0 @@
-import { runOnUI } from '../core';
-
-type CallbackDetails = {
-  callback: (frameInfo: FrameInfo) => void;
-  startTime: number | null;
-};
-
-export type FrameInfo = {
-  timestamp: number;
-  timeSincePreviousFrame: number | null;
-  timeSinceFirstFrame: number;
-};
-
-export interface FrameCallbackRegistryUI {
-  frameCallbackRegistry: Map<number, CallbackDetails>;
-  activeFrameCallbacks: Set<number>;
-  previousFrameTimestamp: number | null;
-  runCallbacks: () => void;
-  registerFrameCallback: (
-    callback: (frameInfo: FrameInfo) => void,
-    callbackId: number
-  ) => void;
-  unregisterFrameCallback: (callbackId: number) => void;
-  manageStateFrameCallback: (callbackId: number, state: boolean) => void;
-}
-
-export const prepareUIRegistry = runOnUI(() => {
-  'worklet';
-
-  const frameCallbackRegistry: FrameCallbackRegistryUI = {
-    frameCallbackRegistry: new Map<number, CallbackDetails>(),
-    activeFrameCallbacks: new Set<number>(),
-    previousFrameTimestamp: null,
-
-    runCallbacks() {
-      const loop = (timestamp: number) => {
-        if (this.previousFrameTimestamp === null) {
-          this.previousFrameTimestamp = timestamp;
-        }
-
-        const delta = timestamp - this.previousFrameTimestamp;
-
-        this.activeFrameCallbacks.forEach((callbackId: number) => {
-          const callbackDetails = this.frameCallbackRegistry.get(callbackId)!;
-
-          const { startTime } = callbackDetails;
-
-          if (startTime === null) {
-            // First frame
-            callbackDetails.startTime = timestamp;
-
-            callbackDetails.callback({
-              timestamp,
-              timeSincePreviousFrame: null,
-              timeSinceFirstFrame: 0,
-            });
-          } else {
-            // Next frame
-            callbackDetails.callback({
-              timestamp,
-              timeSincePreviousFrame: delta,
-              timeSinceFirstFrame: timestamp - startTime,
-            });
-          }
-        });
-
-        if (this.activeFrameCallbacks.size > 0) {
-          this.previousFrameTimestamp = timestamp;
-          requestAnimationFrame(loop);
-        } else {
-          this.previousFrameTimestamp = null;
-        }
-      };
-
-      // runCallback() should only be called after registering a callback,
-      // so if there is only one active callback, then it means that there were
-      // zero previously and the loop isn't running yet.
-      if (this.activeFrameCallbacks.size === 1) {
-        requestAnimationFrame(loop);
-      }
-    },
-
-    registerFrameCallback(
-      callback: (frameInfo: FrameInfo) => void,
-      callbackId: number
-    ) {
-      this.frameCallbackRegistry.set(callbackId, {
-        callback: callback,
-        startTime: null,
-      });
-    },
-
-    unregisterFrameCallback(callbackId: number) {
-      this.manageStateFrameCallback(callbackId, false);
-      this.frameCallbackRegistry.delete(callbackId);
-    },
-
-    manageStateFrameCallback(callbackId: number, state: boolean) {
-      if (callbackId === -1) {
-        return;
-      }
-      if (state) {
-        this.activeFrameCallbacks.add(callbackId);
-        this.runCallbacks();
-      } else {
-        const callback = this.frameCallbackRegistry.get(callbackId)!;
-        callback.startTime = null;
-
-        this.activeFrameCallbacks.delete(callbackId);
-      }
-    },
-  };
-
-  global._frameCallbackRegistry = frameCallbackRegistry;
-});

package/vendored/react-native-reanimated/src/reanimated2/globals.d.ts

@@ -1,91 +0,0 @@
-import type {
-  AnimatedStyle,
-  StyleProps,
-  MeasuredDimensions,
-} from './commonTypes';
-import type { ReanimatedConsole } from './core';
-import type { NativeReanimated } from './NativeReanimated/NativeReanimated';
-import type { FrameCallbackRegistryUI } from './frameCallback/FrameCallbackRegistryUI';
-
-declare global {
-  const _WORKLET: boolean;
-  const _REANIMATED_VERSION_CPP: string;
-  const _frameTimestamp: number | null;
-  const _eventTimestamp: number;
-  const __reanimatedModuleProxy: NativeReanimated;
-  const _setGlobalConsole: (console?: ReanimatedConsole) => void;
-  const _log: (s: string) => void;
-  const _getCurrentTime: () => number;
-  const _stopObservingProgress: (tag: number, flag: boolean) => void;
-  const _startObservingProgress: (
-    tag: number,
-    flag: { value: boolean; _value: boolean }
-  ) => void;
-  const _setGestureState: (handlerTag: number, newState: number) => void;
-  const _updateProps: (
-    tag: number,
-    name: string,
-    updates: StyleProps | AnimatedStyle
-  ) => void;
-  const _measure: (viewTag: number) => MeasuredDimensions;
-  const _scrollTo: (
-    viewTag: number,
-    x: number,
-    y: number,
-    animated: boolean
-  ) => void;
-  const _chronoNow: () => number;
-  const performance: { now: () => number };
-  const LayoutAnimationRepository: {
-    configs: Record<string, unknown>;
-    registerConfig(tag: number, config: Record<string, unknown>): void;
-    removeConfig(tag: number): void;
-    startAnimationForTag(tag: number, type: string, yogaValues: unknown): void;
-  };
-  const ReanimatedDataMock: {
-    now: () => number;
-  };
-  const _frameCallbackRegistry: FrameCallbackRegistryUI;
-  namespace NodeJS {
-    interface Global {
-      _WORKLET: boolean;
-      _IS_FABRIC: boolean;
-      _REANIMATED_VERSION_CPP: string;
-      _frameTimestamp: number | null;
-      _eventTimestamp: number;
-      __reanimatedModuleProxy: NativeReanimated;
-      _setGlobalConsole: (console?: ReanimatedConsole) => void;
-      _log: (s: string) => void;
-      _getCurrentTime: () => number;
-      _stopObservingProgress: (tag: number, flag: boolean) => void;
-      _startObservingProgress: (
-        tag: number,
-        flag: { value: boolean; _value: boolean }
-      ) => void;
-      _setGestureState: (handlerTag: number, newState: number) => void;
-      _measure: (viewTag: number) => MeasuredDimensions;
-      _scrollTo: (
-        viewTag: number,
-        x: number,
-        y: number,
-        animated: boolean
-      ) => void;
-      _chronoNow: () => number;
-      performance: { now: () => number };
-      LayoutAnimationRepository: {
-        configs: Record<string, unknown>;
-        registerConfig(tag: number, config: Record<string, unknown>): void;
-        removeConfig(tag: number): void;
-        startAnimationForTag(
-          tag: number,
-          type: string,
-          yogaValues: unknown
-        ): void;
-      };
-      ReanimatedDataMock: {
-        now: () => number;
-      };
-      _frameCallbackRegistry: FrameCallbackRegistryUI;
-    }
-  }
-}

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

@@ -1,16 +0,0 @@
-import { useCallback } from 'react';
-import { DependencyList } from './commonTypes';
-import { useAnimatedStyle } from './useAnimatedStyle';
-
-// TODO: we should make sure that when useAP is used we are not assigning styles
-// when you need styles to animated you should always use useAS
-export const useAnimatedProps = useAnimatedStyle;
-
-export function useWorkletCallback<A extends unknown[], R>(
-  fun: (...args: A) => R,
-  deps?: DependencyList
-): (...args: Parameters<typeof fun>) => R {
-  return useCallback(fun, deps ?? []);
-}
-
-export { useEvent, useHandler } from './utils';

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

@@ -1,17 +0,0 @@
-export type DependencyList = Array<unknown> | undefined;
-
-export type Context = Record<string, unknown>;
-
-export interface ContextWithDependencies<TContext extends Context> {
-  context: TContext;
-  savedDependencies: DependencyList;
-}
-export interface Descriptor {
-  tag: number;
-  name: string;
-}
-
-export interface RefObjectFunction<T> {
-  current: T | null;
-  (component?: T): number;
-}

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

@@ -1,30 +0,0 @@
-export { DependencyList, Context } from './commonTypes';
-export {
-  useAnimatedProps,
-  useEvent,
-  useHandler,
-  useWorkletCallback,
-} from './Hooks';
-export { useSharedValue } from './useSharedValue';
-export { useAnimatedStyle, AnimatedStyleResult } from './useAnimatedStyle';
-export {
-  useAnimatedGestureHandler,
-  GestureHandlerEvent,
-  GestureHandlers,
-} from './useAnimatedGestureHandler';
-export {
-  useAnimatedReaction,
-  AnimatedReactionWorkletFunction,
-} from './useAnimatedReaction';
-export { useAnimatedRef } from './useAnimatedRef';
-export {
-  useAnimatedScrollHandler,
-  ScrollHandler,
-  ScrollHandlers,
-} from './useAnimatedScrollHandler';
-export { useDerivedValue, DerivedValue } from './useDerivedValue';
-export { useAnimatedSensor, SensorType } from './useAnimatedSensor';
-export { useFrameCallback } from './useFrameCallback';
-export type { FrameCallback } from './useFrameCallback';
-export { useAnimatedKeyboard } from './useAnimatedKeyboard';
-export { useScrollViewOffset } from './useScrollViewOffset';