@depup/react-native-web 0.21.2-depup.0

package/dist/vendor/react-native/Animated/nodes/AnimatedTransform.js.flow

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+import AnimatedNode from './AnimatedNode';
+import AnimatedWithChildren from './AnimatedWithChildren';
+import NativeAnimatedHelper from '../NativeAnimatedHelper';
+declare class AnimatedTransform extends AnimatedWithChildren {
+  _transforms: $ReadOnlyArray<Object>,
+  constructor(transforms: $ReadOnlyArray<Object>): any,
+  __makeNative(): any,
+  __getValue(): $ReadOnlyArray<Object>,
+  __getAnimatedValue(): $ReadOnlyArray<Object>,
+  __attach(): void,
+  __detach(): void,
+  __getNativeConfig(): any,
+}
+export default AnimatedTransform;

package/dist/vendor/react-native/Animated/nodes/AnimatedValue.js

@@ -0,0 +1,267 @@
+/**
+ * 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';
+
+import AnimatedInterpolation from './AnimatedInterpolation';
+import AnimatedWithChildren from './AnimatedWithChildren';
+import InteractionManager from '../../../../exports/InteractionManager';
+import NativeAnimatedHelper from '../NativeAnimatedHelper';
+var NativeAnimatedAPI = NativeAnimatedHelper.API;
+
+/**
+ * Animated works by building a directed acyclic graph of dependencies
+ * transparently when you render your Animated components.
+ *
+ *               new Animated.Value(0)
+ *     .interpolate()        .interpolate()    new Animated.Value(1)
+ *         opacity               translateY      scale
+ *          style                         transform
+ *         View#234                         style
+ *                                         View#123
+ *
+ * A) Top Down phase
+ * When an Animated.Value is updated, we recursively go down through this
+ * graph in order to find leaf nodes: the views that we flag as needing
+ * an update.
+ *
+ * B) Bottom Up phase
+ * When a view is flagged as needing an update, we recursively go back up
+ * in order to build the new value that it needs. The reason why we need
+ * this two-phases process is to deal with composite props such as
+ * transform which can receive values from multiple parents.
+ */
+function _flush(rootNode) {
+  var animatedStyles = new Set();
+  function findAnimatedStyles(node) {
+    /* $FlowFixMe[prop-missing] (>=0.68.0 site=react_native_fb) This comment
+     * suppresses an error found when Flow v0.68 was deployed. To see the error
+     * delete this comment and run Flow. */
+    if (typeof node.update === 'function') {
+      animatedStyles.add(node);
+    } else {
+      node.__getChildren().forEach(findAnimatedStyles);
+    }
+  }
+  findAnimatedStyles(rootNode);
+  // $FlowFixMe[prop-missing]
+  animatedStyles.forEach(animatedStyle => animatedStyle.update());
+}
+
+/**
+ * Some operations are executed only on batch end, which is _mostly_ scheduled when
+ * Animated component props change. For some of the changes which require immediate execution
+ * (e.g. setValue), we create a separate batch in case none is scheduled.
+ */
+function _executeAsAnimatedBatch(id, operation) {
+  NativeAnimatedAPI.setWaitingForIdentifier(id);
+  operation();
+  NativeAnimatedAPI.unsetWaitingForIdentifier(id);
+}
+
+/**
+ * Standard value for driving animations.  One `Animated.Value` can drive
+ * multiple properties in a synchronized fashion, but can only be driven by one
+ * mechanism at a time.  Using a new mechanism (e.g. starting a new animation,
+ * or calling `setValue`) will stop any previous ones.
+ *
+ * See https://reactnative.dev/docs/animatedvalue
+ */
+class AnimatedValue extends AnimatedWithChildren {
+  constructor(value, config) {
+    super();
+    if (typeof value !== 'number') {
+      throw new Error('AnimatedValue: Attempting to set value to undefined');
+    }
+    this._startingValue = this._value = value;
+    this._offset = 0;
+    this._animation = null;
+    if (config && config.useNativeDriver) {
+      this.__makeNative();
+    }
+  }
+  __detach() {
+    if (this.__isNative) {
+      NativeAnimatedAPI.getValue(this.__getNativeTag(), value => {
+        this._value = value - this._offset;
+      });
+    }
+    this.stopAnimation();
+    super.__detach();
+  }
+  __getValue() {
+    return this._value + this._offset;
+  }
+
+  /**
+   * Directly set the value.  This will stop any animations running on the value
+   * and update all the bound properties.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#setvalue
+   */
+  setValue(value) {
+    if (this._animation) {
+      this._animation.stop();
+      this._animation = null;
+    }
+    this._updateValue(value, !this.__isNative /* don't perform a flush for natively driven values */);
+    if (this.__isNative) {
+      _executeAsAnimatedBatch(this.__getNativeTag().toString(), () => NativeAnimatedAPI.setAnimatedNodeValue(this.__getNativeTag(), value));
+    }
+  }
+
+  /**
+   * Sets an offset that is applied on top of whatever value is set, whether via
+   * `setValue`, an animation, or `Animated.event`.  Useful for compensating
+   * things like the start of a pan gesture.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#setoffset
+   */
+  setOffset(offset) {
+    this._offset = offset;
+    if (this.__isNative) {
+      NativeAnimatedAPI.setAnimatedNodeOffset(this.__getNativeTag(), offset);
+    }
+  }
+
+  /**
+   * Merges the offset value into the base value and resets the offset to zero.
+   * The final output of the value is unchanged.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#flattenoffset
+   */
+  flattenOffset() {
+    this._value += this._offset;
+    this._offset = 0;
+    if (this.__isNative) {
+      NativeAnimatedAPI.flattenAnimatedNodeOffset(this.__getNativeTag());
+    }
+  }
+
+  /**
+   * Sets the offset value to the base value, and resets the base value to zero.
+   * The final output of the value is unchanged.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#extractoffset
+   */
+  extractOffset() {
+    this._offset += this._value;
+    this._value = 0;
+    if (this.__isNative) {
+      NativeAnimatedAPI.extractAnimatedNodeOffset(this.__getNativeTag());
+    }
+  }
+
+  /**
+   * Stops any running animation or tracking. `callback` is invoked with the
+   * final value after stopping the animation, which is useful for updating
+   * state to match the animation position with layout.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#stopanimation
+   */
+  stopAnimation(callback) {
+    this.stopTracking();
+    this._animation && this._animation.stop();
+    this._animation = null;
+    if (callback) {
+      if (this.__isNative) {
+        NativeAnimatedAPI.getValue(this.__getNativeTag(), callback);
+      } else {
+        callback(this.__getValue());
+      }
+    }
+  }
+
+  /**
+   * Stops any animation and resets the value to its original.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#resetanimation
+   */
+  resetAnimation(callback) {
+    this.stopAnimation(callback);
+    this._value = this._startingValue;
+    if (this.__isNative) {
+      NativeAnimatedAPI.setAnimatedNodeValue(this.__getNativeTag(), this._startingValue);
+    }
+  }
+  __onAnimatedValueUpdateReceived(value) {
+    this._updateValue(value, false /*flush*/);
+  }
+
+  /**
+   * Interpolates the value before updating the property, e.g. mapping 0-1 to
+   * 0-10.
+   */
+  interpolate(config) {
+    return new AnimatedInterpolation(this, config);
+  }
+
+  /**
+   * Typically only used internally, but could be used by a custom Animation
+   * class.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#animate
+   */
+  animate(animation, callback) {
+    var handle = null;
+    if (animation.__isInteraction) {
+      handle = InteractionManager.createInteractionHandle();
+    }
+    var previousAnimation = this._animation;
+    this._animation && this._animation.stop();
+    this._animation = animation;
+    animation.start(this._value, value => {
+      // Natively driven animations will never call into that callback
+      this._updateValue(value, true /* flush */);
+    }, result => {
+      this._animation = null;
+      if (handle !== null) {
+        InteractionManager.clearInteractionHandle(handle);
+      }
+      callback && callback(result);
+    }, previousAnimation, this);
+  }
+
+  /**
+   * Typically only used internally.
+   */
+  stopTracking() {
+    this._tracking && this._tracking.__detach();
+    this._tracking = null;
+  }
+
+  /**
+   * Typically only used internally.
+   */
+  track(tracking) {
+    this.stopTracking();
+    this._tracking = tracking;
+    // Make sure that the tracking animation starts executing
+    this._tracking && this._tracking.update();
+  }
+  _updateValue(value, flush) {
+    if (value === undefined) {
+      throw new Error('AnimatedValue: Attempting to set value to undefined');
+    }
+    this._value = value;
+    if (flush) {
+      _flush(this);
+    }
+    super.__callListeners(this.__getValue());
+  }
+  __getNativeConfig() {
+    return {
+      type: 'value',
+      value: this._value,
+      offset: this._offset
+    };
+  }
+}
+export default AnimatedValue;

