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

package/dist/vendor/react-native/Animated/NativeAnimatedHelper.js.flow

@@ -0,0 +1,396 @@
+/**
+ * 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 strict-local
+ * @format
+ */
+
+import NativeAnimatedNonTurboModule from './NativeAnimatedModule';
+import NativeAnimatedTurboModule from './NativeAnimatedTurboModule';
+import NativeEventEmitter from '../EventEmitter/NativeEventEmitter';
+import Platform from '../Utilities/Platform';
+import type { EventConfig } from './AnimatedEvent';
+import type { EventMapping, AnimatedNodeConfig, AnimatingNodeConfig } from './NativeAnimatedModule';
+import type { AnimationConfig, EndCallback } from './animations/Animation';
+import type { InterpolationConfigType } from './nodes/AnimatedInterpolation';
+import ReactNativeFeatureFlags from '../ReactNative/ReactNativeFeatureFlags';
+import invariant from 'fbjs/lib/invariant';
+import RCTDeviceEventEmitter from '../EventEmitter/RCTDeviceEventEmitter';
+import type { EventSubscription } from '../vendor/emitter/EventEmitter';
+
+// TODO T69437152 @petetheheat - Delete this fork when Fabric ships to 100%.
+const NativeAnimatedModule = Platform.OS === 'ios' && global.RN$Bridgeless === true ? NativeAnimatedTurboModule : NativeAnimatedNonTurboModule;
+let __nativeAnimatedNodeTagCount = 1; /* used for animated nodes */
+let __nativeAnimationIdCount = 1; /* used for started animations */
+
+let nativeEventEmitter;
+let waitingForQueuedOperations = new Set();
+let queueOperations = false;
+let queue: Array<() => void> = [];
+// $FlowFixMe
+let singleOpQueue: Array<any> = [];
+const useSingleOpBatching = false;
+Platform.OS === 'android' && !!NativeAnimatedModule?.queueAndExecuteBatchedOperations && ReactNativeFeatureFlags.animatedShouldUseSingleOp();
+let flushQueueTimeout = null;
+const eventListenerGetValueCallbacks = {};
+const eventListenerAnimationFinishedCallbacks = {};
+let globalEventEmitterGetValueListener: ?EventSubscription = null;
+let globalEventEmitterAnimationFinishedListener: ?EventSubscription = null;
+const nativeOps: ?typeof NativeAnimatedModule = useSingleOpBatching ? (function () {
+  const apis = ['createAnimatedNode',
+  // 1
+  'updateAnimatedNodeConfig',
+  // 2
+  'getValue',
+  // 3
+  'startListeningToAnimatedNodeValue',
+  // 4
+  'stopListeningToAnimatedNodeValue',
+  // 5
+  'connectAnimatedNodes',
+  // 6
+  'disconnectAnimatedNodes',
+  // 7
+  'startAnimatingNode',
+  // 8
+  'stopAnimation',
+  // 9
+  'setAnimatedNodeValue',
+  // 10
+  'setAnimatedNodeOffset',
+  // 11
+  'flattenAnimatedNodeOffset',
+  // 12
+  'extractAnimatedNodeOffset',
+  // 13
+  'connectAnimatedNodeToView',
+  // 14
+  'disconnectAnimatedNodeFromView',
+  // 15
+  'restoreDefaultValues',
+  // 16
+  'dropAnimatedNode',
+  // 17
+  'addAnimatedEventToView',
+  // 18
+  'removeAnimatedEventFromView',
+  // 19
+  'addListener',
+  // 20
+  'removeListener' // 21
+  ];
+  return apis.reduce((acc, functionName, i) => {
+    // These indices need to be kept in sync with the indices in native (see NativeAnimatedModule in Java, or the equivalent for any other native platform).
+    // $FlowFixMe[prop-missing]
+    acc[functionName] = i + 1;
+    return acc;
+  }, {});
+}(): $FlowFixMe) : NativeAnimatedModule;
+
+/**
+ * Wrappers around NativeAnimatedModule to provide flow and autocomplete support for
+ * the native module methods, and automatic queue management on Android
+ */
+const API = {
+  getValue: function (tag: number, saveValueCallback: (value: number) => void): void {
+    invariant(nativeOps, 'Native animated module is not available');
+    if (useSingleOpBatching) {
+      if (saveValueCallback) {
+        eventListenerGetValueCallbacks[tag] = saveValueCallback;
+      }
+      // $FlowFixMe
+      API.queueOperation(nativeOps.getValue, tag);
+    } else {
+      API.queueOperation(nativeOps.getValue, tag, saveValueCallback);
+    }
+  },
+  setWaitingForIdentifier: function (id: string): void {
+    waitingForQueuedOperations.add(id);
+    queueOperations = true;
+    if (ReactNativeFeatureFlags.animatedShouldDebounceQueueFlush() && flushQueueTimeout) {
+      clearTimeout(flushQueueTimeout);
+    }
+  },
+  unsetWaitingForIdentifier: function (id: string): void {
+    waitingForQueuedOperations.delete(id);
+    if (waitingForQueuedOperations.size === 0) {
+      queueOperations = false;
+      API.disableQueue();
+    }
+  },
+  disableQueue: function (): void {
+    invariant(nativeOps, 'Native animated module is not available');
+    if (ReactNativeFeatureFlags.animatedShouldDebounceQueueFlush()) {
+      const prevTimeout = flushQueueTimeout;
+      clearImmediate(prevTimeout);
+      flushQueueTimeout = setImmediate(API.flushQueue);
+    } else {
+      API.flushQueue();
+    }
+  },
+  flushQueue: function (): void {
+    /*
+    invariant(NativeAnimatedModule, 'Native animated module is not available');
+    flushQueueTimeout = null;
+     // Early returns before calling any APIs
+    if (useSingleOpBatching && singleOpQueue.length === 0) {
+      return;
+    }
+    if (!useSingleOpBatching && queue.length === 0) {
+      return;
+    }
+     if (useSingleOpBatching) {
+      // Set up event listener for callbacks if it's not set up
+      if (
+        !globalEventEmitterGetValueListener ||
+        !globalEventEmitterAnimationFinishedListener
+      ) {
+        setupGlobalEventEmitterListeners();
+      }
+      // Single op batching doesn't use callback functions, instead we
+      // use RCTDeviceEventEmitter. This reduces overhead of sending lots of
+      // JSI functions across to native code; but also, TM infrastructure currently
+      // does not support packing a function into native arrays.
+      NativeAnimatedModule.queueAndExecuteBatchedOperations?.(singleOpQueue);
+      singleOpQueue.length = 0;
+    } else {
+      Platform.OS === 'android' && NativeAnimatedModule.startOperationBatch?.();
+      for (let q = 0, l = queue.length; q < l; q++) {
+        queue[q]();
+      }
+      queue.length = 0;
+      Platform.OS === 'android' &&
+        NativeAnimatedModule.finishOperationBatch?.();
+    }
+    */
+  },
+  queueOperation: <Args: $ReadOnlyArray<mixed>, Fn: (...Args) => void>(fn: Fn, ...args: Args): void => {
+    if (useSingleOpBatching) {
+      // Get the command ID from the queued function, and push that ID and any arguments needed to execute the operation
+      // $FlowFixMe: surprise, fn is actually a number
+      singleOpQueue.push(fn, ...args);
+      return;
+    }
+
+    // If queueing is explicitly on, *or* the queue has not yet
+    // been flushed, use the queue. This is to prevent operations
+    // from being executed out of order.
+    if (queueOperations || queue.length !== 0) {
+      queue.push(() => fn(...args));
+    } else {
+      fn(...args);
+    }
+  },
+  createAnimatedNode: function (tag: number, config: AnimatedNodeConfig): void {
+    invariant(nativeOps, 'Native animated module is not available');
+    API.queueOperation(nativeOps.createAnimatedNode, tag, config);
+  },
+  updateAnimatedNodeConfig: function (tag: number, config: AnimatedNodeConfig): void {
+    invariant(nativeOps, 'Native animated module is not available');
+    //if (nativeOps.updateAnimatedNodeConfig) {
+    //  API.queueOperation(nativeOps.updateAnimatedNodeConfig, tag, config);
+    //}
+  },
+  startListeningToAnimatedNodeValue: function (tag: number) {
+    invariant(nativeOps, 'Native animated module is not available');
+    API.queueOperation(nativeOps.startListeningToAnimatedNodeValue, tag);
+  },
+  stopListeningToAnimatedNodeValue: function (tag: number) {
+    invariant(nativeOps, 'Native animated module is not available');
+    API.queueOperation(nativeOps.stopListeningToAnimatedNodeValue, tag);
+  },
+  connectAnimatedNodes: function (parentTag: number, childTag: number): void {
+    invariant(nativeOps, 'Native animated module is not available');
+    API.queueOperation(nativeOps.connectAnimatedNodes, parentTag, childTag);
+  },
+  disconnectAnimatedNodes: function (parentTag: number, childTag: number): void {
+    invariant(nativeOps, 'Native animated module is not available');
+    API.queueOperation(nativeOps.disconnectAnimatedNodes, parentTag, childTag);
+  },
+  startAnimatingNode: function (animationId: number, nodeTag: number, config: AnimatingNodeConfig, endCallback: EndCallback): void {
+    invariant(nativeOps, 'Native animated module is not available');
+    if (useSingleOpBatching) {
+      if (endCallback) {
+        eventListenerAnimationFinishedCallbacks[animationId] = endCallback;
+      }
+      // $FlowFixMe
+      API.queueOperation(nativeOps.startAnimatingNode, animationId, nodeTag, config);
+    } else {
+      API.queueOperation(nativeOps.startAnimatingNode, animationId, nodeTag, config, endCallback);
+    }
+  },
+  stopAnimation: function (animationId: number) {
+    invariant(nativeOps, 'Native animated module is not available');
+    API.queueOperation(nativeOps.stopAnimation, animationId);
+  },
+  setAnimatedNodeValue: function (nodeTag: number, value: number): void {
+    invariant(nativeOps, 'Native animated module is not available');
+    API.queueOperation(nativeOps.setAnimatedNodeValue, nodeTag, value);
+  },
+  setAnimatedNodeOffset: function (nodeTag: number, offset: number): void {
+    invariant(nativeOps, 'Native animated module is not available');
+    API.queueOperation(nativeOps.setAnimatedNodeOffset, nodeTag, offset);
+  },
+  flattenAnimatedNodeOffset: function (nodeTag: number): void {
+    invariant(nativeOps, 'Native animated module is not available');
+    API.queueOperation(nativeOps.flattenAnimatedNodeOffset, nodeTag);
+  },
+  extractAnimatedNodeOffset: function (nodeTag: number): void {
+    invariant(nativeOps, 'Native animated module is not available');
+    API.queueOperation(nativeOps.extractAnimatedNodeOffset, nodeTag);
+  },
+  connectAnimatedNodeToView: function (nodeTag: number, viewTag: number): void {
+    invariant(nativeOps, 'Native animated module is not available');
+    API.queueOperation(nativeOps.connectAnimatedNodeToView, nodeTag, viewTag);
+  },
+  disconnectAnimatedNodeFromView: function (nodeTag: number, viewTag: number): void {
+    invariant(nativeOps, 'Native animated module is not available');
+    API.queueOperation(nativeOps.disconnectAnimatedNodeFromView, nodeTag, viewTag);
+  },
+  restoreDefaultValues: function (nodeTag: number): void {
+    invariant(nativeOps, 'Native animated module is not available');
+    // Backwards compat with older native runtimes, can be removed later.
+    if (nativeOps.restoreDefaultValues != null) {
+      API.queueOperation(nativeOps.restoreDefaultValues, nodeTag);
+    }
+  },
+  dropAnimatedNode: function (tag: number): void {
+    invariant(nativeOps, 'Native animated module is not available');
+    API.queueOperation(nativeOps.dropAnimatedNode, tag);
+  },
+  addAnimatedEventToView: function (viewTag: number, eventName: string, eventMapping: EventMapping) {
+    invariant(nativeOps, 'Native animated module is not available');
+    API.queueOperation(nativeOps.addAnimatedEventToView, viewTag, eventName, eventMapping);
+  },
+  removeAnimatedEventFromView(viewTag: number, eventName: string, animatedNodeTag: number) {
+    invariant(nativeOps, 'Native animated module is not available');
+    API.queueOperation(nativeOps.removeAnimatedEventFromView, viewTag, eventName, animatedNodeTag);
+  }
+};
+declare function setupGlobalEventEmitterListeners(): any;
+/**
+ * Styles allowed by the native animated implementation.
+ *
+ * In general native animated implementation should support any numeric or color property that
+ * doesn't need to be updated through the shadow view hierarchy (all non-layout properties).
+ */
+const SUPPORTED_COLOR_STYLES = {
+  backgroundColor: true,
+  borderBottomColor: true,
+  borderColor: true,
+  borderEndColor: true,
+  borderLeftColor: true,
+  borderRightColor: true,
+  borderStartColor: true,
+  borderTopColor: true,
+  color: true,
+  tintColor: true
+};
+const SUPPORTED_STYLES = {
+  ...SUPPORTED_COLOR_STYLES,
+  borderBottomEndRadius: true,
+  borderBottomLeftRadius: true,
+  borderBottomRightRadius: true,
+  borderBottomStartRadius: true,
+  borderRadius: true,
+  borderTopEndRadius: true,
+  borderTopLeftRadius: true,
+  borderTopRightRadius: true,
+  borderTopStartRadius: true,
+  elevation: true,
+  opacity: true,
+  transform: true,
+  zIndex: true,
+  /* ios styles */
+  shadowOpacity: true,
+  shadowRadius: true,
+  /* legacy android transform properties */
+  scaleX: true,
+  scaleY: true,
+  translateX: true,
+  translateY: true
+};
+const SUPPORTED_TRANSFORMS = {
+  translateX: true,
+  translateY: true,
+  scale: true,
+  scaleX: true,
+  scaleY: true,
+  rotate: true,
+  rotateX: true,
+  rotateY: true,
+  rotateZ: true,
+  perspective: true
+};
+const SUPPORTED_INTERPOLATION_PARAMS = {
+  inputRange: true,
+  outputRange: true,
+  extrapolate: true,
+  extrapolateRight: true,
+  extrapolateLeft: true
+};
+declare function addWhitelistedStyleProp(prop: string): void;
+declare function addWhitelistedTransformProp(prop: string): void;
+declare function addWhitelistedInterpolationParam(param: string): void;
+declare function isSupportedColorStyleProp(prop: string): boolean;
+declare function isSupportedStyleProp(prop: string): boolean;
+declare function isSupportedTransformProp(prop: string): boolean;
+declare function isSupportedInterpolationParam(param: string): boolean;
+declare function validateTransform(configs: Array<{
+  type: 'animated',
+  property: string,
+  nodeTag: ?number,
+  ...
+} | {
+  type: 'static',
+  property: string,
+  value: number | string,
+  ...
+}>): void;
+declare function validateStyles(styles: {
+  [key: string]: ?number,
+  ...
+}): void;
+declare function validateInterpolation<OutputT: number | string>(config: InterpolationConfigType<OutputT>): void;
+declare function generateNewNodeTag(): number;
+declare function generateNewAnimationId(): number;
+declare function assertNativeAnimatedModule(): void;
+let _warnedMissingNativeAnimated = false;
+declare function shouldUseNativeDriver(config: $ReadOnly<{
+  ...AnimationConfig,
+  ...
+}> | EventConfig): boolean;
+declare function transformDataType(value: number | string): number | string;
+export { API, isSupportedColorStyleProp, isSupportedStyleProp, isSupportedTransformProp, isSupportedInterpolationParam, addWhitelistedStyleProp, addWhitelistedTransformProp, addWhitelistedInterpolationParam, validateStyles, validateTransform, validateInterpolation, generateNewNodeTag, generateNewAnimationId, assertNativeAnimatedModule, shouldUseNativeDriver, transformDataType };
+export default {
+  API,
+  isSupportedColorStyleProp,
+  isSupportedStyleProp,
+  isSupportedTransformProp,
+  isSupportedInterpolationParam,
+  addWhitelistedStyleProp,
+  addWhitelistedTransformProp,
+  addWhitelistedInterpolationParam,
+  validateStyles,
+  validateTransform,
+  validateInterpolation,
+  generateNewNodeTag,
+  generateNewAnimationId,
+  assertNativeAnimatedModule,
+  shouldUseNativeDriver,
+  transformDataType,
+  // $FlowExpectedError[unsafe-getters-setters] - unsafe getter lint suppresion
+  // $FlowExpectedError[missing-type-arg] - unsafe getter lint suppresion
+  get nativeEventEmitter(): NativeEventEmitter {
+    if (!nativeEventEmitter) {
+      nativeEventEmitter = new NativeEventEmitter(
+      // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
+      // If you want to use the native module on other platforms, please remove this condition and test its behavior
+      Platform.OS !== 'ios' ? null : NativeAnimatedModule);
+    }
+    return nativeEventEmitter;
+  }
+};

