react-native-reanimated 2.9.1 → 3.0.0-rc.2

package/lib/reanimated1/core/AnimatedCall.js

@@ -1,55 +0,0 @@
-import invariant from 'invariant';
-import ReanimatedEventEmitter from '../../ReanimatedEventEmitter';
-import { val } from '../val';
-import AnimatedNode from './AnimatedNode';
-
-const NODE_MAPPING = new Map();
-
-function listener(data) {
-  const node = NODE_MAPPING.get(data.id);
-  node && node._callback(data.args);
-}
-
-class AnimatedCall extends AnimatedNode {
-  _callback;
-  _args;
-
-  constructor(args, jsFunction) {
-    invariant(
-      args.every((el) => el instanceof AnimatedNode),
-      `Reanimated: Animated.call node args should be an array with elements of type AnimatedNode. One or more of them are not AnimatedNodes`
-    );
-    super({ type: 'call', input: args }, args);
-    this._callback = jsFunction;
-    this._args = args;
-  }
-
-  toString() {
-    return `AnimatedCall, id: ${this.__nodeID}`;
-  }
-
-  __attach() {
-    super.__attach();
-    NODE_MAPPING.set(this.__nodeID, this);
-    if (NODE_MAPPING.size === 1) {
-      ReanimatedEventEmitter.addListener('onReanimatedCall', listener);
-    }
-  }
-
-  __detach() {
-    NODE_MAPPING.delete(this.__nodeID);
-    if (NODE_MAPPING.size === 0) {
-      ReanimatedEventEmitter.removeAllListeners('onReanimatedCall');
-    }
-    super.__detach();
-  }
-
-  __onEvaluate() {
-    this._callback(this._args.map(val));
-    return 0;
-  }
-}
-
-export function createAnimatedCall(args, func) {
-  return new AnimatedCall(args, func);
-}

package/lib/reanimated1/core/AnimatedCallFunc.js

@@ -1,72 +0,0 @@
-import AnimatedNode, { getCallID, setCallID } from './AnimatedNode';
-import { adapt } from './AnimatedBlock';
-import { val } from '../val';
-import invariant from 'invariant';
-
-class AnimatedCallFunc extends AnimatedNode {
-  _previousCallID;
-  _what;
-  _args;
-  _params;
-  constructor(what, args, params) {
-    invariant(
-      what instanceof AnimatedNode,
-      `Reanimated: AnimatedCallFunc 'what' argument should be of type AnimatedNode but got ${what}`
-    );
-    invariant(
-      args.every((el) => el instanceof AnimatedNode),
-      `Reanimated: every AnimatedCallFunc 'args' argument should be of type AnimatedNode but got ${args}`
-    );
-    invariant(
-      params.every((el) => el instanceof AnimatedNode),
-      `Reanimated: every AnimatedCallFunc 'params' argument should be of type AnimatedNode but got ${params}`
-    );
-    super(
-      {
-        type: 'callfunc',
-        what,
-        args,
-        params,
-      },
-      [...args]
-    );
-    this._what = what;
-    this._args = args;
-    this._params = params;
-  }
-
-  toString() {
-    return `AnimatedCallFunc, id: ${this.__nodeID}`;
-  }
-
-  beginContext() {
-    this._previousCallID = getCallID();
-    setCallID(getCallID() + '/' + this.__nodeID);
-
-    this._params.forEach((param, index) => {
-      param.beginContext(this._args[index], this._previousCallID);
-    });
-  }
-
-  endContext() {
-    this._params.forEach((param) => {
-      param.endContext();
-    });
-    setCallID(this._previousCallID);
-  }
-
-  __onEvaluate() {
-    this.beginContext();
-    const value = val(this._what);
-    this.endContext();
-    return value;
-  }
-}
-
-export function createAnimatedCallFunc(proc, args, params) {
-  return new AnimatedCallFunc(
-    proc,
-    args.map((p) => adapt(p)),
-    params
-  );
-}

package/lib/reanimated1/core/AnimatedClock.js

