@tamagui/react-native-web-lite 1.112.5

package/src/vendor/react-native/TouchHistoryMath/index.tsx

@@ -0,0 +1,136 @@
+/**
+ * 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
+ */
+
+const TouchHistoryMath = {
+  /**
+   * This code is optimized and not intended to look beautiful. This allows
+   * computing of touch centroids that have moved after `touchesChangedAfter`
+   * timeStamp. You can compute the current centroid involving all touches
+   * moves after `touchesChangedAfter`, or you can compute the previous
+   * centroid of all touches that were moved after `touchesChangedAfter`.
+   *
+   * @param {TouchHistoryMath} touchHistory Standard Responder touch track
+   * data.
+   * @param {number} touchesChangedAfter timeStamp after which moved touches
+   * are considered "actively moving" - not just "active".
+   * @param {boolean} isXAxis Consider `x` dimension vs. `y` dimension.
+   * @param {boolean} ofCurrent Compute current centroid for actively moving
+   * touches vs. previous centroid of now actively moving touches.
+   * @return {number} value of centroid in specified dimension.
+   */
+  centroidDimension: function (touchHistory, touchesChangedAfter, isXAxis, ofCurrent) {
+    const touchBank = touchHistory.touchBank
+    let total = 0
+    let count = 0
+
+    const oneTouchData =
+      touchHistory.numberActiveTouches === 1
+        ? touchHistory.touchBank[touchHistory.indexOfSingleActiveTouch]
+        : null
+
+    if (oneTouchData !== null) {
+      if (
+        oneTouchData.touchActive &&
+        oneTouchData.currentTimeStamp > touchesChangedAfter
+      ) {
+        total +=
+          ofCurrent && isXAxis
+            ? oneTouchData.currentPageX
+            : ofCurrent && !isXAxis
+            ? oneTouchData.currentPageY
+            : !ofCurrent && isXAxis
+            ? oneTouchData.previousPageX
+            : oneTouchData.previousPageY
+        count = 1
+      }
+    } else {
+      for (let i = 0; i < touchBank.length; i++) {
+        const touchTrack = touchBank[i]
+        if (
+          touchTrack !== null &&
+          touchTrack !== undefined &&
+          touchTrack.touchActive &&
+          touchTrack.currentTimeStamp >= touchesChangedAfter
+        ) {
+          let toAdd // Yuck, program temporarily in invalid state.
+          if (ofCurrent && isXAxis) {
+            toAdd = touchTrack.currentPageX
+          } else if (ofCurrent && !isXAxis) {
+            toAdd = touchTrack.currentPageY
+          } else if (!ofCurrent && isXAxis) {
+            toAdd = touchTrack.previousPageX
+          } else {
+            toAdd = touchTrack.previousPageY
+          }
+          total += toAdd
+          count++
+        }
+      }
+    }
+    return count > 0 ? total / count : TouchHistoryMath.noCentroid
+  },
+
+  currentCentroidXOfTouchesChangedAfter: function (touchHistory, touchesChangedAfter) {
+    return TouchHistoryMath.centroidDimension(
+      touchHistory,
+      touchesChangedAfter,
+      true, // isXAxis
+      true // ofCurrent
+    )
+  },
+
+  currentCentroidYOfTouchesChangedAfter: function (touchHistory, touchesChangedAfter) {
+    return TouchHistoryMath.centroidDimension(
+      touchHistory,
+      touchesChangedAfter,
+      false, // isXAxis
+      true // ofCurrent
+    )
+  },
+
+  previousCentroidXOfTouchesChangedAfter: function (touchHistory, touchesChangedAfter) {
+    return TouchHistoryMath.centroidDimension(
+      touchHistory,
+      touchesChangedAfter,
+      true, // isXAxis
+      false // ofCurrent
+    )
+  },
+
+  previousCentroidYOfTouchesChangedAfter: function (touchHistory, touchesChangedAfter) {
+    return TouchHistoryMath.centroidDimension(
+      touchHistory,
+      touchesChangedAfter,
+      false, // isXAxis
+      false // ofCurrent
+    )
+  },
+
+  currentCentroidX: function (touchHistory) {
+    return TouchHistoryMath.centroidDimension(
+      touchHistory,
+      0, // touchesChangedAfter
+      true, // isXAxis
+      true // ofCurrent
+    )
+  },
+
+  currentCentroidY: function (touchHistory) {
+    return TouchHistoryMath.centroidDimension(
+      touchHistory,
+      0, // touchesChangedAfter
+      false, // isXAxis
+      true // ofCurrent
+    )
+  },
+
+  noCentroid: -1,
+}
+
+export default TouchHistoryMath

