react-native-worklets 0.0.1-alpha → 0.1.0

package/Easing.js

@@ -1,236 +0,0 @@
-let ease;
-
-/**
- * The `Easing` module implements common easing functions. This module is used
- * by [Animate.timing()](docs/animate.html#timing) to convey physically
- * believable motion in animations.
- *
- * You can find a visualization of some common easing functions at
- * http://easings.net/
- *
- * ### Predefined animations
- *
- * The `Easing` module provides several predefined animations through the
- * following methods:
- *
- * - [`back`](docs/easing.html#back) provides a simple animation where the
- *   object goes slightly back before moving forward
- * - [`bounce`](docs/easing.html#bounce) provides a bouncing animation
- * - [`ease`](docs/easing.html#ease) provides a simple inertial animation
- * - [`elastic`](docs/easing.html#elastic) provides a simple spring interaction
- *
- * ### Standard functions
- *
- * Three standard easing functions are provided:
- *
- * - [`linear`](docs/easing.html#linear)
- * - [`quad`](docs/easing.html#quad)
- * - [`cubic`](docs/easing.html#cubic)
- *
- * The [`poly`](docs/easing.html#poly) function can be used to implement
- * quartic, quintic, and other higher power functions.
- *
- * ### Additional functions
- *
- * Additional mathematical functions are provided by the following methods:
- *
- * - [`bezier`](docs/easing.html#bezier) provides a cubic bezier curve
- * - [`circle`](docs/easing.html#circle) provides a circular function
- * - [`sin`](docs/easing.html#sin) provides a sinusoidal function
- * - [`exp`](docs/easing.html#exp) provides an exponential function
- *
- * The following helpers are used to modify other easing functions.
- *
- * - [`in`](docs/easing.html#in) runs an easing function forwards
- * - [`inOut`](docs/easing.html#inout) makes any easing function symmetrical
- * - [`out`](docs/easing.html#out) runs an easing function backwards
- */
-export default class Easing {
-  /**
-   * A stepping function, returns 1 for any positive value of `n`.
-   */
-  static step0(n) {
-    return n > 0 ? 1 : 0;
-  }
-
-  /**
-   * A stepping function, returns 1 if `n` is greater than or equal to 1.
-   */
-  static step1(n) {
-    return n >= 1 ? 1 : 0;
-  }
-
-  /**
-   * A linear function, `f(t) = t`. Position correlates to elapsed time one to
-   * one.
-   *
-   * http://cubic-bezier.com/#0,0,1,1
-   */
-  static linear(t) {
-    return t;
-  }
-
-  /**
-   * A simple inertial interaction, similar to an object slowly accelerating to
-   * speed.
-   *
-   * http://cubic-bezier.com/#.42,0,1,1
-   */
-  static ease(t) {
-    if (!ease) {
-      ease = Easing.bezier(0.42, 0, 1, 1);
-    }
-    return ease(t);
-  }
-
-  /**
-   * A quadratic function, `f(t) = t * t`. Position equals the square of elapsed
-   * time.
-   *
-   * http://easings.net/#easeInQuad
-   */
-  static quad(t) {
-    return t * t;
-  }
-
-  /**
-   * A cubic function, `f(t) = t * t * t`. Position equals the cube of elapsed
-   * time.
-   *
-   * http://easings.net/#easeInCubic
-   */
-  static cubic(t) {
-    return t * t * t;
-  }
-
-  /**
-   * A power function. Position is equal to the Nth power of elapsed time.
-   *
-   * n = 4: http://easings.net/#easeInQuart
-   * n = 5: http://easings.net/#easeInQuint
-   */
-  static poly(n) {
-    return t => Math.pow(t, n);
-  }
-
-  /**
-   * A sinusoidal function.
-   *
-   * http://easings.net/#easeInSine
-   */
-  static sin(t) {
-    return 1 - Math.cos(t * Math.PI / 2);
-  }
-
-  /**
-   * A circular function.
-   *
-   * http://easings.net/#easeInCirc
-   */
-  static circle(t) {
-    return 1 - Math.sqrt(1 - t * t);
-  }
-
-  /**
-   * An exponential function.
-   *
-   * http://easings.net/#easeInExpo
-   */
-  static exp(t) {
-    return Math.pow(2, 10 * (t - 1));
-  }
-
-  /**
-   * A simple elastic interaction, similar to a spring oscillating back and
-   * forth.
-   *
-   * Default bounciness is 1, which overshoots a little bit once. 0 bounciness
-   * doesn't overshoot at all, and bounciness of N > 1 will overshoot about N
-   * times.
-   *
-   * http://easings.net/#easeInElastic
-   */
-  static elastic(bounciness = 1) {
-    const p = bounciness * Math.PI;
-    return t => 1 - Math.pow(Math.cos(t * Math.PI / 2), 3) * Math.cos(t * p);
-  }
-
-  /**
-   * Use with `Animated.parallel()` to create a simple effect where the object
-   * animates back slightly as the animation starts.
-   *
-   * Wolfram Plot:
-   *
-   * - http://tiny.cc/back_default (s = 1.70158, default)
-   */
-  static back(s) {
-    if (s === undefined) {
-      s = 1.70158;
-    }
-    return t => t * t * ((s + 1) * t - s);
-  }
-
-  /**
-   * Provides a simple bouncing effect.
-   *
-   * http://easings.net/#easeInBounce
-   */
-  static bounce(t) {
-    if (t < 1 / 2.75) {
-      return 7.5625 * t * t;
-    }
-
-    if (t < 2 / 2.75) {
-      t -= 1.5 / 2.75;
-      return 7.5625 * t * t + 0.75;
-    }
-
-    if (t < 2.5 / 2.75) {
-      t -= 2.25 / 2.75;
-      return 7.5625 * t * t + 0.9375;
-    }
-
-    t -= 2.625 / 2.75;
-    return 7.5625 * t * t + 0.984375;
-  }
-
-  /**
-   * Provides a cubic bezier curve, equivalent to CSS Transitions'
-   * `transition-timing-function`.
-   *
-   * A useful tool to visualize cubic bezier curves can be found at
-   * http://cubic-bezier.com/
-   */
-  static bezier(x1, y1, x2, y2) {
-    const _bezier = require('bezier');
-    return _bezier(x1, y1, x2, y2);
-  }
-
-  /**
-   * Runs an easing function forwards.
-   */
-  static in(easing) {
-    return easing;
-  }
-
-  /**
-   * Runs an easing function backwards.
-   */
-  static out(easing) {
-    return t => 1 - easing(1 - t);
-  }
-
-  /**
-   * Makes any easing function symmetrical. The easing function will run
-   * forwards for half of the duration, then backwards for the rest of the
-   * duration.
-   */
-  static inOut(easing) {
-    return t => {
-      if (t < 0.5) {
-        return easing(t * 2) / 2;
-      }
-      return 1 - easing((1 - t) * 2) / 2;
-    };
-  }
-}

