expo-dev-menu 2.2.0 → 3.0.0

package/vendored/react-native-reanimated/src/reanimated2/js-reanimated/MapperRegistry.ts

@@ -1,133 +0,0 @@
-import { JSReanimated } from './commonTypes';
-import Mapper from './Mapper';
-
-export default class MapperRegistry<T> {
-  sortedMappers: Mapper<T>[] = [];
-  mappers: Map<number, Mapper<T>> = new Map();
-  _module: JSReanimated;
-
-  updatedSinceLastExecute = false;
-
-  constructor(module: JSReanimated) {
-    this._module = module;
-  }
-
-  startMapper(mapper: Mapper<T>): number {
-    this.mappers.set(mapper.id, mapper);
-    this.updatedSinceLastExecute = true;
-    return mapper.id;
-  }
-
-  stopMapper(id: number): void {
-    this.mappers.delete(id);
-    this.updatedSinceLastExecute = true;
-  }
-
-  execute(): void {
-    if (this.updatedSinceLastExecute) {
-      this.updateOrder();
-      this.updatedSinceLastExecute = false;
-    }
-
-    for (let i = 0, len = this.sortedMappers.length; i < len; ++i) {
-      const mapper = this.sortedMappers[i];
-      if (mapper.dirty) {
-        mapper.execute();
-      }
-    }
-  }
-
-  updateOrder(): void {
-    const nodes = [...this.mappers.values()].map((mapper) => new Node(mapper));
-
-    const mappersById: Record<number, Mapper<T>> = {};
-    this.mappers.forEach((mapper) => {
-      mappersById[mapper.id] = mapper;
-    });
-
-    // create a graph from array of nodes
-    for (let i = 0, nodesLen = nodes.length; i < nodesLen; ++i) {
-      const node = nodes[i];
-      if (node.mapper.outputs.length === 0) {
-        continue;
-      }
-      for (let j = 0; j < nodesLen; ++j) {
-        const restNode = nodes[j];
-        if (i === j || restNode.mapper.inputs.length === 0) {
-          continue;
-        }
-        for (
-          let outi = 0, outputsLen = node.mapper.outputs.length;
-          outi < outputsLen;
-          ++outi
-        ) {
-          for (
-            let resti = 0, restLen = restNode.mapper.inputs.length;
-            resti < restLen;
-            ++resti
-          ) {
-            if (
-              node.mapper.outputs[outi]._id ===
-              restNode.mapper.inputs[resti]._id
-            ) {
-              node.children.push(restNode);
-            }
-          }
-        }
-      }
-    }
-
-    const post: Record<number, number> = {};
-    let postCounter = 1;
-    const dfs = (node: Node<T>) => {
-      const index = nodes.indexOf(node);
-      if (index === -1) {
-        // this node has already been handled
-        return;
-      }
-      ++postCounter;
-      nodes.splice(index, 1);
-      if (node.children.length === 0 && nodes.length > 0) {
-        post[node.mapper.id] = postCounter++;
-        dfs(nodes[0]);
-        return;
-      }
-      for (let i = 0, len = node.children.length; i < len; ++i) {
-        dfs(node.children[i]);
-      }
-      post[node.mapper.id] = postCounter++;
-    };
-
-    while (nodes.length) dfs(nodes[0]);
-
-    const postArray = Object.keys(post).map((key) => {
-      const num = parseInt(key);
-      return [num, post[num]];
-    });
-    postArray.sort((a, b) => {
-      return b[1] - a[1];
-    });
-
-    // clear sorted mappers
-    this.sortedMappers = [];
-
-    for (let i = 0, len = postArray.length; i < len; ++i) {
-      const [id] = postArray[i];
-      this.sortedMappers.push(mappersById[id]);
-    }
-  }
-
-  get needRunOnRender(): boolean {
-    return this.updatedSinceLastExecute;
-  }
-}
-
-class Node<T> {
-  mapper: Mapper<T>;
-  children: Node<T>[];
-
-  constructor(mapper: Mapper<T>, children = []) {
-    this.mapper = mapper;
-    this.children = children;
-  }
-}

package/vendored/react-native-reanimated/src/reanimated2/js-reanimated/MutableValue.ts

