react-native-gtkx 0.2.0-alpha.2 → 0.3.0-alpha.1

package/dist/gesture-handler-compat/index.js

@@ -0,0 +1,255 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { View } from "../components/view";
+import { createUnsupportedFactory } from "../unsupported-export";
+import { Gesture } from "./builder";
+import { GestureDetector } from "./detector";
+import { useCompetingGestures, useExclusiveGestures, useFlingGesture, useHoverGesture, useLongPressGesture, useManualGesture, useNativeGesture, usePanGesture, usePinchGesture, useRotationGesture, useSimultaneousGestures, useTapGesture, } from "./hooks";
+import { DIRECTIONS, GESTURE_STATE, HOVER_EFFECT, MOUSE_BUTTON, POINTER_TYPE, } from "./types";
+export { Gesture, GestureDetector, useCompetingGestures, useExclusiveGestures, useFlingGesture, useHoverGesture, useLongPressGesture, useManualGesture, useNativeGesture, usePanGesture, usePinchGesture, useRotationGesture, useSimultaneousGestures, useTapGesture, };
+export { FlingGestureBuilder, ForceTouchGestureBuilder, HoverGestureBuilder, LongPressGestureBuilder, ManualGestureBuilder, NativeGestureBuilder, PanGestureBuilder, PinchGestureBuilder, RotationGestureBuilder, TapGestureBuilder, } from "./builder";
+/**
+ * Upstream's default, and note that it is `style ?? {flex: 1}` rather than
+ * `[{flex: 1}, style]`: passing a style REPLACES the flex box, it does not
+ * merge with it. Verified against react-native-gesture-handler 3.1.0, where
+ * all three implementations (`.tsx`, `.web.tsx`, `.android.tsx`) agree on
+ * `<View style={style ?? styles.container} {...rest} />`. The difference is
+ * observable — with `style={{height: 100}}` upstream gives a 100px-tall box
+ * with no `flex`, and a merged version would give a flexing one.
+ */
+const ROOT_STYLE = { flex: 1 };
+/**
+ * The root box `react-native-gesture-handler` asks apps to put at the top of
+ * the tree.
+ *
+ * Faithful, not merely tolerated. Upstream's does two things: it renders a
+ * `flex: 1` `View`, and it marks the subtree as gesture-arbitrating. The
+ * first is reproduced exactly. The second is genuinely this platform's job
+ * already — RN's own gesture responder system is implemented here on GTK4
+ * event controllers (#41), and its lock is global — so there is no context to
+ * provide and nothing is being skipped.
+ */
+export const GestureHandlerRootView = ({ children, style, testID, }) => (_jsx(View, { style: style ?? ROOT_STYLE, testID: testID, children: children }));
+const unsupported = createUnsupportedFactory("react-native-gesture-handler", "Implemented: GestureHandlerRootView, GestureDetector, `State`, `Directions`, `HoverEffect`, " +
+    "the re-exported ScrollView/FlatList/TextInput/Switch and the three Touchables, and ALL TEN " +
+    "recognizers — Pan, Tap, LongPress, Native, Pinch, Rotation, Fling, Manual, Hover and " +
+    "ForceTouch — in both spellings where upstream has two (`Gesture.Pan()` and " +
+    "`usePanGesture()`, and so on), plus the three cross-gesture relations and the three " +
+    "composers. Three of them need input a mouse cannot produce: Pinch and Rotation need a " +
+    "TOUCHPAD (GtkGestureZoom/GtkGestureRotate) and ForceTouch needs a pressure-reporting " +
+    "STYLUS (GtkGestureStylus). RN's own responder system and PanResponder also work " +
+    "(docs/api.md); drag-and-drop is react-native-gtkx/dnd.");
+// Every runtime value `react-native-gesture-handler` 3.1.0 exports, minus
+// GestureHandlerRootView above. Enumerated rather than generated by a Proxy
+// over the module, because ESM named imports are resolved statically: a
+// symbol that is not exported here fails at BUILD time with "no export named
+// X", which is loud in its own right — but only the names listed here can
+// produce the descriptive runtime message, so the list is worth keeping
+// complete.
+//
+// The `any` is deliberate and load-bearing: an app's `<PanGestureHandler>`
+// must still type-check (it type-checks against the REAL package anyway, see
+// the note at the top) and fail when it runs, not before.
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// --- the legacy handler components ---
+//
+// ALL NINE STAY REFUSED, and now that every recognizer behind them is
+// implemented the reason is worth stating precisely rather than leaving as a
+// bare `unsupported()`: these are not gestures, they are the RNGH **1.x
+// component API** — `<PanGestureHandler onGestureEvent={...}><View/></PanGestureHandler>`
+// — which upstream deprecated years before it deprecated the builder, and
+// which every one of the four libraries this epic targets has already
+// migrated off. Reimplementing them would mean a second public surface over
+// the same recognizers, with its own `onGestureEvent`/`onHandlerStateChange`
+// event shape, its own `enabled`/`waitFor` prop plumbing and its own
+// `createHandler` HOC — for zero measured consumers and a spelling upstream is
+// removing. `Gesture.Pan()` and `usePanGesture()` are the two spellings that
+// exist here, which is one more than upstream is keeping.
+//
+// The message each throws names itself, so an app on the old API is told which
+// symbol to migrate rather than left with a missing export.
+export const FlingGestureHandler = unsupported("FlingGestureHandler");
+export const ForceTouchGestureHandler = unsupported("ForceTouchGestureHandler");
+export const LongPressGestureHandler = unsupported("LongPressGestureHandler");
+export const NativeViewGestureHandler = unsupported("NativeViewGestureHandler");
+export const PanGestureHandler = unsupported("PanGestureHandler");
+export const PinchGestureHandler = unsupported("PinchGestureHandler");
+export const RotationGestureHandler = unsupported("RotationGestureHandler");
+export const TapGestureHandler = unsupported("TapGestureHandler");
+// `createNativeWrapper(Component, config)` attaches a `NativeViewGestureHandler`
+// to an arbitrary RN component. On this platform the responder system IS the
+// arbitration that wrapper registers with, every component this package ships
+// already speaks it, and `Gesture.Native()` is how a gesture is declared over
+// one explicitly — so the wrapper has nothing to add and would be a no-op
+// dressed as a feature. The re-exported ScrollView/FlatList/Touchables below
+// are that reasoning applied to the components upstream wraps itself.
+export const legacy_createNativeWrapper = unsupported("legacy_createNativeWrapper");
+// --- the new (v3) gesture API ---
+// `Gesture`, `GestureDetector`, the nine gesture hooks and the three composer
+// hooks are re-exported at the top of this file. `Gesture` is a real namespace
+// and none of its statics throws any more.
+//
+// The four below are refused for four different reasons, none of them "not got
+// round to it":
+//
+//   - `GestureDetectorType` is a TYPE upstream, not a value. It only ever
+//     appears in a type position, where this module is not in the path at all
+//     (the alias is a BUNDLER alias; `tsc` resolves the real package's types
+//     from node_modules — see the note at the top of this file). A runtime
+//     value under that name could only be reached by code that has already
+//     gone wrong;
+//   - `GestureStateManager` is upstream's standalone FACTORY, `create(tag)`,
+//     which looks a mounted handler up by tag in a global `NodeManager`. The
+//     manager an app actually uses is the one handed into `onTouchesDown` /
+//     `onTouchesMove` / `onTouchesUp` / `onTouchesCancel`, and that one IS
+//     implemented — it is what drives `Gesture.Manual()`. What is missing is
+//     the global tag→handler registry, and its absence is deliberate: identity
+//     here is the mounted detector, and ./relations resolves an app's gesture
+//     object to a tag lazily precisely so that nothing has to be looked up in
+//     a process-wide map. Upstream marks this export deprecated in favour of
+//     the hook API in the same breath;
+//   - `InterceptingGestureDetector` and `VirtualGestureDetector` are 3.1.0's
+//     new experimental detectors. The first intercepts events destined for
+//     views BELOW it, which on this platform would mean claiming a GTK
+//     sequence before deciding — and `CLAIMED` is irrevocable here, so the
+//     "intercept, look, maybe give back" shape is not expressible. The second
+//     drives a gesture with no view at all, which needs the tag registry the
+//     entry above says why this platform does not have.
+export const GestureDetectorType = unsupported("GestureDetectorType");
+export const GestureStateManager = unsupported("GestureStateManager");
+export const InterceptingGestureDetector = unsupported("InterceptingGestureDetector");
+export const VirtualGestureDetector = unsupported("VirtualGestureDetector");
+// --- enums and constants ---
+//
+// ALL FIVE ARE NOW DATA, and the last four changed here. The old rule was that
+// an enum is only meaningful next to a handler that can run, so reading one
+// was already a symptom — and that rule was right when six of the ten
+// recognizers threw. It stopped describing anything true when the last four
+// shipped, and the honest test is now the plain one: does an app comparing
+// against this constant get a correct answer? For every one of these, yes.
+//
+// `State` went first, in slice 2, and the reasoning generalises to the rest:
+// every payload carries a faithful `state`, so `=== State.ACTIVE` is ordinary
+// correct code. `react-native-drawer-layout` does exactly that — it re-exports
+// it as `GestureState`, seeds a shared value with `GestureState.UNDETERMINED`
+// and tests `=== GestureState.ACTIVE`.
+//
+// `Directions` is REQUIRED rather than merely harmless: `Gesture.Fling()`
+// takes a direction and this is the enum it takes. A refusal here would make
+// the recognizer unusable in its documented spelling.
+//
+// `PointerType` became meaningful with `ForceTouch`, which is the first kind
+// whose events are honestly not a mouse — every payload carries `pointerType`,
+// and a stylus one says `STYLUS`.
+//
+// `HoverEffect` and `MouseButton` are INERT and exported anyway, which is the
+// one place this file's rule bends. Both name values for knobs that are
+// already accepted-and-inert here (`.effect()`, `.mouseButton()`) exactly as
+// they are inert off their platforms upstream, and a knob that accepts a
+// number while refusing the constant that number has a name for is incoherent.
+// The refusal that matters is for something that would silently NOT WORK;
+// these do exactly what they do upstream on this platform, which is nothing.
+//
+// Every number in all five is pinned by a test against 3.1.0's own sources,
+// because nothing about a wrong one is loud: `state === State.ACTIVE` and
+// `direction === Directions.LEFT` both go on compiling, go on running, and
+// quietly answer false.
+export const State = GESTURE_STATE;
+export const Directions = DIRECTIONS;
+export const HoverEffect = HOVER_EFFECT;
+export const MouseButton = MOUSE_BUTTON;
+export const PointerType = POINTER_TYPE;
+// --- the wrapped RN components and buttons ---
+//
+// Upstream builds every one of these with `createNativeWrapper(RN.X, {
+// disallowInterruption: true, shouldCancelWhenOutside: false })` — an RN
+// component with a `NativeViewGestureHandler` attached, so that RNGH's
+// arbitration knows about the native scrolling or the native press underneath.
+// On this platform that wrapper has nothing to add: the responder system IS
+// the arbitration these are being registered with, every one of these
+// components already speaks it, and `Gesture.Native()` is how a gesture is
+// declared over one of them explicitly. So the honest re-export is the
+// platform's own component, unwrapped.
+//
+// They are here because they are RENDERED, not merely imported.
+// `react-native-draggable-flatlist` 4.0.3 hands `FlatList` and `ScrollView` to
+// `Animated.createAnimatedComponent()` at module scope in
+// `DraggableFlatList.tsx` and `NestableScrollContainer.tsx`, which is what
+// stopped that library at IMPORT rather than at use;
+// `react-native-reanimated-dnd`'s `Sortable`/`SortableGrid` do the same;
+// `@gorhom/bottom-sheet` re-exports the three Touchables from its own public
+// entry as `BottomSheetTouchable` on every platform except iOS, and renders
+// `TextInput` as `BottomSheetTextInput`.
+//
+// WHAT IS NOT HERE, and the boundary is upstream's own: the BUTTON family
+// (`RawButton`, `BaseButton`, `RectButton`, `BorderlessButton`) is not RN
+// components with a handler attached — it is RNGH's own NATIVE BUTTON VIEWS,
+// implemented in Java and Objective-C, with an Android ripple
+// (`TouchableNativeFeedback`'s), `borderless` drawable selection, `rippleColor`
+// / `rippleRadius`, `exclusive`, and an `activeOpacity` applied by the native
+// view rather than by style. There is no GTK widget with those semantics and
+// no way to fake the ripple, so any implementation would be a `Pressable`
+// wearing the name of something else — which is precisely the silent
+// substitution this whole surface refuses.
+//
+// RE-CHECKED WITH THE FOUR TARGET LIBRARIES rather than assumed, because that
+// is what settled the `Touchable` question in slice 4. Sweeping the shipped
+// sources of `@gorhom/bottom-sheet` 5.2.14, `react-native-draggable-flatlist`
+// 4.0.3, `react-native-drawer-layout` 4.2.9 and `react-native-reanimated-dnd`
+// 2.0.0 for every symbol still refused here finds exactly one hit —
+// `RefreshControl` in `@gorhom/bottom-sheet` — and it is not this package's:
+// it is imported from `react-native`, as a type in `bottomSheetRefreshControl/
+// index.ts` and as a value only in `BottomSheetRefreshControl.android.tsx`,
+// which Metro on this platform never resolves (`.linux.* -> .native.* -> .*`).
+// Nothing reaches for a button, a legacy handler component, `Directions`,
+// `MouseButton`, `PointerType`, `GestureStateManager` or any `Legacy*` alias.
+// The `Touchable` subset slice 4 shipped remains the only thing upstream's own
+// exports forced.
+//
+// `TouchableNativeFeedback` is Android's ripple by another name and `Touchable`
+// is RN's deprecated mixin; both stay refused for the reason RN itself would
+// not give them to you here. `RefreshControl` is pull-to-refresh, which needs
+// a scroll gesture this platform's `ScrollView` does not expose and a spinner
+// widget it does not have — and, per the sweep above, nothing asks for it.
+export const BaseButton = unsupported("BaseButton");
+export const BorderlessButton = unsupported("BorderlessButton");
+export { FlatList } from "../components/flat-list";
+export { Pressable, TouchableHighlight, TouchableOpacity, TouchableWithoutFeedback, } from "../components/pressable";
+export { ScrollView } from "../components/scroll-view";
+export { Switch } from "../components/switch";
+export { TextInput } from "../components/text-input";
+export const RawButton = unsupported("RawButton");
+export const RectButton = unsupported("RectButton");
+export const RefreshControl = unsupported("RefreshControl");
+export const Touchable = unsupported("Touchable");
+export const TouchableNativeFeedback = unsupported("TouchableNativeFeedback");
+// --- the 2.x legacy aliases, still exported by 3.x ---
+//
+// ALL TWELVE STAY REFUSED, for one reason that covers them: each is 3.x's
+// escape hatch back to the 2.x implementation of a component whose 3.x
+// spelling is either implemented here already (`LegacyScrollView`,
+// `LegacyFlatList`, `LegacyTextInput`, `LegacySwitch`, `LegacyPressable`,
+// `LegacyText`) or refused above with its own reason (`LegacyRawButton`,
+// `LegacyBaseButton`, `LegacyRectButton`, `LegacyBorderlessButton`,
+// `LegacyRefreshControl`). Where the modern name works, the legacy alias would
+// be a second name for the same component with a promise attached — "this one
+// behaves like 2.x did" — that this platform cannot keep, because it never
+// implemented 2.x's behaviour to differ from. Where the modern name is
+// refused, the alias inherits the refusal.
+//
+// `LegacyDrawerLayoutAndroid` is the odd one and is refused twice over: it is
+// Android's `DrawerLayoutAndroid`, which React Native itself does not ship off
+// Android, and `@react-navigation/drawer` reaches for
+// `react-native-drawer-layout` instead — which runs here (probe 3).
+export const LegacyBaseButton = unsupported("LegacyBaseButton");
+export const LegacyBorderlessButton = unsupported("LegacyBorderlessButton");
+export const LegacyDrawerLayoutAndroid = unsupported("LegacyDrawerLayoutAndroid");
+export const LegacyFlatList = unsupported("LegacyFlatList");
+export const LegacyPressable = unsupported("LegacyPressable");
+export const LegacyRawButton = unsupported("LegacyRawButton");
+export const LegacyRectButton = unsupported("LegacyRectButton");
+export const LegacyRefreshControl = unsupported("LegacyRefreshControl");
+export const LegacyScrollView = unsupported("LegacyScrollView");
+export const LegacySwitch = unsupported("LegacySwitch");
+export const LegacyText = unsupported("LegacyText");
+export const LegacyTextInput = unsupported("LegacyTextInput");
+//# sourceMappingURL=index.js.map