package/dist/vendor/react-native/Animated/nodes/AnimatedValue.js.flow

@@ -0,0 +1,86 @@
+/**
+ * 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.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+import AnimatedInterpolation from './AnimatedInterpolation';
+import AnimatedWithChildren from './AnimatedWithChildren';
+import InteractionManager from '../../../../exports/InteractionManager';
+import NativeAnimatedHelper from '../NativeAnimatedHelper';
+import type AnimatedNode from './AnimatedNode';
+import type Animation, { EndCallback } from '../animations/Animation';
+import type { InterpolationConfigType } from './AnimatedInterpolation';
+import type AnimatedTracking from './AnimatedTracking';
+export type AnimatedValueConfig = $ReadOnly<{
+  useNativeDriver: boolean
+}>;
+const NativeAnimatedAPI = NativeAnimatedHelper.API;
+
+/**
+ * Animated works by building a directed acyclic graph of dependencies
+ * transparently when you render your Animated components.
+ *
+ *               new Animated.Value(0)
+ *     .interpolate()        .interpolate()    new Animated.Value(1)
+ *         opacity               translateY      scale
+ *          style                         transform
+ *         View#234                         style
+ *                                         View#123
+ *
+ * A) Top Down phase
+ * When an Animated.Value is updated, we recursively go down through this
+ * graph in order to find leaf nodes: the views that we flag as needing
+ * an update.
+ *
+ * B) Bottom Up phase
+ * When a view is flagged as needing an update, we recursively go back up
+ * in order to build the new value that it needs. The reason why we need
+ * this two-phases process is to deal with composite props such as
+ * transform which can receive values from multiple parents.
+ */
+declare function _flush(rootNode: AnimatedValue): void;
+/**
+ * Some operations are executed only on batch end, which is _mostly_ scheduled when
+ * Animated component props change. For some of the changes which require immediate execution
+ * (e.g. setValue), we create a separate batch in case none is scheduled.
+ */
+declare function _executeAsAnimatedBatch(id: string, operation: () => void): any;
+/**
+ * Standard value for driving animations.  One `Animated.Value` can drive
+ * multiple properties in a synchronized fashion, but can only be driven by one
+ * mechanism at a time.  Using a new mechanism (e.g. starting a new animation,
+ * or calling `setValue`) will stop any previous ones.
+ *
+ * See https://reactnative.dev/docs/animatedvalue
+ */
+declare class AnimatedValue extends AnimatedWithChildren {
+  _value: number,
+  _startingValue: number,
+  _offset: number,
+  _animation: ?Animation,
+  _tracking: ?AnimatedTracking,
+  constructor(value: number, config?: ?AnimatedValueConfig): any,
+  __detach(): any,
+  __getValue(): number,
+  setValue(value: number): void,
+  setOffset(offset: number): void,
+  flattenOffset(): void,
+  extractOffset(): void,
+  stopAnimation(callback?: ?(value: number) => void): void,
+  resetAnimation(callback?: ?(value: number) => void): void,
+  __onAnimatedValueUpdateReceived(value: number): void,
+  interpolate<OutputT: number | string>(config: InterpolationConfigType<OutputT>): AnimatedInterpolation<OutputT>,
+  animate(animation: Animation, callback: ?EndCallback): void,
+  stopTracking(): void,
+  track(tracking: AnimatedTracking): void,
+  _updateValue(value: number, flush: boolean): void,
+  __getNativeConfig(): Object,
+}
+export default AnimatedValue;

