expo-dev-menu 2.2.0 → 3.0.0

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

@@ -1,212 +0,0 @@
-// @ts-ignore JS file
-import interpolateNode from '../reanimated1/derived/interpolate';
-
-export enum Extrapolation {
-  IDENTITY = 'identity',
-  CLAMP = 'clamp',
-  EXTEND = 'extend',
-}
-
-export interface InterpolatedNode {
-  __nodeId: number;
-}
-
-interface InterpolationNarrowedInput {
-  leftEdgeInput: number;
-  rightEdgeInput: number;
-  leftEdgeOutput: number;
-  rightEdgeOutput: number;
-}
-
-export interface ExtrapolationConfig {
-  extrapolateLeft?: Extrapolation | string;
-  extrapolateRight?: Extrapolation | string;
-}
-
-interface RequiredExtrapolationConfig {
-  extrapolateLeft: Extrapolation;
-  extrapolateRight: Extrapolation;
-}
-
-export type ExtrapolationType =
-  | ExtrapolationConfig
-  | Extrapolation
-  | string
-  | undefined;
-
-function isNode(x: number | InterpolatedNode): x is InterpolatedNode {
-  'worklet';
-  return (x as InterpolatedNode).__nodeId !== undefined;
-}
-
-function getVal(
-  type: Extrapolation,
-  coef: number,
-  val: number,
-  leftEdgeOutput: number,
-  rightEdgeOutput: number,
-  x: number
-): number {
-  'worklet';
-
-  switch (type) {
-    case Extrapolation.IDENTITY:
-      return x;
-    case Extrapolation.CLAMP:
-      if (coef * val < coef * leftEdgeOutput) {
-        return leftEdgeOutput;
-      }
-      return rightEdgeOutput;
-    case Extrapolation.EXTEND:
-    default:
-      return val;
-  }
-}
-
-function isExtrapolate(value: string): value is Extrapolation {
-  'worklet';
-
-  return (
-    value === Extrapolation.EXTEND ||
-    value === Extrapolation.CLAMP ||
-    value === Extrapolation.IDENTITY
-  );
-}
-
-// validates extrapolations type
-// if type is correct, converts it to ExtrapolationConfig
-function validateType(type: ExtrapolationType): RequiredExtrapolationConfig {
-  'worklet';
-  // initialize extrapolationConfig with default extrapolation
-  const extrapolationConfig: RequiredExtrapolationConfig = {
-    extrapolateLeft: Extrapolation.EXTEND,
-    extrapolateRight: Extrapolation.EXTEND,
-  };
-
-  if (!type) {
-    return extrapolationConfig;
-  }
-
-  if (typeof type === 'string') {
-    if (!isExtrapolate(type)) {
-      throw new Error(
-        `Reanimated: not supported value for "interpolate" \nSupported values: ["extend", "clamp", "identity", Extrapolatation.CLAMP, Extrapolatation.EXTEND, Extrapolatation.IDENTITY]\n Valid example:
-        interpolate(value, [inputRange], [outputRange], "clamp")`
-      );
-    }
-    extrapolationConfig.extrapolateLeft = type;
-    extrapolationConfig.extrapolateRight = type;
-    return extrapolationConfig;
-  }
-
-  // otherwise type is extrapolation config object
-  if (
-    (type.extrapolateLeft && !isExtrapolate(type.extrapolateLeft)) ||
-    (type.extrapolateRight && !isExtrapolate(type.extrapolateRight))
-  ) {
-    throw new Error(
-      `Reanimated: not supported value for "interpolate" \nSupported values: ["extend", "clamp", "identity", Extrapolatation.CLAMP, Extrapolatation.EXTEND, Extrapolatation.IDENTITY]\n Valid example:
-      interpolate(value, [inputRange], [outputRange], {
-        extrapolateLeft: Extrapolation.CLAMP,
-        extrapolateRight: Extrapolation.IDENTITY
-      }})`
-    );
-  }
-
-  Object.assign(extrapolationConfig, type);
-  return extrapolationConfig;
-}
-
-function internalInterpolate(
-  x: number,
-  narrowedInput: InterpolationNarrowedInput,
-  extrapolationConfig: RequiredExtrapolationConfig
-) {
-  'worklet';
-  const { leftEdgeInput, rightEdgeInput, leftEdgeOutput, rightEdgeOutput } =
-    narrowedInput;
-  if (rightEdgeInput - leftEdgeInput === 0) return leftEdgeOutput;
-  const progress = (x - leftEdgeInput) / (rightEdgeInput - leftEdgeInput);
-  const val = leftEdgeOutput + progress * (rightEdgeOutput - leftEdgeOutput);
-  const coef = rightEdgeOutput >= leftEdgeOutput ? 1 : -1;
-
-  if (coef * val < coef * leftEdgeOutput) {
-    return getVal(
-      extrapolationConfig.extrapolateLeft,
-      coef,
-      val,
-      leftEdgeOutput,
-      rightEdgeOutput,
-      x
-    );
-  } else if (coef * val > coef * rightEdgeOutput) {
-    return getVal(
-      extrapolationConfig.extrapolateRight,
-      coef,
-      val,
-      leftEdgeOutput,
-      rightEdgeOutput,
-      x
-    );
-  }
-
-  return val;
-}
-
-// TODO: support default values in worklets:
-// e.g. function interpolate(x, input, output, type = Extrapolatation.CLAMP)
-export function interpolate(
-  x: number | InterpolatedNode,
-  input: readonly number[],
-  output: readonly number[],
-  type?: ExtrapolationType
-): number {
-  'worklet';
-  if (input.length < 2 || output.length < 2) {
-    throw Error(
-      'Interpolation input and output should contain at least two values.'
-    );
-  }
-
-  const extrapolationConfig = validateType(type);
-
-  if (isNode(x)) {
-    console.warn(
-      `interpolate() was renamed to interpolateNode() in Reanimated 2. Please use interpolateNode() instead`
-    );
-    return interpolateNode(x, {
-      inputRange: input,
-      outputRange: output,
-      extrapolateLeft: extrapolationConfig.extrapolateLeft,
-      extrapolateRight: extrapolationConfig.extrapolateRight,
-    });
-  }
-
-  const length = input.length;
-  const narrowedInput: InterpolationNarrowedInput = {
-    leftEdgeInput: input[0],
-    rightEdgeInput: input[1],
-    leftEdgeOutput: output[0],
-    rightEdgeOutput: output[1],
-  };
-  if (length > 2) {
-    if (x > input[length - 1]) {
-      narrowedInput.leftEdgeInput = input[length - 2];
-      narrowedInput.rightEdgeInput = input[length - 1];
-      narrowedInput.leftEdgeOutput = output[length - 2];
-      narrowedInput.rightEdgeOutput = output[length - 1];
-    } else {
-      for (let i = 1; i < length; ++i) {
-        if (x <= input[i]) {
-          narrowedInput.leftEdgeInput = input[i - 1];
-          narrowedInput.rightEdgeInput = input[i];
-          narrowedInput.leftEdgeOutput = output[i - 1];
-          narrowedInput.rightEdgeOutput = output[i];
-          break;
-        }
-      }
-    }
-  }
-
-  return internalInterpolate(x, narrowedInput, extrapolationConfig);
-}

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