package/dist/gesture-handler-compat/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/index.tsx"],"names":[],"mappings":"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","sourcesContent":["// react-native-gtkx/gesture-handler — all ten recognizers, `GestureDetector`,\n// the relations and the root view, reimplemented over this platform's own\n// responder system, and a loud refusal for what is left.\n//\n// WHAT IS LEFT is now a short and deliberate list rather than a backlog: the\n// RNGH 1.x component API, the native button family, and the three exports that\n// need a process-wide handler-tag registry this platform does not keep. Each\n// carries its reason where it is declared below and in docs/api.md, because a\n// refusal that does not say why is indistinguishable from one nobody has\n// revisited — which is exactly what happened to `Gesture.Hover()`, refused for\n// a year on a judgement about the test rig that turned out to be wrong.\n//\n// NOT A PORT. `docs/research/gestures.md` refused RNGH on four grounds, two of\n// which expired when `react-native-gtkx/reanimated` shipped; the other two —\n// no `exports` map on `src/web/`, no out-of-tree platform story, and a\n// react-native-windows precedent that has been a literal `// NO-OP` since\n// 2.8.0 — stand. So this is the third instance of the pattern that has worked\n// twice already: reimplement the SEMANTICS behind the package name, take the\n// upstream implementation as a blueprint rather than as a dependency. The\n// recognizer and its arbitration are the implementation (see ./recognizer,\n// ./pan); `Gesture.Pan()` and `usePanGesture()` are two thin spellings over\n// it, which is the mistake upstream made and had to undo in 3.1.0.\n//\n// The root view came first and for its own reason: exactly one RNGH symbol\n// appears in apps that do not otherwise use RNGH — `GestureHandlerRootView`.\n// Every drag-and-drop app has it at the root, because\n// `react-native-reanimated-dnd`'s own quick start puts it there.\n//\n// WHY it is not a bare passthrough. `GestureHandlerRootView` is a real layout\n// box: upstream renders `<View style={style ?? {flex: 1}}>`, so an app that\n// leans on that box to fill the screen would collapse without it. Rendering\n// only the children would be a simplification, not a shim. See `ROOT_STYLE`.\n//\n// WHY everything else throws rather than no-oping. docs/research/gestures.md\n// records the failure mode this repo most wants to avoid: `Animated.View`\n// silently accepting the responder props and ignoring them compiled, ran, and\n// did nothing — \"the worst possible failure mode\". A `PanGestureHandler` that\n// renders its children without gestures is the same trap. An unsupported RNGH\n// import must fail where it is used, naming itself.\n//\n// Note on types: this is a BUNDLER alias, so `tsc` never sees it. An app\n// keeps `react-native-gesture-handler` in its dependencies for iOS and\n// Android, and TypeScript goes on resolving the real package's types from\n// node_modules. That is why nothing here mirrors RNGH's ~60 type exports.\nimport type { ReactNode } from \"react\"\nimport { View } from \"../components/view\"\nimport type { StyleProp } from \"../contracts\"\nimport { createUnsupportedFactory } from \"../unsupported-export\"\nimport { Gesture } from \"./builder\"\nimport { GestureDetector } from \"./detector\"\nimport {\n  useCompetingGestures,\n  useExclusiveGestures,\n  useFlingGesture,\n  useHoverGesture,\n  useLongPressGesture,\n  useManualGesture,\n  useNativeGesture,\n  usePanGesture,\n  usePinchGesture,\n  useRotationGesture,\n  useSimultaneousGestures,\n  useTapGesture,\n} from \"./hooks\"\nimport {\n  DIRECTIONS,\n  GESTURE_STATE,\n  HOVER_EFFECT,\n  MOUSE_BUTTON,\n  POINTER_TYPE,\n} from \"./types\"\n\nexport {\n  Gesture,\n  GestureDetector,\n  useCompetingGestures,\n  useExclusiveGestures,\n  useFlingGesture,\n  useHoverGesture,\n  useLongPressGesture,\n  useManualGesture,\n  useNativeGesture,\n  usePanGesture,\n  usePinchGesture,\n  useRotationGesture,\n  useSimultaneousGestures,\n  useTapGesture,\n}\nexport {\n  FlingGestureBuilder,\n  ForceTouchGestureBuilder,\n  HoverGestureBuilder,\n  LongPressGestureBuilder,\n  ManualGestureBuilder,\n  NativeGestureBuilder,\n  PanGestureBuilder,\n  PinchGestureBuilder,\n  RotationGestureBuilder,\n  TapGestureBuilder,\n} from \"./builder\"\nexport type { GestureDetectorProps } from \"./detector\"\nexport type {\n  FlingGestureHookConfig,\n  HoverGestureHookConfig,\n  LongPressGestureHookConfig,\n  ManualGestureHookConfig,\n  NativeGestureHookConfig,\n  PanGestureHookConfig,\n  TapGestureHookConfig,\n} from \"./hooks\"\nexport type {\n  AnyGestureSpec,\n  ComposedGestureKind,\n  ComposedGestureSpec,\n  GestureEndEventPayload,\n  GestureEventPayload,\n  GestureHitSlop,\n  GestureKind,\n  GestureRef,\n  GestureRelations,\n  GestureSpec,\n  GestureStateManagerApi,\n  GestureTouchData,\n  GestureTouchEvent,\n  OffsetBound,\n} from \"./types\"\n\n/**\n * Upstream's default, and note that it is `style ?? {flex: 1}` rather than\n * `[{flex: 1}, style]`: passing a style REPLACES the flex box, it does not\n * merge with it. Verified against react-native-gesture-handler 3.1.0, where\n * all three implementations (`.tsx`, `.web.tsx`, `.android.tsx`) agree on\n * `<View style={style ?? styles.container} {...rest} />`. The difference is\n * observable — with `style={{height: 100}}` upstream gives a 100px-tall box\n * with no `flex`, and a merged version would give a flexing one.\n */\nconst ROOT_STYLE = { flex: 1 } as const\n\nexport type GestureHandlerRootViewProps = {\n  children?: ReactNode\n  style?: StyleProp\n  testID?: string\n}\n\n/**\n * The root box `react-native-gesture-handler` asks apps to put at the top of\n * the tree.\n *\n * Faithful, not merely tolerated. Upstream's does two things: it renders a\n * `flex: 1` `View`, and it marks the subtree as gesture-arbitrating. The\n * first is reproduced exactly. The second is genuinely this platform's job\n * already — RN's own gesture responder system is implemented here on GTK4\n * event controllers (#41), and its lock is global — so there is no context to\n * provide and nothing is being skipped.\n */\nexport const GestureHandlerRootView = ({\n  children,\n  style,\n  testID,\n}: GestureHandlerRootViewProps): ReactNode => (\n  <View\n    style={style ?? ROOT_STYLE}\n    testID={testID}\n  >\n    {children}\n  </View>\n)\n\nconst unsupported = createUnsupportedFactory(\n  \"react-native-gesture-handler\",\n  \"Implemented: GestureHandlerRootView, GestureDetector, `State`, `Directions`, `HoverEffect`, \" +\n    \"the re-exported ScrollView/FlatList/TextInput/Switch and the three Touchables, and ALL TEN \" +\n    \"recognizers — Pan, Tap, LongPress, Native, Pinch, Rotation, Fling, Manual, Hover and \" +\n    \"ForceTouch — in both spellings where upstream has two (`Gesture.Pan()` and \" +\n    \"`usePanGesture()`, and so on), plus the three cross-gesture relations and the three \" +\n    \"composers. Three of them need input a mouse cannot produce: Pinch and Rotation need a \" +\n    \"TOUCHPAD (GtkGestureZoom/GtkGestureRotate) and ForceTouch needs a pressure-reporting \" +\n    \"STYLUS (GtkGestureStylus). RN's own responder system and PanResponder also work \" +\n    \"(docs/api.md); drag-and-drop is react-native-gtkx/dnd.\",\n)\n\n// Every runtime value `react-native-gesture-handler` 3.1.0 exports, minus\n// GestureHandlerRootView above. Enumerated rather than generated by a Proxy\n// over the module, because ESM named imports are resolved statically: a\n// symbol that is not exported here fails at BUILD time with \"no export named\n// X\", which is loud in its own right — but only the names listed here can\n// produce the descriptive runtime message, so the list is worth keeping\n// complete.\n//\n// The `any` is deliberate and load-bearing: an app's `<PanGestureHandler>`\n// must still type-check (it type-checks against the REAL package anyway, see\n// the note at the top) and fail when it runs, not before.\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n// --- the legacy handler components ---\n//\n// ALL NINE STAY REFUSED, and now that every recognizer behind them is\n// implemented the reason is worth stating precisely rather than leaving as a\n// bare `unsupported()`: these are not gestures, they are the RNGH **1.x\n// component API** — `<PanGestureHandler onGestureEvent={...}><View/></PanGestureHandler>`\n// — which upstream deprecated years before it deprecated the builder, and\n// which every one of the four libraries this epic targets has already\n// migrated off. Reimplementing them would mean a second public surface over\n// the same recognizers, with its own `onGestureEvent`/`onHandlerStateChange`\n// event shape, its own `enabled`/`waitFor` prop plumbing and its own\n// `createHandler` HOC — for zero measured consumers and a spelling upstream is\n// removing. `Gesture.Pan()` and `usePanGesture()` are the two spellings that\n// exist here, which is one more than upstream is keeping.\n//\n// The message each throws names itself, so an app on the old API is told which\n// symbol to migrate rather than left with a missing export.\nexport const FlingGestureHandler: any = unsupported(\"FlingGestureHandler\")\nexport const ForceTouchGestureHandler: any = unsupported(\n  \"ForceTouchGestureHandler\",\n)\nexport const LongPressGestureHandler: any = unsupported(\n  \"LongPressGestureHandler\",\n)\nexport const NativeViewGestureHandler: any = unsupported(\n  \"NativeViewGestureHandler\",\n)\nexport const PanGestureHandler: any = unsupported(\"PanGestureHandler\")\nexport const PinchGestureHandler: any = unsupported(\"PinchGestureHandler\")\nexport const RotationGestureHandler: any = unsupported(\"RotationGestureHandler\")\nexport const TapGestureHandler: any = unsupported(\"TapGestureHandler\")\n// `createNativeWrapper(Component, config)` attaches a `NativeViewGestureHandler`\n// to an arbitrary RN component. On this platform the responder system IS the\n// arbitration that wrapper registers with, every component this package ships\n// already speaks it, and `Gesture.Native()` is how a gesture is declared over\n// one explicitly — so the wrapper has nothing to add and would be a no-op\n// dressed as a feature. The re-exported ScrollView/FlatList/Touchables below\n// are that reasoning applied to the components upstream wraps itself.\nexport const legacy_createNativeWrapper: any = unsupported(\n  \"legacy_createNativeWrapper\",\n)\n\n// --- the new (v3) gesture API ---\n// `Gesture`, `GestureDetector`, the nine gesture hooks and the three composer\n// hooks are re-exported at the top of this file. `Gesture` is a real namespace\n// and none of its statics throws any more.\n//\n// The four below are refused for four different reasons, none of them \"not got\n// round to it\":\n//\n//   - `GestureDetectorType` is a TYPE upstream, not a value. It only ever\n//     appears in a type position, where this module is not in the path at all\n//     (the alias is a BUNDLER alias; `tsc` resolves the real package's types\n//     from node_modules — see the note at the top of this file). A runtime\n//     value under that name could only be reached by code that has already\n//     gone wrong;\n//   - `GestureStateManager` is upstream's standalone FACTORY, `create(tag)`,\n//     which looks a mounted handler up by tag in a global `NodeManager`. The\n//     manager an app actually uses is the one handed into `onTouchesDown` /\n//     `onTouchesMove` / `onTouchesUp` / `onTouchesCancel`, and that one IS\n//     implemented — it is what drives `Gesture.Manual()`. What is missing is\n//     the global tag→handler registry, and its absence is deliberate: identity\n//     here is the mounted detector, and ./relations resolves an app's gesture\n//     object to a tag lazily precisely so that nothing has to be looked up in\n//     a process-wide map. Upstream marks this export deprecated in favour of\n//     the hook API in the same breath;\n//   - `InterceptingGestureDetector` and `VirtualGestureDetector` are 3.1.0's\n//     new experimental detectors. The first intercepts events destined for\n//     views BELOW it, which on this platform would mean claiming a GTK\n//     sequence before deciding — and `CLAIMED` is irrevocable here, so the\n//     \"intercept, look, maybe give back\" shape is not expressible. The second\n//     drives a gesture with no view at all, which needs the tag registry the\n//     entry above says why this platform does not have.\nexport const GestureDetectorType: any = unsupported(\"GestureDetectorType\")\nexport const GestureStateManager: any = unsupported(\"GestureStateManager\")\nexport const InterceptingGestureDetector: any = unsupported(\n  \"InterceptingGestureDetector\",\n)\nexport const VirtualGestureDetector: any = unsupported(\"VirtualGestureDetector\")\n\n// --- enums and constants ---\n//\n// ALL FIVE ARE NOW DATA, and the last four changed here. The old rule was that\n// an enum is only meaningful next to a handler that can run, so reading one\n// was already a symptom — and that rule was right when six of the ten\n// recognizers threw. It stopped describing anything true when the last four\n// shipped, and the honest test is now the plain one: does an app comparing\n// against this constant get a correct answer? For every one of these, yes.\n//\n// `State` went first, in slice 2, and the reasoning generalises to the rest:\n// every payload carries a faithful `state`, so `=== State.ACTIVE` is ordinary\n// correct code. `react-native-drawer-layout` does exactly that — it re-exports\n// it as `GestureState`, seeds a shared value with `GestureState.UNDETERMINED`\n// and tests `=== GestureState.ACTIVE`.\n//\n// `Directions` is REQUIRED rather than merely harmless: `Gesture.Fling()`\n// takes a direction and this is the enum it takes. A refusal here would make\n// the recognizer unusable in its documented spelling.\n//\n// `PointerType` became meaningful with `ForceTouch`, which is the first kind\n// whose events are honestly not a mouse — every payload carries `pointerType`,\n// and a stylus one says `STYLUS`.\n//\n// `HoverEffect` and `MouseButton` are INERT and exported anyway, which is the\n// one place this file's rule bends. Both name values for knobs that are\n// already accepted-and-inert here (`.effect()`, `.mouseButton()`) exactly as\n// they are inert off their platforms upstream, and a knob that accepts a\n// number while refusing the constant that number has a name for is incoherent.\n// The refusal that matters is for something that would silently NOT WORK;\n// these do exactly what they do upstream on this platform, which is nothing.\n//\n// Every number in all five is pinned by a test against 3.1.0's own sources,\n// because nothing about a wrong one is loud: `state === State.ACTIVE` and\n// `direction === Directions.LEFT` both go on compiling, go on running, and\n// quietly answer false.\nexport const State = GESTURE_STATE\nexport const Directions = DIRECTIONS\nexport const HoverEffect = HOVER_EFFECT\nexport const MouseButton = MOUSE_BUTTON\nexport const PointerType = POINTER_TYPE\n\n// --- the wrapped RN components and buttons ---\n//\n// Upstream builds every one of these with `createNativeWrapper(RN.X, {\n// disallowInterruption: true, shouldCancelWhenOutside: false })` — an RN\n// component with a `NativeViewGestureHandler` attached, so that RNGH's\n// arbitration knows about the native scrolling or the native press underneath.\n// On this platform that wrapper has nothing to add: the responder system IS\n// the arbitration these are being registered with, every one of these\n// components already speaks it, and `Gesture.Native()` is how a gesture is\n// declared over one of them explicitly. So the honest re-export is the\n// platform's own component, unwrapped.\n//\n// They are here because they are RENDERED, not merely imported.\n// `react-native-draggable-flatlist` 4.0.3 hands `FlatList` and `ScrollView` to\n// `Animated.createAnimatedComponent()` at module scope in\n// `DraggableFlatList.tsx` and `NestableScrollContainer.tsx`, which is what\n// stopped that library at IMPORT rather than at use;\n// `react-native-reanimated-dnd`'s `Sortable`/`SortableGrid` do the same;\n// `@gorhom/bottom-sheet` re-exports the three Touchables from its own public\n// entry as `BottomSheetTouchable` on every platform except iOS, and renders\n// `TextInput` as `BottomSheetTextInput`.\n//\n// WHAT IS NOT HERE, and the boundary is upstream's own: the BUTTON family\n// (`RawButton`, `BaseButton`, `RectButton`, `BorderlessButton`) is not RN\n// components with a handler attached — it is RNGH's own NATIVE BUTTON VIEWS,\n// implemented in Java and Objective-C, with an Android ripple\n// (`TouchableNativeFeedback`'s), `borderless` drawable selection, `rippleColor`\n// / `rippleRadius`, `exclusive`, and an `activeOpacity` applied by the native\n// view rather than by style. There is no GTK widget with those semantics and\n// no way to fake the ripple, so any implementation would be a `Pressable`\n// wearing the name of something else — which is precisely the silent\n// substitution this whole surface refuses.\n//\n// RE-CHECKED WITH THE FOUR TARGET LIBRARIES rather than assumed, because that\n// is what settled the `Touchable` question in slice 4. Sweeping the shipped\n// sources of `@gorhom/bottom-sheet` 5.2.14, `react-native-draggable-flatlist`\n// 4.0.3, `react-native-drawer-layout` 4.2.9 and `react-native-reanimated-dnd`\n// 2.0.0 for every symbol still refused here finds exactly one hit —\n// `RefreshControl` in `@gorhom/bottom-sheet` — and it is not this package's:\n// it is imported from `react-native`, as a type in `bottomSheetRefreshControl/\n// index.ts` and as a value only in `BottomSheetRefreshControl.android.tsx`,\n// which Metro on this platform never resolves (`.linux.* -> .native.* -> .*`).\n// Nothing reaches for a button, a legacy handler component, `Directions`,\n// `MouseButton`, `PointerType`, `GestureStateManager` or any `Legacy*` alias.\n// The `Touchable` subset slice 4 shipped remains the only thing upstream's own\n// exports forced.\n//\n// `TouchableNativeFeedback` is Android's ripple by another name and `Touchable`\n// is RN's deprecated mixin; both stay refused for the reason RN itself would\n// not give them to you here. `RefreshControl` is pull-to-refresh, which needs\n// a scroll gesture this platform's `ScrollView` does not expose and a spinner\n// widget it does not have — and, per the sweep above, nothing asks for it.\nexport const BaseButton: any = unsupported(\"BaseButton\")\nexport const BorderlessButton: any = unsupported(\"BorderlessButton\")\nexport { FlatList } from \"../components/flat-list\"\nexport {\n  Pressable,\n  TouchableHighlight,\n  TouchableOpacity,\n  TouchableWithoutFeedback,\n} from \"../components/pressable\"\nexport { ScrollView } from \"../components/scroll-view\"\nexport { Switch } from \"../components/switch\"\nexport { TextInput } from \"../components/text-input\"\nexport const RawButton: any = unsupported(\"RawButton\")\nexport const RectButton: any = unsupported(\"RectButton\")\nexport const RefreshControl: any = unsupported(\"RefreshControl\")\nexport const Touchable: any = unsupported(\"Touchable\")\nexport const TouchableNativeFeedback: any = unsupported(\n  \"TouchableNativeFeedback\",\n)\n\n// --- the 2.x legacy aliases, still exported by 3.x ---\n//\n// ALL TWELVE STAY REFUSED, for one reason that covers them: each is 3.x's\n// escape hatch back to the 2.x implementation of a component whose 3.x\n// spelling is either implemented here already (`LegacyScrollView`,\n// `LegacyFlatList`, `LegacyTextInput`, `LegacySwitch`, `LegacyPressable`,\n// `LegacyText`) or refused above with its own reason (`LegacyRawButton`,\n// `LegacyBaseButton`, `LegacyRectButton`, `LegacyBorderlessButton`,\n// `LegacyRefreshControl`). Where the modern name works, the legacy alias would\n// be a second name for the same component with a promise attached — \"this one\n// behaves like 2.x did\" — that this platform cannot keep, because it never\n// implemented 2.x's behaviour to differ from. Where the modern name is\n// refused, the alias inherits the refusal.\n//\n// `LegacyDrawerLayoutAndroid` is the odd one and is refused twice over: it is\n// Android's `DrawerLayoutAndroid`, which React Native itself does not ship off\n// Android, and `@react-navigation/drawer` reaches for\n// `react-native-drawer-layout` instead — which runs here (probe 3).\nexport const LegacyBaseButton: any = unsupported(\"LegacyBaseButton\")\nexport const LegacyBorderlessButton: any = unsupported(\"LegacyBorderlessButton\")\nexport const LegacyDrawerLayoutAndroid: any = unsupported(\n  \"LegacyDrawerLayoutAndroid\",\n)\nexport const LegacyFlatList: any = unsupported(\"LegacyFlatList\")\nexport const LegacyPressable: any = unsupported(\"LegacyPressable\")\nexport const LegacyRawButton: any = unsupported(\"LegacyRawButton\")\nexport const LegacyRectButton: any = unsupported(\"LegacyRectButton\")\nexport const LegacyRefreshControl: any = unsupported(\"LegacyRefreshControl\")\nexport const LegacyScrollView: any = unsupported(\"LegacyScrollView\")\nexport const LegacySwitch: any = unsupported(\"LegacySwitch\")\nexport const LegacyText: any = unsupported(\"LegacyText\")\nexport const LegacyTextInput: any = unsupported(\"LegacyTextInput\")\n"]}