@@ -1,38 +0,0 @@
-export default class MutableValue<T> {
-  static MUTABLE_ID = 1;
-  _id: number;
-  _value: T;
-  _setter: (value: T) => void;
-  _animation = null;
-  _listeners: (() => void)[] = [];
-
-  constructor(value: T, setter: (value: T) => void) {
-    this._id = MutableValue.MUTABLE_ID++;
-    this._value = value;
-    this._setter = setter;
-  }
-
-  get value(): T {
-    return this._value;
-  }
-
-  set value(nextValue: T) {
-    this._setter(nextValue);
-  }
-
-  // this changes the value finally and is supposed to be called from this._setter
-  _setValue(newValue: T): void {
-    this._value = newValue;
-    this._triggerListener();
-  }
-
-  addListener(listener: () => void): void {
-    this._listeners.push(listener);
-  }
-
-  _triggerListener(): void {
-    for (let i = 0, len = this._listeners.length; i < len; ++i) {
-      this._listeners[i]();
-    }
-  }
-}

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

@@ -1,51 +0,0 @@
-import { Timestamp, NestedObjectValues } from '../commonTypes';
-import MutableValue from './MutableValue';
-
-export interface Mapper<T> {
-  MAPPER_ID?: number;
-  id: number;
-  inputs: MutableValue<T>[];
-  outputs: MutableValue<T>[];
-  mapper: () => void;
-  dirty: boolean;
-  execute(): void;
-  extractMutablesFromArray<T>(
-    array: NestedObjectValues<MutableValue<T>>
-  ): MutableValue<T>[];
-}
-
-export interface MapperRegistry<T> {
-  sortedMappers: Mapper<T>[];
-  mappers: Map<number, Mapper<T>>;
-  _module: JSReanimated;
-  updatedSinceLastExecute: boolean;
-  startMapper(mapper: Mapper<T>): number;
-  stopMapper(id: number): void;
-  execute(): void;
-  updateOrder(): void;
-}
-
-export interface JSReanimated {
-  _valueSetter?: <T>(value: T) => void;
-  _renderRequested: boolean;
-  _mapperRegistry: MapperRegistry<any>;
-  _frames: ((timestamp: Timestamp) => void)[];
-  timeProvider: { now: () => number };
-  pushFrame(frame: (timestamp: Timestamp) => void): void;
-  getTimestamp(): number;
-  maybeRequestRender(): void;
-  _onRender(timestampMs: number): void;
-  installCoreFunctions(valueSetter: <T>(value: T) => void): void;
-  makeShareable<T>(value: T): T;
-  makeMutable<T>(value: T): MutableValue<T>;
-  makeRemote<T>(object: Record<string, any>): T;
-  startMapper(
-    mapper: () => void,
-    inputs: NestedObjectValues<MutableValue<unknown>>[],
-    outputs: NestedObjectValues<MutableValue<unknown>>[]
-  ): number;
-  stopMapper(mapperId: number): void;
-  registerEventHandler<T>(_: string, __: (event: T) => void): string;
-  unregisterEventHandler(_: string): void;
-  enableLayoutAnimations(): void;
-}

package/vendored/react-native-reanimated/src/reanimated2/js-reanimated/global.ts

@@ -1,45 +0,0 @@
-// In order to keep bundle size down, we treat this file as a polyfill for Web.
-
-import { shouldBeUseWeb } from '../PlatformChecker';
-const initializeGlobalsForWeb = () => {
-  if (shouldBeUseWeb()) {
-    global._frameTimestamp = null;
-    global._setGlobalConsole = (_val) => {
-      // noop
-    };
-    global._measure = () => {
-      console.warn(
-        "[Reanimated] You can't use `measure` with Chrome Debugger or with web version"
-      );
-      return {
-        x: 0,
-        y: 0,
-        width: 0,
-        height: 0,
-        pageX: 0,
-        pageY: 0,
-      };
-    };
-    global._scrollTo = () => {
-      console.warn(
-        "[Reanimated] You can't use `scrollTo` with Chrome Debugger or with web version"
-      );
-    };
-    global._setGestureState = () => {
-      console.warn(
-        "[Reanimated] You can't use `setGestureState` with Chrome Debugger or with web version"
-      );
-    };
-  }
-  return true;
-};
-
-/*
-  If a file doesn't export anything, tree shaking doesn't pack 
-  it into the JS bundle. In effect, the code inside of this file 
-  will never execute. That is why we wrapped initialization code 
-  into a function, and we call this one during creating 
-  the module export object.
-*/
-
-export default initializeGlobalsForWeb();

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

