expo-dev-menu 2.1.4 → 3.0.0

package/vendored/react-native-reanimated/src/reanimated1/derived/interpolate.js

@@ -1,152 +0,0 @@
-import {
-  lessThan,
-  multiply,
-  sub,
-  add,
-  divide,
-  greaterThan,
-  lessOrEq,
-  eq,
-} from '../operators';
-import invariant from 'invariant';
-
-import AnimatedNode from '../core/AnimatedNode';
-import { createAnimatedCond as cond } from '../core/AnimatedCond';
-import { createAnimatedFunction as proc } from '../core/AnimatedFunction';
-
-const interpolateInternalSingleProc = proc(function (
-  value,
-  inS,
-  inE,
-  outS,
-  outE
-) {
-  const progress = divide(sub(value, inS), sub(inE, inS));
-  // logic below was made in order to provide a compatibility witn an Animated API
-  const resultForNonZeroRange = add(outS, multiply(progress, sub(outE, outS)));
-  const result = cond(
-    eq(inS, inE),
-    cond(lessOrEq(value, inS), outS, outE),
-    resultForNonZeroRange
-  );
-  return result;
-});
-
-function interpolateInternalSingle(value, inputRange, outputRange, offset) {
-  const inS = inputRange[offset];
-  const inE = inputRange[offset + 1];
-  const outS = outputRange[offset];
-  const outE = outputRange[offset + 1];
-  return interpolateInternalSingleProc(value, inS, inE, outS, outE);
-}
-
-function interpolateInternal(value, inputRange, outputRange, offset = 0) {
-  if (inputRange.length - offset === 2) {
-    return interpolateInternalSingle(value, inputRange, outputRange, offset);
-  }
-  return cond(
-    lessThan(value, inputRange[offset + 1]),
-    interpolateInternalSingle(value, inputRange, outputRange, offset),
-    interpolateInternal(value, inputRange, outputRange, offset + 1)
-  );
-}
-
-export const Extrapolate = {
-  EXTEND: 'extend',
-  CLAMP: 'clamp',
-  IDENTITY: 'identity',
-};
-
-function checkNonDecreasing(name, arr) {
-  for (let i = 1; i < arr.length; ++i) {
-    // We can't validate animated nodes in JS.
-    if (arr[i] instanceof AnimatedNode || arr[i - 1] instanceof AnimatedNode)
-      continue;
-    invariant(
-      arr[i] >= arr[i - 1],
-      '%s must be monotonically non-decreasing. (%s)',
-      name,
-      arr
-    );
-  }
-}
-
-function checkMinElements(name, arr) {
-  invariant(
-    arr.length >= 2,
-    '%s must have at least 2 elements. (%s)',
-    name,
-    arr
-  );
-}
-
-function checkValidNumbers(name, arr) {
-  for (let i = 0; i < arr.length; i++) {
-    // We can't validate animated nodes in JS.
-    if (arr[i] instanceof AnimatedNode || typeof arr[i] !== 'number') continue;
-    invariant(
-      Number.isFinite(arr[i]),
-      '%s cannot include %s. (%s)',
-      name,
-      arr[i],
-      arr
-    );
-  }
-}
-
-function convertToRadians(outputRange) {
-  for (const [i, value] of outputRange.entries()) {
-    if (typeof value === 'string' && value.endsWith('deg')) {
-      outputRange[i] = parseFloat(value) * (Math.PI / 180);
-    } else if (typeof value === 'string' && value.endsWith('rad')) {
-      outputRange[i] = parseFloat(value);
-    }
-  }
-}
-
-export default function interpolate(value, config) {
-  const {
-    inputRange,
-    outputRange,
-    extrapolate = Extrapolate.EXTEND,
-    extrapolateLeft,
-    extrapolateRight,
-  } = config;
-
-  checkMinElements('inputRange', inputRange);
-  checkValidNumbers('inputRange', inputRange);
-  checkMinElements('outputRange', outputRange);
-  checkValidNumbers('outputRange', outputRange);
-  checkNonDecreasing('inputRange', inputRange);
-  invariant(
-    inputRange.length === outputRange.length,
-    'inputRange and outputRange must be the same length.'
-  );
-
-  convertToRadians(outputRange);
-  const left = extrapolateLeft || extrapolate;
-  const right = extrapolateRight || extrapolate;
-  let output = interpolateInternal(value, inputRange, outputRange);
-
-  if (left === Extrapolate.CLAMP) {
-    output = cond(lessThan(value, inputRange[0]), outputRange[0], output);
-  } else if (left === Extrapolate.IDENTITY) {
-    output = cond(lessThan(value, inputRange[0]), value, output);
-  }
-
-  if (right === Extrapolate.CLAMP) {
-    output = cond(
-      greaterThan(value, inputRange[inputRange.length - 1]),
-      outputRange[outputRange.length - 1],
-      output
-    );
-  } else if (right === Extrapolate.IDENTITY) {
-    output = cond(
-      greaterThan(value, inputRange[inputRange.length - 1]),
-      value,
-      output
-    );
-  }
-
-  return output;
-}