package/dist/gesture-handler-compat/long-press.d.ts

@@ -0,0 +1,6 @@
+import type { RecognizerDecider } from "./recognizer";
+/** Upstream's `DEFAULT_MIN_DURATION_MS`. */
+export declare const DEFAULT_MIN_DURATION = 500;
+/** Upstream's `DEFAULT_MAX_DIST_DP`. */
+export declare const DEFAULT_MAX_DISTANCE = 10;
+export declare const longPressDecider: RecognizerDecider;

package/dist/gesture-handler-compat/long-press.js

@@ -0,0 +1,21 @@
+/** Upstream's `DEFAULT_MIN_DURATION_MS`. */
+export const DEFAULT_MIN_DURATION = 500;
+/** Upstream's `DEFAULT_MAX_DIST_DP`. */
+export const DEFAULT_MAX_DISTANCE = 10;
+const travelledTooFar = (view, config) => view.distanceFromPress > (config.maxDistance ?? DEFAULT_MAX_DISTANCE);
+export const longPressDecider = {
+    kind: "longPress",
+    timer: (config) => ({
+        delay: config.minDuration ?? DEFAULT_MIN_DURATION,
+        elapsed: "activate",
+    }),
+    shouldFail: travelledTooFar,
+    shouldActivate: (view, config) => view.timerElapsed &&
+        // Upstream arms its activation timer only while exactly this many pointers
+        // are down, so a two-finger long press is unreachable on a platform that
+        // fabricates one touch per pointer — honestly unreachable rather than
+        // silently single-finger.
+        view.pointerCount === (config.numberOfPointers ?? 1),
+    shouldCancelWhileActive: travelledTooFar,
+};
+//# sourceMappingURL=long-press.js.map