package/NativeAnimatedHelper.js

@@ -1,226 +0,0 @@
-const NativeAnimatedModule = require('NativeModules').NativeAnimatedModule;
-const NativeEventEmitter = require('NativeEventEmitter');
-
-const invariant = require('fbjs/lib/invariant');
-
-let __nativeAnimatedNodeTagCount = 1; /* used for animated nodes */
-let __nativeAnimationIdCount = 1; /* used for started animations */
-
-let nativeEventEmitter;
-
-/**
- * Simple wrappers around NativeAnimatedModule to provide flow and autocmplete support for
- * the native module methods
- */
-const API = {
-  createAnimatedNode: function(tag, config) {
-    assertNativeAnimatedModule();
-    NativeAnimatedModule.createAnimatedNode(tag, config);
-  },
-  startListeningToAnimatedNodeValue: function(tag) {
-    assertNativeAnimatedModule();
-    NativeAnimatedModule.startListeningToAnimatedNodeValue(tag);
-  },
-  stopListeningToAnimatedNodeValue: function(tag) {
-    assertNativeAnimatedModule();
-    NativeAnimatedModule.stopListeningToAnimatedNodeValue(tag);
-  },
-  connectAnimatedNodes: function(parentTag, childTag) {
-    assertNativeAnimatedModule();
-    NativeAnimatedModule.connectAnimatedNodes(parentTag, childTag);
-  },
-  disconnectAnimatedNodes: function(parentTag, childTag) {
-    assertNativeAnimatedModule();
-    NativeAnimatedModule.disconnectAnimatedNodes(parentTag, childTag);
-  },
-  startAnimatingNode: function(animationId, nodeTag, config, endCallback) {
-    assertNativeAnimatedModule();
-    NativeAnimatedModule.startAnimatingNode(
-      animationId,
-      nodeTag,
-      config,
-      endCallback
-    );
-  },
-  stopAnimation: function(animationId) {
-    assertNativeAnimatedModule();
-    NativeAnimatedModule.stopAnimation(animationId);
-  },
-  setAnimatedNodeValue: function(nodeTag, value) {
-    assertNativeAnimatedModule();
-    NativeAnimatedModule.setAnimatedNodeValue(nodeTag, value);
-  },
-  setAnimatedNodeOffset: function(nodeTag, offset) {
-    assertNativeAnimatedModule();
-    NativeAnimatedModule.setAnimatedNodeOffset(nodeTag, offset);
-  },
-  flattenAnimatedNodeOffset: function(nodeTag) {
-    assertNativeAnimatedModule();
-    NativeAnimatedModule.flattenAnimatedNodeOffset(nodeTag);
-  },
-  extractAnimatedNodeOffset: function(nodeTag) {
-    assertNativeAnimatedModule();
-    NativeAnimatedModule.extractAnimatedNodeOffset(nodeTag);
-  },
-  connectAnimatedNodeToView: function(nodeTag, viewTag) {
-    assertNativeAnimatedModule();
-    NativeAnimatedModule.connectAnimatedNodeToView(nodeTag, viewTag);
-  },
-  disconnectAnimatedNodeFromView: function(nodeTag, viewTag) {
-    assertNativeAnimatedModule();
-    NativeAnimatedModule.disconnectAnimatedNodeFromView(nodeTag, viewTag);
-  },
-  dropAnimatedNode: function(tag) {
-    assertNativeAnimatedModule();
-    NativeAnimatedModule.dropAnimatedNode(tag);
-  },
-  addAnimatedEventToView: function(viewTag, eventName, eventMapping) {
-    assertNativeAnimatedModule();
-    NativeAnimatedModule.addAnimatedEventToView(
-      viewTag,
-      eventName,
-      eventMapping
-    );
-  },
-  removeAnimatedEventFromView(viewTag, eventName, animatedNodeTag) {
-    assertNativeAnimatedModule();
-    NativeAnimatedModule.removeAnimatedEventFromView(
-      viewTag,
-      eventName,
-      animatedNodeTag
-    );
-  },
-};
-
-/**
- * Styles allowed by the native animated implementation.
- *
- * In general native animated implementation should support any numeric property that doesn't need
- * to be updated through the shadow view hierarchy (all non-layout properties).
- */
-const STYLES_WHITELIST = {
-  opacity: true,
-  transform: true,
-  /* ios styles */
-  shadowOpacity: true,
-  shadowRadius: true,
-  /* legacy android transform properties */
-  scaleX: true,
-  scaleY: true,
-  translateX: true,
-  translateY: true,
-};
-
-const TRANSFORM_WHITELIST = {
-  translateX: true,
-  translateY: true,
-  scale: true,
-  scaleX: true,
-  scaleY: true,
-  rotate: true,
-  rotateX: true,
-  rotateY: true,
-  perspective: true,
-};
-
-const SUPPORTED_INTERPOLATION_PARAMS = {
-  inputRange: true,
-  outputRange: true,
-  extrapolate: true,
-  extrapolateRight: true,
-  extrapolateLeft: true,
-};
-
-function addWhitelistedStyleProp(prop) {
-  STYLES_WHITELIST[prop] = true;
-}
-
-function addWhitelistedTransformProp(prop) {
-  TRANSFORM_WHITELIST[prop] = true;
-}
-
-function addWhitelistedInterpolationParam(param) {
-  SUPPORTED_INTERPOLATION_PARAMS[param] = true;
-}
-
-function validateTransform(configs) {
-  configs.forEach(config => {
-    if (!TRANSFORM_WHITELIST.hasOwnProperty(config.property)) {
-      throw new Error(
-        `Property '${config.property}' is not supported by native animated module`
-      );
-    }
-  });
-}
-
-function validateStyles(styles) {
-  for (var key in styles) {
-    if (!STYLES_WHITELIST.hasOwnProperty(key)) {
-      throw new Error(
-        `Style property '${key}' is not supported by native animated module`
-      );
-    }
-  }
-}
-
-function validateInterpolation(config) {
-  for (var key in config) {
-    if (!SUPPORTED_INTERPOLATION_PARAMS.hasOwnProperty(key)) {
-      throw new Error(
-        `Interpolation property '${key}' is not supported by native animated module`
-      );
-    }
-  }
-}
-
-function generateNewNodeTag() {
-  return __nativeAnimatedNodeTagCount++;
-}
-
-function generateNewAnimationId() {
-  return __nativeAnimationIdCount++;
-}
-
-function assertNativeAnimatedModule() {
-  invariant(NativeAnimatedModule, 'Native animated module is not available');
-}
-
-let _warnedMissingNativeAnimated = false;
-
-function shouldUseNativeDriver(config) {
-  if (config.useNativeDriver && !NativeAnimatedModule) {
-    if (!_warnedMissingNativeAnimated) {
-      console.warn(
-        'Animated: `useNativeDriver` is not supported because the native ' +
-          'animated module is missing. Falling back to JS-based animation. To ' +
-          'resolve this, add `RCTAnimation` module to this app, or remove ' +
-          '`useNativeDriver`. ' +
-          'More info: https://github.com/facebook/react-native/issues/11094#issuecomment-263240420'
-      );
-      _warnedMissingNativeAnimated = true;
-    }
-    return false;
-  }
-
-  return config.useNativeDriver || false;
-}
-
-module.exports = {
-  API,
-  addWhitelistedStyleProp,
-  addWhitelistedTransformProp,
-  addWhitelistedInterpolationParam,
-  validateStyles,
-  validateTransform,
-  validateInterpolation,
-  generateNewNodeTag,
-  generateNewAnimationId,
-  assertNativeAnimatedModule,
-  shouldUseNativeDriver,
-  get nativeEventEmitter() {
-    if (!nativeEventEmitter) {
-      nativeEventEmitter = new NativeEventEmitter(NativeAnimatedModule);
-    }
-    return nativeEventEmitter;
-  },
-};

