@hps1978/react-native-web-tv 0.21.2-tv.0

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedInterpolation.js

@@ -0,0 +1,269 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+
+/* eslint no-bitwise: 0 */
+
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _AnimatedWithChildren = _interopRequireDefault(require("./AnimatedWithChildren"));
+var _NativeAnimatedHelper = _interopRequireDefault(require("../NativeAnimatedHelper"));
+var _invariant = _interopRequireDefault(require("fbjs/lib/invariant"));
+var _normalizeColors = _interopRequireDefault(require("@react-native/normalize-colors"));
+var __DEV__ = process.env.NODE_ENV !== 'production';
+var linear = t => t;
+
+/**
+ * Very handy helper to map input ranges to output ranges with an easing
+ * function and custom behavior outside of the ranges.
+ */
+function createInterpolation(config) {
+  if (config.outputRange && typeof config.outputRange[0] === 'string') {
+    return createInterpolationFromStringOutputRange(config);
+  }
+  var outputRange = config.outputRange;
+  var inputRange = config.inputRange;
+  if (__DEV__) {
+    checkInfiniteRange('outputRange', outputRange);
+    checkInfiniteRange('inputRange', inputRange);
+    checkValidInputRange(inputRange);
+    (0, _invariant.default)(inputRange.length === outputRange.length, 'inputRange (' + inputRange.length + ') and outputRange (' + outputRange.length + ') must have the same length');
+  }
+  var easing = config.easing || linear;
+  var extrapolateLeft = 'extend';
+  if (config.extrapolateLeft !== undefined) {
+    extrapolateLeft = config.extrapolateLeft;
+  } else if (config.extrapolate !== undefined) {
+    extrapolateLeft = config.extrapolate;
+  }
+  var extrapolateRight = 'extend';
+  if (config.extrapolateRight !== undefined) {
+    extrapolateRight = config.extrapolateRight;
+  } else if (config.extrapolate !== undefined) {
+    extrapolateRight = config.extrapolate;
+  }
+  return input => {
+    (0, _invariant.default)(typeof input === 'number', 'Cannot interpolation an input which is not a number');
+    var range = findRange(input, inputRange);
+    return interpolate(input, inputRange[range], inputRange[range + 1], outputRange[range], outputRange[range + 1], easing, extrapolateLeft, extrapolateRight);
+  };
+}
+function interpolate(input, inputMin, inputMax, outputMin, outputMax, easing, extrapolateLeft, extrapolateRight) {
+  var result = input;
+
+  // Extrapolate
+  if (result < inputMin) {
+    if (extrapolateLeft === 'identity') {
+      return result;
+    } else if (extrapolateLeft === 'clamp') {
+      result = inputMin;
+    } else if (extrapolateLeft === 'extend') {
+      // noop
+    }
+  }
+  if (result > inputMax) {
+    if (extrapolateRight === 'identity') {
+      return result;
+    } else if (extrapolateRight === 'clamp') {
+      result = inputMax;
+    } else if (extrapolateRight === 'extend') {
+      // noop
+    }
+  }
+  if (outputMin === outputMax) {
+    return outputMin;
+  }
+  if (inputMin === inputMax) {
+    if (input <= inputMin) {
+      return outputMin;
+    }
+    return outputMax;
+  }
+
+  // Input Range
+  if (inputMin === -Infinity) {
+    result = -result;
+  } else if (inputMax === Infinity) {
+    result = result - inputMin;
+  } else {
+    result = (result - inputMin) / (inputMax - inputMin);
+  }
+
+  // Easing
+  result = easing(result);
+
+  // Output Range
+  if (outputMin === -Infinity) {
+    result = -result;
+  } else if (outputMax === Infinity) {
+    result = result + outputMin;
+  } else {
+    result = result * (outputMax - outputMin) + outputMin;
+  }
+  return result;
+}
+function colorToRgba(input) {
+  var normalizedColor = (0, _normalizeColors.default)(input);
+  if (normalizedColor === null || typeof normalizedColor !== 'number') {
+    return input;
+  }
+  normalizedColor = normalizedColor || 0;
+  var r = (normalizedColor & 0xff000000) >>> 24;
+  var g = (normalizedColor & 0x00ff0000) >>> 16;
+  var b = (normalizedColor & 0x0000ff00) >>> 8;
+  var a = (normalizedColor & 0x000000ff) / 255;
+  return "rgba(" + r + ", " + g + ", " + b + ", " + a + ")";
+}
+var stringShapeRegex = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g;
+
+/**
+ * Supports string shapes by extracting numbers so new values can be computed,
+ * and recombines those values into new strings of the same shape.  Supports
+ * things like:
+ *
+ *   rgba(123, 42, 99, 0.36) // colors
+ *   -45deg                  // values with units
+ */
+function createInterpolationFromStringOutputRange(config) {
+  var outputRange = config.outputRange;
+  (0, _invariant.default)(outputRange.length >= 2, 'Bad output range');
+  outputRange = outputRange.map(colorToRgba);
+  checkPattern(outputRange);
+
+  // ['rgba(0, 100, 200, 0)', 'rgba(50, 150, 250, 0.5)']
+  // ->
+  // [
+  //   [0, 50],
+  //   [100, 150],
+  //   [200, 250],
+  //   [0, 0.5],
+  // ]
+  /* $FlowFixMe[incompatible-use] (>=0.18.0): `outputRange[0].match()` can
+   * return `null`. Need to guard against this possibility. */
+  var outputRanges = outputRange[0].match(stringShapeRegex).map(() => []);
+  outputRange.forEach(value => {
+    /* $FlowFixMe[incompatible-use] (>=0.18.0): `value.match()` can return
+     * `null`. Need to guard against this possibility. */
+    value.match(stringShapeRegex).forEach((number, i) => {
+      outputRanges[i].push(+number);
+    });
+  });
+  var interpolations = outputRange[0].match(stringShapeRegex)
+  /* $FlowFixMe[incompatible-use] (>=0.18.0): `outputRange[0].match()` can
+   * return `null`. Need to guard against this possibility. */
+  /* $FlowFixMe[incompatible-call] (>=0.18.0): `outputRange[0].match()` can
+   * return `null`. Need to guard against this possibility. */.map((value, i) => {
+    return createInterpolation((0, _objectSpread2.default)((0, _objectSpread2.default)({}, config), {}, {
+      outputRange: outputRanges[i]
+    }));
+  });
+
+  // rgba requires that the r,g,b are integers.... so we want to round them, but we *dont* want to
+  // round the opacity (4th column).
+  var shouldRound = isRgbOrRgba(outputRange[0]);
+  return input => {
+    var i = 0;
+    // 'rgba(0, 100, 200, 0)'
+    // ->
+    // 'rgba(${interpolations[0](input)}, ${interpolations[1](input)}, ...'
+    return outputRange[0].replace(stringShapeRegex, () => {
+      var val = +interpolations[i++](input);
+      if (shouldRound) {
+        val = i < 4 ? Math.round(val) : Math.round(val * 1000) / 1000;
+      }
+      return String(val);
+    });
+  };
+}
+function isRgbOrRgba(range) {
+  return typeof range === 'string' && range.startsWith('rgb');
+}
+function checkPattern(arr) {
+  var pattern = arr[0].replace(stringShapeRegex, '');
+  for (var i = 1; i < arr.length; ++i) {
+    (0, _invariant.default)(pattern === arr[i].replace(stringShapeRegex, ''), 'invalid pattern ' + arr[0] + ' and ' + arr[i]);
+  }
+}
+function findRange(input, inputRange) {
+  var i;
+  for (i = 1; i < inputRange.length - 1; ++i) {
+    if (inputRange[i] >= input) {
+      break;
+    }
+  }
+  return i - 1;
+}
+function checkValidInputRange(arr) {
+  (0, _invariant.default)(arr.length >= 2, 'inputRange must have at least 2 elements');
+  var message = 'inputRange must be monotonically non-decreasing ' + String(arr);
+  for (var i = 1; i < arr.length; ++i) {
+    (0, _invariant.default)(arr[i] >= arr[i - 1], message);
+  }
+}
+function checkInfiniteRange(name, arr) {
+  (0, _invariant.default)(arr.length >= 2, name + ' must have at least 2 elements');
+  (0, _invariant.default)(arr.length !== 2 || arr[0] !== -Infinity || arr[1] !== Infinity,
+  /* $FlowFixMe[incompatible-type] (>=0.13.0) - In the addition expression
+   * below this comment, one or both of the operands may be something that
+   * doesn't cleanly convert to a string, like undefined, null, and object,
+   * etc. If you really mean this implicit string conversion, you can do
+   * something like String(myThing) */
+  name + 'cannot be ]-infinity;+infinity[ ' + arr);
+}
+class AnimatedInterpolation extends _AnimatedWithChildren.default {
+  constructor(parent, config) {
+    super();
+    this._parent = parent;
+    this._config = config;
+    this._interpolation = createInterpolation(config);
+  }
+  __makeNative(platformConfig) {
+    this._parent.__makeNative(platformConfig);
+    super.__makeNative(platformConfig);
+  }
+  __getValue() {
+    var parentValue = this._parent.__getValue();
+    (0, _invariant.default)(typeof parentValue === 'number', 'Cannot interpolate an input which is not a number.');
+    return this._interpolation(parentValue);
+  }
+  interpolate(config) {
+    return new AnimatedInterpolation(this, config);
+  }
+  __attach() {
+    this._parent.__addChild(this);
+  }
+  __detach() {
+    this._parent.__removeChild(this);
+    super.__detach();
+  }
+  __transformDataType(range) {
+    return range.map(_NativeAnimatedHelper.default.transformDataType);
+  }
+  __getNativeConfig() {
+    if (__DEV__) {
+      _NativeAnimatedHelper.default.validateInterpolation(this._config);
+    }
+    return {
+      inputRange: this._config.inputRange,
+      // Only the `outputRange` can contain strings so we don't need to transform `inputRange` here
+      outputRange: this.__transformDataType(this._config.outputRange),
+      extrapolateLeft: this._config.extrapolateLeft || this._config.extrapolate || 'extend',
+      extrapolateRight: this._config.extrapolateRight || this._config.extrapolate || 'extend',
+      type: 'interpolation'
+    };
+  }
+}
+// Export for testing.
+AnimatedInterpolation.__createInterpolation = createInterpolation;
+var _default = exports.default = AnimatedInterpolation;
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedModulo.js

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _AnimatedInterpolation = _interopRequireDefault(require("./AnimatedInterpolation"));
+var _AnimatedWithChildren = _interopRequireDefault(require("./AnimatedWithChildren"));
+class AnimatedModulo extends _AnimatedWithChildren.default {
+  constructor(a, modulus) {
+    super();
+    this._a = a;
+    this._modulus = modulus;
+  }
+  __makeNative(platformConfig) {
+    this._a.__makeNative(platformConfig);
+    super.__makeNative(platformConfig);
+  }
+  __getValue() {
+    return (this._a.__getValue() % this._modulus + this._modulus) % this._modulus;
+  }
+  interpolate(config) {
+    return new _AnimatedInterpolation.default(this, config);
+  }
+  __attach() {
+    this._a.__addChild(this);
+  }
+  __detach() {
+    this._a.__removeChild(this);
+    super.__detach();
+  }
+  __getNativeConfig() {
+    return {
+      type: 'modulus',
+      input: this._a.__getNativeTag(),
+      modulus: this._modulus
+    };
+  }
+}
+var _default = exports.default = AnimatedModulo;
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedMultiplication.js

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _AnimatedInterpolation = _interopRequireDefault(require("./AnimatedInterpolation"));
+var _AnimatedValue = _interopRequireDefault(require("./AnimatedValue"));
+var _AnimatedWithChildren = _interopRequireDefault(require("./AnimatedWithChildren"));
+class AnimatedMultiplication extends _AnimatedWithChildren.default {
+  constructor(a, b) {
+    super();
+    this._a = typeof a === 'number' ? new _AnimatedValue.default(a) : a;
+    this._b = typeof b === 'number' ? new _AnimatedValue.default(b) : b;
+  }
+  __makeNative(platformConfig) {
+    this._a.__makeNative(platformConfig);
+    this._b.__makeNative(platformConfig);
+    super.__makeNative(platformConfig);
+  }
+  __getValue() {
+    return this._a.__getValue() * this._b.__getValue();
+  }
+  interpolate(config) {
+    return new _AnimatedInterpolation.default(this, config);
+  }
+  __attach() {
+    this._a.__addChild(this);
+    this._b.__addChild(this);
+  }
+  __detach() {
+    this._a.__removeChild(this);
+    this._b.__removeChild(this);
+    super.__detach();
+  }
+  __getNativeConfig() {
+    return {
+      type: 'multiplication',
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+    };
+  }
+}
+var _default = exports.default = AnimatedMultiplication;
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedNode.js