package/dist/gesture-handler-compat/long-press.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"long-press.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/long-press.ts"],"names":[],"mappings":"AA4BA,4CAA4C;AAC5C,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,CAAA;AACvC,wCAAwC;AACxC,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAA;AAEtC,MAAM,eAAe,GAAG,CACtB,IAAoB,EACpB,MAAwB,EACf,EAAE,CACX,IAAI,CAAC,iBAAiB,GAAG,CAAC,MAAM,CAAC,WAAW,IAAI,oBAAoB,CAAC,CAAA;AAEvE,MAAM,CAAC,MAAM,gBAAgB,GAAsB;IACjD,IAAI,EAAE,WAAW;IAEjB,KAAK,EAAE,CAAC,MAAwB,EAAmB,EAAE,CAAC,CAAC;QACrD,KAAK,EAAE,MAAM,CAAC,WAAW,IAAI,oBAAoB;QACjD,OAAO,EAAE,UAAU;KACpB,CAAC;IAEF,UAAU,EAAE,eAAe;IAE3B,cAAc,EAAE,CAAC,IAAoB,EAAE,MAAwB,EAAW,EAAE,CAC1E,IAAI,CAAC,YAAY;QACjB,2EAA2E;QAC3E,yEAAyE;QACzE,sEAAsE;QACtE,0BAA0B;QAC1B,IAAI,CAAC,YAAY,KAAK,CAAC,MAAM,CAAC,gBAAgB,IAAI,CAAC,CAAC;IAEtD,uBAAuB,EAAE,eAAe;CACzC,CAAA","sourcesContent":["// LongPress's predicates, over the same machine `Pan` runs on.\n//\n// The shortest of the three, and the one that needed no new machinery at all:\n// `Pan().activateAfterLongPress()` already activates on a timer through the\n// out-of-event grant channel slice 1 added, and a long press is that, minus\n// the pan. What it does add is the only case where an ALREADY ACTIVE gesture\n// is cancelled by movement it would otherwise have reported — `maxDistance`\n// keeps applying after the press has matured, and going past it then is a\n// cancellation rather than a failure (upstream's `checkDistanceFail` branches\n// on exactly that).\n//\n// The distance is measured from the PRESS and not from the activation point,\n// which is why `RecognizerView` carries `distanceFromPress` at all. Upstream\n// sets `startX`/`startY` on pointer-down and never moves them (its base\n// `resetProgress()` is empty, unlike `Pan`'s), so a hold that drifts 8px\n// before the timer and 8px after it has travelled 16 and is cancelled at a\n// `maxDistance` of 10. Re-basing at activation would have let it drift twice.\n//\n// Restated from `src/web/handlers/LongPressGestureHandler.ts` at 3.1.0.\n// `DEFAULT_MAX_DIST_DP * SCALING_FACTOR` there is 10 × 10 — a squared\n// distance whose square root is the documented default of 10.\nimport type {\n  RecognizerDecider,\n  RecognizerTimer,\n  RecognizerView,\n} from \"./recognizer\"\nimport type { RecognizerConfig } from \"./types\"\n\n/** Upstream's `DEFAULT_MIN_DURATION_MS`. */\nexport const DEFAULT_MIN_DURATION = 500\n/** Upstream's `DEFAULT_MAX_DIST_DP`. */\nexport const DEFAULT_MAX_DISTANCE = 10\n\nconst travelledTooFar = (\n  view: RecognizerView,\n  config: RecognizerConfig,\n): boolean =>\n  view.distanceFromPress > (config.maxDistance ?? DEFAULT_MAX_DISTANCE)\n\nexport const longPressDecider: RecognizerDecider = {\n  kind: \"longPress\",\n\n  timer: (config: RecognizerConfig): RecognizerTimer => ({\n    delay: config.minDuration ?? DEFAULT_MIN_DURATION,\n    elapsed: \"activate\",\n  }),\n\n  shouldFail: travelledTooFar,\n\n  shouldActivate: (view: RecognizerView, config: RecognizerConfig): boolean =>\n    view.timerElapsed &&\n    // Upstream arms its activation timer only while exactly this many pointers\n    // are down, so a two-finger long press is unreachable on a platform that\n    // fabricates one touch per pointer — honestly unreachable rather than\n    // silently single-finger.\n    view.pointerCount === (config.numberOfPointers ?? 1),\n\n  shouldCancelWhileActive: travelledTooFar,\n}\n"]}