package/src/vendor/react-native/TurboModule/RCTExport.js

@@ -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.
+ *
+ *
+ * @format
+ */
+'use strict'
+/**
+ * NOTE: This is React Native specific export type.
+ *
+ * RCTExport is an interface type that allows native code generation for React
+ * Native native modules. It exists as a hint to the codegen tool that any
+ * interface that extends it needs to be codegen'ed. Example usage:
+ *
+ *   export interface RCTFoobar extends RCTExport<void> {}
+ *
+ * Native definition for RCTFoobar will then be generated.
+ *
+ * The type param T is a placeholder for future codegen hinting, like versioning
+ * information, native base classes, etc. For now, simply use `void` type as
+ * there's nothing to give hint about.
+ */
+// eslint-disable-next-line no-unused-vars

package/src/vendor/react-native/TurboModule/TurboModuleRegistry.js

@@ -0,0 +1,17 @@
+/**
+ * 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'
+
+export function get(name) {
+  return null
+}
+export function getEnforcing(name) {
+  return null
+}

package/src/vendor/react-native/Types/CoreEventTypes.tsx

@@ -0,0 +1,88 @@
+/**
+ * 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
+ * @format
+ */
+
+'use strict'
+
+export type SyntheticEvent<T> = {
+  readonly bubbles: boolean | null
+  readonly cancelable: boolean | null
+  readonly currentTarget: HTMLElement
+  readonly defaultPrevented: boolean | null
+  readonly dispatchConfig: {
+    readonly registrationName: string
+  }
+  readonly eventPhase: number | null
+  readonly preventDefault: () => void
+  readonly isDefaultPrevented: () => boolean
+  readonly stopPropagation: () => void
+  readonly isPropagationStopped: () => boolean
+  readonly isTrusted: boolean | null
+  readonly nativeEvent: T
+  readonly persist: () => void
+  readonly target: HTMLElement | null
+  readonly timeStamp: number
+  readonly type: string | null
+}
+
+export type ResponderSyntheticEvent<T> = {
+  touchHistory: {
+    readonly indexOfSingleActiveTouch: number
+    readonly mostRecentTimeStamp: number
+    readonly numberActiveTouches: number
+    readonly touchBank: ReadonlyArray<{
+      readonly touchActive: boolean
+      readonly startPageX: number
+      readonly startPageY: number
+      readonly startTimeStamp: number
+      readonly currentPageX: number
+      readonly currentPageY: number
+      readonly currentTimeStamp: number
+      readonly previousPageX: number
+      readonly previousPageY: number
+      readonly previousTimeStamp: number
+    }>
+  }
+} & React.SyntheticEvent
+
+export type Layout = {
+  readonly x: number
+  readonly y: number
+  readonly width: number
+  readonly height: number
+}
+
+export type TextLayout = {
+  ascender: number
+  capHeight: number
+  descender: number
+  text: string
+  xHeight: number
+} & Layout
+
+export type LayoutEvent = React.SyntheticEvent
+
+export type TextLayoutEvent = React.SyntheticEvent
+
+export type PressEvent = ResponderSyntheticEvent<{
+  readonly changedTouches: ReadonlyArray<PressEvent['nativeEvent']>
+  readonly force: number
+  readonly identifier: number
+  readonly locationX: number
+  readonly locationY: number
+  readonly pageX: number
+  readonly pageY: number
+  readonly target: HTMLElement | null
+  readonly timestamp: number
+  readonly touches: ReadonlyArray<PressEvent['nativeEvent']>
+}>
+
+export type ScrollEvent = React.SyntheticEvent
+
+export type SwitchChangeEvent = React.SyntheticEvent

package/src/vendor/react-native/Utilities/setAndForwardRef.js

