expo-dev-menu 2.1.4 → 3.0.0

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

@@ -1,245 +0,0 @@
-import { MutableRefObject, useEffect, useRef } from 'react';
-import { processColor } from '../Colors';
-import {
-  AnimatedStyle,
-  NativeEvent,
-  NestedObjectValues,
-  StyleProps,
-  WorkletFunction,
-  AnimationObject,
-} from '../commonTypes';
-import { makeRemote } from '../core';
-import { isWeb, isJest } from '../PlatformChecker';
-import { colorProps } from '../UpdateProps';
-import WorkletEventHandler from '../WorkletEventHandler';
-import {
-  Context,
-  ContextWithDependencies,
-  DependencyList,
-} from './commonTypes';
-
-interface Handler<T, TContext extends Context> extends WorkletFunction {
-  (event: T, context: TContext): void;
-}
-
-interface Handlers<T, TContext extends Context> {
-  [key: string]: Handler<T, TContext> | undefined;
-}
-
-export interface UseHandlerContext<TContext extends Context> {
-  context: TContext;
-  doDependenciesDiffer: boolean;
-  useWeb: boolean;
-}
-
-export function useEvent<T extends NativeEvent<T>>(
-  handler: (event: T) => void,
-  eventNames: string[] = [],
-  rebuild = false
-): MutableRefObject<WorkletEventHandler<T> | null> {
-  const initRef = useRef<WorkletEventHandler<T> | null>(null);
-  if (initRef.current === null) {
-    initRef.current = new WorkletEventHandler(handler, eventNames);
-  } else if (rebuild) {
-    initRef.current.updateWorklet(handler);
-  }
-
-  return initRef;
-}
-
-export function useHandler<T, TContext extends Context>(
-  handlers: Handlers<T, TContext>,
-  dependencies?: DependencyList
-): UseHandlerContext<TContext> {
-  const initRef = useRef<ContextWithDependencies<TContext> | null>(null);
-  if (initRef.current === null) {
-    initRef.current = {
-      context: makeRemote({}),
-      savedDependencies: [],
-    };
-  }
-
-  useEffect(() => {
-    return () => {
-      initRef.current = null;
-    };
-  }, []);
-
-  const { context, savedDependencies } = initRef.current;
-
-  dependencies = buildDependencies(dependencies, handlers);
-
-  const doDependenciesDiffer = !areDependenciesEqual(
-    dependencies,
-    savedDependencies
-  );
-  initRef.current.savedDependencies = dependencies;
-  const useWeb = isWeb() || isJest();
-
-  return { context, doDependenciesDiffer, useWeb };
-}
-
-// builds one big hash from multiple worklets' hashes
-export function buildWorkletsHash(
-  handlers: Record<string, WorkletFunction> | Array<WorkletFunction>
-): string {
-  return Object.values(handlers).reduce(
-    (acc: string, worklet: WorkletFunction) =>
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      acc + worklet.__workletHash!.toString(),
-    ''
-  );
-}
-
-// builds dependencies array for gesture handlers
-export function buildDependencies(
-  dependencies: DependencyList,
-  handlers: Record<string, WorkletFunction | undefined>
-): Array<unknown> {
-  const handlersList: WorkletFunction[] = Object.values(handlers).filter(
-    (handler) => handler !== undefined
-  ) as WorkletFunction[];
-  if (!dependencies) {
-    dependencies = handlersList.map((handler) => {
-      return {
-        workletHash: handler.__workletHash,
-        closure: handler._closure,
-      };
-    });
-  } else {
-    dependencies.push(buildWorkletsHash(handlersList));
-  }
-  return dependencies;
-}
-
-// this is supposed to work as useEffect comparison
-export function areDependenciesEqual(
-  nextDeps: DependencyList,
-  prevDeps: DependencyList
-): boolean {
-  function is(x: number, y: number) {
-    /* eslint-disable no-self-compare */
-    return (x === y && (x !== 0 || 1 / x === 1 / y)) || (x !== x && y !== y);
-    /* eslint-enable no-self-compare */
-  }
-  const objectIs: (nextDeps: unknown, prevDeps: unknown) => boolean =
-    typeof Object.is === 'function' ? Object.is : is;
-
-  function areHookInputsEqual(
-    nextDeps: DependencyList,
-    prevDeps: DependencyList
-  ): boolean {
-    if (!nextDeps || !prevDeps || prevDeps.length !== nextDeps.length) {
-      return false;
-    }
-    for (let i = 0; i < prevDeps.length; ++i) {
-      if (!objectIs(nextDeps[i], prevDeps[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  return areHookInputsEqual(nextDeps, prevDeps);
-}
-
-export function hasColorProps(updates: AnimatedStyle): boolean {
-  const colorPropsSet = new Set(colorProps);
-  for (const key in updates) {
-    if (colorPropsSet.has(key)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-export function parseColors(updates: AnimatedStyle): void {
-  'worklet';
-  for (const key in updates) {
-    if (colorProps.indexOf(key) !== -1) {
-      // value could be an animation in which case processColor will recognize it and will return undefined
-      // -> in such a case we don't want to override style of that key
-      const processedColor = processColor(updates[key]);
-      if (processedColor !== undefined) {
-        updates[key] = processedColor;
-      }
-    }
-  }
-}
-
-export function canApplyOptimalisation(upadterFn: WorkletFunction): number {
-  const FUNCTIONLESS_FLAG = 0b00000001;
-  const STATEMENTLESS_FLAG = 0b00000010;
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  const optimalization = upadterFn.__optimalization!;
-  return (
-    optimalization & FUNCTIONLESS_FLAG && optimalization & STATEMENTLESS_FLAG
-  );
-}
-
-export function isAnimated(prop: NestedObjectValues<AnimationObject>): boolean {
-  'worklet';
-  if (Array.isArray(prop)) {
-    return prop.some(isAnimated);
-  } else if (typeof prop === 'object') {
-    if (prop.onFrame !== undefined) {
-      return true;
-    } else {
-      return Object.values(prop).some(isAnimated);
-    }
-  }
-  return false;
-}
-
-export function styleDiff<T extends AnimatedStyle>(
-  oldStyle: AnimatedStyle,
-  newStyle: AnimatedStyle
-): Partial<T> {
-  'worklet';
-  const diff: any = {};
-  for (const key in oldStyle) {
-    if (newStyle[key] === undefined) {
-      diff[key] = null;
-    }
-  }
-  for (const key in newStyle) {
-    const value = newStyle[key];
-    const oldValue = oldStyle[key];
-
-    if (isAnimated(value)) {
-      // do nothing
-      continue;
-    }
-    if (oldValue !== value) {
-      diff[key] = value;
-    }
-  }
-  return diff;
-}
-
-export function getStyleWithoutAnimations(newStyle: AnimatedStyle): StyleProps {
-  'worklet';
-  const diff: StyleProps = {};
-
-  for (const key in newStyle) {
-    const value = newStyle[key];
-    if (isAnimated(value)) {
-      continue;
-    }
-    diff[key] = value;
-  }
-  return diff;
-}
-
-export const validateAnimatedStyles = (styles: AnimatedStyle): void => {
-  'worklet';
-  if (typeof styles !== 'object') {
-    throw new Error(
-      `useAnimatedStyle has to return an object, found ${typeof styles} instead`
-    );
-  } else if (Array.isArray(styles)) {
-    throw new Error(
-      'useAnimatedStyle has to return an object and cannot return static styles combined with dynamic ones. Please do merging where a component receives props.'
-    );
-  }
-};

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

@@ -1,12 +0,0 @@
-export * from './core';
-export * from './hook';
-export * from './animation';
-export * from './interpolation';
-export * from './interpolateColor';
-export * from './Easing';
-export * from './NativeMethods';
-export * from './Colors';
-export * from './PropAdapters';
-export * from './layoutReanimation';
-export * from './utils';
-export * from './commonTypes';

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

@@ -1,262 +0,0 @@
-import {
-  hsvToColor,
-  RGBtoHSV,
-  rgbaColor,
-  processColor,
-  red,
-  green,
-  blue,
-  opacity,
-} from './Colors';
-import { makeMutable } from './core';
-import { interpolate } from './interpolation';
-// @ts-ignore JS file
-import { Extrapolate } from '../reanimated1/derived';
-import { SharedValue } from './commonTypes';
-import { useSharedValue } from './hook/useSharedValue';
-
-export type InterpolationOptions = {
-  gamma?: number;
-  useCorrectedHSVInterpolation?: boolean;
-};
-
-const interpolateColorsHSV = (
-  value: number,
-  inputRange: readonly number[],
-  colors: InterpolateHSV,
-  options: InterpolationOptions
-) => {
-  'worklet';
-  let h = 0;
-  const { useCorrectedHSVInterpolation = true } = options;
-  if (useCorrectedHSVInterpolation) {
-    // if the difference between hues in a range is > 180 deg
-    // then move the hue at the right end of the range +/- 360 deg
-    // and add the next point in the original place + 0.00001 with original hue
-    // to not break the next range
-    const correctedInputRange = [inputRange[0]];
-    const originalH = colors.h;
-    const correctedH = [originalH[0]];
-
-    for (let i = 1; i < originalH.length; ++i) {
-      const d = originalH[i] - originalH[i - 1];
-      if (originalH[i] > originalH[i - 1] && d > 0.5) {
-        correctedInputRange.push(inputRange[i]);
-        correctedInputRange.push(inputRange[i] + 0.00001);
-        correctedH.push(originalH[i] - 1);
-        correctedH.push(originalH[i]);
-      } else if (originalH[i] < originalH[i - 1] && d < -0.5) {
-        correctedInputRange.push(inputRange[i]);
-        correctedInputRange.push(inputRange[i] + 0.00001);
-        correctedH.push(originalH[i] + 1);
-        correctedH.push(originalH[i]);
-      } else {
-        correctedInputRange.push(inputRange[i]);
-        correctedH.push(originalH[i]);
-      }
-    }
-    h =
-      (interpolate(value, correctedInputRange, correctedH, Extrapolate.CLAMP) +
-        1) %
-      1;
-  } else {
-    h = interpolate(value, inputRange, colors.h, Extrapolate.CLAMP);
-  }
-  const s = interpolate(value, inputRange, colors.s, Extrapolate.CLAMP);
-  const v = interpolate(value, inputRange, colors.v, Extrapolate.CLAMP);
-  const a = interpolate(value, inputRange, colors.a, Extrapolate.CLAMP);
-  return hsvToColor(h, s, v, a);
-};
-
-const toLinearSpace = (x: number[], gamma: number): number[] => {
-  'worklet';
-  return x.map((v) => Math.pow(v / 255, gamma));
-};
-
-const toGammaSpace = (x: number, gamma: number): number => {
-  'worklet';
-  return Math.round(Math.pow(x, 1 / gamma) * 255);
-};
-
-const interpolateColorsRGB = (
-  value: number,
-  inputRange: readonly number[],
-  colors: InterpolateRGB,
-  options: InterpolationOptions
-) => {
-  'worklet';
-  const { gamma = 2.2 } = options;
-  let { r: outputR, g: outputG, b: outputB } = colors;
-  if (gamma !== 1) {
-    outputR = toLinearSpace(outputR, gamma);
-    outputG = toLinearSpace(outputG, gamma);
-    outputB = toLinearSpace(outputB, gamma);
-  }
-  const r = interpolate(value, inputRange, outputR, Extrapolate.CLAMP);
-  const g = interpolate(value, inputRange, outputG, Extrapolate.CLAMP);
-  const b = interpolate(value, inputRange, outputB, Extrapolate.CLAMP);
-  const a = interpolate(value, inputRange, colors.a, Extrapolate.CLAMP);
-  if (gamma === 1) {
-    return rgbaColor(r, g, b, a);
-  }
-  return rgbaColor(
-    toGammaSpace(r, gamma),
-    toGammaSpace(g, gamma),
-    toGammaSpace(b, gamma),
-    a
-  );
-};
-
-interface InterpolateRGB {
-  r: number[];
-  g: number[];
-  b: number[];
-  a: number[];
-}
-
-const getInterpolateRGB = (
-  colors: readonly (string | number)[]
-): InterpolateRGB => {
-  'worklet';
-
-  const r = [];
-  const g = [];
-  const b = [];
-  const a = [];
-  for (let i = 0; i < colors.length; ++i) {
-    const color = colors[i];
-    const processedColor = processColor(color);
-    // explicit check in case if processedColor is 0
-    if (processedColor !== null && processedColor !== undefined) {
-      r.push(red(processedColor));
-      g.push(green(processedColor));
-      b.push(blue(processedColor));
-      a.push(opacity(processedColor));
-    }
-  }
-  return { r, g, b, a };
-};
-
-interface InterpolateHSV {
-  h: number[];
-  s: number[];
-  v: number[];
-  a: number[];
-}
-
-const getInterpolateHSV = (
-  colors: readonly (string | number)[]
-): InterpolateHSV => {
-  'worklet';
-  const h = [];
-  const s = [];
-  const v = [];
-  const a = [];
-  for (let i = 0; i < colors.length; ++i) {
-    const color = colors[i];
-    const processedColor = processColor(color) as any;
-    if (typeof processedColor === 'number') {
-      const processedHSVColor = RGBtoHSV(
-        red(processedColor),
-        green(processedColor),
-        blue(processedColor)
-      );
-
-      h.push(processedHSVColor.h);
-      s.push(processedHSVColor.s);
-      v.push(processedHSVColor.v);
-      a.push(opacity(processedColor));
-    }
-  }
-  return { h, s, v, a };
-};
-
-export const interpolateColor = (
-  value: number,
-  inputRange: readonly number[],
-  outputRange: readonly (string | number)[],
-  colorSpace: 'RGB' | 'HSV' = 'RGB',
-  options: InterpolationOptions = {}
-): string | number => {
-  'worklet';
-  if (colorSpace === 'HSV') {
-    return interpolateColorsHSV(
-      value,
-      inputRange,
-      getInterpolateHSV(outputRange),
-      options
-    );
-  } else if (colorSpace === 'RGB') {
-    return interpolateColorsRGB(
-      value,
-      inputRange,
-      getInterpolateRGB(outputRange),
-      options
-    );
-  }
-  throw new Error(
-    `Invalid color space provided: ${colorSpace}. Supported values are: ['RGB', 'HSV']`
-  );
-};
-
-export enum ColorSpace {
-  RGB = 0,
-  HSV = 1,
-}
-
-export interface InterpolateConfig {
-  inputRange: readonly number[];
-  outputRange: readonly (string | number)[];
-  colorSpace: ColorSpace;
-  cache: SharedValue<InterpolateRGB | InterpolateHSV | null>;
-  options: InterpolationOptions;
-}
-
-export function useInterpolateConfig(
-  inputRange: readonly number[],
-  outputRange: readonly (string | number)[],
-  colorSpace = ColorSpace.RGB,
-  options: InterpolationOptions = {}
-): SharedValue<InterpolateConfig> {
-  return useSharedValue({
-    inputRange,
-    outputRange,
-    colorSpace,
-    cache: makeMutable<InterpolateRGB | InterpolateHSV | null>(null),
-    options,
-  });
-}
-
-export const interpolateSharableColor = (
-  value: number,
-  interpolateConfig: SharedValue<InterpolateConfig>
-): string | number => {
-  'worklet';
-  let colors = interpolateConfig.value.cache.value;
-  if (interpolateConfig.value.colorSpace === ColorSpace.RGB) {
-    if (!colors) {
-      colors = getInterpolateRGB(interpolateConfig.value.outputRange);
-      interpolateConfig.value.cache.value = colors;
-    }
-    return interpolateColorsRGB(
-      value,
-      interpolateConfig.value.inputRange,
-      colors as InterpolateRGB,
-      interpolateConfig.value.options
-    );
-  } else if (interpolateConfig.value.colorSpace === ColorSpace.HSV) {
-    if (!colors) {
-      colors = getInterpolateHSV(interpolateConfig.value.outputRange);
-      interpolateConfig.value.cache.value = colors;
-    }
-    return interpolateColorsHSV(
-      value,
-      interpolateConfig.value.inputRange,
-      colors as InterpolateHSV,
-      interpolateConfig.value.options
-    );
-  }
-  throw new Error(
-    `Invalid color space provided: ${interpolateConfig.value.colorSpace}. Supported values are: ['RGB', 'HSV']`
-  );
-};