@@ -0,0 +1,163 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _NativeAnimatedHelper = _interopRequireDefault(require("../NativeAnimatedHelper"));
+var _invariant = _interopRequireDefault(require("fbjs/lib/invariant"));
+var NativeAnimatedAPI = _NativeAnimatedHelper.default.API;
+var _uniqueId = 1;
+
+// Note(vjeux): this would be better as an interface but flow doesn't
+// support them yet
+class AnimatedNode {
+  __attach() {}
+  __detach() {
+    if (this.__isNative && this.__nativeTag != null) {
+      _NativeAnimatedHelper.default.API.dropAnimatedNode(this.__nativeTag);
+      this.__nativeTag = undefined;
+    }
+  }
+  __getValue() {}
+  __getAnimatedValue() {
+    return this.__getValue();
+  }
+  __addChild(child) {}
+  __removeChild(child) {}
+  __getChildren() {
+    return [];
+  }
+
+  /* Methods and props used by native Animated impl */
+
+  constructor() {
+    this._listeners = {};
+  }
+  __makeNative(platformConfig) {
+    if (!this.__isNative) {
+      throw new Error('This node cannot be made a "native" animated node');
+    }
+    this._platformConfig = platformConfig;
+    if (this.hasListeners()) {
+      this._startListeningToNativeValueUpdates();
+    }
+  }
+
+  /**
+   * Adds an asynchronous listener to the value so you can observe updates from
+   * animations.  This is useful because there is no way to
+   * synchronously read the value because it might be driven natively.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#addlistener
+   */
+  addListener(callback) {
+    var id = String(_uniqueId++);
+    this._listeners[id] = callback;
+    if (this.__isNative) {
+      this._startListeningToNativeValueUpdates();
+    }
+    return id;
+  }
+
+  /**
+   * Unregister a listener. The `id` param shall match the identifier
+   * previously returned by `addListener()`.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#removelistener
+   */
+  removeListener(id) {
+    delete this._listeners[id];
+    if (this.__isNative && !this.hasListeners()) {
+      this._stopListeningForNativeValueUpdates();
+    }
+  }
+
+  /**
+   * Remove all registered listeners.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#removealllisteners
+   */
+  removeAllListeners() {
+    this._listeners = {};
+    if (this.__isNative) {
+      this._stopListeningForNativeValueUpdates();
+    }
+  }
+  hasListeners() {
+    return !!Object.keys(this._listeners).length;
+  }
+  _startListeningToNativeValueUpdates() {
+    if (this.__nativeAnimatedValueListener && !this.__shouldUpdateListenersForNewNativeTag) {
+      return;
+    }
+    if (this.__shouldUpdateListenersForNewNativeTag) {
+      this.__shouldUpdateListenersForNewNativeTag = false;
+      this._stopListeningForNativeValueUpdates();
+    }
+    NativeAnimatedAPI.startListeningToAnimatedNodeValue(this.__getNativeTag());
+    this.__nativeAnimatedValueListener = _NativeAnimatedHelper.default.nativeEventEmitter.addListener('onAnimatedValueUpdate', data => {
+      if (data.tag !== this.__getNativeTag()) {
+        return;
+      }
+      this.__onAnimatedValueUpdateReceived(data.value);
+    });
+  }
+  __onAnimatedValueUpdateReceived(value) {
+    this.__callListeners(value);
+  }
+  __callListeners(value) {
+    for (var _key in this._listeners) {
+      this._listeners[_key]({
+        value
+      });
+    }
+  }
+  _stopListeningForNativeValueUpdates() {
+    if (!this.__nativeAnimatedValueListener) {
+      return;
+    }
+    this.__nativeAnimatedValueListener.remove();
+    this.__nativeAnimatedValueListener = null;
+    NativeAnimatedAPI.stopListeningToAnimatedNodeValue(this.__getNativeTag());
+  }
+  __getNativeTag() {
+    var _this$__nativeTag;
+    _NativeAnimatedHelper.default.assertNativeAnimatedModule();
+    (0, _invariant.default)(this.__isNative, 'Attempt to get native tag from node not marked as "native"');
+    var nativeTag = (_this$__nativeTag = this.__nativeTag) !== null && _this$__nativeTag !== void 0 ? _this$__nativeTag : _NativeAnimatedHelper.default.generateNewNodeTag();
+    if (this.__nativeTag == null) {
+      this.__nativeTag = nativeTag;
+      var config = this.__getNativeConfig();
+      if (this._platformConfig) {
+        config.platformConfig = this._platformConfig;
+      }
+      _NativeAnimatedHelper.default.API.createAnimatedNode(nativeTag, config);
+      this.__shouldUpdateListenersForNewNativeTag = true;
+    }
+    return nativeTag;
+  }
+  __getNativeConfig() {
+    throw new Error('This JS animated node type cannot be used as native animated node');
+  }
+  toJSON() {
+    return this.__getValue();
+  }
+  __getPlatformConfig() {
+    return this._platformConfig;
+  }
+  __setPlatformConfig(platformConfig) {
+    this._platformConfig = platformConfig;
+  }
+}
+var _default = exports.default = AnimatedNode;
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedProps.js