@@ -0,0 +1,59 @@
+/**
+ * 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'
+
+/**
+ * This is a helper function for when a component needs to be able to forward a ref
+ * to a child component, but still needs to have access to that component as part of
+ * its implementation.
+ *
+ * Its main use case is in wrappers for native components.
+ *
+ * Usage:
+ *
+ *   class MyView extends React.Component {
+ *     _nativeRef = null;
+ *
+ *     _setNativeRef = setAndForwardRef({
+ *       getForwardedRef: () => this.props.forwardedRef,
+ *       setLocalRef: ref => {
+ *         this._nativeRef = ref;
+ *       },
+ *     });
+ *
+ *     render() {
+ *       return <View ref={this._setNativeRef} />;
+ *     }
+ *   }
+ *
+ *   const MyViewWithRef = React.forwardRef((props, ref) => (
+ *     <MyView {...props} forwardedRef={ref} />
+ *   ));
+ *
+ *   module.exports = MyViewWithRef;
+ */
+function setAndForwardRef(_ref) {
+  var getForwardedRef = _ref.getForwardedRef,
+    setLocalRef = _ref.setLocalRef
+  return function forwardRef(ref) {
+    var forwardedRef = getForwardedRef()
+    setLocalRef(ref) // Forward to user ref prop (if one has been specified)
+
+    if (typeof forwardedRef === 'function') {
+      // Handle function-based refs. String-based refs are handled as functions.
+      forwardedRef(ref)
+    } else if (typeof forwardedRef === 'object' && forwardedRef != null) {
+      // Handle createRef-based refs
+      forwardedRef.current = ref
+    }
+  }
+}
+
+export default setAndForwardRef

package/src/vendor/react-native/emitter/EventEmitter.js

@@ -0,0 +1,13 @@
+/**
+ * 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 EventEmitter from './_EventEmitter'
+export default EventEmitter

package/src/vendor/react-native/emitter/EventSubscription.js

@@ -0,0 +1,12 @@
+/**
+ * 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' // This exists as a separate file only to avoid circular dependencies from
+// using this in `_EmitterSubscription`. Combine this back into `EventEmitter`
+// after migration and cleanup is done.

package/src/vendor/react-native/emitter/_EmitterSubscription.js

@@ -0,0 +1,46 @@
+/**
+ * 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 _EventSubscription from './_EventSubscription'
+
+/**
+ * EmitterSubscription represents a subscription with listener and context data.
+ */
+class EmitterSubscription extends _EventSubscription {
+  /**
+   * @param {EventEmitter} emitter - The event emitter that registered this
+   *   subscription
+   * @param {EventSubscriptionVendor} subscriber - The subscriber that controls
+   *   this subscription
+   * @param {function} listener - Function to invoke when the specified event is
+   *   emitted
+   * @param {*} context - Optional context object to use when invoking the
+   *   listener
+   */
+  constructor(emitter, subscriber, listener, context) {
+    super(subscriber)
+    this.emitter = emitter
+    this.listener = listener
+    this.context = context
+  }
+  /**
+   * Removes this subscription from the emitter that registered it.
+   * Note: we're overriding the `remove()` method of _EventSubscription here
+   * but deliberately not calling `super.remove()` as the responsibility
+   * for removing the subscription lies with the EventEmitter.
+   */
+
+  remove() {
+    this.emitter.removeSubscription(this)
+  }
+}
+
+export default EmitterSubscription

package/src/vendor/react-native/emitter/_EventEmitter.js