package/dist/vendor/react-native/Animated/nodes/AnimatedValueXY.js

@@ -0,0 +1,187 @@
+/**
+ * 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';
+
+import AnimatedValue from './AnimatedValue';
+import AnimatedWithChildren from './AnimatedWithChildren';
+import invariant from 'fbjs/lib/invariant';
+var _uniqueId = 1;
+
+/**
+ * 2D Value for driving 2D animations, such as pan gestures. Almost identical
+ * API to normal `Animated.Value`, but multiplexed.
+ *
+ * See https://reactnative.dev/docs/animatedvaluexy.html
+ */
+class AnimatedValueXY extends AnimatedWithChildren {
+  constructor(valueIn) {
+    super();
+    var value = valueIn || {
+      x: 0,
+      y: 0
+    }; // fixme: shouldn't need `: any`
+    if (typeof value.x === 'number' && typeof value.y === 'number') {
+      this.x = new AnimatedValue(value.x);
+      this.y = new AnimatedValue(value.y);
+    } else {
+      invariant(value.x instanceof AnimatedValue && value.y instanceof AnimatedValue, 'AnimatedValueXY must be initialized with an object of numbers or ' + 'AnimatedValues.');
+      this.x = value.x;
+      this.y = value.y;
+    }
+    this._listeners = {};
+  }
+
+  /**
+   * Directly set the value. This will stop any animations running on the value
+   * and update all the bound properties.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#setvalue
+   */
+  setValue(value) {
+    this.x.setValue(value.x);
+    this.y.setValue(value.y);
+  }
+
+  /**
+   * Sets an offset that is applied on top of whatever value is set, whether
+   * via `setValue`, an animation, or `Animated.event`. Useful for compensating
+   * things like the start of a pan gesture.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#setoffset
+   */
+  setOffset(offset) {
+    this.x.setOffset(offset.x);
+    this.y.setOffset(offset.y);
+  }
+
+  /**
+   * Merges the offset value into the base value and resets the offset to zero.
+   * The final output of the value is unchanged.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#flattenoffset
+   */
+  flattenOffset() {
+    this.x.flattenOffset();
+    this.y.flattenOffset();
+  }
+
+  /**
+   * Sets the offset value to the base value, and resets the base value to
+   * zero. The final output of the value is unchanged.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#extractoffset
+   */
+  extractOffset() {
+    this.x.extractOffset();
+    this.y.extractOffset();
+  }
+  __getValue() {
+    return {
+      x: this.x.__getValue(),
+      y: this.y.__getValue()
+    };
+  }
+
+  /**
+   * Stops any animation and resets the value to its original.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#resetanimation
+   */
+  resetAnimation(callback) {
+    this.x.resetAnimation();
+    this.y.resetAnimation();
+    callback && callback(this.__getValue());
+  }
+
+  /**
+   * Stops any running animation or tracking. `callback` is invoked with the
+   * final value after stopping the animation, which is useful for updating
+   * state to match the animation position with layout.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#stopanimation
+   */
+  stopAnimation(callback) {
+    this.x.stopAnimation();
+    this.y.stopAnimation();
+    callback && callback(this.__getValue());
+  }
+
+  /**
+   * 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.
+   *
+   * Returns a string that serves as an identifier for the listener.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#addlistener
+   */
+  addListener(callback) {
+    var id = String(_uniqueId++);
+    var jointCallback = _ref => {
+      var number = _ref.value;
+      callback(this.__getValue());
+    };
+    this._listeners[id] = {
+      x: this.x.addListener(jointCallback),
+      y: this.y.addListener(jointCallback)
+    };
+    return id;
+  }
+
+  /**
+   * Unregister a listener. The `id` param shall match the identifier
+   * previously returned by `addListener()`.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#removelistener
+   */
+  removeListener(id) {
+    this.x.removeListener(this._listeners[id].x);
+    this.y.removeListener(this._listeners[id].y);
+    delete this._listeners[id];
+  }
+
+  /**
+   * Remove all registered listeners.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#removealllisteners
+   */
+  removeAllListeners() {
+    this.x.removeAllListeners();
+    this.y.removeAllListeners();
+    this._listeners = {};
+  }
+
+  /**
+   * Converts `{x, y}` into `{left, top}` for use in style.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#getlayout
+   */
+  getLayout() {
+    return {
+      left: this.x,
+      top: this.y
+    };
+  }
+
+  /**
+   * Converts `{x, y}` into a useable translation transform.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#gettranslatetransform
+   */
+  getTranslateTransform() {
+    return [{
+      translateX: this.x
+    }, {
+      translateY: this.y
+    }];
+  }
+}
+export default AnimatedValueXY;

