@tamagui/react-native-web-lite 1.129.13 → 1.129.14

package/src/vendor/react-native/Animated/useAnimatedProps.js

@@ -4,46 +4,37 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *
+ * @format
  * @format
  */
+
 'use strict'
 
-import _createForOfIteratorHelperLoose from '@babel/runtime/helpers/createForOfIteratorHelperLoose'
-import {
-  useLayoutEffect as _,
-  startTransition,
-  useCallback,
-  useEffect,
-  useMemo,
-  useReducer,
-  useRef,
-} from 'react'
-
-import useRefEffect from '../useRefEffect'
+import AnimatedProps from './nodes/AnimatedProps'
 import { AnimatedEvent } from './AnimatedEvent'
+import useRefEffect from '../Utilities/useRefEffect'
 import NativeAnimatedHelper from './NativeAnimatedHelper'
-import AnimatedProps from './nodes/AnimatedProps'
+import { useCallback, useEffect, useMemo, useReducer, useRef } from 'react'
+
+import { useLayoutEffect } from '@tamagui/react-native-web-internals'
 
-const useLayoutEffect = typeof window === 'undefined' ? useEffect : _
+// ReducedProps type removed
 
 export default function useAnimatedProps(props) {
-  var _useReducer = useReducer((count) => count + 1, 0),
-    scheduleUpdate = _useReducer[1]
+  const [, scheduleUpdate] = useReducer((count) => count + 1, 0)
+  const onUpdateRef = useRef(null)
 
-  var onUpdateRef = useRef(null) // TODO: Only invalidate `node` if animated props or `style` change. In the
+  // TODO: Only invalidate `node` if animated props or `style` change. In the
   // previous implementation, we permitted `style` to override props with the
   // same name property name as styles, so we can probably continue doing that.
   // The ordering of other props *should* not matter.
-
-  var node = useMemo(
-    () =>
-      new AnimatedProps(props, () =>
-        onUpdateRef.current == null ? void 0 : onUpdateRef.current()
-      ),
+  const node = useMemo(
+    () => new AnimatedProps(props, () => onUpdateRef.current?.()),
     [props]
   )
-  useAnimatedPropsLifecycle(node) // TODO: This "effect" does three things:
+  useAnimatedPropsLifecycle(node)
+
+  // TODO: This "effect" does three things:
   //
   //   1) Call `setNativeView`.
   //   2) Update `onUpdateRef`.
@@ -56,31 +47,27 @@ export default function useAnimatedProps(props) {
   //
   // But there is no way to transparently compose three separate callback refs,
   // so we just combine them all into one for now.
-
-  var refEffect = useCallback(
+  const refEffect = useCallback(
     (instance) => {
       // NOTE: This may be called more often than necessary (e.g. when `props`
       // changes), but `setNativeView` already optimizes for that.
-      node.setNativeView(instance) // NOTE: This callback is only used by the JavaScript animation driver.
+      node.setNativeView(instance)
 
+      // NOTE: This callback is only used by the JavaScript animation driver.
       onUpdateRef.current = () => {
         // Schedule an update for this component to update `reducedProps`,
         // but do not compute it immediately. If a parent also updated, we
         // need to merge those new props in before updating.
-        startTransition(() => {
-          scheduleUpdate()
-        })
+        scheduleUpdate()
       }
 
-      var target = getEventTarget(instance)
-      var events = []
-
-      for (var propName in props) {
-        var propValue = props[propName]
+      const target = getEventTarget(instance)
+      const events = []
 
+      for (const propName in props) {
+        const propValue = props[propName]
         if (propValue instanceof AnimatedEvent && propValue.__isNative) {
           propValue.__attach(target, propName)
-
           events.push([propName, propValue])
         }
       }
@@ -88,22 +75,15 @@ export default function useAnimatedProps(props) {
       return () => {
         onUpdateRef.current = null
 
-        for (
-          var _iterator = _createForOfIteratorHelperLoose(events), _step;
-          !(_step = _iterator()).done;
-
-        ) {
-          var _step$value = _step.value,
-            _propName = _step$value[0],
-            _propValue = _step$value[1]
-
-          _propValue.__detach(target, _propName)
+        for (const [propName, propValue] of events) {
+          propValue.__detach(target, propName)
         }
       }
     },
     [props, node]
   )
-  var callbackRef = useRefEffect(refEffect)
+  const callbackRef = useRefEffect(refEffect)
+
   return [reduceAnimatedProps(node), callbackRef]
 }
 
@@ -115,6 +95,7 @@ function reduceAnimatedProps(node) {
     collapsable: false,
   }
 }
+
 /**
  * Manages the lifecycle of the supplied `AnimatedProps` by invoking `__attach`
  * and `__detach`. However, this is more complicated because `AnimatedProps`
@@ -122,35 +103,33 @@ function reduceAnimatedProps(node) {
  * nodes. So in order to optimize this, we avoid detaching until the next attach
  * unless we are unmounting.
  */
-
 function useAnimatedPropsLifecycle(node) {
-  var prevNodeRef = useRef(null)
-  var isUnmountingRef = useRef(false)
+  const prevNodeRef = useRef(null)
+  const isUnmountingRef = useRef(false)
+
   useEffect(() => {
     // It is ok for multiple components to call `flushQueue` because it noops
     // if the queue is empty. When multiple animated components are mounted at
     // the same time. Only first component flushes the queue and the others will noop.
     NativeAnimatedHelper.API.flushQueue()
   })
+
   useLayoutEffect(() => {
     isUnmountingRef.current = false
     return () => {
       isUnmountingRef.current = true
     }
   }, [])
+
   useLayoutEffect(() => {
     node.__attach()
-
     if (prevNodeRef.current != null) {
-      var prevNode = prevNodeRef.current // TODO: Stop restoring default values (unless `reset` is called).
-
+      const prevNode = prevNodeRef.current
+      // TODO: Stop restoring default values (unless `reset` is called).
       prevNode.__restoreDefaultValues()
-
       prevNode.__detach()
-
       prevNodeRef.current = null
     }
-
     return () => {
       if (isUnmountingRef.current) {
         // NOTE: Do not restore default values on unmount, see D18197735.
@@ -163,17 +142,15 @@ function useAnimatedPropsLifecycle(node) {
 }
 
 function getEventTarget(instance) {
-  return typeof instance === 'object' &&
-    typeof (instance == null ? void 0 : instance.getScrollableNode) === 'function' // $FlowFixMe[incompatible-use] - Legacy instance assumptions.
+  return typeof instance === 'object' && typeof instance?.getScrollableNode === 'function'
     ? instance.getScrollableNode()
     : instance
-} // $FlowFixMe[unclear-type] - Legacy instance assumptions.
+}
 
 function isFabricInstance(instance) {
-  var _instance$getScrollRe
-
   return (
-    hasFabricHandle(instance) || // Some components have a setNativeProps function but aren't a host component
+    hasFabricHandle(instance) ||
+    // Some components have a setNativeProps function but aren't a host component
     // such as lists like FlatList and SectionList. These should also use
     // forceUpdate in Fabric since setNativeProps doesn't exist on the underlying
     // host component. This crazy hack is essentially special casing those lists and
@@ -181,38 +158,13 @@ function isFabricInstance(instance) {
     // If these components end up using forwardRef then these hacks can go away
     // as instance would actually be the underlying host component and the above check
     // would be sufficient.
-    hasFabricHandle(
-      instance == null
-        ? void 0
-        : instance.getNativeScrollRef == null
-        ? void 0
-        : instance.getNativeScrollRef()
-    ) ||
-    hasFabricHandle(
-      instance == null
-        ? void 0
-        : instance.getScrollResponder == null
-        ? void 0
-        : (_instance$getScrollRe = instance.getScrollResponder()) == null
-        ? void 0
-        : _instance$getScrollRe.getNativeScrollRef == null
-        ? void 0
-        : _instance$getScrollRe.getNativeScrollRef()
-    )
+    hasFabricHandle(instance?.getNativeScrollRef?.()) ||
+    hasFabricHandle(instance?.getScrollResponder?.()?.getNativeScrollRef?.())
   )
-} // $FlowFixMe[unclear-type] - Legacy instance assumptions.
+}
 
+// Legacy instance assumptions.
 function hasFabricHandle(instance) {
-  var _instance$_internalIn, _instance$_internalIn2
-
   // eslint-disable-next-line dot-notation
-  return (
-    (instance == null
-      ? void 0
-      : (_instance$_internalIn = instance['_internalInstanceHandle']) == null
-      ? void 0
-      : (_instance$_internalIn2 = _instance$_internalIn.stateNode) == null
-      ? void 0
-      : _instance$_internalIn2.canonical) != null
-  )
+  return instance?.['_internalInstanceHandle']?.stateNode?.canonical != null
 }

package/src/{Batchinator/index.tsx → vendor/react-native/Batchinator/index.js}

@@ -5,9 +5,12 @@
  * LICENSE file in the root directory of this source tree.
  *
  * @format
+ * @format
  */
 
-import InteractionManager from '../InteractionManager'
+'use strict'
+
+import { InteractionManager } from '@tamagui/react-native-web-internals'
 
 /**
  * A simple class for batching up invocations of a low-pri callback. A timeout is set to run the
@@ -19,7 +22,7 @@ import InteractionManager from '../InteractionManager'
  *
  *   class Widget extends React.Component {
  *     _batchedSave: new Batchinator(() => this._saveState, 1000);
- *     _saveState() {
+ *     _saveSate() {
  *       // save this.state to disk
  *     }
  *     componentDidUpdate() {
@@ -32,22 +35,20 @@ import InteractionManager from '../InteractionManager'
  *   }
  */
 class Batchinator {
-  private _callback: () => void
-  private _delay: number
-  private _taskHandle: { cancel: Function } | null = null
-
-  constructor(callback: () => void, delayMS: number) {
+  _callback
+  _delay
+  _taskHandle
+  constructor(callback, delayMS) {
     this._delay = delayMS
     this._callback = callback
   }
-
   /*
    * Cleanup any pending tasks.
    *
    * By default, if there is a pending task the callback is run immediately. Set the option abort to
    * true to not call the callback if it was pending.
    */
-  dispose(options: { abort: boolean } = { abort: false }) {
+  dispose(options = { abort: false }) {
     if (this._taskHandle) {
       this._taskHandle.cancel()
       if (!options.abort) {
@@ -56,12 +57,10 @@ class Batchinator {
       this._taskHandle = null
     }
   }
-
   schedule() {
     if (this._taskHandle) {
       return
     }
-
     const timeoutHandle = setTimeout(() => {
       this._taskHandle = InteractionManager.runAfterInteractions(() => {
         // Note that we clear the handle before invoking the callback so that if the callback calls
@@ -70,7 +69,6 @@ class Batchinator {
         this._callback()
       })
     }, this._delay)
-
     this._taskHandle = { cancel: () => clearTimeout(timeoutHandle) }
   }
 }

package/src/vendor/react-native/{NativeEventEmitter/index.js → EventEmitter/NativeEventEmitter.js}

@@ -4,14 +4,12 @@
  * 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 { invariant } from '@tamagui/react-native-web-internals'
-import { Platform } from '@tamagui/react-native-web-internals'
+'use strict'
 
+import { Platform, invariant } from '@tamagui/react-native-web-internals'
 import RCTDeviceEventEmitter from './RCTDeviceEventEmitter'
 
 /**
@@ -25,6 +23,8 @@ import RCTDeviceEventEmitter from './RCTDeviceEventEmitter'
  * can theoretically listen to `RCTDeviceEventEmitter` (although discouraged).
  */
 export default class NativeEventEmitter {
+  _nativeModule
+
   constructor(nativeModule) {
     if (Platform.OS === 'ios') {
       invariant(
@@ -36,63 +36,43 @@ export default class NativeEventEmitter {
   }
 
   addListener(eventType, listener, context) {
-    var _this$_nativeModule
-    ;(_this$_nativeModule = this._nativeModule) == null
-      ? void 0
-      : _this$_nativeModule.addListener(eventType)
-    var subscription = RCTDeviceEventEmitter.addListener(eventType, listener, context)
+    this._nativeModule?.addListener(eventType)
+    let subscription = RCTDeviceEventEmitter.addListener(eventType, listener, context)
+
     return {
       remove: () => {
         if (subscription != null) {
-          var _this$_nativeModule2
-          ;(_this$_nativeModule2 = this._nativeModule) == null
-            ? void 0
-            : _this$_nativeModule2.removeListeners(1) // $FlowFixMe[incompatible-use]
-
+          this._nativeModule?.removeListeners(1)
+          // $FlowFixMe[incompatible-use]
           subscription.remove()
           subscription = null
         }
       },
     }
   }
+
   /**
    * @deprecated Use `remove` on the EventSubscription from `addListener`.
    */
-
   removeListener(eventType, listener) {
-    var _this$_nativeModule3
-    ;(_this$_nativeModule3 = this._nativeModule) == null
-      ? void 0
-      : _this$_nativeModule3.removeListeners(1) // NOTE: This will report a deprecation notice via `console.error`.
+    this._nativeModule?.removeListeners(1)
+    // NOTE: This will report a deprecation notice via `console.error`.
     // $FlowFixMe[prop-missing] - `removeListener` exists but is deprecated.
-
     RCTDeviceEventEmitter.removeListener(eventType, listener)
   }
 
-  emit(eventType) {
-    for (
-      var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1;
-      _key < _len;
-      _key++
-    ) {
-      args[_key - 1] = arguments[_key]
-    }
-
+  emit(eventType, ...args) {
     // Generally, `RCTDeviceEventEmitter` is directly invoked. But this is
     // included for completeness.
     RCTDeviceEventEmitter.emit(eventType, ...args)
   }
 
   removeAllListeners(eventType) {
-    var _this$_nativeModule4
-
     invariant(
       eventType != null,
       '`NativeEventEmitter.removeAllListener()` requires a non-null argument.'
     )
-    ;(_this$_nativeModule4 = this._nativeModule) == null
-      ? void 0
-      : _this$_nativeModule4.removeListeners(this.listenerCount(eventType))
+    this._nativeModule?.removeListeners(this.listenerCount(eventType))
     RCTDeviceEventEmitter.removeAllListeners(eventType)
   }
 

package/src/vendor/react-native/{NativeEventEmitter → EventEmitter}/RCTDeviceEventEmitter.js

@@ -4,10 +4,12 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *
  * @format
  */
-import EventEmitter from '../emitter/EventEmitter' // FIXME: use typed events
+
+import EventEmitter from '../emitter/EventEmitter'
+
+// FIXME: use typed events
 
 /**
  * Global EventEmitter used by the native platform to emit events to JavaScript.

package/src/vendor/react-native/FillRateHelper/{index.tsx → index.js}

@@ -3,12 +3,11 @@
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @format
  */
 
-import type { FrameMetricProps } from '../VirtualizedList/VirtualizedListProps'
-
-export type FillRateInfo = Info
-
 class Info {
   any_blank_count = 0
   any_blank_ms = 0
@@ -22,38 +21,35 @@ class Info {
   sample_count = 0
 }
 
-type FrameMetrics = {
-  inLayout?: boolean
-  length: number
-  offset: number
+const defaultFrame = {
+  inLayout: false,
+  length: 0,
+  offset: 0,
 }
 
 const DEBUG = false
 
-let _listeners: Array<(info: Info) => void> = []
+let _listeners = []
 let _minSampleCount = 10
-let _sampleRate: number | null = DEBUG ? 1 : null
+let _sampleRate = DEBUG ? 1 : null
 
 /**
- * A helper class for detecting when the maximum fill rate of `VirtualizedList` is exceeded.
+ * A helper class for detecting when the maximem fill rate of `VirtualizedList` is exceeded.
  * By default the sampling rate is set to zero and this will do nothing. If you want to collect
- * samples (e.g., to log them), make sure to call `FillRateHelper.setSampleRate(0.0-1.0)`.
+ * samples (e.g. to log them), make sure to call `FillRateHelper.setSampleRate(0.0-1.0)`.
  *
  * Listeners and sample rate are global for all `VirtualizedList`s - typical usage will combine with
  * `SceneTracker.getActiveScene` to determine the context of the events.
  */
 class FillRateHelper {
-  private _anyBlankStartTime: number | null = null
-  private _enabled = false
-  private _getFrameMetrics: (
-    index: number,
-    props: FrameMetricProps
-  ) => FrameMetrics | null
-  private _info: Info = new Info()
-  private _mostlyBlankStartTime: number | null = null
-  private _samplesStartTime: number | null = null
-
-  static addListener(callback: (info: FillRateInfo) => void): { remove: () => void } {
+  _anyBlankStartTime = null
+  _enabled = false
+  _getFrameMetrics
+  _info = new Info()
+  _mostlyBlankStartTime = null
+  _samplesStartTime = null
+
+  static addListener(callback) {
     if (_sampleRate === null) {
       console.warn('Call `FillRateHelper.setSampleRate` before `addListener`.')
     }
@@ -65,17 +61,15 @@ class FillRateHelper {
     }
   }
 
-  static setSampleRate(sampleRate: number) {
+  static setSampleRate(sampleRate) {
     _sampleRate = sampleRate
   }
 
-  static setMinSampleCount(minSampleCount: number) {
+  static setMinSampleCount(minSampleCount) {
     _minSampleCount = minSampleCount
   }
 
-  constructor(
-    getFrameMetrics: (index: number, props: FrameMetricProps) => FrameMetrics | null
-  ) {
+  constructor(getFrameMetrics) {
     this._getFrameMetrics = getFrameMetrics
     this._enabled = (_sampleRate || 0) > Math.random()
     this._resetData()
@@ -84,7 +78,7 @@ class FillRateHelper {
   activate() {
     if (this._enabled && this._samplesStartTime == null) {
       DEBUG && console.debug('FillRateHelper: activate')
-      this._samplesStartTime = globalThis.performance.now()
+      this._samplesStartTime = global.performance.now()
     }
   }
 
@@ -92,17 +86,18 @@ class FillRateHelper {
     if (!this._enabled) {
       return
     }
-    const start = this._samplesStartTime
+    const start = this._samplesStartTime // const for flow
     if (start == null) {
       DEBUG && console.debug('FillRateHelper: bail on deactivate with no start time')
       return
     }
     if (this._info.sample_count < _minSampleCount) {
+      // Don't bother with under-sampled events.
       this._resetData()
       return
     }
-    const total_time_spent = globalThis.performance.now() - start
-    const info: Partial<Info> = {
+    const total_time_spent = global.performance.now() - start
+    const info = {
       ...this._info,
       total_time_spent,
     }
@@ -119,24 +114,16 @@ class FillRateHelper {
         mostly_blank_time_frac: this._info.mostly_blank_ms / total_time_spent,
       }
       for (const key in derived) {
-        ;(derived as any)[key] = Math.round(1000 * (derived as any)[key]) / 1000
+        // $FlowFixMe[prop-missing]
+        derived[key] = Math.round(1000 * derived[key]) / 1000
       }
       console.debug('FillRateHelper deactivateAndFlush: ', { derived, info })
     }
-    _listeners.forEach((listener) => listener(info as Info))
+    _listeners.forEach((listener) => listener(info))
     this._resetData()
   }
 
-  computeBlankness(
-    props: FrameMetricProps & { initialNumToRender?: number | null },
-    cellsAroundViewport: { first: number; last: number },
-    scrollMetrics: {
-      dOffset: number
-      offset: number
-      velocity: number
-      visibleLength: number
-    }
-  ): number {
+  computeBlankness(props, cellsAroundViewport, scrollMetrics) {
     if (
       !this._enabled ||
       props.getItemCount(props.data) === 0 ||
@@ -147,12 +134,15 @@ class FillRateHelper {
     }
     const { dOffset, offset, velocity, visibleLength } = scrollMetrics
 
+    // Denominator metrics that we track for all events - most of the time there is no blankness and
+    // we want to capture that.
     this._info.sample_count++
     this._info.pixels_sampled += Math.round(visibleLength)
     this._info.pixels_scrolled += Math.round(Math.abs(dOffset))
     const scrollSpeed = Math.round(Math.abs(velocity) * 1000) // px / sec
 
-    const now = globalThis.performance.now()
+    // Whether blank now or not, record the elapsed time blank if we were blank last time.
+    const now = global.performance.now()
     if (this._anyBlankStartTime != null) {
       this._info.any_blank_ms += now - this._anyBlankStartTime
     }
@@ -169,6 +159,8 @@ class FillRateHelper {
       firstFrame = this._getFrameMetrics(first, props)
       first++
     }
+    // Only count blankTop if we aren't rendering the first item, otherwise we will count the header
+    // as blank.
     if (firstFrame && first > 0) {
       blankTop = Math.min(visibleLength, Math.max(0, firstFrame.offset - offset))
     }
@@ -179,6 +171,8 @@ class FillRateHelper {
       lastFrame = this._getFrameMetrics(last, props)
       last--
     }
+    // Only count blankBottom if we aren't rendering the last item, otherwise we will count the
+    // footer as blank.
     if (lastFrame && last < props.getItemCount(props.data) - 1) {
       const bottomEdge = lastFrame.offset + lastFrame.length
       blankBottom = Math.min(
@@ -203,11 +197,11 @@ class FillRateHelper {
     return blankness
   }
 
-  enabled(): boolean {
+  enabled() {
     return this._enabled
   }
 
-  private _resetData() {
+  _resetData() {
     this._anyBlankStartTime = null
     this._info = new Info()
     this._mostlyBlankStartTime = null