package/dist/gesture-handler-compat/manual.d.ts

@@ -0,0 +1,2 @@
+import type { RecognizerDecider } from "./recognizer";
+export declare const manualDecider: RecognizerDecider;

package/dist/gesture-handler-compat/manual.js

@@ -0,0 +1,18 @@
+export const manualDecider = {
+    kind: "manual",
+    /**
+     * Never, from anything. Upstream's handler has no failure predicate at all —
+     * `onPointerUp` removes the pointer from its tracker and does not touch the
+     * state. `.fail()` is how a manual gesture fails.
+     */
+    shouldFail: () => false,
+    /**
+     * Never, from anything. This is the whole definition of the kind: no
+     * distance, no velocity, no timer and no release criterion. `.activate()` is
+     * the only way in.
+     */
+    shouldActivate: () => false,
+    /** See the header: a lift decides nothing, so the gesture stays BEGAN. */
+    onRelease: () => ({ kind: "hold" }),
+};
+//# sourceMappingURL=manual.js.map

package/dist/gesture-handler-compat/manual.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manual.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/manual.ts"],"names":[],"mappings":"AA4CA,MAAM,CAAC,MAAM,aAAa,GAAsB;IAC9C,IAAI,EAAE,QAAQ;IAEd;;;;OAIG;IACH,UAAU,EAAE,GAAY,EAAE,CAAC,KAAK;IAEhC;;;;OAIG;IACH,cAAc,EAAE,GAAY,EAAE,CAAC,KAAK;IAEpC,0EAA0E;IAC1E,SAAS,EAAE,GAAmB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;CACpD,CAAA","sourcesContent":["// `Gesture.Manual()` — the recognizer that recognizes nothing.\n//\n// It is the smallest kind in the module and the only one whose predicates are\n// both constant, because there is nothing for them to decide: the app drives\n// the state machine itself through the `GestureStateManager` handed to the\n// `onTouches*` callbacks. `.begin()`, `.activate()`, `.end()` and `.fail()`\n// ARE the recognizer.\n//\n// WHY IT IS WORTH HAVING, beyond completing the surface: it exercises the\n// arbitration registry from the OUTSIDE. Every other kind reaches\n// `tryActivate` from a predicate this module wrote, so a test of the registry\n// is also a test of the predicate that woke it. A `Manual` activated by an app\n// at a moment the app chose is the same registry with the recognizer's own\n// judgement removed — which is the only way to drive `requireExternalGestureToFail`,\n// the broadcast cancel and the responder handoff at instants no predicate\n// would have produced.\n//\n// AND IT GOES THROUGH THE SAME LOOP. `.activate()` does not set the state; it\n// asks, exactly as a `Pan` crossing its `activeOffset` asks. It can come back\n// parked behind another gesture, or cancelled, or granted — see\n// `stateManager` in ./recognizer. Upstream is the same shape: its web state\n// manager calls `handler.activate(true)`, and `activate` still routes through\n// `moveToState` into the orchestrator. The `true` is only about bypassing\n// `manualActivation`, not about bypassing arbitration.\n//\n// Restated from `src/web/handlers/ManualGestureHandler.ts` at 3.1.0, which is\n// forty lines of which only one is a state transition: `begin()` on pointer\n// down.\n//\n// ONE DELIBERATE DEVIATION, and this platform forces it. Upstream's Manual\n// does not end when the pointers lift — its documentation says so explicitly\n// (\"It will not fail when all the pointers are lifted from the screen\"). Half\n// of that is reproduced exactly: a Manual still BEGAN when the pointer comes\n// up stays BEGAN, holding nothing (`onRelease` below). The other half is not\n// reachable. A gesture that is ACTIVE here is holding an INTERACTION — the\n// responder lock, the GTK sequence, the suspended scrollers — and that\n// interaction ends when the button does. Staying ACTIVE past it would mean\n// holding a lock that no longer exists, receiving no further events of any\n// kind, and never reporting an ending at all. So an ACTIVE Manual ends with\n// the interaction, successfully. The app's own `onTouchesUp` fires FIRST and\n// gets the state manager, so an app that wants a different ending has the\n// event to write it in. docs/api.md records this.\nimport type { RecognizerDecider, ReleaseOutcome } from \"./recognizer\"\n\nexport const manualDecider: RecognizerDecider = {\n  kind: \"manual\",\n\n  /**\n   * Never, from anything. Upstream's handler has no failure predicate at all —\n   * `onPointerUp` removes the pointer from its tracker and does not touch the\n   * state. `.fail()` is how a manual gesture fails.\n   */\n  shouldFail: (): boolean => false,\n\n  /**\n   * Never, from anything. This is the whole definition of the kind: no\n   * distance, no velocity, no timer and no release criterion. `.activate()` is\n   * the only way in.\n   */\n  shouldActivate: (): boolean => false,\n\n  /** See the header: a lift decides nothing, so the gesture stays BEGAN. */\n  onRelease: (): ReleaseOutcome => ({ kind: \"hold\" }),\n}\n"]}