package/dist/vendor/react-native/Animated/nodes/AnimatedValueXY.js.flow

@@ -0,0 +1,84 @@
+/**
+ * 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.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+import AnimatedValue from './AnimatedValue';
+import AnimatedWithChildren from './AnimatedWithChildren';
+import invariant from 'fbjs/lib/invariant';
+type ValueXYListenerCallback = (value: {
+  x: number,
+  y: number,
+  ...
+}) => mixed;
+let _uniqueId = 1;
+
+/**
+ * 2D Value for driving 2D animations, such as pan gestures. Almost identical
+ * API to normal `Animated.Value`, but multiplexed.
+ *
+ * See https://reactnative.dev/docs/animatedvaluexy.html
+ */
+declare class AnimatedValueXY extends AnimatedWithChildren {
+  x: AnimatedValue,
+  y: AnimatedValue,
+  _listeners: {
+    [key: string]: {
+      x: string,
+      y: string,
+      ...
+    },
+    ...
+  },
+  constructor(valueIn?: ?{
+    +x: number | AnimatedValue,
+    +y: number | AnimatedValue,
+    ...
+  }): any,
+  setValue(value: {
+    x: number,
+    y: number,
+    ...
+  }): any,
+  setOffset(offset: {
+    x: number,
+    y: number,
+    ...
+  }): any,
+  flattenOffset(): void,
+  extractOffset(): void,
+  __getValue(): {
+    x: number,
+    y: number,
+    ...
+  },
+  resetAnimation(callback?: (value: {
+    x: number,
+    y: number,
+    ...
+  }) => void): void,
+  stopAnimation(callback?: (value: {
+    x: number,
+    y: number,
+    ...
+  }) => void): void,
+  addListener(callback: ValueXYListenerCallback): string,
+  removeListener(id: string): void,
+  removeAllListeners(): void,
+  getLayout(): {
+    [key: string]: AnimatedValue,
+    ...
+  },
+  getTranslateTransform(): Array<{
+    [key: string]: AnimatedValue,
+    ...
+  }>,
+}
+export default AnimatedValueXY;