package/vendored/react-native-reanimated/src/reanimated1/derived/interpolateColors.js

@@ -1,62 +0,0 @@
-import { processColor } from 'react-native';
-import { round } from '../base';
-import color from './color';
-import interpolate, { Extrapolate } from './interpolate';
-
-function red(c) {
-  return (c >> 16) & 255;
-}
-function green(c) {
-  return (c >> 8) & 255;
-}
-function blue(c) {
-  return c & 255;
-}
-function opacity(c) {
-  return ((c >> 24) & 255) / 255;
-}
-
-/**
- * Use this if you want to interpolate an `Animated.Value` into color values.
- *
- * #### Why is this needed?
- *
- * Unfortunately, if you'll pass color values directly into the `outputRange` option
- * of `interpolate()` function, that won't really work (at least at the moment).
- * See https://github.com/software-mansion/react-native-reanimated/issues/181 .
- *
- * So, for now you can just use this helper instead.
- */
-export default function interpolateColors(animationValue, options) {
-  const { inputRange, outputColorRange } = options;
-  const colors = outputColorRange.map(processColor);
-
-  const r = round(
-    interpolate(animationValue, {
-      inputRange,
-      outputRange: colors.map(red),
-      extrapolate: Extrapolate.CLAMP,
-    })
-  );
-  const g = round(
-    interpolate(animationValue, {
-      inputRange,
-      outputRange: colors.map(green),
-      extrapolate: Extrapolate.CLAMP,
-    })
-  );
-  const b = round(
-    interpolate(animationValue, {
-      inputRange,
-      outputRange: colors.map(blue),
-      extrapolate: Extrapolate.CLAMP,
-    })
-  );
-  const a = interpolate(animationValue, {
-    inputRange,
-    outputRange: colors.map(opacity),
-    extrapolate: Extrapolate.CLAMP,
-  });
-
-  return color(r, g, b, a);
-}

package/vendored/react-native-reanimated/src/reanimated1/derived/onChange.js

@@ -1,14 +0,0 @@
-import { block, cond, defined, neq, not, set, proc } from '../base';
-import AnimatedValue from '../core/InternalAnimatedValue';
-
-const procOnChange = proc(function (value, action, prevValue) {
-  return block([
-    cond(not(defined(prevValue)), set(prevValue, value)),
-    cond(neq(value, prevValue), [set(prevValue, value), action]),
-  ]);
-});
-
-export default function onChange(value, action) {
-  const prevValue = new AnimatedValue();
-  return procOnChange(value, action, prevValue);
-}

package/vendored/react-native-reanimated/src/reanimated1/derived/useCode.js

@@ -1,41 +0,0 @@
-import React from 'react';
-import { always, block } from '../base';
-
-/**
- * @callback NodeFactory
- * Function to create a node or an array of nodes.
- * @returns {(Node[] | Node | null | undefined | Boolean)}
- */
-
-/**
- * React hook to run a node.
- * @param {NodeFactory} nodeFactory Function to build the node to run.
- * @param dependencies Array of dependencies. Refresh the node on changes.
- */
-export default function useCode(nodeFactory, dependencies) {
-  if (!(React.useEffect instanceof Function)) return;
-
-  React.useEffect(() => {
-    // check and correct 1st parameter
-    if (!(nodeFactory instanceof Function)) {
-      console.warn(
-        'useCode() first argument should be a function that returns an animation node.'
-      );
-
-      const node = nodeFactory;
-      nodeFactory = () => node;
-    }
-
-    let node = nodeFactory();
-    if (node) {
-      // allow factory to return array
-      if (node instanceof Array) node = block(node);
-
-      const animatedAlways = always(node);
-      animatedAlways.__attach();
-
-      // return undo function
-      return () => animatedAlways.__detach();
-    }
-  }, dependencies);
-}