@@ -1,90 +0,0 @@
-import InternalAnimatedValue from './InternalAnimatedValue';
-import AnimatedNode from './AnimatedNode';
-import { val } from '../val';
-
-class AnimatedMainClock extends InternalAnimatedValue {
-  _frameCallback;
-
-  constructor() {
-    super({ type: 'MAIN_CLOCK' });
-  }
-
-  __onEvaluate() {
-    return +new Date();
-  }
-
-  _runFrame = () => {
-    this._updateValue(0);
-    if (this.__children.length > 0) {
-      this._frameCallback = requestAnimationFrame(this._runFrame);
-    }
-  };
-
-  __attach() {
-    super.__attach();
-    if (!this._frameCallback) {
-      this._frameCallback = requestAnimationFrame(this._runFrame);
-    }
-  }
-
-  __detach() {
-    if (this._frameCallback) {
-      cancelAnimationFrame(this._frameCallback);
-      this._frameCallback = null;
-    }
-    super.__detach();
-  }
-}
-
-const mainClock = new AnimatedMainClock();
-
-export default class AnimatedClock extends AnimatedNode {
-  _started;
-  _attached;
-
-  constructor() {
-    super({ type: 'clock' });
-  }
-
-  toString() {
-    return `AnimatedClock, id: ${this.__nodeID}`;
-  }
-
-  __onEvaluate() {
-    return val(mainClock);
-  }
-
-  __attach() {
-    super.__attach();
-    if (this._started && !this._attached) {
-      mainClock.__addChild(this);
-    }
-    this._attached = true;
-  }
-
-  __detach() {
-    if (this._started && this._attached) {
-      mainClock.__removeChild(this);
-    }
-    this._attached = false;
-    super.__detach();
-  }
-
-  start() {
-    if (!this._started && this._attached) {
-      mainClock.__addChild(this);
-    }
-    this._started = true;
-  }
-
-  stop() {
-    if (this._started && this._attached) {
-      mainClock.__removeChild(this);
-    }
-    this._started = false;
-  }
-
-  isStarted() {
-    return this._started;
-  }
-}

package/lib/reanimated1/core/AnimatedClockTest.js

@@ -1,22 +0,0 @@
-import AnimatedNode from './AnimatedNode';
-
-class AnimatedClockTest extends AnimatedNode {
-  _clockNode;
-
-  constructor(clockNode) {
-    super({ type: 'clockTest', clock: clockNode });
-    this._clockNode = clockNode;
-  }
-
-  toString() {
-    return `AnimatedClockTest, id: ${this.__nodeID}`;
-  }
-
-  __onEvaluate() {
-    return this._clockNode.isStarted() ? 1 : 0;
-  }
-}
-
-export function createAnimatedClockTest(clock) {
-  return new AnimatedClockTest(clock);
-}

package/lib/reanimated1/core/AnimatedCode.js

@@ -1,32 +0,0 @@
-import useCode from '../derived/useCode';
-import AnimatedNode from './AnimatedNode';
-
-function assertNodesNotNull(code, children, exec) {
-  if (!code) {
-    const error = !children
-      ? `Got "${typeof children}" type passed to children`
-      : `Got "${typeof exec}" type passed to exec`;
-
-    throw new Error(
-      `<Animated.Code /> expects the 'exec' prop or children to be an animated node or a function returning an animated node. ${error}`
-    );
-  }
-}
-
-function Code({ exec, children, dependencies }) {
-  const nodes = children || exec;
-
-  let code = null;
-  if (nodes instanceof AnimatedNode) {
-    code = () => nodes;
-  } else if (typeof nodes === 'function') {
-    code = nodes;
-  }
-
-  assertNodesNotNull(code, children, exec);
-
-  useCode(code, dependencies);
-  return null;
-}
-
-export default Code;

package/lib/reanimated1/core/AnimatedConcat.js

@@ -1,32 +0,0 @@
-import invariant from 'invariant';
-import { adapt } from '../core/AnimatedBlock';
-import AnimatedNode from './AnimatedNode';
-import { val } from '../val';
-
-class AnimatedConcat extends AnimatedNode {
-  constructor(input) {
-    invariant(
-      input.every(
-        (el) =>
-          el instanceof AnimatedNode ||
-          typeof el === 'number' ||
-          typeof el === 'string'
-      ),
-      `Reanimated: Animated.concat node arguments should be of type AnimatedNode or String or Number. One or more of them are not of that type. Node: ${input}`
-    );
-    super({ type: 'concat', input }, input);
-    this._input = input;
-  }
-
-  __onEvaluate() {
-    return this._input.reduce((prev, current) => prev + val(current), '');
-  }
-
-  toString() {
-    return `AnimatedConcat, id: ${this.__nodeID}`;
-  }
-}
-
-export function createAnimatedConcat(...args) {
-  return new AnimatedConcat(args.map(adapt));
-}

package/lib/reanimated1/core/AnimatedCond.js