@@ -1,57 +0,0 @@
-import JSReanimated from './JSReanimated';
-import { AnimatedStyle, StyleProps } from '../commonTypes';
-
-const reanimatedJS = new JSReanimated();
-
-interface JSReanimatedComponent {
-  previousStyle: StyleProps;
-  setNativeProps: (style: StyleProps) => void;
-  props: Record<string, string | number>;
-  _touchableNode: {
-    setAttribute: (key: string, props: unknown) => void;
-  };
-}
-
-export const _updatePropsJS = (
-  updates: StyleProps | AnimatedStyle,
-  viewRef: { _component?: JSReanimatedComponent }
-): void => {
-  if (viewRef._component) {
-    const component = viewRef._component;
-    const [rawStyles] = Object.keys(updates).reduce(
-      (acc: [StyleProps, AnimatedStyle], key) => {
-        const value = updates[key];
-        const index = typeof value === 'function' ? 1 : 0;
-        acc[index][key] = value;
-        return acc;
-      },
-      [{}, {}]
-    );
-
-    if (typeof component.setNativeProps === 'function') {
-      setNativeProps(component, rawStyles);
-    } else if (Object.keys(component.props).length > 0) {
-      Object.keys(component.props).forEach((key) => {
-        if (!rawStyles[key]) {
-          return;
-        }
-        const dashedKey = key.replace(/[A-Z]/g, (m) => '-' + m.toLowerCase());
-        component._touchableNode.setAttribute(dashedKey, rawStyles[key]);
-      });
-    } else {
-      console.warn('It is not possible to manipulate component');
-    }
-  }
-};
-
-const setNativeProps = (
-  component: JSReanimatedComponent,
-  style: StyleProps
-): void => {
-  const previousStyle = component.previousStyle ? component.previousStyle : {};
-  const currentStyle = { ...previousStyle, ...style };
-  component.previousStyle = currentStyle;
-  component.setNativeProps({ style: currentStyle });
-};
-
-export default reanimatedJS;

package/vendored/react-native-reanimated/src/reanimated2/layoutReanimation/LayoutAnimationRepository.ts

@@ -1,75 +0,0 @@
-/* global _stopObservingProgress, _startObservingProgress */
-import { runOnUI } from '../core';
-import { withStyleAnimation } from '../animation/styleAnimation';
-import { ColorProperties } from '../UpdateProps';
-import { processColor } from '../Colors';
-
-runOnUI(() => {
-  'worklet';
-
-  const configs: Record<string, any> = Object.create(null);
-  const enteringAnimationForTag: Record<string, any> = {};
-
-  global.LayoutAnimationRepository = {
-    configs,
-    registerConfig(tag, config) {
-      configs[tag] = config;
-      enteringAnimationForTag[tag] = null;
-    },
-    removeConfig(tag) {
-      delete configs[tag];
-      delete enteringAnimationForTag[tag];
-    },
-    startAnimationForTag(tag, type, yogaValues) {
-      if (configs[tag] == null) {
-        return; // :(
-      }
-      const style = configs[tag][type](yogaValues);
-      let currentAnimation = style.animations;
-      if (type === 'entering') {
-        enteringAnimationForTag[tag] = style;
-      } else if (type === 'layout' && enteringAnimationForTag[tag] !== null) {
-        const entryAniamtion = enteringAnimationForTag[tag].animations;
-        const layoutAnimation = style.animations;
-        currentAnimation = {};
-        for (const key in entryAniamtion) {
-          currentAnimation[key] = entryAniamtion[key];
-        }
-        for (const key in layoutAnimation) {
-          currentAnimation[key] = layoutAnimation[key];
-        }
-      }
-
-      const sv: { value: boolean; _value: boolean } = configs[tag].sv;
-      _stopObservingProgress(tag, false);
-      _startObservingProgress(tag, sv);
-
-      const backupColor: Record<string, string> = {};
-      for (const key in style.initialValues) {
-        if (ColorProperties.includes(key)) {
-          const value = style.initialValues[key];
-          backupColor[key] = value;
-          style.initialValues[key] = processColor(value);
-        }
-      }
-
-      sv.value = Object.assign({}, sv._value, style.initialValues);
-      _stopObservingProgress(tag, false);
-      const animation = withStyleAnimation(currentAnimation);
-
-      animation.callback = (finished?: boolean) => {
-        if (finished) {
-          _stopObservingProgress(tag, finished);
-        }
-        style.callback && style.callback(finished);
-      };
-
-      if (backupColor) {
-        configs[tag].sv._value = { ...configs[tag].sv.value, ...backupColor };
-      }
-
-      configs[tag].sv.value = animation;
-      _startObservingProgress(tag, sv);
-    },
-  };
-})();