@@ -0,0 +1,174 @@
+/**
+ * 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
+ *
+ * @typecheck
+ */
+import { invariant } from '@tamagui/react-native-web-internals'
+
+import EmitterSubscription from './_EmitterSubscription'
+import EventSubscriptionVendor from './_EventSubscriptionVendor'
+
+var sparseFilterPredicate = () => true
+
+/**
+ * @class EventEmitter
+ * @description
+ * An EventEmitter is responsible for managing a set of listeners and publishing
+ * events to them when it is told that such events happened. In addition to the
+ * data for the given event it also sends a event control object which allows
+ * the listeners/handlers to prevent the default behavior of the given event.
+ *
+ * The emitter is designed to be generic enough to support all the different
+ * contexts in which one might want to emit events. It is a simple multicast
+ * mechanism on top of which extra functionality can be composed. For example, a
+ * more advanced emitter may use an EventHolder and EventFactory.
+ */
+class EventEmitter {
+  /**
+   * @constructor
+   *
+   * @param {EventSubscriptionVendor} subscriber - Optional subscriber instance
+   *   to use. If omitted, a new subscriber will be created for the emitter.
+   */
+  constructor(subscriber = new EventSubscriptionVendor()) {
+    this._subscriber = subscriber
+  }
+  /**
+   * Adds a listener to be invoked when events of the specified type are
+   * emitted. An optional calling context may be provided. The data arguments
+   * emitted will be passed to the listener function.
+   *
+   * TODO: Annotate the listener arg's type. This is tricky because listeners
+   *       can be invoked with varargs.
+   *
+   * @param {string} eventType - Name of the event to listen to
+   * @param {function} listener - Function to invoke when the specified event is
+   *   emitted
+   * @param {*} context - Optional context object to use when invoking the
+   *   listener
+   */
+
+  addListener(
+    eventType, // FIXME: listeners should return void instead of mixed to prevent issues
+    listener,
+    context
+  ) {
+    return this._subscriber.addSubscription(
+      eventType,
+      new EmitterSubscription(this, this._subscriber, listener, context)
+    )
+  }
+  /**
+   * Removes all of the registered listeners, including those registered as
+   * listener maps.
+   *
+   * @param {?string} eventType - Optional name of the event whose registered
+   *   listeners to remove
+   */
+
+  removeAllListeners(eventType) {
+    this._subscriber.removeAllSubscriptions(eventType)
+  }
+  /**
+   * @deprecated Use `remove` on the EventSubscription from `addListener`.
+   */
+
+  removeSubscription(subscription) {
+    invariant(
+      subscription.emitter === this,
+      'Subscription does not belong to this emitter.'
+    )
+
+    this._subscriber.removeSubscription(subscription)
+  }
+  /**
+   * Returns the number of listeners that are currently registered for the given
+   * event.
+   *
+   * @param {string} eventType - Name of the event to query
+   * @returns {number}
+   */
+
+  listenerCount(eventType) {
+    var subscriptions = this._subscriber.getSubscriptionsForType(eventType)
+
+    return subscriptions // We filter out missing entries because the array is sparse.
+      ? // "callbackfn is called only for elements of the array which actually
+        // exist; it is not called for missing elements of the array."
+        // https://www.ecma-international.org/ecma-262/9.0/index.html#sec-array.prototype.filter
+        subscriptions.filter(sparseFilterPredicate).length
+      : 0
+  }
+  /**
+   * Emits an event of the given type with the given data. All handlers of that
+   * particular type will be notified.
+   *
+   * @param {string} eventType - Name of the event to emit
+   * @param {...*} Arbitrary arguments to be passed to each registered listener
+   *
+   * @example
+   *   emitter.addListener('someEvent', function(message) {
+   *     console.log(message);
+   *   });
+   *
+   *   emitter.emit('someEvent', 'abc'); // logs 'abc'
+   */
+
+  emit(eventType) {
+    var subscriptions = this._subscriber.getSubscriptionsForType(eventType)
+
+    if (subscriptions) {
+      for (
+        var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1;
+        _key < _len;
+        _key++
+      ) {
+        args[_key - 1] = arguments[_key]
+      }
+
+      for (var i = 0, l = subscriptions.length; i < l; i++) {
+        var subscription = subscriptions[i] // The subscription may have been removed during this event loop.
+
+        if (subscription && subscription.listener) {
+          subscription.listener.apply(subscription.context, args)
+        }
+      }
+    }
+  }
+  /**
+   * @deprecated Use `remove` on the EventSubscription from `addListener`.
+   */
+
+  removeListener(
+    eventType, // FIXME: listeners should return void instead of mixed to prevent issues
+    listener
+  ) {
+    console.error(
+      "EventEmitter.removeListener('" +
+        eventType +
+        "', ...): Method has been " +
+        'deprecated. Please instead use `remove()` on the subscription ' +
+        'returned by `EventEmitter.addListener`.'
+    )
+
+    var subscriptions = this._subscriber.getSubscriptionsForType(eventType)
+
+    if (subscriptions) {
+      for (var i = 0, l = subscriptions.length; i < l; i++) {
+        var subscription = subscriptions[i] // The subscription may have been removed during this event loop.
+        // its listener matches the listener in method parameters
+
+        if (subscription && subscription.listener === listener) {
+          subscription.remove()
+        }
+      }
+    }
+  }
+}
+
+export default EventEmitter

package/src/vendor/react-native/emitter/_EventSubscription.js

@@ -0,0 +1,33 @@
+/**
+ * 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'
+
+/**
+ * EventSubscription represents a subscription to a particular event. It can
+ * remove its own subscription.
+ */
+class _EventSubscription {
+  /**
+   * @param {EventSubscriptionVendor} subscriber the subscriber that controls
+   *   this subscription.
+   */
+  constructor(subscriber) {
+    this.subscriber = subscriber
+  }
+  /**
+   * Removes this subscription from the subscriber that controls it.
+   */
+
+  remove() {
+    this.subscriber.removeSubscription(this)
+  }
+}
+
+export default _EventSubscription