@@ -1,57 +0,0 @@
-import invariant from 'invariant';
-import { adapt } from '../core/AnimatedBlock';
-import { val } from '../val';
-import AnimatedNode from './AnimatedNode';
-
-class AnimatedCond extends AnimatedNode {
-  _condition;
-  _ifBlock;
-  _elseBlock;
-
-  constructor(condition, ifBlock, elseBlock) {
-    invariant(
-      condition instanceof AnimatedNode,
-      `Reanimated: Animated.cond node first argument should be of type AnimatedNode but got ${condition}`
-    );
-    invariant(
-      ifBlock instanceof AnimatedNode,
-      `Reanimated: Animated.cond node second argument should be of type AnimatedNode but got ${ifBlock}`
-    );
-    invariant(
-      elseBlock instanceof AnimatedNode || elseBlock === undefined,
-      `Reanimated: Animated.cond node third argument should be of type AnimatedNode or should be undefined but got ${elseBlock}`
-    );
-    super(
-      {
-        type: 'cond',
-        cond: condition,
-        ifBlock,
-        elseBlock,
-      },
-      [condition, ifBlock, elseBlock]
-    );
-    this._condition = condition;
-    this._ifBlock = ifBlock;
-    this._elseBlock = elseBlock;
-  }
-
-  toString() {
-    return `AnimatedCond, id: ${this.__nodeID}`;
-  }
-
-  __onEvaluate() {
-    if (val(this._condition)) {
-      return val(this._ifBlock);
-    } else {
-      return this._elseBlock !== undefined ? val(this._elseBlock) : undefined;
-    }
-  }
-}
-
-export function createAnimatedCond(cond, ifBlock, elseBlock) {
-  return new AnimatedCond(
-    adapt(cond),
-    adapt(ifBlock),
-    elseBlock === undefined ? undefined : adapt(elseBlock)
-  );
-}

package/lib/reanimated1/core/AnimatedDebug.js

@@ -1,62 +0,0 @@
-import invariant from 'invariant';
-import { NativeModules } from 'react-native';
-import { val } from '../val';
-import { adapt, createAnimatedBlock as block } from './AnimatedBlock';
-import { createAnimatedCall as call } from './AnimatedCall';
-import AnimatedNode from './AnimatedNode';
-
-class AnimatedDebug extends AnimatedNode {
-  _message;
-  _value;
-
-  constructor(message, value) {
-    invariant(
-      typeof message === 'string',
-      `Reanimated: Animated.debug node first argument should be of type string but got ${message}`
-    );
-    invariant(
-      value instanceof AnimatedNode,
-      `Reanimated: Animated.debug node second argument should be of type AnimatedNode but got ${value}`
-    );
-    super({ type: 'debug', message, value }, [value]);
-    this._message = message;
-    this._value = value;
-  }
-
-  toString() {
-    return `AnimatedDebug, id: ${this.__nodeID}`;
-  }
-
-  __onEvaluate() {
-    const value = val(this._value);
-    console.log(this._message, value);
-    return value;
-  }
-}
-
-export function createAnimatedDebug(message, value) {
-  if (__DEV__) {
-    // hack to detect if app is running in remote debugger
-    // https://stackoverflow.com/questions/39022216
-    const runningInRemoteDebugger = typeof atob !== 'undefined';
-
-    // read the executionEnvironment off of expo-constants without explicitly
-    // depending on the package
-    const runningInExpoShell =
-      NativeModules.NativeUnimoduleProxy?.modulesConstants?.ExponentConstants
-        ?.executionEnvironment === 'storeClient';
-
-    if (runningInRemoteDebugger || runningInExpoShell) {
-      // When running in expo or remote debugger we use JS console.log to output variables
-      // otherwise we output to the native console using native debug node
-      return block([
-        call([value], ([a]) => console.log(`${message} ${a}`)),
-        value,
-      ]);
-    } else {
-      return new AnimatedDebug(message, adapt(value));
-    }
-  }
-  // Debugging is disabled in PROD
-  return value;
-}

package/lib/reanimated1/core/AnimatedEvent.js