package/vendored/react-native-reanimated/src/reanimated1/index.js

@@ -1,53 +0,0 @@
-import EasingNode from './Easing';
-import AnimatedClock from './core/AnimatedClock';
-import AnimatedValue from './core/AnimatedValue';
-import AnimatedNode from './core/AnimatedNode';
-import AnimatedCode from './core/AnimatedCode';
-import decay from './animations/decay';
-import timing from './animations/timing';
-import spring from './animations/spring';
-import Animation from './animations/Animation';
-import {
-  Transition,
-  Transitioning,
-  createTransitioningComponent,
-} from './Transitioning';
-import SpringUtils from './animations/SpringUtils';
-import useValue from './useValue';
-import backwardCompatibleAnimWrapper from './animations/backwardCompatibleAnimWrapper';
-
-const decayWrapper = backwardCompatibleAnimWrapper(
-  decay,
-  Animation.decayDefaultState
-);
-const timingWrapper = backwardCompatibleAnimWrapper(
-  timing,
-  Animation.timingDefaultState
-);
-const springWrapper = backwardCompatibleAnimWrapper(
-  spring,
-  Animation.springDefaultState
-);
-
-// operations
-export * from './base';
-export * from './derived';
-export {
-  AnimatedCode as Code,
-  // transitions
-  EasingNode,
-  Transitioning,
-  Transition,
-  createTransitioningComponent,
-  // nodes
-  AnimatedClock as Clock,
-  AnimatedValue as Value,
-  AnimatedNode as Node,
-  // animations
-  decayWrapper as decay,
-  timingWrapper as timing,
-  springWrapper as spring,
-  SpringUtils,
-  // hooks
-  useValue,
-};

package/vendored/react-native-reanimated/src/reanimated1/operators.js

@@ -1,35 +0,0 @@
-import { createAnimatedOperator } from './core/AnimatedOperator';
-
-const operator = createAnimatedOperator;
-
-export const add = operator('add');
-export const sub = operator('sub');
-export const multiply = operator('multiply');
-export const divide = operator('divide');
-export const pow = operator('pow');
-export const modulo = operator('modulo');
-export const sqrt = operator('sqrt');
-export const log = operator('log');
-export const sin = operator('sin');
-export const cos = operator('cos');
-export const exp = operator('exp');
-export const round = operator('round');
-export const lessThan = operator('lessThan');
-export const eq = operator('eq');
-export const greaterThan = operator('greaterThan');
-export const lessOrEq = operator('lessOrEq');
-export const greaterOrEq = operator('greaterOrEq');
-export const neq = operator('neq');
-export const and = operator('and');
-export const or = operator('or');
-export const defined = operator('defined');
-export const not = operator('not');
-export const tan = operator('tan');
-export const acos = operator('acos');
-export const asin = operator('asin');
-export const atan = operator('atan');
-export const abs = operator('abs');
-export const ceil = operator('ceil');
-export const floor = operator('floor');
-export const max = operator('max');
-export const min = operator('min');

package/vendored/react-native-reanimated/src/reanimated1/useValue.js

@@ -1,10 +0,0 @@
-import React from 'react';
-import AnimatedValue from './core/AnimatedValue';
-
-export default function useValue(initialValue) {
-  const ref = React.useRef(null);
-  if (ref.current === null) {
-    ref.current = new AnimatedValue(initialValue);
-  }
-  return ref.current;
-}

package/vendored/react-native-reanimated/src/reanimated1/val.js

@@ -1,3 +0,0 @@
-export function val(v) {
-  return v && v.__getValue ? v.__getValue() : v || 0;
-}

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