package/SpringConfig.js

@@ -1,79 +0,0 @@
-function stiffnessFromOrigamiValue(oValue) {
-  return (oValue - 30) * 3.62 + 194;
-}
-
-function dampingFromOrigamiValue(oValue) {
-  return (oValue - 8) * 3 + 25;
-}
-
-function fromOrigamiTensionAndFriction(tension, friction) {
-  return {
-    stiffness: stiffnessFromOrigamiValue(tension),
-    damping: dampingFromOrigamiValue(friction),
-  };
-}
-
-function fromBouncinessAndSpeed(bounciness, speed) {
-  function normalize(value, startValue, endValue) {
-    return (value - startValue) / (endValue - startValue);
-  }
-
-  function projectNormal(n, start, end) {
-    return start + n * (end - start);
-  }
-
-  function linearInterpolation(t, start, end) {
-    return t * end + (1 - t) * start;
-  }
-
-  function quadraticOutInterpolation(t, start, end) {
-    return linearInterpolation(2 * t - t * t, start, end);
-  }
-
-  function b3Friction1(x) {
-    return 0.0007 * Math.pow(x, 3) - 0.031 * Math.pow(x, 2) + 0.64 * x + 1.28;
-  }
-
-  function b3Friction2(x) {
-    return 0.000044 * Math.pow(x, 3) - 0.006 * Math.pow(x, 2) + 0.36 * x + 2;
-  }
-
-  function b3Friction3(x) {
-    return (
-      0.00000045 * Math.pow(x, 3) -
-      0.000332 * Math.pow(x, 2) +
-      0.1078 * x +
-      5.84
-    );
-  }
-
-  function b3Nobounce(tension) {
-    if (tension <= 18) {
-      return b3Friction1(tension);
-    } else if (tension > 18 && tension <= 44) {
-      return b3Friction2(tension);
-    } else {
-      return b3Friction3(tension);
-    }
-  }
-
-  var b = normalize(bounciness / 1.7, 0, 20);
-  b = projectNormal(b, 0, 0.8);
-  var s = normalize(speed / 1.7, 0, 20);
-  var bouncyTension = projectNormal(s, 0.5, 200);
-  var bouncyFriction = quadraticOutInterpolation(
-    b,
-    b3Nobounce(bouncyTension),
-    0.01
-  );
-
-  return {
-    stiffness: stiffnessFromOrigamiValue(bouncyTension),
-    damping: dampingFromOrigamiValue(bouncyFriction),
-  };
-}
-
-module.exports = {
-  fromOrigamiTensionAndFriction,
-  fromBouncinessAndSpeed,
-};