@@ -1,126 +0,0 @@
-import { Platform, findNodeHandle } from 'react-native';
-import ReanimatedModule from '../../ReanimatedModule';
-
-import AnimatedNode from './AnimatedNode';
-import InternalAnimatedValue from './AnimatedValue';
-import { createAnimatedAlways } from './AnimatedAlways';
-
-import invariant from 'invariant';
-import createEventObjectProxyPolyfill from './createEventObjectProxyPolyfill';
-
-function sanitizeArgMapping(argMapping) {
-  // Find animated values in `argMapping` and create an array representing their
-  // key path inside the `nativeEvent` object. Ex.: ['contentOffset', 'x'].
-  const eventMappings = [];
-  const alwaysNodes = [];
-
-  const getNode = (node) => {
-    if (
-      Platform.OS === 'web' ||
-      Platform.OS === 'windows' ||
-      Platform.OS === 'macos'
-    ) {
-      return node;
-    }
-    return node.__nodeID;
-  };
-
-  const traverse = (value, path) => {
-    if (value instanceof InternalAnimatedValue) {
-      eventMappings.push(path.concat(getNode(value)));
-    } else if (typeof value === 'object' && value.__val) {
-      eventMappings.push(path.concat(getNode(value.__val)));
-    } else if (typeof value === 'function') {
-      const node = new InternalAnimatedValue(0);
-      alwaysNodes.push(createAnimatedAlways(value(node)));
-      eventMappings.push(path.concat(getNode(node)));
-    } else if (typeof value === 'object') {
-      for (const key in value) {
-        traverse(value[key], path.concat(key));
-      }
-    }
-  };
-
-  invariant(
-    argMapping[0] && argMapping[0].nativeEvent,
-    'Native driven events only support animated values contained inside `nativeEvent`.'
-  );
-
-  // Assume that the event containing `nativeEvent` is always the first argument.
-  const ev = argMapping[0].nativeEvent;
-  if (typeof ev === 'object') {
-    traverse(ev, []);
-  } else if (typeof ev === 'function') {
-    const proxyHandler = {
-      get: function (target, name) {
-        if (name === '__isProxy') {
-          return true;
-        }
-        if (!target[name] && name !== '__val') {
-          target[name] = new Proxy({}, proxyHandler);
-        }
-        return target[name];
-      },
-      set: function (target, prop, value) {
-        if (prop === '__val') {
-          target[prop] = value;
-          return true;
-        }
-        return false;
-      },
-    };
-
-    const proxy =
-      typeof Proxy === 'function'
-        ? new Proxy({}, proxyHandler)
-        : createEventObjectProxyPolyfill();
-    alwaysNodes.push(createAnimatedAlways(ev(proxy)));
-    traverse(proxy, []);
-  }
-
-  return { eventMappings, alwaysNodes };
-}
-
-export default class AnimatedEvent extends AnimatedNode {
-  constructor(argMapping, _config = {}) {
-    const { eventMappings, alwaysNodes } = sanitizeArgMapping(argMapping);
-    super({ type: 'event', argMapping: eventMappings });
-    this._alwaysNodes = alwaysNodes;
-  }
-
-  toString() {
-    return `AnimatedEvent, id: ${this.__nodeID}`;
-  }
-
-  // The below field is a temporary workaround to make AnimatedEvent object be recognized
-  // as Animated.event event callback and therefore filtered out from being send over the
-  // bridge which was causing the object to be frozen in JS.
-  __isNative = true;
-
-  attachEvent(viewRef, eventName) {
-    for (let i = 0; i < this._alwaysNodes.length; i++) {
-      this._alwaysNodes[i].__attach();
-    }
-    this.__attach();
-    const viewTag = findNodeHandle(viewRef);
-    ReanimatedModule.attachEvent(viewTag, eventName, this.__nodeID);
-  }
-
-  __onEvaluate() {
-    return 0;
-  }
-
-  detachEvent(viewRef, eventName) {
-    for (let i = 0; i < this._alwaysNodes.length; i++) {
-      this._alwaysNodes[i].isNativelyInitialized() &&
-        this._alwaysNodes[i].__detach();
-    }
-    const viewTag = findNodeHandle(viewRef);
-    ReanimatedModule.detachEvent(viewTag, eventName, this.__nodeID);
-    this.__detach();
-  }
-}
-
-export function createAnimatedEvent(argMapping, config) {
-  return new AnimatedEvent(argMapping, config);
-}

package/lib/reanimated1/core/AnimatedFunction.js

@@ -1,55 +0,0 @@
-import AnimatedNode from './AnimatedNode';
-import { createAnimatedCallFunc } from './AnimatedCallFunc';
-import { createAnimatedParam } from './AnimatedParam';
-import { val } from '../val';
-import invariant from 'invariant';
-
-class AnimatedFunction extends AnimatedNode {
-  _what;
-
-  constructor(what, ...params) {
-    invariant(
-      what instanceof AnimatedNode,
-      `Reanimated: AnimatedCallFunc 'what' argument should be of type AnimatedNode but got ${what}`
-    );
-    super(
-      {
-        type: 'func',
-        what,
-      },
-      [what, ...params]
-    );
-    this._what = what;
-    this.__attach();
-  }
-
-  __onEvaluate() {
-    return val(this._what);
-  }
-
-  toString() {
-    return `AnimatedFunction, id: ${this.__nodeID}`;
-  }
-}
-
-export function createAnimatedFunction(cb) {
-  const params = new Array(cb.length);
-  for (let i = 0; i < params.length; i++) {
-    params[i] = createAnimatedParam();
-  }
-  // eslint-disable-next-line node/no-callback-literal
-  const what = cb(...params);
-  const func = new AnimatedFunction(what, ...params);
-  return (...args) => {
-    if (args.length !== params.length) {
-      throw new Error(
-        'Parameter mismatch when calling reanimated function. Expected ' +
-          params.length +
-          ' parameters, got ' +
-          args.length +
-          '.'
-      );
-    }
-    return createAnimatedCallFunc(func, args, params);
-  };
-}