package/dist/vendor/react-native/Animated/NativeAnimatedModule.js

@@ -0,0 +1,16 @@
+/**
+ * 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
+ */
+
+import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
+
+// The config has different keys depending on the type of the Node
+// TODO(T54896888): Make these types strict
+
+export default TurboModuleRegistry.get('NativeAnimatedModule');

package/dist/vendor/react-native/Animated/NativeAnimatedModule.js.flow

@@ -0,0 +1,56 @@
+/**
+ * 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
+ */
+
+import type { TurboModule } from '../TurboModule/RCTExport';
+import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
+type EndResult = {
+  finished: boolean,
+  ...
+};
+type EndCallback = (result: EndResult) => void;
+type SaveValueCallback = (value: number) => void;
+export type EventMapping = {|
+  nativeEventPath: Array<string>,
+  animatedValueTag: ?number,
+|};
+
+// The config has different keys depending on the type of the Node
+// TODO(T54896888): Make these types strict
+export type AnimatedNodeConfig = Object;
+export type AnimatingNodeConfig = Object;
+export interface Spec extends TurboModule {
+  +startOperationBatch: () => void,
+  +finishOperationBatch: () => void,
+  +createAnimatedNode: (tag: number, config: AnimatedNodeConfig) => void,
+  +updateAnimatedNodeConfig?: (tag: number, config: AnimatedNodeConfig) => void,
+  +getValue: (tag: number, saveValueCallback: SaveValueCallback) => void,
+  +startListeningToAnimatedNodeValue: (tag: number) => void,
+  +stopListeningToAnimatedNodeValue: (tag: number) => void,
+  +connectAnimatedNodes: (parentTag: number, childTag: number) => void,
+  +disconnectAnimatedNodes: (parentTag: number, childTag: number) => void,
+  +startAnimatingNode: (animationId: number, nodeTag: number, config: AnimatingNodeConfig, endCallback: EndCallback) => void,
+  +stopAnimation: (animationId: number) => void,
+  +setAnimatedNodeValue: (nodeTag: number, value: number) => void,
+  +setAnimatedNodeOffset: (nodeTag: number, offset: number) => void,
+  +flattenAnimatedNodeOffset: (nodeTag: number) => void,
+  +extractAnimatedNodeOffset: (nodeTag: number) => void,
+  +connectAnimatedNodeToView: (nodeTag: number, viewTag: number) => void,
+  +disconnectAnimatedNodeFromView: (nodeTag: number, viewTag: number) => void,
+  +restoreDefaultValues: (nodeTag: number) => void,
+  +dropAnimatedNode: (tag: number) => void,
+  +addAnimatedEventToView: (viewTag: number, eventName: string, eventMapping: EventMapping) => void,
+  +removeAnimatedEventFromView: (viewTag: number, eventName: string, animatedNodeTag: number) => void,
+  // Events
+  +addListener: (eventName: string) => void,
+  +removeListeners: (count: number) => void,
+  // All of the above in a batched mode
+  +queueAndExecuteBatchedOperations?: (operationsAndArgs: Array<any>) => void,
+}
+export default (TurboModuleRegistry.get<Spec>('NativeAnimatedModule'): ?Spec);