@@ -1,172 +0,0 @@
-/**
- * https://github.com/gre/bezier-easing
- * BezierEasing - use bezier curve for transition easing function
- * by Gaëtan Renaudeau 2014 - 2015 – MIT License
- */
-
-// These values are established by empiricism with tests (tradeoff: performance VS precision)
-
-export function Bezier(
-  mX1: number,
-  mY1: number,
-  mX2: number,
-  mY2: number
-): (x: number) => number {
-  'worklet';
-
-  const NEWTON_ITERATIONS = 4;
-  const NEWTON_MIN_SLOPE = 0.001;
-  const SUBDIVISION_PRECISION = 0.0000001;
-  const SUBDIVISION_MAX_ITERATIONS = 10;
-
-  const kSplineTableSize = 11;
-  const kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
-
-  function A(aA1: number, aA2: number): number {
-    'worklet';
-    return 1.0 - 3.0 * aA2 + 3.0 * aA1;
-  }
-  function B(aA1: number, aA2: number): number {
-    'worklet';
-    return 3.0 * aA2 - 6.0 * aA1;
-  }
-  function C(aA1: number) {
-    'worklet';
-    return 3.0 * aA1;
-  }
-
-  // Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
-  function calcBezier(aT: number, aA1: number, aA2: number): number {
-    'worklet';
-    return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
-  }
-
-  // Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
-  function getSlope(aT: number, aA1: number, aA2: number): number {
-    'worklet';
-    return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1);
-  }
-
-  function binarySubdivide(
-    aX: number,
-    aA: number,
-    aB: number,
-    mX1: number,
-    mX2: number
-  ): number {
-    'worklet';
-    let currentX;
-    let currentT;
-    let i = 0;
-    do {
-      currentT = aA + (aB - aA) / 2.0;
-      currentX = calcBezier(currentT, mX1, mX2) - aX;
-      if (currentX > 0.0) {
-        aB = currentT;
-      } else {
-        aA = currentT;
-      }
-    } while (
-      Math.abs(currentX) > SUBDIVISION_PRECISION &&
-      ++i < SUBDIVISION_MAX_ITERATIONS
-    );
-    return currentT;
-  }
-
-  function newtonRaphsonIterate(
-    aX: number,
-    aGuessT: number,
-    mX1: number,
-    mX2: number
-  ): number {
-    'worklet';
-    for (let i = 0; i < NEWTON_ITERATIONS; ++i) {
-      const currentSlope = getSlope(aGuessT, mX1, mX2);
-      if (currentSlope === 0.0) {
-        return aGuessT;
-      }
-      const currentX = calcBezier(aGuessT, mX1, mX2) - aX;
-      aGuessT -= currentX / currentSlope;
-    }
-    return aGuessT;
-  }
-
-  function LinearEasing(x: number): number {
-    'worklet';
-    return x;
-  }
-
-  if (!(mX1 >= 0 && mX1 <= 1 && mX2 >= 0 && mX2 <= 1)) {
-    throw new Error('bezier x values must be in [0, 1] range');
-  }
-
-  if (mX1 === mY1 && mX2 === mY2) {
-    return LinearEasing;
-  }
-
-  // FIXME: Float32Array is not available in Hermes right now
-  //
-  // var float32ArraySupported = typeof Float32Array === 'function';
-  // const sampleValues = float32ArraySupported
-  // ? new Float32Array(kSplineTableSize)
-  // : new Array(kSplineTableSize);
-
-  // Precompute samples table
-  const sampleValues = new Array(kSplineTableSize);
-
-  for (let i = 0; i < kSplineTableSize; ++i) {
-    sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
-  }
-
-  function getTForX(aX: number): number {
-    'worklet';
-    let intervalStart = 0.0;
-    let currentSample = 1;
-    const lastSample = kSplineTableSize - 1;
-
-    for (
-      ;
-      currentSample !== lastSample && sampleValues[currentSample] <= aX;
-      ++currentSample
-    ) {
-      intervalStart += kSampleStepSize;
-    }
-    --currentSample;
-
-    // Interpolate to provide an initial guess for t
-    const dist =
-      (aX - sampleValues[currentSample]) /
-      (sampleValues[currentSample + 1] - sampleValues[currentSample]);
-    const guessForT = intervalStart + dist * kSampleStepSize;
-
-    const initialSlope = getSlope(guessForT, mX1, mX2);
-    if (initialSlope >= NEWTON_MIN_SLOPE) {
-      return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
-    } else if (initialSlope === 0.0) {
-      return guessForT;
-    } else {
-      return binarySubdivide(
-        aX,
-        intervalStart,
-        intervalStart + kSampleStepSize,
-        mX1,
-        mX2
-      );
-    }
-  }
-
-  return function BezierEasing(x) {
-    'worklet';
-    if (mX1 === mY1 && mX2 === mY2) {
-      return x; // linear
-    }
-    // Because JavaScript number are imprecise, we should guarantee the extremes are right.
-    if (x === 0) {
-      return 0;
-    }
-    if (x === 1) {
-      return 1;
-    }
-    return calcBezier(getTForX(x), mY1, mY2);
-  };
-}