package/dist/gesture-handler-compat/native.d.ts

@@ -0,0 +1,7 @@
+import type { RecognizerDecider } from "./recognizer";
+/**
+ * Upstream's `DEFAULT_TOUCH_SLOP` (`src/web/constants.ts`), the travel at
+ * which a wrapped native view is taken to have started handling the gesture.
+ */
+export declare const NATIVE_TOUCH_SLOP = 15;
+export declare const nativeDecider: RecognizerDecider;

package/dist/gesture-handler-compat/native.js

@@ -0,0 +1,34 @@
+/**
+ * Upstream's `DEFAULT_TOUCH_SLOP` (`src/web/constants.ts`), the travel at
+ * which a wrapped native view is taken to have started handling the gesture.
+ */
+export const NATIVE_TOUCH_SLOP = 15;
+export const nativeDecider = {
+    // The one kind the arbitration loop asks about by name: an already ACTIVE or
+    // parked gesture is cancelled by nothing except an active native one, which
+    // is upstream's rule and the reason `Native` is special rather than just
+    // another recognizer. See ./orchestrator.
+    kind: "native",
+    // Reporting, not competing: it never takes the interaction, so it never
+    // suspends the scroller it is reporting on. See the file header.
+    claimsResponder: false,
+    /**
+     * Never on its own. Upstream's native handler has no failure predicate over
+     * movement at all — a native view that is being dragged is a native view
+     * doing its job. It still fails when the pointer lifts before it activated
+     * (the shared machine's default `onRelease`), when the pointer leaves and
+     * `shouldCancelWhenOutside` is on, and when the pointer count is refused.
+     */
+    shouldFail: () => false,
+    shouldActivate: (view, config) => {
+        if (config.shouldActivateOnStart === true) {
+            return true;
+        }
+        // From the PRESS rather than from the translation origin, matching
+        // upstream's `startX`/`startY` — a native view has no notion of being
+        // re-based, and nothing has activated yet for translation to be measured
+        // from anyway.
+        return view.distanceFromPress >= NATIVE_TOUCH_SLOP;
+    },
+};
+//# sourceMappingURL=native.js.map