package/animations/Animation.js

@@ -1,36 +0,0 @@
-import NativeAnimatedHelper from 'NativeAnimatedHelper';
-
-// Important note: start() and stop() will only be called at most once.
-// Once an animation has been stopped or finished its course, it will
-// not be reused.
-class Animation {
-  start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {}
-  stop() {
-    if (this.__nativeId) {
-      NativeAnimatedHelper.API.stopAnimation(this.__nativeId);
-    }
-  }
-  __getNativeAnimationConfig() {
-    // Subclasses that have corresponding animation implementation done in native
-    // should override this method
-    throw new Error('This animation type cannot be offloaded to native');
-  }
-  // Helper function for subclasses to make sure onEnd is only called once.
-  __debouncedOnEnd(result) {
-    const onEnd = this.__onEnd;
-    this.__onEnd = null;
-    onEnd && onEnd(result);
-  }
-  __startNativeAnimation(animatedValue) {
-    animatedValue.__makeNative();
-    this.__nativeId = NativeAnimatedHelper.generateNewAnimationId();
-    NativeAnimatedHelper.API.startAnimatingNode(
-      this.__nativeId,
-      animatedValue.__getNativeTag(),
-      this.__getNativeAnimationConfig(),
-      this.__debouncedOnEnd.bind(this)
-    );
-  }
-}
-
-export default Animation;