@@ -1,225 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
-import { jestResetJsReanimatedModule } from './core';
-
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace jest {
-    interface Matchers<R> {
-      toHaveAnimatedStyle(
-        style: Record<string, unknown>[] | Record<string, unknown>
-      ): R;
-    }
-  }
-}
-
-let config = {
-  fps: 60,
-};
-
-const isAnimatedStyle = (style) => {
-  return !!style.animatedStyle;
-};
-
-const getAnimatedStyleFromObject = (style) => {
-  return style.animatedStyle.current.value;
-};
-
-const getCurrentStyle = (received) => {
-  const styleObject = received.props.style;
-  let currentStyle = {};
-  if (Array.isArray(styleObject)) {
-    received.props.style.forEach((style) => {
-      if (isAnimatedStyle(style)) {
-        currentStyle = {
-          ...currentStyle,
-          ...getAnimatedStyleFromObject(style),
-        };
-      } else {
-        currentStyle = {
-          ...currentStyle,
-          ...style,
-        };
-      }
-    });
-  } else {
-    if (isAnimatedStyle(styleObject)) {
-      currentStyle = getAnimatedStyleFromObject(styleObject);
-    } else {
-      currentStyle = {
-        ...styleObject,
-        ...received.props.animatedStyle.value,
-      };
-    }
-  }
-  return currentStyle;
-};
-
-const checkEqual = (currentStyle, expectStyle) => {
-  if (Array.isArray(expectStyle)) {
-    if (expectStyle.length !== currentStyle.length) return false;
-    for (let i = 0; i < currentStyle.length; i++) {
-      if (!checkEqual(currentStyle[i], expectStyle[i])) {
-        return false;
-      }
-    }
-  } else if (typeof currentStyle === 'object' && currentStyle) {
-    for (const property in expectStyle) {
-      if (!checkEqual(currentStyle[property], expectStyle[property])) {
-        return false;
-      }
-    }
-  } else {
-    return currentStyle === expectStyle;
-  }
-  return true;
-};
-
-const findStyleDiff = (current, expect, requireAllMatch) => {
-  const diffs = [];
-  let isEqual = true;
-  for (const property in expect) {
-    if (!checkEqual(current[property], expect[property])) {
-      isEqual = false;
-      diffs.push({
-        property: property,
-        current: current[property],
-        expect: expect[property],
-      });
-    }
-  }
-
-  if (
-    requireAllMatch &&
-    Object.keys(current).length !== Object.keys(expect).length
-  ) {
-    isEqual = false;
-    for (const property in current) {
-      if (expect[property] === undefined) {
-        diffs.push({
-          property: property,
-          current: current[property],
-          expect: expect[property],
-        });
-      }
-    }
-  }
-
-  return { isEqual, diffs };
-};
-
-const compareStyle = (received, expectedStyle, config) => {
-  if (!received.props.style) {
-    return { message: () => message, pass: false };
-  }
-  const { exact } = config;
-  const currentStyle = getCurrentStyle(received);
-  const { isEqual, diffs } = findStyleDiff(currentStyle, expectedStyle, exact);
-
-  if (isEqual) {
-    return { message: () => 'ok', pass: true };
-  }
-
-  const currentStyleStr = JSON.stringify(currentStyle);
-  const expectedStyleStr = JSON.stringify(expectedStyle);
-  const differences = diffs
-    .map(
-      (diff) =>
-        `- '${diff.property}' should be ${JSON.stringify(
-          diff.expect
-        )}, but is ${JSON.stringify(diff.current)}`
-    )
-    .join('\n');
-
-  return {
-    message: () =>
-      `Expected: ${expectedStyleStr}\nReceived: ${currentStyleStr}\n\nDifferences:\n${differences}`,
-    pass: false,
-  };
-};
-
-let frameTime = 1000 / config.fps;
-let requestAnimationFrameCopy;
-let currentTimestamp = 0;
-
-const requestAnimationFrame = (callback) => {
-  setTimeout(callback, frameTime);
-};
-
-const beforeTest = () => {
-  jestResetJsReanimatedModule();
-  requestAnimationFrameCopy = global.requestAnimationFrame;
-  global.requestAnimationFrame = requestAnimationFrame;
-  global.ReanimatedDataMock = {
-    now: () => currentTimestamp,
-  };
-  currentTimestamp = 0;
-  jest.useFakeTimers();
-};
-
-const afterTest = () => {
-  jest.useRealTimers();
-  global.requestAnimationFrame = requestAnimationFrameCopy;
-};
-
-const tickTravel = () => {
-  currentTimestamp += frameTime;
-  jest.advanceTimersByTime(frameTime);
-};
-
-export const withReanimatedTimer = (animationTest) => {
-  beforeTest();
-  animationTest();
-  afterTest();
-};
-
-export const advanceAnimationByTime = (time = frameTime) => {
-  for (let i = 0; i <= Math.ceil(time / frameTime); i++) {
-    tickTravel();
-  }
-  jest.advanceTimersByTime(frameTime);
-};
-
-export const advanceAnimationByFrame = (count) => {
-  for (let i = 0; i <= count; i++) {
-    tickTravel();
-  }
-  jest.advanceTimersByTime(frameTime);
-};
-
-export const setUpTests = (userConfig = {}) => {
-  let expect = global.expect;
-  if (expect === undefined) {
-    const expectModule = require('expect');
-    expect = expectModule;
-    // Starting from Jest 28, "expect" package uses named exports instead of default export.
-    // So, requiring "expect" package doesn't give direct access to "expect" function anymore.
-    // It gives access to the module object instead.
-    // We use this info to detect if the project uses Jest 28 or higher.
-    if (typeof expect === 'object') {
-      const jestGlobals = require('@jest/globals');
-      expect = jestGlobals.expect;
-    }
-    if (expect === undefined || expect.extend === undefined) {
-      expect = expectModule.default;
-    }
-  }
-
-  require('setimmediate');
-  frameTime = Math.round(1000 / config.fps);
-
-  config = {
-    ...config,
-    ...userConfig,
-  };
-
-  expect.extend({
-    toHaveAnimatedStyle(received, expectedStyle, config = {}) {
-      return compareStyle(received, expectedStyle, config);
-    },
-  });
-};
-
-export const getAnimatedStyle = (received) => {
-  return getCurrentStyle(received);
-};

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