package/dist/gesture-handler-compat/native.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/native.ts"],"names":[],"mappings":"AAwCA;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,CAAA;AAEnC,MAAM,CAAC,MAAM,aAAa,GAAsB;IAC9C,6EAA6E;IAC7E,4EAA4E;IAC5E,yEAAyE;IACzE,0CAA0C;IAC1C,IAAI,EAAE,QAAQ;IAEd,wEAAwE;IACxE,iEAAiE;IACjE,eAAe,EAAE,KAAK;IAEtB;;;;;;OAMG;IACH,UAAU,EAAE,GAAY,EAAE,CAAC,KAAK;IAEhC,cAAc,EAAE,CAAC,IAAoB,EAAE,MAAwB,EAAW,EAAE;QAC1E,IAAI,MAAM,CAAC,qBAAqB,KAAK,IAAI,EAAE,CAAC;YAC1C,OAAO,IAAI,CAAA;QACb,CAAC;QACD,mEAAmE;QACnE,sEAAsE;QACtE,yEAAyE;QACzE,eAAe;QACf,OAAO,IAAI,CAAC,iBAAiB,IAAI,iBAAiB,CAAA;IACpD,CAAC;CACF,CAAA","sourcesContent":["// `Gesture.Native()` — the recognizer that stands for the widget underneath\n// it rather than for anything React Native is doing.\n//\n// WHAT IT IS FOR. Upstream's `NativeViewGestureHandler` wraps a native\n// scrollable, a button or a switch and puts THAT into the arbitration, so a\n// JS gesture can be declared simultaneous with the platform's own scrolling\n// instead of racing it. `@gorhom/bottom-sheet` is the canonical use and the\n// reason this exists here: it builds\n// `Gesture.Native().simultaneousWithExternalGesture(sheetPan)` around its\n// scrollable so the list can scroll while the sheet's pan watches for a drag\n// on the handle.\n//\n// THE PREDICATES ARE UPSTREAM'S, restated from `src/web/handlers/\n// NativeViewGestureHandler.ts` at 3.1.0: BEGAN on press; ACTIVE once the\n// pointer has travelled `DEFAULT_TOUCH_SLOP` (15 px) from it, because that is\n// the point at which a native scrollable would have started scrolling;\n// immediately ACTIVE instead when `shouldActivateOnStart` is set, which is how\n// a button-shaped native view takes the press at once; `shouldCancelWhenOutside`\n// on by default, as upstream's `init` sets it; and a lift before activation is\n// a failure rather than an end.\n//\n// THE ONE THING THAT IS NOT UPSTREAM'S, and it is the whole point of putting\n// this in the slice that also fixed `->DENIED`: **this recognizer never takes\n// the responder** (`claimsResponder: false`). On this platform taking it is\n// what makes `responder/use-responder.ts` declare `CLAIMED` on the GTK\n// sequence and call `setKineticScrolling(false)` on every enclosing\n// `GtkScrolledWindow` — RN's `setIsJSResponder`, which exists to stop a native\n// scroller stealing a JS drag. A gesture whose entire meaning is \"the native\n// scroller is handling this\" cannot be the thing that switches the native\n// scroller off. So it reports, and yields.\n//\n// The consequence is that it runs off the touch props, which fire regardless\n// of responder status — and therefore that its ending is `onTouchEnd` or\n// `onTouchCancel`. Which is exactly why the `->DENIED` correction had to land\n// with it: before that fix a native ancestor claiming the sequence mid-drag\n// reached JS as `onTouchEnd`, and this gesture would have reported a clean,\n// successful end to a drag that had been taken away from it.\nimport type { RecognizerDecider, RecognizerView } from \"./recognizer\"\nimport type { RecognizerConfig } from \"./types\"\n\n/**\n * Upstream's `DEFAULT_TOUCH_SLOP` (`src/web/constants.ts`), the travel at\n * which a wrapped native view is taken to have started handling the gesture.\n */\nexport const NATIVE_TOUCH_SLOP = 15\n\nexport const nativeDecider: RecognizerDecider = {\n  // The one kind the arbitration loop asks about by name: an already ACTIVE or\n  // parked gesture is cancelled by nothing except an active native one, which\n  // is upstream's rule and the reason `Native` is special rather than just\n  // another recognizer. See ./orchestrator.\n  kind: \"native\",\n\n  // Reporting, not competing: it never takes the interaction, so it never\n  // suspends the scroller it is reporting on. See the file header.\n  claimsResponder: false,\n\n  /**\n   * Never on its own. Upstream's native handler has no failure predicate over\n   * movement at all — a native view that is being dragged is a native view\n   * doing its job. It still fails when the pointer lifts before it activated\n   * (the shared machine's default `onRelease`), when the pointer leaves and\n   * `shouldCancelWhenOutside` is on, and when the pointer count is refused.\n   */\n  shouldFail: (): boolean => false,\n\n  shouldActivate: (view: RecognizerView, config: RecognizerConfig): boolean => {\n    if (config.shouldActivateOnStart === true) {\n      return true\n    }\n    // From the PRESS rather than from the translation origin, matching\n    // upstream's `startX`/`startY` — a native view has no notion of being\n    // re-based, and nothing has activated yet for translation to be measured\n    // from anyway.\n    return view.distanceFromPress >= NATIVE_TOUCH_SLOP\n  },\n}\n"]}