package/animations/DecayAnimation.js

@@ -1,70 +0,0 @@
-import Animation from './Animation';
-
-import { shouldUseNativeDriver } from '../NativeAnimatedHelper';
-
-class DecayAnimation extends Animation {
-  constructor(config) {
-    super();
-    this._deceleration =
-      config.deceleration !== undefined ? config.deceleration : 0.998;
-    this._velocity = config.velocity;
-    this._useNativeDriver = shouldUseNativeDriver(config);
-    this.__isInteraction =
-      config.isInteraction !== undefined ? config.isInteraction : true;
-    this.__iterations = config.iterations !== undefined ? config.iterations : 1;
-  }
-
-  __getNativeAnimationConfig() {
-    return {
-      type: 'decay',
-      deceleration: this._deceleration,
-      velocity: this._velocity,
-      iterations: this.__iterations,
-    };
-  }
-
-  start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
-    this.__active = true;
-    this._lastValue = fromValue;
-    this._fromValue = fromValue;
-    this._onUpdate = onUpdate;
-    this.__onEnd = onEnd;
-    this._startTime = Date.now();
-    if (this._useNativeDriver) {
-      this.__startNativeAnimation(animatedValue);
-    } else {
-      this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
-    }
-  }
-
-  onUpdate() {
-    const now = Date.now();
-
-    const value =
-      this._fromValue +
-      this._velocity /
-        (1 - this._deceleration) *
-        (1 - Math.exp(-(1 - this._deceleration) * (now - this._startTime)));
-
-    this._onUpdate(value);
-
-    if (Math.abs(this._lastValue - value) < 0.1) {
-      this.__debouncedOnEnd({ finished: true });
-      return;
-    }
-
-    this._lastValue = value;
-    if (this.__active) {
-      this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
-    }
-  }
-
-  stop() {
-    super.stop();
-    this.__active = false;
-    global.cancelAnimationFrame(this._animationFrame);
-    this.__debouncedOnEnd({ finished: false });
-  }
-}
-
-export default DecayAnimation;