@@ -1,144 +0,0 @@
-import MapperRegistry from './MapperRegistry';
-import Mapper from './Mapper';
-import MutableValue from './MutableValue';
-import { NativeReanimated } from '../NativeReanimated/NativeReanimated';
-import {
-  Timestamp,
-  NestedObjectValues,
-  AnimatedKeyboardInfo,
-} from '../commonTypes';
-import { isJest } from '../PlatformChecker';
-
-export default class JSReanimated extends NativeReanimated {
-  _valueSetter?: <T>(value: T) => void = undefined;
-
-  _renderRequested = false;
-  _mapperRegistry: MapperRegistry<any> = new MapperRegistry(this);
-  _frames: ((timestamp: Timestamp) => void)[] = [];
-  timeProvider: { now: () => number };
-
-  constructor() {
-    super(false);
-    if (isJest()) {
-      this.timeProvider = { now: () => global.ReanimatedDataMock.now() };
-    } else {
-      this.timeProvider = { now: () => window.performance.now() };
-    }
-  }
-
-  pushFrame(frame: (timestamp: Timestamp) => void): void {
-    this._frames.push(frame);
-    this.maybeRequestRender();
-  }
-
-  getTimestamp(): number {
-    return this.timeProvider.now();
-  }
-
-  maybeRequestRender(): void {
-    if (!this._renderRequested) {
-      this._renderRequested = true;
-
-      requestAnimationFrame((_timestampMs) => {
-        this._renderRequested = false;
-
-        this._onRender(this.getTimestamp());
-      });
-    }
-  }
-
-  _onRender(timestampMs: number): void {
-    this._mapperRegistry.execute();
-
-    const frames = [...this._frames];
-    this._frames = [];
-
-    for (let i = 0, len = frames.length; i < len; ++i) {
-      frames[i](timestampMs);
-    }
-
-    if (this._mapperRegistry.needRunOnRender) {
-      this._mapperRegistry.execute();
-    }
-  }
-
-  installCoreFunctions(valueSetter: <T>(value: T) => void): void {
-    this._valueSetter = valueSetter;
-  }
-
-  makeShareable<T>(value: T): T {
-    return value;
-  }
-
-  makeMutable<T>(value: T): MutableValue<T> {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return new MutableValue(value, this._valueSetter!);
-  }
-
-  makeRemote<T>(object = {}): T {
-    return object as T;
-  }
-
-  startMapper(
-    mapper: () => void,
-    inputs: NestedObjectValues<MutableValue<unknown>>[] = [],
-    outputs: NestedObjectValues<MutableValue<unknown>>[] = []
-  ): number {
-    const instance = new Mapper(this, mapper, inputs, outputs);
-    const mapperId = this._mapperRegistry.startMapper(instance);
-    this.maybeRequestRender();
-    return mapperId;
-  }
-
-  stopMapper(mapperId: number): void {
-    this._mapperRegistry.stopMapper(mapperId);
-  }
-
-  registerEventHandler<T>(_: string, __: (event: T) => void): string {
-    // noop
-    return '';
-  }
-
-  unregisterEventHandler(_: string): void {
-    // noop
-  }
-
-  enableLayoutAnimations() {
-    console.warn(
-      '[Reanimated] enableLayoutAnimations is not available for WEB yet'
-    );
-  }
-
-  registerSensor(): number {
-    console.warn('[Reanimated] useAnimatedSensor is not available on web yet.');
-    return -1;
-  }
-
-  unregisterSensor(): void {
-    // noop
-  }
-
-  jestResetModule() {
-    if (isJest()) {
-      /**
-       * If someone used timers to stop animation before the end,
-       * then _renderRequested was set as true
-       * and any new update from another test wasn't applied.
-       */
-      this._renderRequested = false;
-    } else {
-      throw Error('This method can be only use in Jest testing.');
-    }
-  }
-
-  subscribeForKeyboardEvents(_: AnimatedKeyboardInfo): number {
-    console.warn(
-      '[Reanimated] useAnimatedKeyboard is not available on web yet.'
-    );
-    return -1;
-  }
-
-  unsubscribeFromKeyboardEvents(_: number): void {
-    // noop
-  }
-}

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