package/vendored/react-native-reanimated/src/reanimated2/layoutReanimation/animationBuilder/BaseAnimationBuilder.ts

@@ -1,91 +0,0 @@
-import { withDelay } from '../../animation';
-import {
-  EntryExitAnimationFunction,
-  AnimationFunction,
-  LayoutAnimationFunction,
-} from './commonTypes';
-
-export class BaseAnimationBuilder {
-  durationV?: number;
-  delayV?: number;
-  randomizeDelay = false;
-  callbackV?: (finished: boolean) => void;
-
-  static createInstance: () => BaseAnimationBuilder;
-  build = (): EntryExitAnimationFunction | LayoutAnimationFunction => {
-    throw Error('Unimplemented method in child class.');
-  };
-
-  static duration(durationMs: number): BaseAnimationBuilder {
-    const instance = this.createInstance();
-    return instance.duration(durationMs);
-  }
-
-  duration(durationMs: number): BaseAnimationBuilder {
-    this.durationV = durationMs;
-    return this;
-  }
-
-  static delay(delayMs: number): BaseAnimationBuilder {
-    const instance = this.createInstance();
-    return instance.delay(delayMs);
-  }
-
-  delay(delayMs: number): BaseAnimationBuilder {
-    this.delayV = delayMs;
-    return this;
-  }
-
-  static withCallback(
-    callback: (finished: boolean) => void
-  ): BaseAnimationBuilder {
-    const instance = this.createInstance();
-    return instance.withCallback(callback);
-  }
-
-  withCallback(callback: (finsihed: boolean) => void): BaseAnimationBuilder {
-    this.callbackV = callback;
-    return this;
-  }
-
-  // 300ms is the default animation duration. If any animation has different default has to override this method.
-  static getDuration(): number {
-    return 300;
-  }
-
-  getDuration(): number {
-    return this.durationV ?? 300;
-  }
-
-  static randomDelay(): BaseAnimationBuilder {
-    const instance = this.createInstance();
-    return instance.randomDelay();
-  }
-
-  randomDelay(): BaseAnimationBuilder {
-    this.randomizeDelay = true;
-    return this;
-  }
-
-  // when randomizeDelay is set to true, randomize delay between 0 and provided value (or 1000ms if delay is not provided)
-  getDelay(): number {
-    return this.randomizeDelay
-      ? Math.random() * (this.delayV ?? 1000)
-      : this.delayV ?? 0;
-  }
-
-  getDelayFunction(): AnimationFunction {
-    const isDelayProvided = this.randomizeDelay || this.delayV;
-    return isDelayProvided
-      ? withDelay
-      : (_, animation) => {
-          'worklet';
-          return animation;
-        };
-  }
-
-  static build(): EntryExitAnimationFunction | LayoutAnimationFunction {
-    const instance = this.createInstance();
-    return instance.build();
-  }
-}

package/vendored/react-native-reanimated/src/reanimated2/layoutReanimation/animationBuilder/ComplexAnimationBuilder.ts