package/dist/vendor/react-native/Animated/NativeAnimatedTurboModule.js

@@ -0,0 +1,16 @@
+/**
+ * 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
+ */
+
+import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
+
+// The config has different keys depending on the type of the Node
+// TODO(T54896888): Make these types strict
+
+export default TurboModuleRegistry.get('NativeAnimatedTurboModule');

package/dist/vendor/react-native/Animated/NativeAnimatedTurboModule.js.flow

@@ -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.
+ *
+ * @flow
+ * @format
+ */
+
+import type { TurboModule } from '../TurboModule/RCTExport';
+import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
+type EndResult = {
+  finished: boolean,
+  ...
+};
+type EndCallback = (result: EndResult) => void;
+type SaveValueCallback = (value: number) => void;
+export type EventMapping = {|
+  nativeEventPath: Array<string>,
+  animatedValueTag: ?number,
+|};
+
+// The config has different keys depending on the type of the Node
+// TODO(T54896888): Make these types strict
+export type AnimatedNodeConfig = Object;
+export type AnimatingNodeConfig = Object;
+export interface Spec extends TurboModule {
+  +startOperationBatch: () => void,
+  +finishOperationBatch: () => void,
+  +createAnimatedNode: (tag: number, config: AnimatedNodeConfig) => void,
+  +getValue: (tag: number, saveValueCallback: SaveValueCallback) => void,
+  +startListeningToAnimatedNodeValue: (tag: number) => void,
+  +stopListeningToAnimatedNodeValue: (tag: number) => void,
+  +connectAnimatedNodes: (parentTag: number, childTag: number) => void,
+  +disconnectAnimatedNodes: (parentTag: number, childTag: number) => void,
+  +startAnimatingNode: (animationId: number, nodeTag: number, config: AnimatingNodeConfig, endCallback: EndCallback) => void,
+  +stopAnimation: (animationId: number) => void,
+  +setAnimatedNodeValue: (nodeTag: number, value: number) => void,
+  +setAnimatedNodeOffset: (nodeTag: number, offset: number) => void,
+  +flattenAnimatedNodeOffset: (nodeTag: number) => void,
+  +extractAnimatedNodeOffset: (nodeTag: number) => void,
+  +connectAnimatedNodeToView: (nodeTag: number, viewTag: number) => void,
+  +disconnectAnimatedNodeFromView: (nodeTag: number, viewTag: number) => void,
+  +restoreDefaultValues: (nodeTag: number) => void,
+  +dropAnimatedNode: (tag: number) => void,
+  +addAnimatedEventToView: (viewTag: number, eventName: string, eventMapping: EventMapping) => void,
+  +removeAnimatedEventFromView: (viewTag: number, eventName: string, animatedNodeTag: number) => void,
+  // Events
+  +addListener: (eventName: string) => void,
+  +removeListeners: (count: number) => void,
+}
+export default (TurboModuleRegistry.get<Spec>('NativeAnimatedTurboModule'): ?Spec);