@@ -1,62 +0,0 @@
-import { NestedObjectValues } from '../commonTypes';
-import { JSReanimated } from './commonTypes';
-import MutableValue from './MutableValue';
-
-export default class Mapper<T> {
-  static MAPPER_ID = 1;
-  id: number;
-  inputs: MutableValue<T>[];
-  outputs: MutableValue<T>[];
-  mapper: () => void;
-
-  dirty = true;
-
-  constructor(
-    module: JSReanimated,
-    mapper: () => void,
-    inputs: NestedObjectValues<MutableValue<T>>[] = [],
-    outputs: NestedObjectValues<MutableValue<T>>[] = []
-  ) {
-    this.id = Mapper.MAPPER_ID++;
-    this.inputs = this.extractMutablesFromArray(inputs);
-    this.outputs = this.extractMutablesFromArray(outputs);
-    this.mapper = mapper;
-
-    const markDirty = () => {
-      this.dirty = true;
-      module.maybeRequestRender();
-    };
-
-    this.inputs.forEach((input) => {
-      input.addListener(markDirty);
-    });
-  }
-
-  execute(): void {
-    this.dirty = false;
-    this.mapper();
-  }
-
-  extractMutablesFromArray<T>(
-    array: NestedObjectValues<MutableValue<T>>
-  ): MutableValue<T>[] {
-    const res: MutableValue<T>[] = [];
-
-    function extractMutables(value: NestedObjectValues<MutableValue<T>>) {
-      if (value == null) {
-        // return;
-      } else if (value instanceof MutableValue) {
-        res.push(value);
-      } else if (Array.isArray(value)) {
-        value.forEach((v) => extractMutables(v));
-      } else if (typeof value === 'object') {
-        Object.keys(value).forEach((key) => {
-          extractMutables(value[key]);
-        });
-      }
-    }
-
-    extractMutables(array);
-    return res;
-  }
-}