package/dist/gesture-handler-compat/orchestrator.d.ts

@@ -0,0 +1,77 @@
+import { type RelationRegistry } from "./relations";
+import { type GestureStateValue } from "./types";
+/** One mounted recognizer, as the loop sees it. */
+export type Participant = {
+    readonly tag: number;
+    /**
+     * The recognizer kind.
+     *
+     * The loop reads exactly one thing off it — whether this is
+     * `Gesture.Native()` — because that is the single rule the relation
+     * registry contributes to cancellation, and it is why `Native` is special
+     * rather than just another recognizer: an ALREADY ACTIVE or parked gesture
+     * is cancelled by nothing except an active native one, and a gesture that
+     * wants to activate beside one is refused by it. `@gorhom/bottom-sheet`'s
+     * scrollable is the shape that needs both halves.
+     */
+    readonly kind: string;
+    /**
+     * Cleared to become ACTIVE.
+     *
+     * `needsResponder` is false when another participant already holds the
+     * interaction, and it is where the two locks meet: a gesture told `false`
+     * activates in JS without touching the responder lock, which is the only
+     * way `Simultaneous` can be expressed on a single-holder lock.
+     */
+    authorize: (needsResponder: boolean) => void;
+    /**
+     * Whether this gesture is holding the responder right now.
+     *
+     * Asked rather than assumed, because "is anything else active" is the wrong
+     * question and `Gesture.Native()` is what makes the difference visible: it
+     * is ACTIVE and it deliberately holds nothing, so a pan activating beside it
+     * still has an interaction to take. Nor is it a static per-kind fact — a
+     * `Pan` that lost the lock to a simultaneous partner is a claiming kind that
+     * does not hold it either.
+     */
+    holdsResponder: () => boolean;
+    /** Lost the arbitration: end now, unsuccessfully. */
+    cancel: () => void;
+};
+export type Orchestrator = {
+    readonly relations: RelationRegistry;
+    /** This gesture reached BEGAN and is part of the interaction under way. */
+    record: (participant: Participant) => void;
+    /** This gesture unmounted. Drops its relations with it. */
+    forget: (participant: Participant) => void;
+    /** This gesture's own criteria are met; may it activate? */
+    tryActivate: (participant: Participant) => void;
+    /** It really is ACTIVE now — the moment mutual exclusion is enforced. */
+    activated: (participant: Participant) => void;
+    finished: (participant: Participant, outcome: GestureStateValue) => void;
+    /**
+     * The participant holding the responder lost it to something outside this
+     * registry — an ancestor took the interaction, or the window went away.
+     */
+    interactionLost: (participant: Participant) => void;
+    /** Whether the loop is holding this one in BEGAN, waiting on another. */
+    isAwaiting: (participant: Participant) => boolean;
+    /** Every tag ACTIVE right now. `Simultaneous` is a claim about this list. */
+    activeTags: () => number[];
+    reset: () => void;
+};
+export declare const createOrchestrator: (relations?: RelationRegistry) => Orchestrator;
+/**
+ * The process-wide loop, which is the right scope for it and needs saying
+ * because the responder lock's scope is the question slice 3 had to answer.
+ *
+ * This registry has NO tree knowledge at all: it is keyed by handler tag and
+ * a gesture enters it only when the interaction's pointer reaches it. That is
+ * what makes the islands answer simple — see docs/api.md, "Relations across
+ * `Root`s". A relation naming a gesture in another `Root` is expressible and
+ * simply never has an occasion to apply, because a gesture in another `Root`
+ * is never recorded during this interaction. In particular it does not
+ * deadlock: parking only ever happens against a gesture that is live in the
+ * interaction under way.
+ */
+export declare const gestureOrchestrator: Orchestrator;