package/dist/vendor/react-native/Animated/SpringConfig.js

@@ -0,0 +1,69 @@
+/**
+ * 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';
+
+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)
+  };
+}
+export default {
+  fromOrigamiTensionAndFriction,
+  fromBouncinessAndSpeed
+};

package/dist/vendor/react-native/Animated/SpringConfig.js.flow

@@ -0,0 +1,25 @@
+/**
+ * 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
+ * @flow strict
+ */
+
+'use strict';
+
+type SpringConfigType = {
+  stiffness: number,
+  damping: number,
+  ...
+};
+declare function stiffnessFromOrigamiValue(oValue: any): any;
+declare function dampingFromOrigamiValue(oValue: any): any;
+declare function fromOrigamiTensionAndFriction(tension: number, friction: number): SpringConfigType;
+declare function fromBouncinessAndSpeed(bounciness: number, speed: number): SpringConfigType;
+export default {
+  fromOrigamiTensionAndFriction,
+  fromBouncinessAndSpeed
+};

package/dist/vendor/react-native/Animated/animations/Animation.js

@@ -0,0 +1,55 @@
+/**
+ * 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 NativeAnimatedHelper from '../NativeAnimatedHelper';
+var startNativeAnimationNextId = 1;
+
+// 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) {
+    var onEnd = this.__onEnd;
+    this.__onEnd = null;
+    onEnd && onEnd(result);
+  }
+  __startNativeAnimation(animatedValue) {
+    var startNativeAnimationWaitId = startNativeAnimationNextId + ":startAnimation";
+    startNativeAnimationNextId += 1;
+    NativeAnimatedHelper.API.setWaitingForIdentifier(startNativeAnimationWaitId);
+    try {
+      var config = this.__getNativeAnimationConfig();
+      animatedValue.__makeNative(config.platformConfig);
+      this.__nativeId = NativeAnimatedHelper.generateNewAnimationId();
+      NativeAnimatedHelper.API.startAnimatingNode(this.__nativeId, animatedValue.__getNativeTag(), config,
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      this.__debouncedOnEnd.bind(this));
+    } catch (e) {
+      throw e;
+    } finally {
+      NativeAnimatedHelper.API.unsetWaitingForIdentifier(startNativeAnimationWaitId);
+    }
+  }
+}
+export default Animation;