@tamagui/native 2.0.0-rc.9 → 2.1.0

package/src/gestureState.ts

@@ -6,8 +6,123 @@ const state = createGlobalState<GestureState>(`gesture`, {
   Gesture: null,
   GestureDetector: null,
   ScrollView: null,
+  RootView: null,
 })
 
+type GestureEnabledFreezeState = {
+  frozen: boolean
+  enabled: boolean
+  warned: boolean
+}
+
+const GESTURE_ENABLED_FREEZE_KEY = '__tamagui_gesture_enabled_freeze__'
+
+function getGestureEnabledFreezeState(): GestureEnabledFreezeState {
+  const g = globalThis as typeof globalThis & {
+    [GESTURE_ENABLED_FREEZE_KEY]?: GestureEnabledFreezeState
+  }
+
+  if (!g[GESTURE_ENABLED_FREEZE_KEY]) {
+    g[GESTURE_ENABLED_FREEZE_KEY] = {
+      frozen: false,
+      enabled: false,
+      warned: false,
+    }
+  }
+
+  return g[GESTURE_ENABLED_FREEZE_KEY]!
+}
+
+function warnGestureEnabledMutationIgnored(source: string) {
+  const freezeState = getGestureEnabledFreezeState()
+
+  if (freezeState.warned || process.env.NODE_ENV === 'production') {
+    return
+  }
+
+  freezeState.warned = true
+
+  console.warn(
+    `[Tamagui] Ignored ${source} because gesture handler press events were already ` +
+      `${freezeState.enabled ? 'enabled' : 'disabled'} when TamaguiProvider mounted. ` +
+      `Configure gesture handler mode before the first render.`
+  )
+}
+
+export function canChangeGestureHandlerEnabled(
+  nextEnabled: boolean,
+  source: string
+): boolean {
+  const freezeState = getGestureEnabledFreezeState()
+
+  if (!freezeState.frozen || freezeState.enabled === nextEnabled) {
+    return true
+  }
+
+  warnGestureEnabledMutationIgnored(source)
+  return false
+}
+
+let pressGestureDebugId = 0
+let externalPressDebugId = 0
+
+// distance in dp the finger may travel before a press is treated as a
+// scroll/drag and cancelled. tracked in absolute (screen) coordinates by the
+// Tap's onTouchesMove (see createPressGesture) so a view translating under a
+// stationary finger - a sheet sliding on keyboard open/close, a sheet open
+// animation - does not cancel the press; only genuine finger travel does.
+// this also makes scroll-cancels-press work for any scroll container (a plain
+// RN ScrollView/FlatList or an RNGH one), since the press cancels itself
+// rather than relying on a parent RNGH gesture to steal it.
+const PRESS_MOVE_CANCEL_DISTANCE = 12
+const PRESS_MOVE_CANCEL_DISTANCE_SQ =
+  PRESS_MOVE_CANCEL_DISTANCE * PRESS_MOVE_CANCEL_DISTANCE
+
+// minimal shapes of the RNGH gesture events createPressGesture reads. RNGH is
+// injected at runtime (GestureState.Gesture is untyped), so this module keeps
+// no type dependency on react-native-gesture-handler - these name just the
+// fields the press gesture touches.
+type GesturePoint = {
+  absoluteX: number
+  absoluteY: number
+}
+type GestureBeginEvent = Partial<GesturePoint>
+type GestureTouchEvent = {
+  changedTouches?: GesturePoint[]
+  allTouches?: GesturePoint[]
+}
+
+type PressOwnerSource = 'internal' | 'external' | null
+
+function getEventPointerId(e: any): number | null {
+  const pointerId =
+    e?.pointerId ??
+    e?.pointer?.id ??
+    e?.event?.pointerId ??
+    e?.event?.pointer?.id ??
+    e?.nativeEvent?.pointerId ??
+    e?.nativeEvent?.id ??
+    e?.event?.nativeEvent?.pointerId ??
+    e?.event?.nativeEvent?.id ??
+    null
+
+  return pointerId == null || Number.isNaN(pointerId) ? null : Number(pointerId)
+}
+
+/**
+ * Global press coordination - ensures only innermost pressable fires press events,
+ * matching RN Pressable/responder system semantics where deepest component wins.
+ * Uses a grace period to allow child gestures to steal ownership from parent,
+ * since RNGH fires parent gestures before child gestures.
+ */
+const pressState = {
+  owner: null as object | null,
+  ownerId: null as number | null,
+  ownerSource: null as PressOwnerSource,
+  ownerPointerId: null as number | null,
+  timestamp: 0,
+}
+
 export interface Insets {
   top?: number
   left?: number
@@ -16,6 +131,7 @@ export interface Insets {
 }
 
 export type PressGestureConfig = {
+  debugName?: string | null
   onPressIn?: (e: any) => void
   onPressOut?: (e: any) => void
   onPress?: (e: any) => void
@@ -32,6 +148,49 @@ export interface GestureHandlerAccessor {
   createPressGesture(config: PressGestureConfig): any
 }
 
+export type ExternalPressOwnershipToken = object
+
+function resetPressOwner() {
+  pressState.owner = null
+  pressState.ownerId = null
+  pressState.ownerSource = null
+  pressState.ownerPointerId = null
+  pressState.timestamp = 0
+}
+
+function resetStaleOwner(now: number, debugName?: string | null) {
+  if (now - pressState.timestamp > 2000) {
+    resetPressOwner()
+  }
+}
+
+export function claimExternalPressOwnership(
+  debugName?: string | null
+): ExternalPressOwnershipToken {
+  const now = Date.now()
+  resetStaleOwner(now, debugName)
+
+  const token = {}
+  const ownerId = ++externalPressDebugId
+
+  pressState.owner = token
+  pressState.ownerId = ownerId
+  pressState.ownerSource = 'external'
+  pressState.timestamp = now
+
+  return token
+}
+
+export function releaseExternalPressOwnership(
+  token: ExternalPressOwnershipToken | null | undefined,
+  debugName?: string | null
+): void {
+  if (!token || pressState.owner !== token) {
+    return
+  }
+  resetPressOwner()
+}
+
 export function getGestureHandler(): GestureHandlerAccessor {
   return {
     get isEnabled(): boolean {
@@ -41,10 +200,21 @@ export function getGestureHandler(): GestureHandlerAccessor {
       return state.get()
     },
     set(updates: Partial<GestureState>): void {
+      if (
+        updates.enabled !== undefined &&
+        !canChangeGestureHandlerEnabled(updates.enabled, 'getGestureHandler().set()')
+      ) {
+        return
+      }
+
       Object.assign(state.get(), updates)
     },
 
     disable(): void {
+      if (!canChangeGestureHandlerEnabled(false, 'getGestureHandler().disable()')) {
+        return
+      }
+
       state.get().enabled = false
     },
 
@@ -54,19 +224,153 @@ export function getGestureHandler(): GestureHandlerAccessor {
 
       const longPressDuration = config.delayLongPress ?? 500
 
-      // Tap gesture for regular presses
-      // Use long maxDuration to not cancel during long presses
+      // unique token for this gesture instance - used to track ownership
+      const myToken = {}
+      const myDebugId = ++pressGestureDebugId
+      // mutable gesture state kept on an object so handler bodies that get
+      // workletized by react-native-worklets (>=0.7.4) see live values.
+      // primitive `let`s get frozen into the worklet's serialized __closure
+      // at factory time, so reassignments from workletized handlers never
+      // propagate out. object property mutation goes through the captured
+      // reference and is always observed.
+      const flags = {
+        didLongPress: false,
+        didPressIn: false,
+        pressInTimer: null as ReturnType<typeof setTimeout> | null,
+        // absolute (screen) coords of the press start, and whether the finger
+        // has since travelled far enough to be treated as a scroll/drag.
+        moveStartX: null as number | null,
+        moveStartY: 0,
+        cancelledByMove: false,
+      }
+
+      // Grace period for child gestures to steal ownership from parent.
+      // RNGH fires parent before child, but we want innermost to win.
+      // Claims typically span a few ms, 24ms gives enough room to observe
+      // ordering while debugging slower frames.
+      const GRACE_PERIOD_MS = process.env.TAMAGUI_RNGH_PRESS_DELAY
+        ? +process.env.TAMAGUI_RNGH_PRESS_DELAY
+        : 24
+
+      const tryClaimOwnership = (e: any) => {
+        const now = Date.now()
+        resetStaleOwner(now, config.debugName)
+
+        const currentPointerId = getEventPointerId(e)
+        const isSameTouchPointer =
+          currentPointerId == null ||
+          pressState.ownerPointerId == null ||
+          pressState.ownerPointerId === currentPointerId
+
+        if (
+          pressState.owner === null ||
+          (pressState.ownerSource === 'internal' && isSameTouchPointer)
+        ) {
+          pressState.owner = myToken
+          pressState.ownerId = myDebugId
+          pressState.ownerSource = 'internal'
+          pressState.ownerPointerId = currentPointerId
+          pressState.timestamp = now
+        }
+        return pressState.owner === myToken
+      }
+
+      const isOwner = () => pressState.owner === myToken
+
+      const releaseOwnership = () => {
+        if (flags.pressInTimer) {
+          clearTimeout(flags.pressInTimer)
+          flags.pressInTimer = null
+        }
+        if (pressState.owner === myToken) {
+          resetPressOwner()
+        }
+      }
+
+      const firePressIn = (e: any) => {
+        if (!flags.didPressIn && isOwner()) {
+          flags.didPressIn = true
+          config.onPressIn?.(e)
+        }
+      }
+
+      const schedulePressIn = (e: any) => {
+        if (flags.pressInTimer) {
+          clearTimeout(flags.pressInTimer)
+        }
+        flags.pressInTimer = setTimeout(() => {
+          flags.pressInTimer = null
+          if (isOwner()) {
+            firePressIn(e)
+          }
+        }, GRACE_PERIOD_MS + 1)
+      }
+
+      // Tap gesture for regular presses.
+      //
+      // maxDuration is long so long-presses aren't cut off. We deliberately do
+      // not use RNGH's .maxDistance(): it measures finger travel in the gesture
+      // view's own coordinate space, so a view that translates under a
+      // stationary finger (a sheet sliding on keyboard open/close, a sheet open
+      // animation) reads as finger movement and silently cancels the press -
+      // onPress never fires. Instead onTouchesMove tracks the finger in
+      // absolute (screen) coordinates and cancels only on genuine finger
+      // travel. That also makes scroll-cancels-press work for any scroll
+      // container, since the press cancels itself instead of depending on a
+      // parent RNGH gesture to steal the touch.
       const tap = Gesture.Tap()
         .runOnJS(true)
         .maxDuration(10000) // allow very long presses
-        .onBegin((e: any) => {
-          config.onPressIn?.(e)
+        .onBegin((e: GestureBeginEvent) => {
+          flags.didLongPress = false
+          flags.didPressIn = false
+          flags.cancelledByMove = false
+          flags.moveStartX = typeof e.absoluteX === 'number' ? e.absoluteX : null
+          flags.moveStartY = typeof e.absoluteY === 'number' ? e.absoluteY : 0
+          tryClaimOwnership(e)
+          // Defer onPressIn until after the grace window so child pressables
+          // can steal ownership, but flush it on tap end for very fast taps.
+          schedulePressIn(e)
+        })
+        .onTouchesMove((e: GestureTouchEvent) => {
+          if (flags.cancelledByMove || flags.moveStartX === null) return
+          const touch = e.changedTouches?.[0] ?? e.allTouches?.[0]
+          if (!touch) return
+          const dx = touch.absoluteX - flags.moveStartX
+          const dy = touch.absoluteY - flags.moveStartY
+          if (dx * dx + dy * dy <= PRESS_MOVE_CANCEL_DISTANCE_SQ) return
+          // finger has travelled far enough to be a scroll/drag, not a tap.
+          // release the pressStyle now (mid-scroll, so it doesn't stay stuck)
+          // and make onEnd skip onPress on finger lift.
+          flags.cancelledByMove = true
+          if (flags.pressInTimer) {
+            clearTimeout(flags.pressInTimer)
+            flags.pressInTimer = null
+          }
+          if (flags.didPressIn) {
+            flags.didPressIn = false
+            config.onPressOut?.(e)
+          }
+          releaseOwnership()
         })
-        .onEnd((e: any) => {
-          config.onPress?.(e)
+        .onEnd((e: unknown) => {
+          if (isOwner() && !flags.didLongPress && !flags.cancelledByMove) {
+            firePressIn(e)
+            config.onPress?.(e)
+          }
         })
-        .onFinalize((e: any) => {
-          config.onPressOut?.(e)
+        .onFinalize((e: unknown) => {
+          if (isOwner()) {
+            config.onPressOut?.(e)
+            releaseOwnership()
+          } else if (flags.didPressIn) {
+            // we already fired onPressIn but lost ownership before finalize
+            // (e.g. finger dragged onto a sibling pressable and that one
+            // claimed ownership). fire onPressOut so callers can clear their
+            // press state - otherwise pressStyle stays stuck on this view.
+            flags.didPressIn = false
+            config.onPressOut?.(e)
+          }
         })
 
       if (config.hitSlop) tap.hitSlop(config.hitSlop)
@@ -78,9 +382,13 @@ export function getGestureHandler(): GestureHandlerAccessor {
       const longPress = Gesture.LongPress()
         .runOnJS(true)
         .minDuration(longPressDuration)
-        .onBegin((e: any) => config.onPressIn?.(e))
-        .onStart((e: any) => config.onLongPress?.(e))
-        .onFinalize((e: any) => config.onPressOut?.(e))
+        .onStart((e: any) => {
+          flags.didLongPress = true
+          if (isOwner()) {
+            firePressIn(e)
+            config.onLongPress?.(e)
+          }
+        })
 
       if (config.hitSlop) longPress.hitSlop(config.hitSlop)
 

package/src/index.ts

@@ -42,7 +42,18 @@ export type { PortalAccessor } from './portalState'
 
 // gesture handler
 export { getGestureHandler } from './gestureState'
-export type { GestureHandlerAccessor, PressGestureConfig } from './gestureState'
+export {
+  claimExternalPressOwnership as unstable_claimExternalPressOwnership,
+  releaseExternalPressOwnership as unstable_releaseExternalPressOwnership,
+} from './gestureState'
+export type {
+  ExternalPressOwnershipToken,
+  GestureHandlerAccessor,
+  PressGestureConfig,
+} from './gestureState'
+// NOTE: setupGestureHandler is exported from setup-gesture-handler.ts entry point,
+// not here, to avoid bundler pulling in RNGH require during tree-shaking
+export type { GestureHandlerConfig } from './setup-gesture-handler'
 
 // worklets
 export { getWorklets } from './workletsState'
@@ -67,6 +78,7 @@ export type { KeyboardControllerState } from './keyboardControllerState'
 // zeego (native menus)
 export { getZeego } from './zeegoState'
 export type { ZeegoAccessor } from './zeegoState'
+export { NativeMenuContext } from './nativeMenuContext'
 
 // burnt (native toasts)
 export { getBurnt } from './burntState'

package/src/nativeMenuContext.ts

@@ -0,0 +1,4 @@
+import type React from 'react'
+import { createContext } from 'react'
+
+export const NativeMenuContext: React.Context<boolean> = createContext(false)

package/src/setup-gesture-handler.ts

@@ -5,41 +5,83 @@
  *
  * @example
  * ```tsx
+ * // auto-setup with all features enabled
  * import '@tamagui/native/setup-gesture-handler'
+ *
+ * // or configure selectively
+ * import { setupGestureHandler } from '@tamagui/native/setup-gesture-handler'
+ * setupGestureHandler({ pressEvents: true, sheet: false })
  * ```
  *
  * This automatically detects and configures react-native-gesture-handler
  * for use with Sheet and other gesture-aware components.
  */
 
-import { getGestureHandler } from './gestureState'
+import { canChangeGestureHandlerEnabled, getGestureHandler } from './gestureState'
+
+export interface GestureHandlerConfig {
+  /** use RNGH for press events on Tamagui components (default: true) */
+  pressEvents?: boolean
+  /** use RNGH for Sheet drag gestures (default: true) */
+  sheet?: boolean
+}
+
+let currentConfig: GestureHandlerConfig = {
+  pressEvents: true,
+  sheet: true,
+}
+
+export function getGestureHandlerConfig(): GestureHandlerConfig {
+  return currentConfig
+}
 
-function setup() {
+export function setupGestureHandler(config?: GestureHandlerConfig): void {
   const g = globalThis as any
-  if (g.__tamagui_native_gesture_setup_complete) {
-    return
+
+  // override config if provided
+  if (config) {
+    currentConfig = config
+
+    if (
+      config.pressEvents !== undefined &&
+      !canChangeGestureHandlerEnabled(
+        config.pressEvents !== false,
+        'setupGestureHandler()'
+      )
+    ) {
+      currentConfig = {
+        ...currentConfig,
+        pressEvents: getGestureHandler().isEnabled,
+      }
+    }
   }
+
+  // allow re-running setup to change config
+  const isFirstRun = !g.__tamagui_native_gesture_setup_complete
   g.__tamagui_native_gesture_setup_complete = true
 
   try {
     // dynamically require RNGH - it should already be imported by the app
     const rngh = require('react-native-gesture-handler')
-    const { Gesture, GestureDetector, ScrollView } = rngh
+    const { Gesture, GestureDetector, ScrollView, GestureHandlerRootView } = rngh
 
     if (Gesture && GestureDetector) {
+      // only enable if pressEvents is true
       getGestureHandler().set({
-        enabled: true,
+        enabled: currentConfig.pressEvents !== false,
         Gesture,
         GestureDetector,
         ScrollView: ScrollView || null,
+        RootView: GestureHandlerRootView || null,
       })
 
-      // also set on the legacy key for backward compat with @tamagui/sheet
+      // sheet state - only enable if sheet is true
       g.__tamagui_sheet_gesture_state__ = {
-        enabled: true,
+        enabled: currentConfig.sheet !== false,
         Gesture,
         GestureDetector,
         ScrollView: ScrollView || null,
+        RootView: GestureHandlerRootView || null,
       }
     }
   } catch {
@@ -47,5 +89,5 @@ function setup() {
   }
 }
 
-// run setup immediately on import
-setup()
+// run setup immediately on import (can be overridden by calling setupGestureHandler)
+setupGestureHandler()

package/src/types.ts

@@ -10,6 +10,10 @@ export interface GestureState {
   Gesture: any
   GestureDetector: any
   ScrollView: any
+  // rngh's GestureHandlerRootView. native portals can render outside the app's
+  // root gesture view, so components that portal rngh gestures need to
+  // re-establish one around their content.
+  RootView: any
 }
 
 export interface WorkletsState {

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "isolatedDeclarations": true
+  },
+  "exclude": [
+    "types",
+    "dist",
+    "**/__tests__"
+  ]
+}

package/types/PressBoundary.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import { View, type ViewProps } from "react-native";
+export interface PressBoundaryProps extends ViewProps {
+	enabled?: boolean;
+	/**
+	* Alias for enabling the boundary. The behavior is limited to Tamagui's
+	* shared press ownership and does not patch arbitrary RN bubbling.
+	*/
+	stopPropagation?: boolean;
+	debugName?: string | null;
+}
+export declare const PressBoundary: React.ForwardRefExoticComponent<PressBoundaryProps & React.RefAttributes<View>>;
+
+//# sourceMappingURL=PressBoundary.d.ts.map

package/types/PressBoundary.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,OAAO,WAAW;AAClB,SAAS,WAAW,iBAAiB;AAOrC,iBAAiB,2BAA2B,UAAU;CACpD;;;;;CAKA;CACA;;AAiBF,OAAO,cAAM,eAAe,MAAM,0BAChC,qBAAqB,MAAM,cAAc",
+  "names": [],
+  "sources": [
+    "src/PressBoundary.tsx"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import React from 'react'\nimport { View, type ViewProps } from 'react-native'\nimport {\n  claimExternalPressOwnership,\n  releaseExternalPressOwnership,\n  type ExternalPressOwnershipToken,\n} from './gestureState'\n\nexport interface PressBoundaryProps extends ViewProps {\n  enabled?: boolean\n  /**\n   * Alias for enabling the boundary. The behavior is limited to Tamagui's\n   * shared press ownership and does not patch arbitrary RN bubbling.\n   */\n  stopPropagation?: boolean\n  debugName?: string | null\n}\n\nfunction composeFirst<T extends (...args: any[]) => void>(ours: T, theirs?: T) {\n  return (...args: Parameters<T>) => {\n    ours(...args)\n    theirs?.(...args)\n  }\n}\n\nfunction composeLast<T extends (...args: any[]) => void>(theirs: T | undefined, ours: T) {\n  return (...args: Parameters<T>) => {\n    theirs?.(...args)\n    ours(...args)\n  }\n}\n\nexport const PressBoundary: React.ForwardRefExoticComponent<\n  PressBoundaryProps & React.RefAttributes<View>\n> = React.forwardRef<View, PressBoundaryProps>(function PressBoundary(\n  {\n    enabled,\n    stopPropagation,\n    debugName,\n    onTouchStart,\n    onTouchEnd,\n    onTouchCancel,\n    onResponderGrant,\n    onResponderRelease,\n    onResponderTerminate,\n    ...props\n  },\n  forwardedRef\n) {\n  const tokenRef = React.useRef<ExternalPressOwnershipToken | null>(null)\n  const isEnabled = enabled ?? stopPropagation ?? true\n\n  const claim = React.useCallback((): void => {\n    if (!isEnabled) return\n    if (tokenRef.current) {\n      releaseExternalPressOwnership(tokenRef.current, debugName)\n    }\n    tokenRef.current = claimExternalPressOwnership(debugName)\n  }, [debugName, isEnabled])\n\n  const release = React.useCallback((): void => {\n    if (!tokenRef.current) return\n    releaseExternalPressOwnership(tokenRef.current, debugName)\n    tokenRef.current = null\n  }, [debugName])\n\n  React.useEffect(() => release, [release])\n\n  return (\n    <View\n      ref={forwardedRef}\n      {...props}\n      onTouchStart={composeFirst(claim, onTouchStart)}\n      onTouchEnd={composeLast(onTouchEnd, release)}\n      onTouchCancel={composeLast(onTouchCancel, release)}\n      onResponderGrant={composeFirst(claim, onResponderGrant)}\n      onResponderRelease={composeLast(onResponderRelease, release)}\n      onResponderTerminate={composeLast(onResponderTerminate, release)}\n    />\n  )\n})\n"
+  ]
+}

package/types/burntState.d.ts.map

@@ -4,8 +4,8 @@
   "sources": [
     "src/burntState.ts"
   ],
+  "version": 3,
   "sourcesContent": [
     "import { createGlobalState } from './globalState'\nimport type { BurntState } from './types'\n\nconst state = createGlobalState<BurntState>(`burnt`, {\n  enabled: false,\n  toast: null,\n  dismissAllAlerts: null,\n})\n\nexport interface BurntAccessor {\n  readonly isEnabled: boolean\n  readonly state: BurntState\n  set(newState: BurntState): void\n}\n\nexport function getBurnt(): BurntAccessor {\n  return {\n    get isEnabled(): boolean {\n      return state.get().enabled\n    },\n    get state(): BurntState {\n      return state.get()\n    },\n    set(newState: BurntState): void {\n      state.set(newState)\n    },\n  }\n}\n"
-  ],
-  "version": 3
+  ]
 }

package/types/components.d.ts.map

@@ -4,8 +4,8 @@
   "sources": [
     "src/components.tsx"
   ],
+  "version": 3,
   "sourcesContent": [
     "import type { ReactNode } from 'react'\nimport { getPortal } from './portalState'\nimport type {\n  NativePortalProps,\n  NativePortalHostProps,\n  NativePortalProviderProps,\n} from './types'\n\nexport type { NativePortalProps, NativePortalHostProps, NativePortalProviderProps }\n\n/**\n * Renders children into a teleport Portal when available.\n * Returns null when teleport is not set up (allows fallback handling by caller).\n */\nexport function NativePortal({\n  hostName = 'root',\n  children,\n}: NativePortalProps): ReactNode {\n  const state = getPortal().state\n  if (state.type !== 'teleport') return null\n\n  const { Portal } = (globalThis as any).__tamagui_teleport\n  return <Portal hostName={hostName}>{children}</Portal>\n}\n\n/**\n * Renders a teleport PortalHost when available.\n * Returns null when teleport is not set up.\n */\nexport function NativePortalHost({ name }: NativePortalHostProps): ReactNode {\n  const state = getPortal().state\n  if (state.type !== 'teleport') return null\n\n  const { PortalHost } = (globalThis as any).__tamagui_teleport\n  return <PortalHost name={name} />\n}\n\n/**\n * Wraps children with teleport PortalProvider when available.\n * Returns children as-is when teleport is not set up.\n */\nexport function NativePortalProvider({ children }: NativePortalProviderProps): ReactNode {\n  const state = getPortal().state\n  if (state.type !== 'teleport') return <>{children}</>\n\n  const { PortalProvider } = (globalThis as any).__tamagui_teleport\n  return <PortalProvider>{children}</PortalProvider>\n}\n"
-  ],
-  "version": 3
+  ]
 }

package/types/gesture-handler.d.ts

@@ -0,0 +1,8 @@
+export { getGestureHandler } from "./gestureState";
+export type { ExternalPressOwnershipToken, GestureHandlerAccessor, PressGestureConfig } from "./gestureState";
+export { claimExternalPressOwnership as unstable_claimExternalPressOwnership, releaseExternalPressOwnership as unstable_releaseExternalPressOwnership } from "./gestureState";
+export { PressBoundary } from "./PressBoundary";
+export type { PressBoundaryProps } from "./PressBoundary";
+export { getGestureHandlerConfig, setupGestureHandler, type GestureHandlerConfig } from "./setup-gesture-handler";
+
+//# sourceMappingURL=gesture-handler.d.ts.map

package/types/gesture-handler.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,SAAS,yBAAyB;AAClC,cACE,6BACA,wBACA,0BACK;AACP,SACE,+BAA+B,sCAC/B,iCAAiC,8CAC5B;AACP,SAAS,qBAAqB;AAC9B,cAAc,0BAA0B;AACxC,SACE,yBACA,0BACK,4BACA",
+  "names": [],
+  "sources": [
+    "src/gesture-handler.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "export { getGestureHandler } from './gestureState'\nexport type {\n  ExternalPressOwnershipToken,\n  GestureHandlerAccessor,\n  PressGestureConfig,\n} from './gestureState'\nexport {\n  claimExternalPressOwnership as unstable_claimExternalPressOwnership,\n  releaseExternalPressOwnership as unstable_releaseExternalPressOwnership,\n} from './gestureState'\nexport { PressBoundary } from './PressBoundary'\nexport type { PressBoundaryProps } from './PressBoundary'\nexport {\n  getGestureHandlerConfig,\n  setupGestureHandler,\n  type GestureHandlerConfig,\n} from './setup-gesture-handler'\n"
+  ]
+}

package/types/gestureState.d.ts

@@ -1,4 +1,5 @@
 import type { GestureState } from "./types";
+export declare function canChangeGestureHandlerEnabled(nextEnabled: boolean, source: string): boolean;
 export interface Insets {
 	top?: number;
 	left?: number;
@@ -6,6 +7,7 @@ export interface Insets {
 	right?: number;
 }
 export type PressGestureConfig = {
+	debugName?: string | null;
 	onPressIn?: (e: any) => void;
 	onPressOut?: (e: any) => void;
 	onPress?: (e: any) => void;
@@ -20,6 +22,9 @@ export interface GestureHandlerAccessor {
 	disable(): void;
 	createPressGesture(config: PressGestureConfig): any;
 }
+export type ExternalPressOwnershipToken = object;
+export declare function claimExternalPressOwnership(debugName?: string | null): ExternalPressOwnershipToken;
+export declare function releaseExternalPressOwnership(token: ExternalPressOwnershipToken | null | undefined, debugName?: string | null): void;
 export declare function getGestureHandler(): GestureHandlerAccessor;
 
 //# sourceMappingURL=gestureState.d.ts.map