@@ -1,182 +0,0 @@
-import { withTiming, withSpring } from '../../animation';
-import {
-  AnimationFunction,
-  BaseBuilderAnimationConfig,
-  LayoutAnimationAndConfig,
-} from './commonTypes';
-import { EasingFn } from '../../Easing';
-import { BaseAnimationBuilder } from './BaseAnimationBuilder';
-import { StyleProps } from '../../commonTypes';
-
-export class ComplexAnimationBuilder extends BaseAnimationBuilder {
-  easingV?: EasingFn;
-  rotateV?: string;
-  type?: AnimationFunction;
-  dampingV?: number;
-  massV?: number;
-  stiffnessV?: number;
-  overshootClampingV?: number;
-  restDisplacementThresholdV?: number;
-  restSpeedThresholdV?: number;
-  initialValues?: StyleProps;
-
-  static createInstance: () => ComplexAnimationBuilder;
-
-  static easing(easingFunction: EasingFn): ComplexAnimationBuilder {
-    const instance = this.createInstance();
-    return instance.easing(easingFunction);
-  }
-
-  easing(easingFunction: EasingFn): ComplexAnimationBuilder {
-    this.easingV = easingFunction;
-    return this;
-  }
-
-  static rotate(degree: string): ComplexAnimationBuilder {
-    const instance = this.createInstance();
-    return instance.rotate(degree);
-  }
-
-  rotate(degree: string): ComplexAnimationBuilder {
-    this.rotateV = degree;
-    return this;
-  }
-
-  static springify(): ComplexAnimationBuilder {
-    const instance = this.createInstance();
-    return instance.springify();
-  }
-
-  springify(): ComplexAnimationBuilder {
-    this.type = withSpring as AnimationFunction;
-    return this;
-  }
-
-  static damping(damping: number): ComplexAnimationBuilder {
-    const instance = this.createInstance();
-    return instance.damping(damping);
-  }
-
-  damping(damping: number): ComplexAnimationBuilder {
-    this.dampingV = damping;
-    return this;
-  }
-
-  static mass(mass: number): ComplexAnimationBuilder {
-    const instance = this.createInstance();
-    return instance.mass(mass);
-  }
-
-  mass(mass: number): ComplexAnimationBuilder {
-    this.massV = mass;
-    return this;
-  }
-
-  static stiffness(stiffness: number): ComplexAnimationBuilder {
-    const instance = this.createInstance();
-    return instance.stiffness(stiffness);
-  }
-
-  stiffness(stiffness: number): ComplexAnimationBuilder {
-    this.stiffnessV = stiffness;
-    return this;
-  }
-
-  static overshootClamping(overshootClamping: number): ComplexAnimationBuilder {
-    const instance = this.createInstance();
-    return instance.overshootClamping(overshootClamping);
-  }
-
-  overshootClamping(overshootClamping: number): ComplexAnimationBuilder {
-    this.overshootClampingV = overshootClamping;
-    return this;
-  }
-
-  static restDisplacementThreshold(
-    restDisplacementThreshold: number
-  ): ComplexAnimationBuilder {
-    const instance = this.createInstance();
-    return instance.restDisplacementThreshold(restDisplacementThreshold);
-  }
-
-  restDisplacementThreshold(
-    restDisplacementThreshold: number
-  ): ComplexAnimationBuilder {
-    this.restDisplacementThresholdV = restDisplacementThreshold;
-    return this;
-  }
-
-  static restSpeedThreshold(
-    restSpeedThreshold: number
-  ): ComplexAnimationBuilder {
-    const instance = this.createInstance();
-    return instance.restSpeedThreshold(restSpeedThreshold);
-  }
-
-  restSpeedThreshold(restSpeedThreshold: number): ComplexAnimationBuilder {
-    this.restSpeedThresholdV = restSpeedThreshold;
-    return this;
-  }
-
-  static withInitialValues(values: StyleProps): BaseAnimationBuilder {
-    const instance = this.createInstance();
-    return instance.withInitialValues(values);
-  }
-
-  withInitialValues(values: StyleProps): BaseAnimationBuilder {
-    this.initialValues = values;
-    return this;
-  }
-
-  getAnimationAndConfig(): LayoutAnimationAndConfig {
-    const duration = this.durationV;
-    const easing = this.easingV;
-    const rotate = this.rotateV;
-    const type = this.type ? this.type : (withTiming as AnimationFunction);
-    const damping = this.dampingV;
-    const mass = this.massV;
-    const stiffness = this.stiffnessV;
-    const overshootClamping = this.overshootClampingV;
-    const restDisplacementThreshold = this.restDisplacementThresholdV;
-    const restSpeedThreshold = this.restSpeedThresholdV;
-
-    const animation = type;
-
-    const config: BaseBuilderAnimationConfig = {};
-
-    if (type === withTiming) {
-      if (easing) {
-        config.easing = easing;
-      }
-      if (duration) {
-        config.duration = duration;
-      }
-      if (rotate) {
-        config.rotate = rotate;
-      }
-    } else {
-      if (damping) {
-        config.damping = damping;
-      }
-      if (mass) {
-        config.mass = mass;
-      }
-      if (stiffness) {
-        config.stiffness = stiffness;
-      }
-      if (overshootClamping) {
-        config.overshootClamping = overshootClamping;
-      }
-      if (restDisplacementThreshold) {
-        config.restDisplacementThreshold = restDisplacementThreshold;
-      }
-      if (restSpeedThreshold) {
-        config.restSpeedThreshold = restSpeedThreshold;
-      }
-      if (rotate) {
-        config.rotate = rotate;
-      }
-    }
-    return [animation, config];
-  }
-}