@@ -0,0 +1,145 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _AnimatedEvent = require("../AnimatedEvent");
+var _AnimatedNode = _interopRequireDefault(require("./AnimatedNode"));
+var _AnimatedStyle = _interopRequireDefault(require("./AnimatedStyle"));
+var _NativeAnimatedHelper = _interopRequireDefault(require("../NativeAnimatedHelper"));
+var _invariant = _interopRequireDefault(require("fbjs/lib/invariant"));
+class AnimatedProps extends _AnimatedNode.default {
+  constructor(props, callback) {
+    super();
+    if (props.style) {
+      props = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, props), {}, {
+        style: new _AnimatedStyle.default(props.style)
+      });
+    }
+    this._props = props;
+    this._callback = callback;
+  }
+  __getValue() {
+    var props = {};
+    for (var key in this._props) {
+      var value = this._props[key];
+      if (value instanceof _AnimatedNode.default) {
+        if (!value.__isNative || value instanceof _AnimatedStyle.default) {
+          // We cannot use value of natively driven nodes this way as the value we have access from
+          // JS may not be up to date.
+          props[key] = value.__getValue();
+        }
+      } else if (value instanceof _AnimatedEvent.AnimatedEvent) {
+        props[key] = value.__getHandler();
+      } else {
+        props[key] = value;
+      }
+    }
+    return props;
+  }
+  __getAnimatedValue() {
+    var props = {};
+    for (var key in this._props) {
+      var value = this._props[key];
+      if (value instanceof _AnimatedNode.default) {
+        props[key] = value.__getAnimatedValue();
+      }
+    }
+    return props;
+  }
+  __attach() {
+    for (var key in this._props) {
+      var value = this._props[key];
+      if (value instanceof _AnimatedNode.default) {
+        value.__addChild(this);
+      }
+    }
+  }
+  __detach() {
+    if (this.__isNative && this._animatedView) {
+      this.__disconnectAnimatedView();
+    }
+    this._animatedView = null;
+    for (var key in this._props) {
+      var value = this._props[key];
+      if (value instanceof _AnimatedNode.default) {
+        value.__removeChild(this);
+      }
+    }
+    super.__detach();
+  }
+  update() {
+    this._callback();
+  }
+  __makeNative() {
+    if (!this.__isNative) {
+      this.__isNative = true;
+      for (var key in this._props) {
+        var value = this._props[key];
+        if (value instanceof _AnimatedNode.default) {
+          value.__makeNative();
+        }
+      }
+      if (this._animatedView) {
+        this.__connectAnimatedView();
+      }
+    }
+  }
+  setNativeView(animatedView) {
+    if (this._animatedView === animatedView) {
+      return;
+    }
+    this._animatedView = animatedView;
+    if (this.__isNative) {
+      this.__connectAnimatedView();
+    }
+  }
+  __connectAnimatedView() {
+    (0, _invariant.default)(this.__isNative, 'Expected node to be marked as "native"');
+    var nativeViewTag = this._animatedView;
+    (0, _invariant.default)(nativeViewTag != null, 'Unable to locate attached view in the native tree');
+    _NativeAnimatedHelper.default.API.connectAnimatedNodeToView(this.__getNativeTag(), nativeViewTag);
+  }
+  __disconnectAnimatedView() {
+    (0, _invariant.default)(this.__isNative, 'Expected node to be marked as "native"');
+    var nativeViewTag = this._animatedView;
+    (0, _invariant.default)(nativeViewTag != null, 'Unable to locate attached view in the native tree');
+    _NativeAnimatedHelper.default.API.disconnectAnimatedNodeFromView(this.__getNativeTag(), nativeViewTag);
+  }
+  __restoreDefaultValues() {
+    // When using the native driver, view properties need to be restored to
+    // their default values manually since react no longer tracks them. This
+    // is needed to handle cases where a prop driven by native animated is removed
+    // after having been changed natively by an animation.
+    if (this.__isNative) {
+      _NativeAnimatedHelper.default.API.restoreDefaultValues(this.__getNativeTag());
+    }
+  }
+  __getNativeConfig() {
+    var propsConfig = {};
+    for (var propKey in this._props) {
+      var value = this._props[propKey];
+      if (value instanceof _AnimatedNode.default) {
+        value.__makeNative();
+        propsConfig[propKey] = value.__getNativeTag();
+      }
+    }
+    return {
+      type: 'props',
+      props: propsConfig
+    };
+  }
+}
+var _default = exports.default = AnimatedProps;
+module.exports = exports.default;